import { CreateExperimentRequest, CreateExperimentResponse, CreateLoggedModelRequest, CreateLoggedModelResponse, CreateRunRequest, CreateRunResponse, DeleteExperimentRequest, DeleteExperimentResponse, DeleteLoggedModelRequest, DeleteLoggedModelResponse, DeleteLoggedModelTagRequest, DeleteLoggedModelTagResponse, DeleteRunRequest, DeleteRunResponse, DeleteRunsRequest, DeleteRunsResponse, DeleteTagRequest, DeleteTagResponse, Experiment, FileInfo, FinalizeLoggedModelRequest, FinalizeLoggedModelResponse, GetExperimentByNameRequest, GetExperimentByNameResponse, GetExperimentRequest, GetExperimentResponse, GetLoggedModelRequest, GetLoggedModelResponse, GetMetricHistoryResponse, GetRunRequest, GetRunResponse, ListArtifactsRequest, ListArtifactsResponse, ListExperimentsRequest, ListExperimentsResponse, ListMetricHistoryRequest, LogBatchRequest, LogBatchResponse, LogInputsRequest, LogInputsResponse, LogLoggedModelParamsRequest, LogLoggedModelParamsResponse, LogMetricRequest, LogMetricResponse, LogModelRequest, LogModelResponse, LogOutputsRequest, LogOutputsResponse, LogParamRequest, LogParamResponse, Metric, RestoreExperimentRequest, RestoreExperimentResponse, RestoreRunRequest, RestoreRunResponse, RestoreRunsRequest, RestoreRunsResponse, Run, SearchExperimentsRequest, SearchExperimentsResponse, SearchLoggedModelsRequest, SearchLoggedModelsResponse, SearchRunsRequest, SearchRunsResponse, SetExperimentTagRequest, SetExperimentTagResponse, SetLoggedModelTagsRequest, SetLoggedModelTagsResponse, SetTagRequest, SetTagResponse, UpdateExperimentRequest, UpdateExperimentResponse, UpdateRunRequest, UpdateRunResponse } from "./model.js"; import { CallOptions } from "@databricks/sdk-options/call"; import { ClientOptions } from "@databricks/sdk-options/client"; //#region src/v1/client.d.ts declare class ExperimentsClient { private readonly options; private readonly logger; private readonly userAgent; private config; constructor(options: ClientOptions); private resolveConfig; /** * Creates an experiment with a name. Returns the ID of the newly created experiment. * Validates that another experiment with the same name does not already exist and fails * if another experiment with the same name already exists. * * * Throws `RESOURCE_ALREADY_EXISTS` if an experiment with the given name exists. * Note: In some contexts, this error may be remapped to `ALREADY_EXISTS`. * To be safe, clients should check for both error codes. */ createExperiment(req: CreateExperimentRequest, options?: CallOptions): Promise; /** Create a logged model. */ createLoggedModel(req: CreateLoggedModelRequest, options?: CallOptions): Promise; /** * Creates a new run within an experiment. A run is usually a single execution of a * machine learning or data ETL pipeline. MLflow uses runs to track the `mlflowParam`, * `mlflowMetric`, and `mlflowRunTag` associated with a single execution. */ createRun(req: CreateRunRequest, options?: CallOptions): Promise; /** * Marks an experiment and associated metadata, runs, metrics, params, and tags for deletion. * If the experiment uses FileStore, artifacts associated with the experiment are also deleted. */ deleteExperiment(req: DeleteExperimentRequest, options?: CallOptions): Promise; /** Delete a logged model. */ deleteLoggedModel(req: DeleteLoggedModelRequest, options?: CallOptions): Promise; /** Delete a tag on a logged model. */ deleteLoggedModelTag(req: DeleteLoggedModelTagRequest, options?: CallOptions): Promise; /** Marks a run for deletion. */ deleteRun(req: DeleteRunRequest, options?: CallOptions): Promise; /** * Bulk delete runs in an experiment that were created prior to or at the specified timestamp. Deletes at most * max_runs per request. To call this API from a Databricks Notebook in Python, you can use the client code snippet on */ deleteRuns(req: DeleteRunsRequest, options?: CallOptions): Promise; /** * Deletes a tag on a run. Tags are run metadata that can be updated during a run and after * a run completes. */ deleteTag(req: DeleteTagRequest, options?: CallOptions): Promise; /** Finalize a logged model. */ finalizeLoggedModel(req: FinalizeLoggedModelRequest, options?: CallOptions): Promise; /** Gets metadata for an experiment. This method works on deleted experiments. */ getExperiment(req: GetExperimentRequest, options?: CallOptions): Promise; /** * Gets metadata for an experiment. * * This endpoint will return deleted experiments, but prefers the active experiment * if an active and deleted experiment share the same name. If multiple deleted * experiments share the same name, the API will return one of them. * * Throws `RESOURCE_DOES_NOT_EXIST` if no experiment with the specified name exists. */ getExperimentByName(req: GetExperimentByNameRequest, options?: CallOptions): Promise; /** Get a logged model. */ getLoggedModel(req: GetLoggedModelRequest, options?: CallOptions): Promise; /** * Gets the metadata, metrics, params, and tags for a run. In the case where multiple metrics with the same key are * logged for a run, return only the value with the latest timestamp. * * If there are multiple values with the latest timestamp, return the maximum of these values. */ getRun(req: GetRunRequest, options?: CallOptions): Promise; /** * List artifacts for a run. Takes an optional `artifact_path` prefix which if specified, * the response contains only artifacts with the specified prefix. * A maximum of 1000 artifacts will be retrieved for UC Volumes. Please call * `/api/2.0/fs/directories{directory_path}` for listing artifacts in UC Volumes, which supports pagination. See [List * directory contents | Files API](/api/workspace/files/listdirectorycontents). */ listArtifacts(req: ListArtifactsRequest, options?: CallOptions): Promise; listArtifactsIter(req: ListArtifactsRequest, options?: CallOptions): AsyncGenerator; /** Gets a list of all experiments. */ listExperiments(req: ListExperimentsRequest, options?: CallOptions): Promise; listExperimentsIter(req: ListExperimentsRequest, options?: CallOptions): AsyncGenerator; /** Gets a list of all values for the specified metric for a given run. */ listMetricHistory(req: ListMetricHistoryRequest, options?: CallOptions): Promise; listMetricHistoryIter(req: ListMetricHistoryRequest, options?: CallOptions): AsyncGenerator; /** * Logs a batch of metrics, params, and tags for a run. If any data failed to be persisted, the server will respond * with an error (non-200 status code). * * In case of error (due to internal server error or an invalid request), partial data may be written. * * You can write metrics, params, and tags in interleaving fashion, but within a given entity type are guaranteed to * follow the order specified in the request body. * * The overwrite behavior for metrics, params, and tags is as follows: * * * Metrics: metric values are never overwritten. Logging a metric (key, value, timestamp) appends to the set of values * for the metric with the provided key. * * * Tags: tag values can be overwritten by successive writes to the same tag key. That is, if multiple tag values * with the same key are provided in the same API request, the last-provided tag value is written. Logging the same * tag (key, value) is permitted. Specifically, logging a tag is idempotent. * * * Parameters: once written, param values cannot be changed (attempting to overwrite a param value will result in an * error). However, logging the same param (key, value) is permitted. Specifically, logging a param is idempotent. * * Request Limits * ------------------------------- * A single JSON-serialized API request may be up to 1 MB in size and contain: * * * No more than 1000 metrics, params, and tags in total * * * Up to 1000 metrics * * * Up to 100 params * * * Up to 100 tags * * For example, a valid request might contain 900 metrics, 50 params, and 50 tags, but logging 900 metrics, 50 params, * and 51 tags is invalid. * * The following limits also apply to metric, param, and tag keys and values: * * * Metric keys, param keys, and tag keys can be up to 250 characters in length * * * Parameter and tag values can be up to 250 characters in length */ logBatch(req: LogBatchRequest, options?: CallOptions): Promise; /** Logs inputs, such as datasets and models, to an MLflow Run. */ logInputs(req: LogInputsRequest, options?: CallOptions): Promise; /** * Logs params for a logged model. A param is a key-value pair (string key, string value). Examples include * hyperparameters used for ML model training. A param can be logged only once for a logged model, and * attempting to overwrite an existing param with a different value will result in an error */ logLoggedModelParams(req: LogLoggedModelParamsRequest, options?: CallOptions): Promise; /** * Log a metric for a run. A metric is a key-value pair (string key, float value) with an * associated timestamp. Examples include the various metrics that represent ML model accuracy. * A metric can be logged multiple times. */ logMetric(req: LogMetricRequest, options?: CallOptions): Promise; /** * **Note:** the [Create a logged model](/api/workspace/experiments/createloggedmodel) API replaces this endpoint. * * Log a model to an MLflow Run. */ logModel(req: LogModelRequest, options?: CallOptions): Promise; /** Logs outputs, such as models, from an MLflow Run. */ logOutputs(req: LogOutputsRequest, options?: CallOptions): Promise; /** * Logs a param used for a run. A param is a key-value pair (string key, * string value). Examples include hyperparameters used for ML model training and * constant dates and values used in an ETL pipeline. A param can be logged only once for a run. */ logParam(req: LogParamRequest, options?: CallOptions): Promise; /** * Restore an experiment marked for deletion. This also restores * associated metadata, runs, metrics, params, and tags. If experiment uses FileStore, underlying * artifacts associated with experiment are also restored. * * Throws `RESOURCE_DOES_NOT_EXIST` if experiment was never created or was permanently deleted. */ restoreExperiment(req: RestoreExperimentRequest, options?: CallOptions): Promise; /** * Restores a deleted run. This also restores associated metadata, runs, metrics, params, and tags. * * Throws `RESOURCE_DOES_NOT_EXIST` if the run was never created or was permanently deleted. */ restoreRun(req: RestoreRunRequest, options?: CallOptions): Promise; /** * Bulk restore runs in an experiment that were deleted no earlier than the specified timestamp. Restores at most * max_runs per request. To call this API from a Databricks Notebook in Python, you can use the client code snippet on */ restoreRuns(req: RestoreRunsRequest, options?: CallOptions): Promise; /** Searches for experiments that satisfy specified search criteria. */ searchExperiments(req: SearchExperimentsRequest, options?: CallOptions): Promise; searchExperimentsIter(req: SearchExperimentsRequest, options?: CallOptions): AsyncGenerator; /** Search for Logged Models that satisfy specified search criteria. */ searchLoggedModels(req: SearchLoggedModelsRequest, options?: CallOptions): Promise; /** * Searches for runs that satisfy expressions. * * Search expressions can use `mlflowMetric` and `mlflowParam` keys. */ searchRuns(req: SearchRunsRequest, options?: CallOptions): Promise; searchRunsIter(req: SearchRunsRequest, options?: CallOptions): AsyncGenerator; /** Sets a tag on an experiment. Experiment tags are metadata that can be updated. */ setExperimentTag(req: SetExperimentTagRequest, options?: CallOptions): Promise; /** Set tags for a logged model. */ setLoggedModelTags(req: SetLoggedModelTagsRequest, options?: CallOptions): Promise; /** * Sets a tag on a run. Tags are run metadata that can be updated during a run and after * a run completes. */ setTag(req: SetTagRequest, options?: CallOptions): Promise; /** Updates experiment metadata. */ updateExperiment(req: UpdateExperimentRequest, options?: CallOptions): Promise; /** Updates run metadata. */ updateRun(req: UpdateRunRequest, options?: CallOptions): Promise; } //#endregion export { ExperimentsClient }; //# sourceMappingURL=client.d.ts.map