@meistrari/vault-sdk 1.9.0 → 2.0.0

package/dist/index.cjs

@@ -237,7 +237,7 @@ function getFileName(content) {
 }
 
 const name = "@meistrari/vault-sdk";
-const version = "1.9.0";
+const version = "2.0.0";
 const license = "UNLICENSED";
 const repository = {
 	type: "git",
@@ -264,8 +264,8 @@ const scripts = {
 	check: "bun run lint && bun tsc --noEmit"
 };
 const dependencies = {
-	"@meistrari/vault-shared": "workspace:*",
 	"@meistrari/file-type": "22.0.0",
+	"@meistrari/vault-shared": "workspace:*",
 	"mime-types": "3.0.1",
 	ofetch: "1.4.1",
 	zod: "3.23.8"
@@ -326,6 +326,7 @@ async function wrappedFetch(url, requestInit) {
   };
   const request = new Request(url, options);
   request.headers.set("User-Agent", userAgent);
+  request.headers.set("x-compatibility-date", compatibilityDate);
   const response = await fetch(request);
   if (!response.ok) {
     throw await FetchError.from(request.url, request.method, response);
@@ -369,9 +370,7 @@ class VaultFile {
    * @returns The headers for the request
    */
   get headers() {
-    const headers = this.config.authStrategy.getHeaders();
-    headers.set("User-Agent", userAgent);
-    return headers;
+    return this.config.authStrategy.getHeaders();
   }
   /**
    * Performs a request to the vault service and handles the response or errors.
@@ -388,7 +387,6 @@ class VaultFile {
     const { method, path, body, signal, query } = params;
     const url = new URL(path, this.baseUrl);
     const headers = new Headers(this.headers);
-    headers.set("x-compatibility-date", compatibilityDate);
     if (query) {
       Object.entries(query).forEach(([key, value]) => {
         url.searchParams.set(key, value);
@@ -675,6 +673,84 @@ class VaultFile {
     }, { signal: options?.signal });
     return file;
   }
+  /**
+   * Creates multiple VaultFile instances from given content in a single request.
+   *
+   * @param params - Parameters for creating VaultFiles from content
+   * @param params.files - Array of file inputs with content and optional metadata
+   * @param params.config - The configuration for the VaultFiles
+   * @param params.upload - Whether to upload all files (default: false)
+   * @param options - The options for the request
+   * @param options.signal - The signal to abort the request
+   *
+   * @returns Array of new VaultFile instances
+   *
+   * @example
+   * ```ts
+   * const files = await VaultFile.fromContentBulk({
+   *     files: [
+   *         { content: blob1, name: 'file1.txt' },
+   *         { content: blob2, name: 'file2.txt', parentId: 'parent-id' },
+   *     ],
+   *     config: { vaultUrl, authStrategy },
+   *     upload: true
+   * })
+   * ```
+   */
+  static async fromContentBulk(params, options) {
+    const { files: fileInputs, config: vaultConfig, upload = false } = params;
+    const config = resolveConfig(vaultConfig);
+    const preparedFiles = await Promise.all(
+      fileInputs.map(async (input) => {
+        const name = basename(input.name) ?? getFileName(input.content);
+        const sha256sum = await getFileHash(input.content);
+        const mimeType = input.mimeType ?? await detectFileMimeType(input.content);
+        const size = input.content.size;
+        return { ...input, name, sha256sum, mimeType, size };
+      })
+    );
+    const url = new URL("files/bulk", config.vaultUrl);
+    const headers = config.authStrategy.getHeaders();
+    headers.set("Content-Type", "application/json");
+    const body = preparedFiles.map((file) => ({
+      fileName: file.name,
+      sha256sum: file.sha256sum,
+      mimeType: file.mimeType,
+      size: file.size,
+      parentId: file.parentId,
+      onMissingParent: file.onMissingParent,
+      onParentConflict: file.onParentConflict
+    }));
+    const response = await wrappedFetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: options?.signal
+    });
+    const data = await response.json();
+    const vaultFiles = data.map((item, index) => {
+      const file = new VaultFile({
+        config,
+        id: item.id,
+        name: item.metadata?.originalFileName ?? preparedFiles[index].name,
+        content: preparedFiles[index].content,
+        metadata: item.metadata
+      });
+      file.lastUploadUrl = {
+        url: new URL(item.uploadUrl),
+        expiresAt: new Date(item.expiresAt)
+      };
+      return file;
+    });
+    if (upload) {
+      await Promise.all(
+        vaultFiles.map(
+          (file) => file.upload(void 0, void 0, { signal: options?.signal })
+        )
+      );
+    }
+    return vaultFiles;
+  }
   /**
    * Fetches and populates the metadata fields for this VaultFile instance.
    *
@@ -1596,8 +1672,80 @@ class VaultFile {
       options
     );
   }
+  /**
+   * Updates the metadata of this file in the vault.
+   *
+   * This method allows you to modify specific metadata properties of the file, such as renaming it.
+   * The instance's metadata property is automatically updated with the response from the server.
+   * Only the provided parameters will be updated; all other metadata remains unchanged.
+   *
+   * @param params - The metadata properties to update
+   * @param params.name - The new name to assign to the file
+   * @param options - Additional options for the request
+   * @param options.signal - AbortSignal to cancel the request
+   *
+   * @returns A Promise that resolves when the update completes successfully
+   * @throws {Error} If the file ID is not set
+   * @throws {FetchError} If the update request fails
+   *
+   * @example
+   * ```ts
+   * // Rename a file
+   * const vaultFile = await VaultFile.fromVaultReference({
+   *     reference: 'vault://file-id',
+   *     config: { vaultUrl, authStrategy }
+   * })
+   * await vaultFile.updateMetadata({ name: 'new-name.txt' })
+   * console.log('File renamed to:', vaultFile.metadata?.originalFileName)
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Rename a file with abort signal
+   * const controller = new AbortController()
+   * await vaultFile.updateMetadata(
+   *     { name: 'document-v2.pdf' },
+   *     { signal: controller.signal }
+   * )
+   * // Later: controller.abort()
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Rename after upload
+   * const file = new File(['content'], 'temp.txt')
+   * const vaultFile = await VaultFile.fromContent({
+   *     name: 'temp.txt',
+   *     content: file,
+   *     config: { vaultUrl, authStrategy },
+   *     upload: true
+   * })
+   * // Later, rename the file
+   * await vaultFile.updateMetadata({ name: 'final-document.txt' })
+   * ```
+   */
+  async updateMetadata(params, options) {
+    if (!this.id) {
+      throw new Error("File ID is not set");
+    }
+    const updatedMetadata = await this._fetch({
+      method: "PATCH",
+      path: `files/${this.id}`,
+      body: JSON.stringify(params),
+      signal: options?.signal
+    });
+    this.metadata = updatedMetadata;
+  }
 }
 
+const VAULT_REFERENCE_UUID_REGEX = /^vault:\/\/[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const VAULT_REFERENCE_SHA256_REGEX = /^vault:\/\/[a-f0-9]{64}$/i;
+function isValidUuidV4(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid);
+}
+function isValidSha256(sha256) {
+  return /^[a-f0-9]{64}$/i.test(sha256);
+}
 function isS3UrlExpired(url) {
   try {
     const urlObj = new URL(url);
@@ -1621,59 +1769,94 @@ function isS3UrlExpired(url) {
   }
 }
 function isVaultReference(url) {
-  return url.startsWith("vault://") && url.length === 10;
+  return VAULT_REFERENCE_UUID_REGEX.test(url) || VAULT_REFERENCE_SHA256_REGEX.test(url);
 }
-function isVaultFileS3Url(url) {
-  const urlObj = new URL(url);
-  const amzDate = urlObj.searchParams.get("X-Amz-Date");
-  const amzExpires = urlObj.searchParams.get("X-Amz-Expires");
-  return urlObj.hostname.includes("amazonaws.com") && Boolean(amzDate) && Boolean(amzExpires);
+function isPresignedS3Url(url) {
+  try {
+    const urlObj = new URL(url);
+    const amzDate = urlObj.searchParams.get("X-Amz-Date");
+    const amzExpires = urlObj.searchParams.get("X-Amz-Expires");
+    return urlObj.hostname.includes("amazonaws.com") && Boolean(amzDate) && Boolean(amzExpires);
+  } catch {
+    return false;
+  }
 }
 const URL_STRATEGIES = [
-  {
-    separator: "/",
-    extractSegments: ([workspaceId, vaultFileId]) => ({
-      workspaceId,
-      vaultFileId
-    })
-  },
   {
     separator: "_",
     extractSegments: ([vaultFileId, workspaceId]) => ({
       vaultFileId,
       workspaceId
     })
+  },
+  {
+    separator: "/",
+    extractSegments: ([workspaceId, vaultFileId]) => ({
+      workspaceId,
+      vaultFileId
+    })
   }
 ];
-function extractVaultFileIdFromS3Url(url) {
-  if (isVaultReference(url))
-    return vaultUtils__default.file.getFileIdFromVaultReference(url);
+function extractVaultFileIdFromLegacyS3Url(url) {
   try {
-    if (!isVaultFileS3Url(url))
-      return null;
     const urlObj = new URL(url);
     const strategy = URL_STRATEGIES.find((strategy2) => urlObj.pathname.includes(strategy2.separator));
     if (!strategy)
       return null;
-    const segments = urlObj.pathname.split(strategy.separator).filter((segment) => segment.length > 0);
+    const segments = urlObj.pathname.split(strategy.separator).map((segment) => segment.replace(/^\/+|\/+$/g, "")).filter((segment) => segment.length > 0);
     if (segments.length < 2)
       return null;
     const extractedIds = strategy.extractSegments(segments);
-    if (!extractedIds || !extractedIds.vaultFileId || !extractedIds.workspaceId || extractedIds.vaultFileId.length < 32)
+    if (!extractedIds.vaultFileId || !extractedIds.workspaceId || extractedIds.vaultFileId.length < 32)
       return null;
     return extractedIds.vaultFileId;
   } catch {
     return null;
   }
 }
+function extractVaultFileIdFromS3Url(url) {
+  if (isVaultReference(url))
+    return vaultUtils__default.file.getFileIdFromVaultReference(url);
+  if (!isPresignedS3Url(url))
+    return null;
+  if (isTaggedVaultPresignedUrl(url))
+    return getVaultParamsFromS3Url(url)?.fileId ?? null;
+  return extractVaultFileIdFromLegacyS3Url(url);
+}
 function convertS3UrlToVaultReference(url) {
   const vaultFileId = extractVaultFileIdFromS3Url(url);
   return vaultFileId ? `vault://${vaultFileId}` : null;
 }
+function isTaggedVaultPresignedUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    const workspaceId = urlObj.searchParams.get("vault-workspace-id");
+    const fileId = urlObj.searchParams.get("vault-file-id");
+    if (!workspaceId || !fileId) {
+      return false;
+    }
+    const hasWorkspaceId = isValidUuidV4(workspaceId);
+    const hasFileId = isValidSha256(fileId) || isValidUuidV4(fileId);
+    const hasAmazonDomain = urlObj.hostname.endsWith("amazonaws.com");
+    return hasWorkspaceId && hasFileId && hasAmazonDomain;
+  } catch {
+    return false;
+  }
+}
+function getVaultParamsFromS3Url(url) {
+  if (!isTaggedVaultPresignedUrl(url))
+    return null;
+  const urlObj = new URL(url);
+  return {
+    fileId: urlObj.searchParams.get("vault-file-id"),
+    workspaceId: urlObj.searchParams.get("vault-workspace-id"),
+    parentId: urlObj.searchParams.get("vault-parent-id")
+  };
+}
 
 function vaultClient(vaultConfig) {
   const config = resolveConfig(vaultConfig);
-  function createFromContent(nameOrContent, contentOrNameOrOptions, options) {
+  async function createFromContent(nameOrContent, contentOrNameOrOptions, options) {
     const isOptionsObject = (value) => {
       return typeof value === "object" && value !== null && !(value instanceof Blob) && !(value instanceof File);
     };
@@ -1684,7 +1867,7 @@ function vaultClient(vaultConfig) {
       const parentId2 = options?.parentId;
       const mimeType2 = options?.mimeType;
       const upload2 = options?.upload;
-      return VaultFile.fromContent({ content: content2, name: name2, config, parentId: parentId2, mimeType: mimeType2, upload: upload2 }, { signal: signal2 });
+      return await VaultFile.fromContent({ content: content2, name: name2, config, parentId: parentId2, mimeType: mimeType2, upload: upload2 }, { signal: signal2 });
     }
     const content = nameOrContent;
     const name = typeof contentOrNameOrOptions === "string" ? contentOrNameOrOptions : void 0;
@@ -1692,16 +1875,16 @@ function vaultClient(vaultConfig) {
     const parentId = isOptionsObject(contentOrNameOrOptions) ? contentOrNameOrOptions.parentId : options?.parentId;
     const mimeType = isOptionsObject(contentOrNameOrOptions) ? contentOrNameOrOptions.mimeType : options?.mimeType;
     const upload = isOptionsObject(contentOrNameOrOptions) ? contentOrNameOrOptions.upload : options?.upload;
-    return VaultFile.fromContent({ content, name, config, parentId, mimeType, upload }, { signal });
+    return await VaultFile.fromContent({ content, name, config, parentId, mimeType, upload }, { signal });
   }
-  function createFromReference(reference, options) {
-    return VaultFile.fromVaultReference({
+  async function createFromReference(reference, options) {
+    return await VaultFile.fromVaultReference({
       reference,
       config
     }, { signal: options?.signal });
   }
   async function createFromStream(name, contentLength, options) {
-    return VaultFile.fromStream({
+    return await VaultFile.fromStream({
       name,
       contentLength,
       config,
@@ -1709,7 +1892,14 @@ function vaultClient(vaultConfig) {
       parentId: options?.parentId
     }, { signal: options?.signal });
   }
-  return { createFromContent, createFromReference, createFromStream };
+  async function createFromContentBulk(files, options) {
+    return await VaultFile.fromContentBulk({
+      files,
+      config,
+      upload: options?.upload
+    }, { signal: options?.signal });
+  }
+  return { createFromContent, createFromReference, createFromStream, createFromContentBulk };
 }
 
 exports.APIKeyAuthStrategy = APIKeyAuthStrategy;
@@ -1718,6 +1908,9 @@ exports.FetchError = FetchError;
 exports.VaultFile = VaultFile;
 exports.convertS3UrlToVaultReference = convertS3UrlToVaultReference;
 exports.extractVaultFileIdFromS3Url = extractVaultFileIdFromS3Url;
+exports.getVaultParamsFromS3Url = getVaultParamsFromS3Url;
 exports.isS3UrlExpired = isS3UrlExpired;
-exports.isVaultFileS3Url = isVaultFileS3Url;
+exports.isTaggedVaultPresignedUrl = isTaggedVaultPresignedUrl;
+exports.isVaultFileS3Url = isPresignedS3Url;
+exports.isVaultReference = isVaultReference;
 exports.vaultClient = vaultClient;

package/dist/index.d.cts

@@ -89,6 +89,21 @@ type VaultFileParams = {
 };
 type OnMissingParent = 'error' | 'create-as-root';
 type OnParentConflict = 'error' | 'update-parent-id' | 'ignore';
+/**
+ * Parameters for updating metadata of a VaultFile.
+ */
+interface VaultFileUpdateMetadataParams {
+    /** The new name to assign to the file. If not provided, the name will not be changed. */
+    name?: string;
+}
+type BulkFileInput = {
+    content: Blob | File;
+    name?: string;
+    mimeType?: string;
+    parentId?: string;
+    onMissingParent?: OnMissingParent;
+    onParentConflict?: OnParentConflict;
+};
 /**
  * Represents a file in the vault and allows interacting with it.
  *
@@ -343,6 +358,37 @@ declare class VaultFile {
     }, options?: {
         signal?: AbortSignal;
     }): Promise<VaultFile>;
+    /**
+     * Creates multiple VaultFile instances from given content in a single request.
+     *
+     * @param params - Parameters for creating VaultFiles from content
+     * @param params.files - Array of file inputs with content and optional metadata
+     * @param params.config - The configuration for the VaultFiles
+     * @param params.upload - Whether to upload all files (default: false)
+     * @param options - The options for the request
+     * @param options.signal - The signal to abort the request
+     *
+     * @returns Array of new VaultFile instances
+     *
+     * @example
+     * ```ts
+     * const files = await VaultFile.fromContentBulk({
+     *     files: [
+     *         { content: blob1, name: 'file1.txt' },
+     *         { content: blob2, name: 'file2.txt', parentId: 'parent-id' },
+     *     ],
+     *     config: { vaultUrl, authStrategy },
+     *     upload: true
+     * })
+     * ```
+     */
+    static fromContentBulk(params: {
+        files: BulkFileInput[];
+        config: VaultConfig;
+        upload?: boolean;
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<VaultFile[]>;
     /**
      * Fetches and populates the metadata fields for this VaultFile instance.
      *
@@ -1110,6 +1156,61 @@ declare class VaultFile {
      * ```
      */
     createChildFromStream(params: Omit<Parameters<typeof VaultFile.fromStream>[0], 'config' | 'parentId'>, options?: Parameters<typeof VaultFile.fromStream>[1]): Promise<VaultFile>;
+    /**
+     * Updates the metadata of this file in the vault.
+     *
+     * This method allows you to modify specific metadata properties of the file, such as renaming it.
+     * The instance's metadata property is automatically updated with the response from the server.
+     * Only the provided parameters will be updated; all other metadata remains unchanged.
+     *
+     * @param params - The metadata properties to update
+     * @param params.name - The new name to assign to the file
+     * @param options - Additional options for the request
+     * @param options.signal - AbortSignal to cancel the request
+     *
+     * @returns A Promise that resolves when the update completes successfully
+     * @throws {Error} If the file ID is not set
+     * @throws {FetchError} If the update request fails
+     *
+     * @example
+     * ```ts
+     * // Rename a file
+     * const vaultFile = await VaultFile.fromVaultReference({
+     *     reference: 'vault://file-id',
+     *     config: { vaultUrl, authStrategy }
+     * })
+     * await vaultFile.updateMetadata({ name: 'new-name.txt' })
+     * console.log('File renamed to:', vaultFile.metadata?.originalFileName)
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Rename a file with abort signal
+     * const controller = new AbortController()
+     * await vaultFile.updateMetadata(
+     *     { name: 'document-v2.pdf' },
+     *     { signal: controller.signal }
+     * )
+     * // Later: controller.abort()
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Rename after upload
+     * const file = new File(['content'], 'temp.txt')
+     * const vaultFile = await VaultFile.fromContent({
+     *     name: 'temp.txt',
+     *     content: file,
+     *     config: { vaultUrl, authStrategy },
+     *     upload: true
+     * })
+     * // Later, rename the file
+     * await vaultFile.updateMetadata({ name: 'final-document.txt' })
+     * ```
+     */
+    updateMetadata(params: VaultFileUpdateMetadataParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
 }
 
 /**
@@ -1121,19 +1222,41 @@ declare class VaultFile {
  */
 declare function isS3UrlExpired(url: string): boolean;
 /**
- * Checks if a URL is a valid S3 vault URL
- * @param url - The S3 URL to check
- * @returns true if the URL is a valid S3 vault URL, false otherwise
+ * Checks if a URL is a valid vault reference
+ * @param url - The URL to check
+ * @returns true if the URL is a valid vault reference, false otherwise
+ */
+declare function isVaultReference(url: string): boolean;
+/**
+ * Checks if a URL seems like a valid presigned S3 URL, with no additional checks.
+ *
+ * For usage with legacy URLs only. For new URLs, use {@link isTaggedVaultPresignedUrl} instead,
+ * since this function only checks if the URL is a valid S3 URL, not if it was generated by Vault.
+ *
+ * @param url - The URL to check
+ * @returns true if the URL is a valid S3 URL, false otherwise
  */
-declare function isVaultFileS3Url(url: string): boolean;
+declare function isPresignedS3Url(url: string): boolean;
 /**
- * Detects if a URL is an expired S3 vault URL and extracts the vault file ID
- * Returns null if not a vault S3 URL, not expired, or extraction fails
+ * Extracts the vault file ID from an S3 presigned URL.
+ * Supports multiple URL formats: tagged vault URLs, vault references, and legacy URL formats.
+ *
+ * @param url - The S3 URL to extract the vault file ID from
+ * @returns The vault file ID (UUID or SHA-256 hash) if extraction succeeds, null otherwise
+ * @example
+ * // Tagged vault URL
+ * extractVaultFileIdFromS3Url('https://vault-prod.s3.amazonaws.com/file?vault-file-id=abc123...')
+ * // Returns: 'abc123...'
+ *
+ * // Vault reference
+ * extractVaultFileIdFromS3Url('vault://2fce5740-83da-49fe-3f10-b32205893ec0')
+ * // Returns: '2fce5740-83da-49fe-3f10-b32205893ec0'
  */
 declare function extractVaultFileIdFromS3Url(url: string): string | null;
 /**
  * Converts an S3 vault URL to a vault reference format
  * Extracts the vault file ID from the S3 URL path and formats it as vault://[fileId]
+ *
  * @param url - The S3 vault URL to convert
  * @returns A vault reference string (vault://[fileId]) if successful, null if the URL is not a valid vault S3 URL
  * @example
@@ -1141,6 +1264,33 @@ declare function extractVaultFileIdFromS3Url(url: string): string | null;
  * // Returns: 'vault://2fce574083da49fe3f10b32205893ec0bb024fe1c7673fa54927fdfe1d0db9d6'
  */
 declare function convertS3UrlToVaultReference(url: string): string | null;
+/**
+ * Checks if a URL is a tagged vault presigned S3 URL.
+ * Tagged URLs contain vault-specific query parameters (vault-workspace-id, vault-file-id)
+ * that identify the vault workspace and file.
+ *
+ * @param url - The URL to check
+ * @returns true if the URL is a tagged vault presigned URL with valid workspace and file IDs, false otherwise
+ * @example
+ * const isTagged = isTaggedVaultPresignedUrl('https://vault-prod.s3.amazonaws.com/file?vault-workspace-id=abc-123&vault-file-id=def456...')
+ * // Returns: true
+ */
+declare function isTaggedVaultPresignedUrl(url: string): boolean;
+/**
+ * Extracts vault-specific parameters from a tagged vault presigned S3 URL.
+ * Returns workspace ID, file ID, and optional parent ID from the URL query parameters.
+ *
+ * @param url - The tagged vault S3 URL to parse
+ * @returns An object containing fileId, workspaceId, and parentId (if present), or null if the URL is not a tagged vault URL
+ * @example
+ * const params = getVaultParamsFromS3Url('https://vault-prod.s3.amazonaws.com/file?vault-workspace-id=abc-123&vault-file-id=def456&vault-parent-id=parent789')
+ * // Returns: { fileId: 'def456', workspaceId: 'abc-123', parentId: 'parent789' }
+ */
+declare function getVaultParamsFromS3Url(url: string): {
+    fileId: string | null;
+    workspaceId: string | null;
+    parentId: string | null;
+} | null;
 
 declare function vaultClient(vaultConfig: VaultConfig): {
     createFromContent: {
@@ -1171,7 +1321,18 @@ declare function vaultClient(vaultConfig: VaultConfig): {
         signal?: AbortSignal;
         parentId?: string;
     }) => Promise<VaultFile>;
+    createFromContentBulk: (files: Array<{
+        content: Blob | File;
+        name?: string;
+        mimeType?: string;
+        parentId?: string;
+        onMissingParent?: "error" | "create-as-root";
+        onParentConflict?: "error" | "update-parent-id" | "ignore";
+    }>, options?: {
+        upload?: boolean;
+        signal?: AbortSignal;
+    }) => Promise<VaultFile[]>;
 };
 
-export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, VaultFile, convertS3UrlToVaultReference, extractVaultFileIdFromS3Url, isS3UrlExpired, isVaultFileS3Url, vaultClient };
+export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, VaultFile, convertS3UrlToVaultReference, extractVaultFileIdFromS3Url, getVaultParamsFromS3Url, isS3UrlExpired, isTaggedVaultPresignedUrl, isPresignedS3Url as isVaultFileS3Url, isVaultReference, vaultClient };
 export type { AuthStrategy, VaultConfig };