@juanito_boop/w-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,716 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActivityLogSchema: () => ActivityLogSchema,
+  ApiErrorSchema: () => ApiErrorSchema,
+  ApiKeySchema: () => ApiKeySchema,
+  AuthResponseSchema: () => AuthResponseSchema,
+  BulkInsertWinesResultSchema: () => BulkInsertWinesResultSchema,
+  BulkInsertWinesSchema: () => BulkInsertWinesSchema,
+  ClientOptionsSchema: () => ClientOptionsSchema,
+  CreateWineSchema: () => CreateWineSchema,
+  EditWineSchema: () => EditWineSchema,
+  ImgbbAssetSchema: () => ImgbbAssetSchema,
+  ImgbbUploadDataSchema: () => ImgbbUploadDataSchema,
+  InsertWineResultSchema: () => InsertWineResultSchema,
+  LoginDataSchema: () => LoginDataSchema,
+  MagicLinkRequestDataSchema: () => MagicLinkRequestDataSchema,
+  MagicLinkResponseSchema: () => MagicLinkResponseSchema,
+  RealtimeOptionsSchema: () => RealtimeOptionsSchema,
+  RegisterDataSchema: () => RegisterDataSchema,
+  ReusedWineImageSchema: () => ReusedWineImageSchema,
+  RollbackLogSchema: () => RollbackLogSchema,
+  SessionDataSchema: () => SessionDataSchema,
+  ValidateSessionResponseSchema: () => ValidateSessionResponseSchema,
+  WineClient: () => WineClient,
+  WineDataSchema: () => WineDataSchema,
+  WineDetailsSchema: () => WineDetailsSchema,
+  WineSchema: () => WineSchema,
+  createClient: () => createClient,
+  createWsImageFile: () => createWsImageFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http/auth.ts
+function buildQueryString(params) {
+  const query = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value) query.append(key, value);
+  });
+  const str = query.toString();
+  return str ? `?${str}` : "";
+}
+function createAuthHttp(opts) {
+  const fetcher = opts.fetch ?? globalThis.fetch;
+  async function post(path, body) {
+    try {
+      const res = await fetcher(`${opts.baseUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.apiKey ? { "x-api-key": opts.apiKey } : {}
+        },
+        body: JSON.stringify(body)
+      });
+      const json = await res.json().catch(() => null);
+      if (!res.ok) {
+        return {
+          success: false,
+          error: {
+            message: json?.message ?? res.statusText,
+            code: json?.code,
+            statusCode: res.status,
+            details: json
+          }
+        };
+      }
+      return { success: true, data: json };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          message: err instanceof Error ? err.message : "Network error",
+          code: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  async function get(path) {
+    try {
+      const res = await fetcher(`${opts.baseUrl}${path}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.apiKey ? { "x-api-key": opts.apiKey } : {}
+        }
+      });
+      const json = await res.json().catch(() => null);
+      if (!res.ok) {
+        return {
+          success: false,
+          error: {
+            message: json?.message ?? res.statusText,
+            code: json?.code,
+            statusCode: res.status,
+            details: json
+          }
+        };
+      }
+      return { success: true, data: json };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          message: err instanceof Error ? err.message : "Network error",
+          code: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  async function del(path) {
+    try {
+      const res = await fetcher(`${opts.baseUrl}${path}`, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          ...opts.apiKey ? { "x-api-key": opts.apiKey } : {}
+        }
+      });
+      const json = await res.json().catch(() => null);
+      if (!res.ok) {
+        return {
+          success: false,
+          error: {
+            message: json?.message ?? res.statusText,
+            code: json?.code,
+            statusCode: res.status,
+            details: json
+          }
+        };
+      }
+      return { success: true, data: json };
+    } catch (err) {
+      return {
+        success: false,
+        error: {
+          message: err instanceof Error ? err.message : "Network error",
+          code: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  return {
+    register: (data) => post("/auth/register", data),
+    login: (data) => post("/auth/login", data),
+    logout: (data) => post("/auth/logout", data),
+    requestMagicLink: (data) => post("/auth/magic-link/request", data),
+    verifyMagicLink: (token) => post("/auth/magic-link/verify", { token }),
+    createApiKey: (data) => post("/auth/api-keys", data),
+    listApiKeys: (userId) => get(`/auth/api-keys/${userId}`),
+    revokeApiKey: (userId, keyId) => del(`/auth/api-keys/${userId}/${keyId}`),
+    validateSession: (token) => post("/auth/validate-session", { token }),
+    rollbackApiKey: (data) => {
+      const query = buildQueryString({
+        fromActivityId: data.fromActivityId,
+        fromTimestamp: data.fromTimestamp,
+        initiatedBy: data.initiatedBy
+      });
+      return post(
+        `/auth/api-keys/${data.keyId}/rollback${query}`,
+        {}
+      );
+    },
+    verifyMagicLinkWithQuery: (token) => get(`/auth/magic-link/verify?token=${token}`),
+    getSessions: (userId) => get(`/auth/sessions/${userId}`),
+    getLogs: () => get("/auth/logs"),
+    getUserLogs: (userId) => get(`/auth/logs/${userId}`),
+    getRollbackHistory: (keyId, limit = 50) => get(
+      `/auth/rollback-history${buildQueryString({ keyId, limit: String(limit) })}`
+    )
+  };
+}
+
+// src/ws/realtime.ts
+var import_socket = require("socket.io-client");
+async function toBytes(input) {
+  if (input instanceof Uint8Array) {
+    return Array.from(input);
+  }
+  if (input instanceof ArrayBuffer) {
+    return Array.from(new Uint8Array(input));
+  }
+  const arrayBuffer = await input.arrayBuffer();
+  return Array.from(new Uint8Array(arrayBuffer));
+}
+async function createWsImageFile(file, opts) {
+  if (file instanceof Blob) {
+    const detectedMime = opts?.mime ?? file.type;
+    const payload2 = {
+      filename: opts?.filename ?? file.name ?? "image.bin",
+      mime: detectedMime || "application/octet-stream",
+      buffer: await toBytes(file),
+      name: opts?.name,
+      expiration: opts?.expiration
+    };
+    return payload2;
+  }
+  const payload = {
+    filename: opts?.filename ?? "image.bin",
+    mime: opts?.mime ?? "application/octet-stream",
+    buffer: await toBytes(file),
+    name: opts?.name,
+    expiration: opts?.expiration
+  };
+  return payload;
+}
+function createRealtime(opts) {
+  let socket = null;
+  let apiKey = opts.apiKey;
+  const ACK_TIMEOUT_MS = 3e4;
+  function connect() {
+    return new Promise((resolve, reject) => {
+      if (socket?.connected) {
+        resolve();
+        return;
+      }
+      const auth = apiKey ? { apiKey } : void 0;
+      const extraHeaders = apiKey ? { "x-api-key": apiKey } : void 0;
+      let timeoutId;
+      socket = (0, import_socket.io)(opts.baseUrl, {
+        path: "/ws",
+        transports: ["websocket", "polling"],
+        auth,
+        extraHeaders
+      });
+      const handleConnect = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        socket?.off("connect", handleConnect);
+        socket?.off("connect_error", handleError);
+        resolve();
+      };
+      const handleError = (error) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        socket?.off("connect", handleConnect);
+        socket?.off("connect_error", handleError);
+        reject(error);
+      };
+      socket.on("connect", handleConnect);
+      socket.on("connect_error", handleError);
+      timeoutId = setTimeout(() => {
+        socket?.off("connect", handleConnect);
+        socket?.off("connect_error", handleError);
+        reject(new Error("Connection timeout"));
+      }, 5e3);
+    });
+  }
+  function disconnect() {
+    socket?.disconnect();
+    socket = null;
+  }
+  function setApiKey(key) {
+    apiKey = key;
+    if (socket) {
+      disconnect();
+      connect();
+    }
+  }
+  function emitAck(event, payload) {
+    if (!socket) {
+      return Promise.resolve({
+        success: false,
+        error: {
+          message: "Socket no conectado",
+          code: "SOCKET_NOT_CONNECTED"
+        }
+      });
+    }
+    return new Promise((resolve) => {
+      socket.timeout(ACK_TIMEOUT_MS).emit(event, payload, (err, res) => {
+        if (err) {
+          resolve({
+            success: false,
+            error: {
+              message: err.message ?? "Socket error",
+              code: err.code ?? "SOCKET_ERROR",
+              details: err
+            }
+          });
+          return;
+        }
+        if (res?.error) {
+          resolve({
+            success: false,
+            error: {
+              message: res.error.message,
+              code: res.error.code,
+              details: res.error
+            }
+          });
+          return;
+        }
+        resolve({ success: true, data: res });
+      });
+    });
+  }
+  return {
+    connect,
+    disconnect,
+    setApiKey,
+    getWines: () => emitAck("get_wines", void 0),
+    getWinesPage: (page = 1, perPage = 16) => emitAck("get_wines_page", { page, perPage }),
+    insertWine: (data) => emitAck("insert_wine", data),
+    insertBulkWines: (data) => emitAck("insert_bulk_wines", data),
+    editWine: (data) => emitAck("edit_wine", data)
+  };
+}
+
+// src/client.ts
+var WineClient = class {
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error("baseUrl es requerido");
+    }
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.auth = createAuthHttp({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey
+    });
+    this.realtime = createRealtime({
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey
+    });
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+    this.realtime.setApiKey(apiKey);
+  }
+  async connectRealtime() {
+    await this.realtime.connect();
+    return this.realtime;
+  }
+  disconnectRealtime() {
+    this.realtime.disconnect();
+  }
+};
+function createClient(options) {
+  return new WineClient(options);
+}
+
+// src/types.ts
+var import_zod = require("zod");
+
+// src/types/_helpers.ts
+function defineSchema(schema) {
+  return {
+    schema
+  };
+}
+
+// src/types.ts
+var ClientOptionsDef = defineSchema(
+  import_zod.z.object({
+    baseUrl: import_zod.z.url("baseUrl debe ser una URL v\xE1lida"),
+    apiKey: import_zod.z.string().optional()
+  })
+);
+var ApiErrorDef = defineSchema(
+  import_zod.z.object({
+    message: import_zod.z.string(),
+    code: import_zod.z.string().optional(),
+    statusCode: import_zod.z.number().optional(),
+    details: import_zod.z.unknown().optional()
+  })
+);
+var LoginDataDef = defineSchema(
+  import_zod.z.object({
+    email: import_zod.z.email("Email inv\xE1lido"),
+    password: import_zod.z.string().min(1, "Password es requerido")
+  })
+);
+var RegisterDataDef = defineSchema(
+  import_zod.z.object({
+    email: import_zod.z.email("Email inv\xE1lido"),
+    password: import_zod.z.string().min(6, "Password debe tener al menos 6 caracteres"),
+    fullName: import_zod.z.string().optional()
+  })
+);
+var LogoutDataDef = defineSchema(
+  import_zod.z.object({
+    token: import_zod.z.string(),
+    logoutAll: import_zod.z.boolean().optional()
+  })
+);
+var MagicLinkRequestDataDef = defineSchema(
+  import_zod.z.object({
+    email: import_zod.z.email("Email inv\xE1lido"),
+    redirectUrl: import_zod.z.url().optional()
+  })
+);
+var AuthResponseDef = defineSchema(
+  import_zod.z.object({
+    token: import_zod.z.string(),
+    user: import_zod.z.object({
+      id: import_zod.z.uuid(),
+      email: import_zod.z.email(),
+      fullName: import_zod.z.string().optional()
+    }),
+    apiKey: import_zod.z.object({
+      id: import_zod.z.uuid(),
+      key: import_zod.z.string(),
+      name: import_zod.z.string(),
+      expiresAt: import_zod.z.iso.datetime()
+    }).optional()
+  })
+);
+var ApiKeyDef = defineSchema(
+  import_zod.z.object({
+    id: import_zod.z.uuid(),
+    key: import_zod.z.string(),
+    name: import_zod.z.string(),
+    expiresAt: import_zod.z.iso.datetime().optional(),
+    createdAt: import_zod.z.iso.datetime()
+  })
+);
+var MagicLinkResponseDef = defineSchema(
+  import_zod.z.object({
+    success: import_zod.z.boolean(),
+    message: import_zod.z.string(),
+    email: import_zod.z.email()
+  })
+);
+var CreateApiKeyDef = import_zod.z.object({
+  userId: import_zod.z.uuid(),
+  name: import_zod.z.string(),
+  expiresAt: import_zod.z.iso.datetime().optional(),
+  // ISO 8601
+  expiresIn: import_zod.z.number().positive().optional()
+  // Segundos
+});
+var RollbackApiKeyDataDef = import_zod.z.object({
+  keyId: import_zod.z.uuid(),
+  fromActivityId: import_zod.z.uuid().optional(),
+  fromTimestamp: import_zod.z.iso.datetime().optional(),
+  initiatedBy: import_zod.z.string().optional()
+});
+var RollbackResponseDef = import_zod.z.object({
+  success: import_zod.z.boolean(),
+  message: import_zod.z.string(),
+  changesReverted: import_zod.z.number(),
+  errors: import_zod.z.array(import_zod.z.string()),
+  rollbackSince: import_zod.z.iso.datetime().optional()
+});
+var SessionDataDef = defineSchema(
+  import_zod.z.object({
+    id: import_zod.z.uuid(),
+    userId: import_zod.z.uuid(),
+    token: import_zod.z.string(),
+    ipAddress: import_zod.z.string().nullable(),
+    userAgent: import_zod.z.string().nullable(),
+    isActive: import_zod.z.boolean(),
+    lastActivityAt: import_zod.z.iso.datetime(),
+    createdAt: import_zod.z.iso.datetime(),
+    expiresAt: import_zod.z.iso.datetime().nullable()
+  })
+);
+var ValidateSessionResponseDef = defineSchema(
+  import_zod.z.object({
+    valid: import_zod.z.boolean(),
+    userId: import_zod.z.uuid().optional(),
+    sessionId: import_zod.z.uuid().optional()
+  })
+);
+var ActivityLogDef = defineSchema(
+  import_zod.z.object({
+    id: import_zod.z.uuid(),
+    userId: import_zod.z.uuid().nullable().optional(),
+    apiKeyId: import_zod.z.uuid().nullable().optional(),
+    action: import_zod.z.string(),
+    ipAddress: import_zod.z.string().nullable(),
+    userAgent: import_zod.z.string().nullable(),
+    location: import_zod.z.string().nullable(),
+    metadata: import_zod.z.string().nullable(),
+    beforeState: import_zod.z.string().nullable(),
+    afterState: import_zod.z.string().nullable(),
+    tableName: import_zod.z.string().nullable(),
+    recordId: import_zod.z.uuid().nullable(),
+    timestamp: import_zod.z.iso.datetime()
+  })
+);
+var RollbackLogDef = defineSchema(
+  import_zod.z.object({
+    id: import_zod.z.uuid(),
+    apiKeyId: import_zod.z.uuid(),
+    initiatedBy: import_zod.z.uuid().nullable().optional(),
+    status: import_zod.z.string(),
+    changesReverted: import_zod.z.string(),
+    errorMessage: import_zod.z.string().nullable(),
+    createdAt: import_zod.z.iso.datetime(),
+    completedAt: import_zod.z.iso.datetime().nullable().optional()
+  })
+);
+var RealtimeOptionsDef = defineSchema(
+  import_zod.z.object({
+    baseUrl: import_zod.z.url(),
+    apiKey: import_zod.z.string().optional()
+  })
+);
+var WineDataDef = defineSchema(
+  import_zod.z.object({
+    id: import_zod.z.uuid().optional()
+  }).strict()
+);
+var WineDetailsDef = defineSchema(
+  import_zod.z.object({
+    id_detalle: import_zod.z.uuid().nullable().optional(),
+    id_vino: import_zod.z.uuid().nullable().optional(),
+    notas_cata: import_zod.z.string().nullable().optional(),
+    tipo_crianza: import_zod.z.string().nullable().optional(),
+    bodega: import_zod.z.string().nullable().optional()
+  })
+);
+var WineDef = defineSchema(
+  import_zod.z.object({
+    id_vino: import_zod.z.uuid(),
+    nombre: import_zod.z.string(),
+    precio: import_zod.z.number(),
+    url_imagen: import_zod.z.string(),
+    imgbb_delete_url: import_zod.z.string().optional(),
+    image_hash: import_zod.z.string().optional(),
+    descripcion: import_zod.z.string(),
+    nivel_alcohol: import_zod.z.number(),
+    variedades: import_zod.z.array(import_zod.z.string()),
+    pais_importacion: import_zod.z.string(),
+    color_vino: import_zod.z.string(),
+    stock: import_zod.z.number(),
+    capacidad: import_zod.z.number(),
+    wine_details: WineDetailsDef.schema.nullable().optional()
+  })
+);
+var EditWineDef = defineSchema(
+  WineDef.schema.omit({ wine_details: true }).partial().extend({
+    id_vino: import_zod.z.uuid(),
+    wine_details: WineDetailsDef.schema.partial().optional(),
+    image_file: import_zod.z.object({
+      filename: import_zod.z.string().min(1),
+      mime: import_zod.z.string().min(1),
+      buffer: import_zod.z.union([
+        import_zod.z.instanceof(Uint8Array),
+        import_zod.z.array(import_zod.z.number().int().min(0).max(255)),
+        import_zod.z.object({
+          type: import_zod.z.literal("Buffer"),
+          data: import_zod.z.array(import_zod.z.number().int().min(0).max(255))
+        })
+      ]),
+      name: import_zod.z.string().optional(),
+      expiration: import_zod.z.number().int().nonnegative().optional()
+    }).optional()
+  }).strict()
+);
+var CreateWineDef = defineSchema(
+  import_zod.z.object({
+    nombre: import_zod.z.string().min(1, 'El campo "nombre" es obligatorio'),
+    precio: import_zod.z.number().positive("El precio debe ser positivo"),
+    url_imagen: import_zod.z.string().optional(),
+    imgbb_delete_url: import_zod.z.string().optional(),
+    image_hash: import_zod.z.string().optional(),
+    descripcion: import_zod.z.string().optional(),
+    nivel_alcohol: import_zod.z.number().default(0),
+    variedades: import_zod.z.array(import_zod.z.string()).optional(),
+    pais_importacion: import_zod.z.string().optional(),
+    color_vino: import_zod.z.string().optional(),
+    stock: import_zod.z.number().default(0),
+    capacidad: import_zod.z.number().default(750),
+    notas_cata: import_zod.z.string().optional(),
+    tipo_crianza: import_zod.z.string().optional(),
+    bodega: import_zod.z.string().optional(),
+    image_file: import_zod.z.object({
+      filename: import_zod.z.string().min(1),
+      mime: import_zod.z.string().min(1),
+      buffer: import_zod.z.union([
+        import_zod.z.instanceof(Uint8Array),
+        import_zod.z.array(import_zod.z.number().int().min(0).max(255)),
+        import_zod.z.object({
+          type: import_zod.z.literal("Buffer"),
+          data: import_zod.z.array(import_zod.z.number().int().min(0).max(255))
+        })
+      ]),
+      name: import_zod.z.string().optional(),
+      expiration: import_zod.z.number().int().nonnegative().optional()
+    }).optional()
+  })
+);
+var BulkInsertWinesDef = defineSchema(import_zod.z.array(CreateWineDef.schema));
+var BulkInsertWinesResultDef = defineSchema(
+  import_zod.z.object({
+    total: import_zod.z.number(),
+    successful: import_zod.z.number(),
+    failed: import_zod.z.number(),
+    results: import_zod.z.array(
+      import_zod.z.object({
+        insertado_id: import_zod.z.string().nullable(),
+        error: import_zod.z.string().nullable()
+      })
+    )
+  })
+);
+var ReusedWineImageDef = defineSchema(
+  import_zod.z.object({
+    url: import_zod.z.string(),
+    delete_url: import_zod.z.string()
+  })
+);
+var ImgbbAssetDef = defineSchema(
+  import_zod.z.object({
+    filename: import_zod.z.string(),
+    name: import_zod.z.string(),
+    mime: import_zod.z.string(),
+    extension: import_zod.z.string(),
+    url: import_zod.z.string()
+  })
+);
+var ImgbbUploadDataDef = defineSchema(
+  import_zod.z.object({
+    id: import_zod.z.string(),
+    title: import_zod.z.string(),
+    url_viewer: import_zod.z.string(),
+    url: import_zod.z.string(),
+    display_url: import_zod.z.string(),
+    width: import_zod.z.string(),
+    height: import_zod.z.string(),
+    size: import_zod.z.string(),
+    time: import_zod.z.string(),
+    expiration: import_zod.z.string(),
+    image: ImgbbAssetDef.schema,
+    thumb: ImgbbAssetDef.schema,
+    medium: ImgbbAssetDef.schema,
+    delete_url: import_zod.z.string()
+  })
+);
+var InsertWineResultDef = defineSchema(
+  import_zod.z.object({
+    insertado_id: import_zod.z.string().nullable(),
+    error: import_zod.z.string().nullable(),
+    image: import_zod.z.union([ImgbbUploadDataDef.schema, ReusedWineImageDef.schema]).optional(),
+    deduplicated: import_zod.z.boolean().optional()
+  })
+);
+
+// src/index.ts
+var ClientOptionsSchema = ClientOptionsDef.schema;
+var ApiErrorSchema = ApiErrorDef.schema;
+var LoginDataSchema = LoginDataDef.schema;
+var RegisterDataSchema = RegisterDataDef.schema;
+var MagicLinkRequestDataSchema = MagicLinkRequestDataDef.schema;
+var AuthResponseSchema = AuthResponseDef.schema;
+var ApiKeySchema = ApiKeyDef.schema;
+var MagicLinkResponseSchema = MagicLinkResponseDef.schema;
+var ValidateSessionResponseSchema = ValidateSessionResponseDef.schema;
+var SessionDataSchema = SessionDataDef.schema;
+var ActivityLogSchema = ActivityLogDef.schema;
+var RollbackLogSchema = RollbackLogDef.schema;
+var RealtimeOptionsSchema = RealtimeOptionsDef.schema;
+var WineSchema = WineDef.schema;
+var WineDetailsSchema = WineDetailsDef.schema;
+var WineDataSchema = WineDataDef.schema;
+var CreateWineSchema = CreateWineDef.schema;
+var EditWineSchema = EditWineDef.schema;
+var BulkInsertWinesSchema = BulkInsertWinesDef.schema;
+var BulkInsertWinesResultSchema = BulkInsertWinesResultDef.schema;
+var ReusedWineImageSchema = ReusedWineImageDef.schema;
+var ImgbbAssetSchema = ImgbbAssetDef.schema;
+var ImgbbUploadDataSchema = ImgbbUploadDataDef.schema;
+var InsertWineResultSchema = InsertWineResultDef.schema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivityLogSchema,
+  ApiErrorSchema,
+  ApiKeySchema,
+  AuthResponseSchema,
+  BulkInsertWinesResultSchema,
+  BulkInsertWinesSchema,
+  ClientOptionsSchema,
+  CreateWineSchema,
+  EditWineSchema,
+  ImgbbAssetSchema,
+  ImgbbUploadDataSchema,
+  InsertWineResultSchema,
+  LoginDataSchema,
+  MagicLinkRequestDataSchema,
+  MagicLinkResponseSchema,
+  RealtimeOptionsSchema,
+  RegisterDataSchema,
+  ReusedWineImageSchema,
+  RollbackLogSchema,
+  SessionDataSchema,
+  ValidateSessionResponseSchema,
+  WineClient,
+  WineDataSchema,
+  WineDetailsSchema,
+  WineSchema,
+  createClient,
+  createWsImageFile
+});