@azure/ai-projects 2.0.0-beta.4 → 2.0.0

package/dist/commonjs/api/datasets/operations.js

@@ -1,346 +1,442 @@
-"use strict";
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._getCredentialsSend = _getCredentialsSend;
-exports._getCredentialsDeserialize = _getCredentialsDeserialize;
-exports.getCredentials = getCredentials;
-exports._pendingUploadSend = _pendingUploadSend;
-exports._pendingUploadDeserialize = _pendingUploadDeserialize;
-exports.pendingUpload = pendingUpload;
-exports._createOrUpdateSend = _createOrUpdateSend;
-exports._createOrUpdateDeserialize = _createOrUpdateDeserialize;
-exports.createOrUpdate = createOrUpdate;
-exports._$deleteSend = _$deleteSend;
-exports._$deleteDeserialize = _$deleteDeserialize;
-exports.$delete = $delete;
-exports._getSend = _getSend;
-exports._getDeserialize = _getDeserialize;
-exports.get = get;
-exports._listSend = _listSend;
-exports._listDeserialize = _listDeserialize;
-exports.list = list;
-exports._listVersionsSend = _listVersionsSend;
-exports._listVersionsDeserialize = _listVersionsDeserialize;
-exports.listVersions = listVersions;
-exports.uploadFile = uploadFile;
-exports.uploadFolder = uploadFolder;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const models_js_1 = require("../../models/models.js");
-const pagingHelpers_js_1 = require("../../static-helpers/pagingHelpers.js");
-const urlTemplate_js_1 = require("../../static-helpers/urlTemplate.js");
-const core_client_1 = require("@azure-rest/core-client");
-const storage_blob_1 = require("@azure/storage-blob");
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operations_exports = {};
+__export(operations_exports, {
+  $delete: () => $delete,
+  _$deleteDeserialize: () => _$deleteDeserialize,
+  _$deleteSend: () => _$deleteSend,
+  _createOrUpdateDeserialize: () => _createOrUpdateDeserialize,
+  _createOrUpdateSend: () => _createOrUpdateSend,
+  _getCredentialsDeserialize: () => _getCredentialsDeserialize,
+  _getCredentialsSend: () => _getCredentialsSend,
+  _getDeserialize: () => _getDeserialize,
+  _getSend: () => _getSend,
+  _listDeserialize: () => _listDeserialize,
+  _listSend: () => _listSend,
+  _listVersionsDeserialize: () => _listVersionsDeserialize,
+  _listVersionsSend: () => _listVersionsSend,
+  _pendingUploadDeserialize: () => _pendingUploadDeserialize,
+  _pendingUploadSend: () => _pendingUploadSend,
+  createOrUpdate: () => createOrUpdate,
+  get: () => get,
+  getCredentials: () => getCredentials,
+  list: () => list,
+  listVersions: () => listVersions,
+  pendingUpload: () => pendingUpload,
+  uploadFile: () => uploadFile,
+  uploadFolder: () => uploadFolder
+});
+module.exports = __toCommonJS(operations_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_models = require("../../models/models.js");
+var import_pagingHelpers = require("../../static-helpers/pagingHelpers.js");
+var import_urlTemplate = require("../../static-helpers/urlTemplate.js");
+var import_core_client = require("@azure-rest/core-client");
+var import_storage_blob = require("@azure/storage-blob");
 function _getCredentialsSend(context, name, version, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets/{name}/versions/{version}/credentials{?api-version}", {
-        name: name,
-        version: version,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).post({
-        ...(0, core_client_1.operationOptionsToRequestParameters)(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets/{name}/versions/{version}/credentials{?api-version}",
+    {
+      name,
+      version,
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: {
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    }
+  });
 }
 async function _getCredentialsDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return (0, models_js_1.datasetCredentialDeserializer)(result.body);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return (0, import_models.datasetCredentialDeserializer)(result.body);
 }
-/** Get the SAS credential to access the storage account associated with a Dataset version. */
 async function getCredentials(context, name, version, options = { requestOptions: {} }) {
-    const result = await _getCredentialsSend(context, name, version, options);
-    return _getCredentialsDeserialize(result);
+  const result = await _getCredentialsSend(context, name, version, options);
+  return _getCredentialsDeserialize(result);
 }
 function _pendingUploadSend(context, name, version, pendingUploadRequest, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets/{name}/versions/{version}/startPendingUpload{?api-version}", {
-        name: name,
-        version: version,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).post({
-        ...(0, core_client_1.operationOptionsToRequestParameters)(options),
-        contentType: "application/json",
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-        body: (0, models_js_1.pendingUploadRequestSerializer)(pendingUploadRequest),
-    });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets/{name}/versions/{version}/startPendingUpload{?api-version}",
+    {
+      name,
+      version,
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).post({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/json",
+    headers: {
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: (0, import_models.pendingUploadRequestSerializer)(pendingUploadRequest)
+  });
 }
 async function _pendingUploadDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return (0, models_js_1.pendingUploadResponseDeserializer)(result.body);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return (0, import_models.pendingUploadResponseDeserializer)(result.body);
 }
-/** Start a new or get an existing pending upload of a dataset for a specific version. */
 async function pendingUpload(context, name, version, pendingUploadRequest, options = { requestOptions: {} }) {
-    const result = await _pendingUploadSend(context, name, version, pendingUploadRequest, options);
-    return _pendingUploadDeserialize(result);
+  const result = await _pendingUploadSend(context, name, version, pendingUploadRequest, options);
+  return _pendingUploadDeserialize(result);
 }
 function _createOrUpdateSend(context, name, version, datasetVersion, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets/{name}/versions/{version}{?api-version}", {
-        name: name,
-        version: version,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).patch({
-        ...(0, core_client_1.operationOptionsToRequestParameters)(options),
-        contentType: "application/merge-patch+json",
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-        body: (0, models_js_1.datasetVersionUnionSerializer)(datasetVersion),
-    });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets/{name}/versions/{version}{?api-version}",
+    {
+      name,
+      version,
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).patch({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    contentType: "application/merge-patch+json",
+    headers: {
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    },
+    body: (0, import_models.datasetVersionUnionSerializer)(datasetVersion)
+  });
 }
 async function _createOrUpdateDeserialize(result) {
-    const expectedStatuses = ["201", "200"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return (0, models_js_1.datasetVersionUnionDeserializer)(result.body);
+  const expectedStatuses = ["201", "200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return (0, import_models.datasetVersionUnionDeserializer)(result.body);
 }
-/** Create a new or update an existing DatasetVersion with the given version id */
 async function createOrUpdate(context, name, version, datasetVersion, options = { requestOptions: {} }) {
-    const result = await _createOrUpdateSend(context, name, version, datasetVersion, options);
-    return _createOrUpdateDeserialize(result);
+  const result = await _createOrUpdateSend(context, name, version, datasetVersion, options);
+  return _createOrUpdateDeserialize(result);
 }
 function _$deleteSend(context, name, version, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets/{name}/versions/{version}{?api-version}", {
-        name: name,
-        version: version,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).delete({ ...(0, core_client_1.operationOptionsToRequestParameters)(options) });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets/{name}/versions/{version}{?api-version}",
+    {
+      name,
+      version,
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).delete({ ...(0, import_core_client.operationOptionsToRequestParameters)(options) });
 }
 async function _$deleteDeserialize(result) {
-    const expectedStatuses = ["204"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return;
+  const expectedStatuses = ["204"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return;
 }
-/** Delete the specific version of the DatasetVersion. The service returns 204 No Content if the DatasetVersion was deleted successfully or if the DatasetVersion does not exist. */
 async function $delete(context, name, version, options = { requestOptions: {} }) {
-    const result = await _$deleteSend(context, name, version, options);
-    return _$deleteDeserialize(result);
+  const result = await _$deleteSend(context, name, version, options);
+  return _$deleteDeserialize(result);
 }
 function _getSend(context, name, version, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets/{name}/versions/{version}{?api-version}", {
-        name: name,
-        version: version,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).get({
-        ...(0, core_client_1.operationOptionsToRequestParameters)(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets/{name}/versions/{version}{?api-version}",
+    {
+      name,
+      version,
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: {
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    }
+  });
 }
 async function _getDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return (0, models_js_1.datasetVersionUnionDeserializer)(result.body);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return (0, import_models.datasetVersionUnionDeserializer)(result.body);
 }
-/** Get the specific version of the DatasetVersion. The service returns 404 Not Found error if the DatasetVersion does not exist. */
 async function get(context, name, version, options = { requestOptions: {} }) {
-    const result = await _getSend(context, name, version, options);
-    return _getDeserialize(result);
+  const result = await _getSend(context, name, version, options);
+  return _getDeserialize(result);
 }
 function _listSend(context, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets{?api-version}", {
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).get({
-        ...(0, core_client_1.operationOptionsToRequestParameters)(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets{?api-version}",
+    {
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: {
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    }
+  });
 }
 async function _listDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return (0, models_js_1._pagedDatasetVersionDeserializer)(result.body);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return (0, import_models._pagedDatasetVersionDeserializer)(result.body);
 }
-/** List the latest version of each DatasetVersion */
 function list(context, options = { requestOptions: {} }) {
-    return (0, pagingHelpers_js_1.buildPagedAsyncIterator)(context, () => _listSend(context, options), _listDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink" });
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listSend(context, options),
+    _listDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion }
+  );
 }
 function _listVersionsSend(context, name, options = { requestOptions: {} }) {
-    const path = (0, urlTemplate_js_1.expandUrlTemplate)("/datasets/{name}/versions{?api-version}", {
-        name: name,
-        "api-version": context.apiVersion,
-    }, {
-        allowReserved: options?.requestOptions?.skipUrlEncoding,
-    });
-    return context.path(path).get({
-        ...(0, core_client_1.operationOptionsToRequestParameters)(options),
-        headers: {
-            accept: "application/json",
-            ...options.requestOptions?.headers,
-        },
-    });
+  const path = (0, import_urlTemplate.expandUrlTemplate)(
+    "/datasets/{name}/versions{?api-version}",
+    {
+      name,
+      "api-version": context.apiVersion
+    },
+    {
+      allowReserved: options?.requestOptions?.skipUrlEncoding
+    }
+  );
+  return context.path(path).get({
+    ...(0, import_core_client.operationOptionsToRequestParameters)(options),
+    headers: {
+      accept: "application/json",
+      ...options.requestOptions?.headers
+    }
+  });
 }
 async function _listVersionsDeserialize(result) {
-    const expectedStatuses = ["200"];
-    if (!expectedStatuses.includes(result.status)) {
-        throw (0, core_client_1.createRestError)(result);
-    }
-    return (0, models_js_1._pagedDatasetVersionDeserializer)(result.body);
+  const expectedStatuses = ["200"];
+  if (!expectedStatuses.includes(result.status)) {
+    throw (0, import_core_client.createRestError)(result);
+  }
+  return (0, import_models._pagedDatasetVersionDeserializer)(result.body);
 }
-/** List all versions of the given DatasetVersion */
 function listVersions(context, name, options = { requestOptions: {} }) {
-    return (0, pagingHelpers_js_1.buildPagedAsyncIterator)(context, () => _listVersionsSend(context, name, options), _listVersionsDeserialize, ["200"], { itemName: "value", nextLinkName: "nextLink" });
+  return (0, import_pagingHelpers.buildPagedAsyncIterator)(
+    context,
+    () => _listVersionsSend(context, name, options),
+    _listVersionsDeserialize,
+    ["200"],
+    { itemName: "value", nextLinkName: "nextLink", apiVersion: context.apiVersion }
+  );
 }
-// Internal helper method to create a new dataset and return a ContainerClient from azure-storage-blob package, to the dataset's blob storage.
 async function createDatasetAndGetItsContainer(context, name, version, options) {
-    const { connectionName, projectOptions = {} } = options || {};
-    // Start a pending upload to get the container URL with SAS token
-    const pendingUploadResponse = await pendingUpload(context, name, version, {
-        pendingUploadType: "BlobReference",
-        connectionName,
-    });
-    const blobReference = pendingUploadResponse.blobReference;
-    // Validate the response
-    if (!blobReference) {
-        throw new Error("Blob reference for consumption is not present");
-    }
-    if (!blobReference.credential?.type) {
-        throw new Error("Credential type is not present");
-    }
-    if (blobReference.credential.type !== "SAS") {
-        throw new Error("Credential type is not SAS");
-    }
-    if (!blobReference.blobUri) {
-        throw new Error("Blob URI is not present or empty");
-    }
-    // Optional debug logging
-    console.debug(`[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadId = ${pendingUploadResponse.pendingUploadId}`);
-    console.debug(`[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadType = ${pendingUploadResponse.pendingUploadType}`);
-    console.debug(`[createDatasetAndGetItsContainer] blobReference.blobUri = ${blobReference.blobUri}`);
-    console.debug(`[createDatasetAndGetItsContainer] blobReference.storageAccountArmId = ${blobReference.storageAccountArmId}`);
-    console.debug(`[createDatasetAndGetItsContainer] blobReference.credential.sasUri = ${blobReference.credential.sasUri}`);
-    console.debug(`[createDatasetAndGetItsContainer] blobReference.credential.type = ${blobReference.credential.type}`);
-    // Create container client from the blob URI (which includes the SAS token)
-    const containerClient = new storage_blob_1.ContainerClient(blobReference.credential.sasUri);
-    const pipeline = containerClient["storageClientContext"].pipeline;
-    for (const { policy } of projectOptions.additionalPolicies ?? []) {
-        pipeline.addPolicy(policy, { afterPhase: "Sign" });
-    }
-    return {
-        containerClient,
-        version,
-    };
+  const { connectionName, projectOptions = {} } = options || {};
+  const pendingUploadResponse = await pendingUpload(context, name, version, {
+    pendingUploadType: "BlobReference",
+    connectionName
+  });
+  const blobReference = pendingUploadResponse.blobReference;
+  if (!blobReference) {
+    throw new Error("Blob reference for consumption is not present");
+  }
+  if (!blobReference.credential?.type) {
+    throw new Error("Credential type is not present");
+  }
+  if (blobReference.credential.type !== "SAS") {
+    throw new Error("Credential type is not SAS");
+  }
+  if (!blobReference.blobUri) {
+    throw new Error("Blob URI is not present or empty");
+  }
+  console.debug(
+    `[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadId = ${pendingUploadResponse.pendingUploadId}`
+  );
+  console.debug(
+    `[createDatasetAndGetItsContainer] pendingUploadResponse.pendingUploadType = ${pendingUploadResponse.pendingUploadType}`
+  );
+  console.debug(
+    `[createDatasetAndGetItsContainer] blobReference.blobUri = ${blobReference.blobUri}`
+  );
+  console.debug(
+    `[createDatasetAndGetItsContainer] blobReference.storageAccountArmId = ${blobReference.storageAccountArmId}`
+  );
+  console.debug(
+    `[createDatasetAndGetItsContainer] blobReference.credential.sasUri = ${blobReference.credential.sasUri}`
+  );
+  console.debug(
+    `[createDatasetAndGetItsContainer] blobReference.credential.type = ${blobReference.credential.type}`
+  );
+  const containerClient = new import_storage_blob.ContainerClient(blobReference.credential.sasUri);
+  const pipeline = containerClient["storageClientContext"].pipeline;
+  for (const { policy } of projectOptions.additionalPolicies ?? []) {
+    pipeline.addPolicy(policy, { afterPhase: "Sign" });
+  }
+  return {
+    containerClient,
+    version
+  };
 }
 async function uploadFile(context, name, version, filePath, options) {
-    // if file does not exist
-    const fileExists = node_fs_1.default.existsSync(filePath);
-    if (!fileExists) {
-        throw new Error(`File does not exist at path: ${filePath}`);
-    }
-    // Check if the file is a directory
-    const isDirectory = node_fs_1.default.lstatSync(filePath).isDirectory();
-    if (isDirectory) {
-        throw new Error(`The provided file is actually a folder. Use method uploadFolder instead`);
-    }
-    const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(context, name, version, options);
-    // file name as blob name
-    const blobName = node_path_1.default.basename(filePath);
-    const blockBlobClient = containerClient.getBlockBlobClient(blobName);
-    await blockBlobClient.uploadStream(node_fs_1.default.createReadStream(filePath));
-    const datasetVersion = await createOrUpdate(context, name, outputVersion, {
-        name: name,
-        version: outputVersion,
-        type: "uri_file",
-        dataUri: blockBlobClient.url,
-    });
-    return datasetVersion;
+  const fileExists = import_node_fs.default.existsSync(filePath);
+  if (!fileExists) {
+    throw new Error(`File does not exist at path: ${filePath}`);
+  }
+  const isDirectory = import_node_fs.default.lstatSync(filePath).isDirectory();
+  if (isDirectory) {
+    throw new Error(`The provided file is actually a folder. Use method uploadFolder instead`);
+  }
+  const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(
+    context,
+    name,
+    version,
+    options
+  );
+  const blobName = import_node_path.default.basename(filePath);
+  const blockBlobClient = containerClient.getBlockBlobClient(blobName);
+  await blockBlobClient.uploadStream(import_node_fs.default.createReadStream(filePath));
+  const datasetVersion = await createOrUpdate(context, name, outputVersion, {
+    name,
+    version: outputVersion,
+    type: "uri_file",
+    dataUri: blockBlobClient.url
+  });
+  return datasetVersion;
 }
 async function uploadFolder(context, name, version, folderPath, options) {
-    // Check if the folder exists
-    const folderExists = node_fs_1.default.existsSync(folderPath);
-    if (!folderExists) {
-        throw new Error(`Folder does not exist at path: ${folderPath}`);
-    }
-    // Check if the folder is a file
-    const isFile = node_fs_1.default.lstatSync(folderPath).isFile();
-    if (isFile) {
-        throw new Error(`The provided path is actually a file. Use method uploadFile instead`);
-    }
-    const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(context, name, version, options);
-    // Helper function to recursively get all files in a directory
-    async function getAllFiles(dir, fileList = []) {
-        const files = await node_fs_1.default.promises.readdir(dir);
-        for (const file of files) {
-            const filePath = `${dir}/${file}`;
-            const stat = await node_fs_1.default.promises.lstat(filePath);
-            if (stat.isDirectory()) {
-                await getAllFiles(filePath, fileList);
-            }
-            else {
-                fileList.push(filePath);
-            }
-        }
-        return fileList;
-    }
-    // Get all files in the folder
-    const allFiles = await getAllFiles(folderPath);
-    let filteredFiles = allFiles;
-    if (options?.filePattern) {
-        filteredFiles = allFiles.filter((file) => options.filePattern?.test(file));
-    }
-    if (filteredFiles.length === 0) {
-        throw new Error("The provided folder is empty.");
+  const folderExists = import_node_fs.default.existsSync(folderPath);
+  if (!folderExists) {
+    throw new Error(`Folder does not exist at path: ${folderPath}`);
+  }
+  const isFile = import_node_fs.default.lstatSync(folderPath).isFile();
+  if (isFile) {
+    throw new Error(`The provided path is actually a file. Use method uploadFile instead`);
+  }
+  const { containerClient, version: outputVersion } = await createDatasetAndGetItsContainer(
+    context,
+    name,
+    version,
+    options
+  );
+  async function getAllFiles(dir, fileList = []) {
+    const files = await import_node_fs.default.promises.readdir(dir);
+    for (const file of files) {
+      const filePath = `${dir}/${file}`;
+      const stat = await import_node_fs.default.promises.lstat(filePath);
+      if (stat.isDirectory()) {
+        await getAllFiles(filePath, fileList);
+      } else {
+        fileList.push(filePath);
+      }
     }
-    // Upload each file to blob storage while maintaining relative paths
-    for (const filePath of filteredFiles) {
-        // Create blob name as relative path from the base folder
-        const relativePath = node_path_1.default.relative(folderPath, filePath).split(node_path_1.default.sep).join("/");
-        console.debug(`[uploadFolderAndCreate] Start uploading file '${filePath}' as blob '${relativePath}'`);
-        // Get a block blob client for the relative path
-        const blobClient = containerClient.getBlockBlobClient(relativePath);
-        // Upload the file using a readable stream for better performance
-        const fileStream = node_fs_1.default.createReadStream(filePath);
-        await blobClient.uploadStream(fileStream);
-        console.debug(`[uploadFolderAndCreate] Done uploading file '${filePath}' as blob '${relativePath}'`);
+    return fileList;
+  }
+  const allFiles = await getAllFiles(folderPath);
+  let filteredFiles = allFiles;
+  if (options?.filePattern) {
+    try {
+      const filePattern = new RegExp(options.filePattern);
+      filteredFiles = allFiles.filter((file) => filePattern.test(file));
+    } catch {
     }
-    // Create dataset version that references this folder
-    const datasetVersion = await createOrUpdate(context, name, outputVersion, {
-        name: name,
-        version: outputVersion,
-        type: "uri_folder",
-        dataUri: containerClient.url,
-    });
-    return datasetVersion;
+  }
+  if (filteredFiles.length === 0) {
+    throw new Error("The provided folder is empty.");
+  }
+  for (const filePath of filteredFiles) {
+    const relativePath = import_node_path.default.relative(folderPath, filePath).split(import_node_path.default.sep).join("/");
+    console.debug(
+      `[uploadFolderAndCreate] Start uploading file '${filePath}' as blob '${relativePath}'`
+    );
+    const blobClient = containerClient.getBlockBlobClient(relativePath);
+    const fileStream = import_node_fs.default.createReadStream(filePath);
+    await blobClient.uploadStream(fileStream);
+    console.debug(
+      `[uploadFolderAndCreate] Done uploading file '${filePath}' as blob '${relativePath}'`
+    );
+  }
+  const datasetVersion = await createOrUpdate(context, name, outputVersion, {
+    name,
+    version: outputVersion,
+    type: "uri_folder",
+    dataUri: containerClient.url
+  });
+  return datasetVersion;
 }
-//# sourceMappingURL=operations.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $delete,
+  _$deleteDeserialize,
+  _$deleteSend,
+  _createOrUpdateDeserialize,
+  _createOrUpdateSend,
+  _getCredentialsDeserialize,
+  _getCredentialsSend,
+  _getDeserialize,
+  _getSend,
+  _listDeserialize,
+  _listSend,
+  _listVersionsDeserialize,
+  _listVersionsSend,
+  _pendingUploadDeserialize,
+  _pendingUploadSend,
+  createOrUpdate,
+  get,
+  getCredentials,
+  list,
+  listVersions,
+  pendingUpload,
+  uploadFile,
+  uploadFolder
+});