@settlemint/sdk-minio 2.1.5 → 2.2.0

package/dist/minio.d.cts

@@ -1,14 +1,14 @@
 import { Client } from 'minio';
+export { Client, ItemBucketMetadata } from 'minio';
 import { z } from 'zod';
+import { Buffer } from 'node:buffer';
 
 /**
- * Schema for validating server client options for the Portal client.
- * Extends the ClientOptionsSchema with additional server-specific fields.
+ * Schema for validating server client options for the MinIO client.
  */
 declare const ServerClientOptionsSchema: z.ZodObject<{
     /** The URL of the MinIO instance to connect to */
     instance: z.ZodString;
-} & {
     /** The MinIO access key used to authenticate with the MinIO server */
     accessKey: z.ZodString;
     /** The MinIO secret key used to authenticate with the MinIO server */
@@ -27,6 +27,168 @@ declare const ServerClientOptionsSchema: z.ZodObject<{
  */
 type ServerClientOptions = z.infer<typeof ServerClientOptionsSchema>;
 
+/**
+ * Type representing file metadata after validation.
+ */
+interface FileMetadata {
+    /**
+     * The unique identifier for the file.
+     */
+    id: string;
+    /**
+     * The name of the file.
+     */
+    name: string;
+    /**
+     * The content type of the file.
+     */
+    contentType: string;
+    /**
+     * The size of the file in bytes.
+     */
+    size: number;
+    /**
+     * The date and time the file was uploaded.
+     */
+    uploadedAt: string;
+    /**
+     * The ETag of the file.
+     */
+    etag: string;
+    /**
+     * The URL of the file.
+     */
+    url?: string;
+}
+/**
+ * Default bucket name to use for file storage when none is specified.
+ */
+declare const DEFAULT_BUCKET = "uploads";
+
+/**
+ * Gets a list of files with optional prefix filter
+ *
+ * @param client - The MinIO client to use
+ * @param prefix - Optional prefix to filter files (like a folder path)
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns Array of file metadata objects
+ * @throws Will throw an error if the operation fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, getFilesList } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * const files = await getFilesList(client, "documents/");
+ */
+declare function getFilesList(client: Client, prefix?: string, bucket?: string): Promise<FileMetadata[]>;
+/**
+ * Gets a single file by its object name
+ *
+ * @param client - The MinIO client to use
+ * @param fileId - The file identifier/path
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns File metadata with presigned URL
+ * @throws Will throw an error if the file doesn't exist or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, getFileByObjectName } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * const file = await getFileByObjectName(client, "documents/report.pdf");
+ */
+declare function getFileById(client: Client, fileId: string, bucket?: string): Promise<FileMetadata>;
+/**
+ * Deletes a file from storage
+ *
+ * @param client - The MinIO client to use
+ * @param fileId - The file identifier/path
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns Success status
+ * @throws Will throw an error if deletion fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, deleteFile } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * await deleteFile(client, "documents/report.pdf");
+ */
+declare function deleteFile(client: Client, fileId: string, bucket?: string): Promise<boolean>;
+/**
+ * Creates a presigned upload URL for direct browser uploads
+ *
+ * @param client - The MinIO client to use
+ * @param fileName - The file name to use
+ * @param path - Optional path/folder
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @param expirySeconds - How long the URL should be valid for
+ * @returns Presigned URL for PUT operation
+ * @throws Will throw an error if URL creation fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, createPresignedUploadUrl } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * // Generate the presigned URL on the server
+ * const url = await createPresignedUploadUrl(client, "report.pdf", "documents/");
+ *
+ * // Send the URL to the client/browser via HTTP response
+ * return Response.json({ uploadUrl: url });
+ *
+ * // Then in the browser:
+ * const response = await fetch('/api/get-upload-url');
+ * const { uploadUrl } = await response.json();
+ * await fetch(uploadUrl, {
+ *  method: 'PUT',
+ *  headers: { 'Content-Type': 'application/pdf' },
+ *  body: pdfFile
+ * });
+ */
+declare function createPresignedUploadUrl(client: Client, fileName: string, path?: string, bucket?: string, expirySeconds?: number): Promise<string>;
+/**
+ * Uploads a buffer directly to storage
+ *
+ * @param client - The MinIO client to use
+ * @param buffer - The buffer to upload
+ * @param objectName - The full object name/path
+ * @param contentType - The content type of the file
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns The uploaded file metadata
+ * @throws Will throw an error if upload fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, uploadBuffer } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * const buffer = Buffer.from("Hello, world!");
+ * const uploadedFile = await uploadFile(client, buffer, "documents/hello.txt", "text/plain");
+ */
+declare function uploadFile(client: Client, buffer: Buffer, objectName: string, contentType: string, bucket?: string): Promise<FileMetadata>;
+
 /**
  * Creates a MinIO client for server-side use with authentication.
  *
@@ -48,4 +210,4 @@ declare function createServerMinioClient(options: ServerClientOptions): {
     client: Client;
 };
 
-export { createServerMinioClient };
+export { DEFAULT_BUCKET, type FileMetadata, createPresignedUploadUrl, createServerMinioClient, deleteFile, getFileById, getFilesList, uploadFile };

package/dist/minio.d.ts

@@ -1,14 +1,14 @@
 import { Client } from 'minio';
+export { Client, ItemBucketMetadata } from 'minio';
 import { z } from 'zod';
+import { Buffer } from 'node:buffer';
 
 /**
- * Schema for validating server client options for the Portal client.
- * Extends the ClientOptionsSchema with additional server-specific fields.
+ * Schema for validating server client options for the MinIO client.
  */
 declare const ServerClientOptionsSchema: z.ZodObject<{
     /** The URL of the MinIO instance to connect to */
     instance: z.ZodString;
-} & {
     /** The MinIO access key used to authenticate with the MinIO server */
     accessKey: z.ZodString;
     /** The MinIO secret key used to authenticate with the MinIO server */
@@ -27,6 +27,168 @@ declare const ServerClientOptionsSchema: z.ZodObject<{
  */
 type ServerClientOptions = z.infer<typeof ServerClientOptionsSchema>;
 
+/**
+ * Type representing file metadata after validation.
+ */
+interface FileMetadata {
+    /**
+     * The unique identifier for the file.
+     */
+    id: string;
+    /**
+     * The name of the file.
+     */
+    name: string;
+    /**
+     * The content type of the file.
+     */
+    contentType: string;
+    /**
+     * The size of the file in bytes.
+     */
+    size: number;
+    /**
+     * The date and time the file was uploaded.
+     */
+    uploadedAt: string;
+    /**
+     * The ETag of the file.
+     */
+    etag: string;
+    /**
+     * The URL of the file.
+     */
+    url?: string;
+}
+/**
+ * Default bucket name to use for file storage when none is specified.
+ */
+declare const DEFAULT_BUCKET = "uploads";
+
+/**
+ * Gets a list of files with optional prefix filter
+ *
+ * @param client - The MinIO client to use
+ * @param prefix - Optional prefix to filter files (like a folder path)
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns Array of file metadata objects
+ * @throws Will throw an error if the operation fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, getFilesList } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * const files = await getFilesList(client, "documents/");
+ */
+declare function getFilesList(client: Client, prefix?: string, bucket?: string): Promise<FileMetadata[]>;
+/**
+ * Gets a single file by its object name
+ *
+ * @param client - The MinIO client to use
+ * @param fileId - The file identifier/path
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns File metadata with presigned URL
+ * @throws Will throw an error if the file doesn't exist or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, getFileByObjectName } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * const file = await getFileByObjectName(client, "documents/report.pdf");
+ */
+declare function getFileById(client: Client, fileId: string, bucket?: string): Promise<FileMetadata>;
+/**
+ * Deletes a file from storage
+ *
+ * @param client - The MinIO client to use
+ * @param fileId - The file identifier/path
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns Success status
+ * @throws Will throw an error if deletion fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, deleteFile } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * await deleteFile(client, "documents/report.pdf");
+ */
+declare function deleteFile(client: Client, fileId: string, bucket?: string): Promise<boolean>;
+/**
+ * Creates a presigned upload URL for direct browser uploads
+ *
+ * @param client - The MinIO client to use
+ * @param fileName - The file name to use
+ * @param path - Optional path/folder
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @param expirySeconds - How long the URL should be valid for
+ * @returns Presigned URL for PUT operation
+ * @throws Will throw an error if URL creation fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, createPresignedUploadUrl } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * // Generate the presigned URL on the server
+ * const url = await createPresignedUploadUrl(client, "report.pdf", "documents/");
+ *
+ * // Send the URL to the client/browser via HTTP response
+ * return Response.json({ uploadUrl: url });
+ *
+ * // Then in the browser:
+ * const response = await fetch('/api/get-upload-url');
+ * const { uploadUrl } = await response.json();
+ * await fetch(uploadUrl, {
+ *  method: 'PUT',
+ *  headers: { 'Content-Type': 'application/pdf' },
+ *  body: pdfFile
+ * });
+ */
+declare function createPresignedUploadUrl(client: Client, fileName: string, path?: string, bucket?: string, expirySeconds?: number): Promise<string>;
+/**
+ * Uploads a buffer directly to storage
+ *
+ * @param client - The MinIO client to use
+ * @param buffer - The buffer to upload
+ * @param objectName - The full object name/path
+ * @param contentType - The content type of the file
+ * @param bucket - Optional bucket name (defaults to DEFAULT_BUCKET)
+ * @returns The uploaded file metadata
+ * @throws Will throw an error if upload fails or client initialization fails
+ *
+ * @example
+ * import { createServerMinioClient, uploadBuffer } from "@settlemint/sdk-minio";
+ *
+ * const { client } = createServerMinioClient({
+ *   instance: process.env.SETTLEMINT_MINIO_ENDPOINT!,
+ *   accessKey: process.env.SETTLEMINT_MINIO_ACCESS_KEY!,
+ *   secretKey: process.env.SETTLEMINT_MINIO_SECRET_KEY!
+ * });
+ *
+ * const buffer = Buffer.from("Hello, world!");
+ * const uploadedFile = await uploadFile(client, buffer, "documents/hello.txt", "text/plain");
+ */
+declare function uploadFile(client: Client, buffer: Buffer, objectName: string, contentType: string, bucket?: string): Promise<FileMetadata>;
+
 /**
  * Creates a MinIO client for server-side use with authentication.
  *
@@ -48,4 +210,4 @@ declare function createServerMinioClient(options: ServerClientOptions): {
     client: Client;
 };
 
-export { createServerMinioClient };
+export { DEFAULT_BUCKET, type FileMetadata, createPresignedUploadUrl, createServerMinioClient, deleteFile, getFileById, getFilesList, uploadFile };

package/dist/minio.mjs

@@ -1,26 +1,252 @@
 // src/minio.ts
-import { ensureServer } from "@settlemint/sdk-utils/runtime";
-import { validate } from "@settlemint/sdk-utils/validation";
+import { ensureServer as ensureServer3 } from "@settlemint/sdk-utils/runtime";
+import { validate as validate2 } from "@settlemint/sdk-utils/validation";
 import { Client } from "minio";
 
 // src/helpers/client-options.schema.ts
 import { UrlSchema } from "@settlemint/sdk-utils/validation";
 import { z } from "zod";
-var ClientOptionsSchema = z.object({
+var ServerClientOptionsSchema = z.object({
   /** The URL of the MinIO instance to connect to */
-  instance: UrlSchema
-});
-var ServerClientOptionsSchema = ClientOptionsSchema.extend({
+  instance: UrlSchema,
   /** The MinIO access key used to authenticate with the MinIO server */
   accessKey: z.string(),
   /** The MinIO secret key used to authenticate with the MinIO server */
   secretKey: z.string()
 });
 
+// src/helpers/schema.ts
+import { z as z2 } from "zod";
+var FileMetadataSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  contentType: z2.string(),
+  size: z2.number(),
+  uploadedAt: z2.string().datetime(),
+  etag: z2.string(),
+  url: z2.string().url().optional()
+});
+var DEFAULT_BUCKET = "uploads";
+
+// src/helpers/functions.ts
+import { ensureServer as ensureServer2 } from "@settlemint/sdk-utils/runtime";
+import { validate } from "@settlemint/sdk-utils/validation";
+
+// src/helpers/executor.ts
+import { ensureServer } from "@settlemint/sdk-utils/runtime";
+async function executeMinioOperation(client, operation) {
+  ensureServer();
+  return operation.execute(client);
+}
+
+// src/helpers/operations.ts
+function createListObjectsOperation(bucket, prefix = "") {
+  return {
+    execute: async (client) => {
+      const objectsStream = client.listObjects(bucket, prefix, true);
+      const objects = [];
+      return new Promise((resolve, reject) => {
+        objectsStream.on("data", (obj) => {
+          if (obj.name && typeof obj.size === "number" && obj.etag && obj.lastModified) {
+            objects.push({
+              name: obj.name,
+              prefix: obj.prefix,
+              size: obj.size,
+              etag: obj.etag,
+              lastModified: obj.lastModified
+            });
+          }
+        });
+        objectsStream.on("error", (err) => {
+          reject(err);
+        });
+        objectsStream.on("end", () => {
+          resolve(objects);
+        });
+      });
+    }
+  };
+}
+function createStatObjectOperation(bucket, objectName) {
+  return {
+    execute: async (client) => {
+      return client.statObject(bucket, objectName);
+    }
+  };
+}
+function createDeleteOperation(bucket, objectName) {
+  return {
+    execute: async (client) => {
+      return client.removeObject(bucket, objectName);
+    }
+  };
+}
+function createPresignedUrlOperation(bucket, objectName, expirySeconds) {
+  return {
+    execute: async (client) => {
+      return client.presignedGetObject(bucket, objectName, expirySeconds);
+    }
+  };
+}
+function createPresignedPutOperation(bucket, objectName, expirySeconds) {
+  return {
+    execute: async (client) => {
+      return client.presignedPutObject(bucket, objectName, expirySeconds);
+    }
+  };
+}
+function createSimpleUploadOperation(client) {
+  return async (buffer, bucket, objectName, metadata) => {
+    return client.putObject(bucket, objectName, buffer, void 0, metadata);
+  };
+}
+
+// src/helpers/functions.ts
+function normalizePath(path, fileName) {
+  if (path.length > 1e3) {
+    throw new Error("Path is too long");
+  }
+  const cleanPath = path.replace(/\/+$/, "");
+  if (!cleanPath) {
+    return fileName;
+  }
+  return `${cleanPath}/${fileName}`;
+}
+async function getFilesList(client, prefix = "", bucket = DEFAULT_BUCKET) {
+  ensureServer2();
+  console.log(`Listing files with prefix: "${prefix}" in bucket: "${bucket}"`);
+  try {
+    const listOperation = createListObjectsOperation(bucket, prefix);
+    const objects = await executeMinioOperation(client, listOperation);
+    console.log(`Found ${objects.length} files in MinIO`);
+    const fileObjects = await Promise.all(
+      objects.map(async (obj) => {
+        const presignedUrlOperation = createPresignedUrlOperation(
+          bucket,
+          obj.name,
+          3600
+          // 1 hour expiry
+        );
+        const url = await executeMinioOperation(client, presignedUrlOperation);
+        return {
+          id: obj.name,
+          name: obj.name.split("/").pop() || obj.name,
+          contentType: "application/octet-stream",
+          // Default type
+          size: obj.size,
+          uploadedAt: obj.lastModified.toISOString(),
+          etag: obj.etag,
+          url
+        };
+      })
+    );
+    return validate(FileMetadataSchema.array(), fileObjects);
+  } catch (error) {
+    console.error("Failed to list files:", error);
+    throw new Error(`Failed to list files: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function getFileById(client, fileId, bucket = DEFAULT_BUCKET) {
+  ensureServer2();
+  console.log(`Getting file details for: ${fileId} in bucket: ${bucket}`);
+  try {
+    const statOperation = createStatObjectOperation(bucket, fileId);
+    const statResult = await executeMinioOperation(client, statOperation);
+    const presignedUrlOperation = createPresignedUrlOperation(
+      bucket,
+      fileId,
+      3600
+      // 1 hour expiry
+    );
+    const url = await executeMinioOperation(client, presignedUrlOperation);
+    let size = 0;
+    if (statResult.metaData["content-length"]) {
+      const parsedSize = Number.parseInt(statResult.metaData["content-length"], 10);
+      if (!Number.isNaN(parsedSize)) {
+        size = parsedSize;
+      }
+    } else if (typeof statResult.size === "number" && !Number.isNaN(statResult.size)) {
+      size = statResult.size;
+    }
+    const fileMetadata = {
+      id: fileId,
+      name: fileId.split("/").pop() || fileId,
+      contentType: statResult.metaData["content-type"] || "application/octet-stream",
+      size,
+      uploadedAt: statResult.lastModified.toISOString(),
+      etag: statResult.etag,
+      url
+    };
+    return validate(FileMetadataSchema, fileMetadata);
+  } catch (error) {
+    console.error(`Failed to get file ${fileId}:`, error);
+    throw new Error(`Failed to get file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function deleteFile(client, fileId, bucket = DEFAULT_BUCKET) {
+  ensureServer2();
+  try {
+    const deleteOperation = createDeleteOperation(bucket, fileId);
+    await executeMinioOperation(client, deleteOperation);
+    return true;
+  } catch (error) {
+    console.error(`Failed to delete file ${fileId}:`, error);
+    throw new Error(`Failed to delete file ${fileId}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function createPresignedUploadUrl(client, fileName, path = "", bucket = DEFAULT_BUCKET, expirySeconds = 3600) {
+  ensureServer2();
+  try {
+    const safeFileName = fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const objectName = normalizePath(path, safeFileName);
+    const presignedPutOperation = createPresignedPutOperation(bucket, objectName, expirySeconds);
+    const url = await executeMinioOperation(client, presignedPutOperation);
+    if (!url) {
+      throw new Error("Failed to generate presigned upload URL");
+    }
+    return url;
+  } catch (error) {
+    console.error("Failed to create presigned upload URL:", error);
+    throw new Error(`Failed to create presigned upload URL: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function uploadFile(client, buffer, objectName, contentType, bucket = DEFAULT_BUCKET) {
+  ensureServer2();
+  try {
+    const metadata = {
+      "content-type": contentType,
+      "upload-time": (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const simpleUploadFn = createSimpleUploadOperation(client);
+    const result = await simpleUploadFn(buffer, bucket, objectName, metadata);
+    const presignedUrlOperation = createPresignedUrlOperation(
+      bucket,
+      objectName,
+      3600
+      // 1 hour expiry
+    );
+    const url = await executeMinioOperation(client, presignedUrlOperation);
+    const fileName = objectName.split("/").pop() || objectName;
+    const fileMetadata = {
+      id: objectName,
+      name: fileName,
+      contentType,
+      size: buffer.length,
+      uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      etag: result.etag,
+      url
+    };
+    return validate(FileMetadataSchema, fileMetadata);
+  } catch (error) {
+    console.error("Failed to upload file:", error);
+    throw new Error(`Failed to upload file: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
 // src/minio.ts
 function createServerMinioClient(options) {
-  ensureServer();
-  const validatedOptions = validate(ServerClientOptionsSchema, options);
+  ensureServer3();
+  const validatedOptions = validate2(ServerClientOptionsSchema, options);
   const url = new URL(validatedOptions.instance);
   return {
     client: new Client({
@@ -34,6 +260,12 @@ function createServerMinioClient(options) {
   };
 }
 export {
-  createServerMinioClient
+  DEFAULT_BUCKET,
+  createPresignedUploadUrl,
+  createServerMinioClient,
+  deleteFile,
+  getFileById,
+  getFilesList,
+  uploadFile
 };
 //# sourceMappingURL=minio.mjs.map