@superatomai/sdk-web 0.0.5

package/dist/index.js

@@ -0,0 +1,1570 @@
+import { z } from 'zod';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var ExpressionSchema = z.object({
+  $exp: z.string(),
+  $deps: z.array(z.string()).optional()
+});
+var BindingSchema = z.object({
+  $bind: z.string(),
+  $transform: z.array(
+    z.object({
+      name: z.string(),
+      args: z.array(z.any()).optional()
+    })
+  ).optional()
+});
+var ForDirectiveSchema = z.object({
+  in: z.union([ExpressionSchema, BindingSchema, z.string()]),
+  as: z.string(),
+  key: z.string().optional(),
+  index: z.string().optional()
+});
+var QuerySpecSchema = z.object({
+  graphql: z.string().optional(),
+  sql: z.string().optional(),
+  variables: z.record(z.string(), z.any()).optional(),
+  params: z.record(z.string(), z.any()).optional(),
+  key: z.string().optional(),
+  refetchPolicy: z.enum(["cache-first", "network-only", "cache-and-network"]).optional(),
+  dependencies: z.array(z.string()).optional()
+});
+var UIElementSchema = z.lazy(
+  () => z.object({
+    id: z.string(),
+    type: z.string(),
+    key: z.union([z.string(), ExpressionSchema]).optional(),
+    props: z.record(z.string(), z.any()).optional(),
+    query: QuerySpecSchema.optional(),
+    if: ExpressionSchema.optional(),
+    elseIf: ExpressionSchema.optional(),
+    for: ForDirectiveSchema.optional(),
+    "link-to": z.union([
+      z.string(),
+      ExpressionSchema,
+      BindingSchema,
+      z.object({
+        ui: z.union([z.string(), ExpressionSchema, BindingSchema]),
+        params: z.record(z.string(), z.any()).optional()
+      })
+    ]).optional(),
+    _meta: z.object({
+      id: z.string().optional(),
+      version: z.string().optional(),
+      created: z.string().optional(),
+      lastModified: z.string().optional()
+    }).optional(),
+    children: z.any().optional(),
+    else: UIElementSchema.optional(),
+    slots: z.record(z.string(), z.union([UIElementSchema, z.array(UIElementSchema)])).optional(),
+    platform: z.object({
+      web: z.any().optional(),
+      ios: z.any().optional(),
+      android: z.any().optional()
+    }).optional()
+  })
+);
+var UIComponentSchema = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  props: z.record(z.string(), z.any()).optional(),
+  states: z.record(z.string(), z.any()).optional(),
+  methods: z.record(
+    z.string(),
+    z.object({
+      fn: z.string(),
+      params: z.record(z.string(), z.any()).optional()
+    })
+  ).optional(),
+  effects: z.array(
+    z.object({
+      fn: z.string(),
+      deps: z.array(z.string()).optional()
+    })
+  ).optional(),
+  data: z.record(z.string(), z.any()).optional(),
+  render: UIElementSchema,
+  query: QuerySpecSchema.optional()
+});
+var DSLRendererPropsSchema = z.object({
+  dsl: UIComponentSchema,
+  data: z.record(z.string(), z.any()).optional(),
+  context: z.record(z.string(), z.any()).optional()
+});
+var ExpressionSchema2 = z.object({
+  $exp: z.string(),
+  $deps: z.array(z.string()).optional()
+});
+var BindingSchema2 = z.object({
+  $bind: z.string(),
+  $transform: z.array(
+    z.object({
+      name: z.string(),
+      args: z.array(z.any()).optional()
+    })
+  ).optional()
+});
+var ForDirectiveSchema2 = z.object({
+  in: z.union([ExpressionSchema2, BindingSchema2, z.string()]),
+  as: z.string(),
+  key: z.string().optional(),
+  index: z.string().optional()
+});
+var QuerySpecSchema2 = z.object({
+  graphql: z.string().optional(),
+  sql: z.string().optional(),
+  variables: z.record(z.string(), z.any()).optional(),
+  params: z.record(z.string(), z.any()).optional(),
+  key: z.string().optional(),
+  refetchPolicy: z.enum(["cache-first", "network-only", "cache-and-network"]).optional(),
+  dependencies: z.array(z.string()).optional()
+});
+var UIElementSchema2 = z.lazy(
+  () => z.object({
+    id: z.string(),
+    type: z.string(),
+    key: z.union([z.string(), ExpressionSchema2]).optional(),
+    props: z.record(z.string(), z.any()).optional(),
+    query: QuerySpecSchema2.optional(),
+    if: ExpressionSchema2.optional(),
+    elseIf: ExpressionSchema2.optional(),
+    for: ForDirectiveSchema2.optional(),
+    "link-to": z.union([
+      z.string(),
+      ExpressionSchema2,
+      BindingSchema2,
+      z.object({
+        ui: z.union([z.string(), ExpressionSchema2, BindingSchema2]),
+        params: z.record(z.string(), z.any()).optional()
+      })
+    ]).optional(),
+    _meta: z.object({
+      id: z.string().optional(),
+      version: z.string().optional(),
+      created: z.string().optional(),
+      lastModified: z.string().optional()
+    }).optional(),
+    children: z.any().optional(),
+    else: UIElementSchema2.optional(),
+    slots: z.record(z.string(), z.union([UIElementSchema2, z.array(UIElementSchema2)])).optional(),
+    platform: z.object({
+      web: z.any().optional(),
+      ios: z.any().optional(),
+      android: z.any().optional()
+    }).optional()
+  })
+);
+var UIComponentSchema2 = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  props: z.record(z.string(), z.any()).optional(),
+  states: z.record(z.string(), z.any()).optional(),
+  methods: z.record(
+    z.string(),
+    z.object({
+      fn: z.string(),
+      params: z.record(z.string(), z.any()).optional()
+    })
+  ).optional(),
+  effects: z.array(
+    z.object({
+      fn: z.string(),
+      deps: z.array(z.string()).optional()
+    })
+  ).optional(),
+  data: z.record(z.string(), z.any()).optional(),
+  render: UIElementSchema2,
+  query: QuerySpecSchema2.optional()
+});
+var DSLRendererPropsSchema2 = z.object({
+  dsl: UIComponentSchema2,
+  data: z.record(z.string(), z.any()).optional(),
+  context: z.record(z.string(), z.any()).optional()
+});
+
+// src/schemas.ts
+var MessageParticipantSchema = z.object({
+  id: z.string().optional(),
+  type: z.string().optional()
+});
+var MessageSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: z.unknown()
+});
+var AuthLoginPayloadSchema = z.object({
+  login_data: z.string()
+  // Base64 encoded login data (username + SHA-1 hashed password)
+});
+var AuthLoginRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("AUTH_LOGIN_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthLoginPayloadSchema
+});
+var AuthLoginResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.unknown().optional()
+  // User ID or additional auth data
+});
+var AuthLoginResponseMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("AUTH_LOGIN_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthLoginResponsePayloadSchema
+});
+var AuthVerifyPayloadSchema = z.object({
+  token: z.string()
+  // Base64 encoded authentication token
+});
+var AuthVerifyRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("AUTH_VERIFY_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthVerifyPayloadSchema
+});
+var AuthVerifyResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.unknown().optional()
+});
+var AuthVerifyResponseMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("AUTH_VERIFY_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: AuthVerifyResponsePayloadSchema
+});
+var UserPromptRequestPayloadSchema = z.object({
+  prompt: z.string(),
+  SA_RUNTIME: z.object({
+    threadId: z.string(),
+    uiBlockId: z.string()
+  }).optional()
+});
+var UserPromptRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("USER_PROMPT_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptRequestPayloadSchema
+});
+var ComponentSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string(),
+  description: z.string(),
+  props: z.object({
+    query: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    config: z.record(z.string(), z.unknown()).optional()
+  }),
+  category: z.string().optional(),
+  keywords: z.array(z.string()).optional()
+});
+var UserPromptResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.object({
+    component: ComponentSchema.optional()
+  }).optional(),
+  uiBlockId: z.string().optional(),
+  threadId: z.string().optional()
+});
+var UserPromptResponseMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("USER_PROMPT_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptResponsePayloadSchema
+});
+var UserPromptSuggestionsRequestPayloadSchema = z.object({
+  prompt: z.string(),
+  limit: z.number().int().positive().default(5)
+});
+var UserPromptSuggestionsRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("USER_PROMPT_SUGGESTIONS_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptSuggestionsRequestPayloadSchema
+});
+var UserPromptSuggestionsResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.object({
+    prompt: z.string(),
+    suggestions: z.array(ComponentSchema),
+    count: z.number(),
+    message: z.string().optional()
+  }).optional()
+});
+var UserPromptSuggestionsResponseMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("USER_PROMPT_SUGGESTIONS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UserPromptSuggestionsResponsePayloadSchema
+});
+var BundleRequestPayloadSchema = z.object({});
+var BundleRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("BUNDLE_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleRequestPayloadSchema
+});
+var BundleChunkPayloadSchema = z.object({
+  chunk: z.string(),
+  chunkIndex: z.number(),
+  totalChunks: z.number(),
+  isComplete: z.boolean(),
+  progress: z.number()
+});
+var BundleChunkMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("BUNDLE_CHUNK"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleChunkPayloadSchema
+});
+var BundleErrorPayloadSchema = z.object({
+  error: z.string()
+});
+var BundleErrorMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("BUNDLE_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: BundleErrorPayloadSchema
+});
+var DataRequestPayloadSchema = z.object({
+  collection: z.string(),
+  op: z.string(),
+  params: z.record(z.string(), z.unknown()).optional(),
+  SA_RUNTIME: z.record(z.string(), z.unknown()).optional()
+});
+var DataRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("DATA_REQ"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DataRequestPayloadSchema
+});
+var DataResponsePayloadSchema = z.object({
+  collection: z.string(),
+  op: z.string(),
+  data: z.unknown(),
+  executionMs: z.number().optional(),
+  error: z.string().optional()
+});
+var DataResponseMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("DATA_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DataResponsePayloadSchema
+});
+var UILogEntrySchema = z.object({
+  timestamp: z.number(),
+  level: z.enum(["info", "error", "warn", "debug"]),
+  message: z.string(),
+  type: z.enum(["explanation", "query", "general"]).optional(),
+  data: z.record(z.string(), z.unknown()).optional()
+});
+var UILogsPayloadSchema = z.object({
+  logs: z.array(UILogEntrySchema)
+});
+var UILogsMessageSchema = z.object({
+  id: z.string(),
+  // uiBlockId
+  type: z.literal("UI_LOGS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UILogsPayloadSchema
+});
+var UsersRequestPayloadSchema = z.object({
+  operation: z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: z.object({
+    username: z.string().optional(),
+    password: z.string().optional()
+  }).optional()
+});
+var UsersRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("USERS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UsersRequestPayloadSchema
+});
+var UsersResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.object({
+    username: z.string().optional(),
+    message: z.string().optional(),
+    users: z.array(z.object({
+      username: z.string(),
+      wsIds: z.array(z.string())
+    })).optional(),
+    user: z.object({
+      username: z.string(),
+      wsIds: z.array(z.string())
+    }).optional(),
+    count: z.number().optional()
+  }).optional()
+});
+z.object({
+  id: z.string(),
+  type: z.literal("USERS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: UsersResponsePayloadSchema
+});
+var DashboardsRequestPayloadSchema = z.object({
+  operation: z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: z.object({
+    dashboardId: z.string().optional(),
+    dashboard: DSLRendererPropsSchema.optional()
+  }).optional()
+});
+var DashboardsRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("DASHBOARDS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashboardsRequestPayloadSchema
+});
+var DashboardsResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.object({
+    dashboardId: z.string().optional(),
+    dashboard: DSLRendererPropsSchema.optional(),
+    dashboards: z.array(z.object({
+      dashboardId: z.string(),
+      dashboard: DSLRendererPropsSchema
+    })).optional(),
+    count: z.number().optional(),
+    message: z.string().optional()
+  }).optional()
+});
+z.object({
+  id: z.string(),
+  type: z.literal("DASHBOARDS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: DashboardsResponsePayloadSchema
+});
+var ReportsRequestPayloadSchema = z.object({
+  operation: z.enum(["create", "update", "delete", "getAll", "getOne"]),
+  data: z.object({
+    reportId: z.string().optional(),
+    report: DSLRendererPropsSchema2.optional()
+  }).optional()
+});
+var ReportsRequestMessageSchema = z.object({
+  id: z.string(),
+  type: z.literal("REPORTS"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ReportsRequestPayloadSchema
+});
+var ReportsResponsePayloadSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional(),
+  data: z.object({
+    reportId: z.string().optional(),
+    report: DSLRendererPropsSchema2.optional(),
+    reports: z.array(z.object({
+      reportId: z.string(),
+      report: DSLRendererPropsSchema2
+    })).optional(),
+    count: z.number().optional(),
+    message: z.string().optional()
+  }).optional()
+});
+z.object({
+  id: z.string(),
+  type: z.literal("REPORTS_RES"),
+  from: MessageParticipantSchema,
+  to: MessageParticipantSchema.optional(),
+  payload: ReportsResponsePayloadSchema
+});
+var ClientConfigSchema = z.object({
+  userId: z.string(),
+  projectId: z.string(),
+  baseUrl: z.string().default("wss://ws.superatom.ai/websocket"),
+  type: z.string().default("runtime"),
+  maxReconnectAttempts: z.number().min(0).default(Infinity),
+  initialReconnectDelay: z.number().min(0).default(1e3),
+  maxReconnectDelay: z.number().min(0).default(3e4),
+  defaultTimeout: z.number().min(0).default(3e4),
+  debug: z.boolean().default(false)
+});
+
+// src/services/index.ts
+var services_exports = {};
+__export(services_exports, {
+  BindingSchema: () => BindingSchema,
+  DSLRendererPropsSchema: () => DSLRendererPropsSchema,
+  ExpressionSchema: () => ExpressionSchema,
+  ForDirectiveSchema: () => ForDirectiveSchema,
+  QuerySpecSchema: () => QuerySpecSchema,
+  UIComponentSchema: () => UIComponentSchema,
+  UIElementSchema: () => UIElementSchema,
+  createDashboard: () => createDashboard,
+  createReport: () => createReport,
+  createUser: () => createUser,
+  deleteDashboard: () => deleteDashboard,
+  deleteReport: () => deleteReport,
+  deleteUser: () => deleteUser,
+  getAllDashboards: () => getAllDashboards,
+  getAllReports: () => getAllReports,
+  getAllUsers: () => getAllUsers,
+  getComponentSuggestions: () => getComponentSuggestions,
+  getDashboard: () => getDashboard,
+  getReport: () => getReport,
+  getUser: () => getUser,
+  requestBundle: () => requestBundle,
+  requestData: () => requestData,
+  sendAuthLoginRequest: () => sendAuthLoginRequest,
+  sendAuthVerifyRequest: () => sendAuthVerifyRequest,
+  sendUserPromptRequest: () => sendUserPromptRequest,
+  sendUserPromptSuggestionsRequest: () => sendUserPromptSuggestionsRequest,
+  updateDashboard: () => updateDashboard,
+  updateReport: () => updateReport,
+  updateUser: () => updateUser
+});
+
+// src/services/auth.ts
+async function sendAuthLoginRequest(client, loginDataBase64, timeout) {
+  const messageId = `login_${Date.now()}`;
+  const message = AuthLoginRequestMessageSchema.parse({
+    id: messageId,
+    type: "AUTH_LOGIN_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      login_data: loginDataBase64
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+async function sendAuthVerifyRequest(client, token, timeout) {
+  const messageId = `verify_${Date.now()}`;
+  const message = AuthVerifyRequestMessageSchema.parse({
+    id: messageId,
+    type: "AUTH_VERIFY_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      token
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+
+// src/services/userPrompt.ts
+async function sendUserPromptRequest(client, prompt, threadId, uiBlockId, timeout) {
+  const messageId = `msg_${Date.now()}`;
+  const message = UserPromptRequestMessageSchema.parse({
+    id: messageId,
+    type: "USER_PROMPT_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      SA_RUNTIME: {
+        threadId,
+        uiBlockId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+async function sendUserPromptSuggestionsRequest(client, prompt, limit = 5, timeout) {
+  if (!prompt || prompt.trim().length === 0) {
+    return null;
+  }
+  const messageId = `suggestions_${Date.now()}`;
+  const message = UserPromptSuggestionsRequestMessageSchema.parse({
+    id: messageId,
+    type: "USER_PROMPT_SUGGESTIONS_REQ",
+    from: {
+      type: "runtime"
+    },
+    to: {
+      type: "data-agent"
+    },
+    payload: {
+      prompt,
+      limit
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  return response;
+}
+
+// src/services/bundle.ts
+async function requestBundle(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = BundleRequestMessageSchema.parse({
+    id: messageId,
+    type: "BUNDLE_REQ",
+    from: { type: "runtime" },
+    to: { type: "data-agent" },
+    payload: {}
+  });
+  const chunks = [];
+  let totalChunks = 0;
+  const unsubscribe = client.onMessage((msg) => {
+    try {
+      if (msg.type === "BUNDLE_CHUNK" && msg.id?.startsWith(messageId)) {
+        const chunkMessage = BundleChunkMessageSchema.parse(msg);
+        const payload = chunkMessage.payload;
+        chunks[payload.chunkIndex] = payload.chunk;
+        totalChunks = payload.totalChunks;
+        if (options?.onProgress) {
+          options.onProgress(payload.progress);
+        }
+      }
+    } catch (error) {
+      console.error("[SuperAtom] Failed to parse bundle chunk:", error);
+    }
+  });
+  client.send(message);
+  const timeout = options?.timeout ?? 6e4;
+  const startTime = Date.now();
+  return new Promise((resolve, reject) => {
+    const checkInterval = setInterval(() => {
+      if (Date.now() - startTime > timeout) {
+        clearInterval(checkInterval);
+        unsubscribe();
+        reject(new Error(`Bundle request timeout after ${timeout}ms`));
+        return;
+      }
+      if (totalChunks > 0 && chunks.length === totalChunks) {
+        clearInterval(checkInterval);
+        unsubscribe();
+        const bundle = chunks.join("");
+        resolve(bundle);
+      }
+    }, 100);
+  });
+}
+
+// src/services/data.ts
+async function requestData(client, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = DataRequestMessageSchema.parse({
+    id: messageId,
+    type: "DATA_REQ",
+    from: { type: "runtime" },
+    to: { type: "data-agent" },
+    payload: {
+      collection: options.collection,
+      op: options.operation,
+      params: options.params
+    }
+  });
+  const response = await client.sendWithResponse(message, options.timeout);
+  const payload = response.payload;
+  return {
+    data: payload.data,
+    error: payload.error,
+    executionMs: payload.executionMs
+  };
+}
+
+// src/services/component.ts
+async function getComponentSuggestions(client, query, options) {
+  const messageId = `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+  const message = {
+    id: messageId,
+    type: "USER_PROMPT_REQ",
+    to: { type: "data-agent" },
+    payload: {
+      prompt: query
+    }
+  };
+  const response = await client.sendWithResponse(message, options?.timeout);
+  const payload = response.payload;
+  return {
+    component: payload.component,
+    error: payload.error
+  };
+}
+
+// src/services/users.ts
+async function createUser(client, username, password, timeout) {
+  const messageId = `users_create_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        username,
+        password
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username
+  };
+}
+async function updateUser(client, username, password, timeout) {
+  const messageId = `users_update_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        username,
+        password
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username
+  };
+}
+async function deleteUser(client, username, timeout) {
+  const messageId = `users_delete_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        username
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    username: payload.data?.username
+  };
+}
+async function getAllUsers(client, timeout) {
+  const messageId = `users_getall_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    users: payload.data?.users,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getUser(client, username, timeout) {
+  const messageId = `users_getone_${Date.now()}`;
+  const message = UsersRequestMessageSchema.parse({
+    id: messageId,
+    type: "USERS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        username
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    user: payload.data?.user,
+    message: payload.data?.message
+  };
+}
+
+// src/services/dashboards/index.ts
+async function createDashboard(client, dashboardId, dashboard, timeout) {
+  const messageId = `dashboards_create_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        dashboardId,
+        dashboard
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard
+  };
+}
+async function updateDashboard(client, dashboardId, dashboard, timeout) {
+  const messageId = `dashboards_update_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        dashboardId,
+        dashboard
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard
+  };
+}
+async function deleteDashboard(client, dashboardId, timeout) {
+  const messageId = `dashboards_delete_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        dashboardId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    dashboardId: payload.data?.dashboardId
+  };
+}
+async function getAllDashboards(client, timeout) {
+  const messageId = `dashboards_getall_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    dashboards: payload.data?.dashboards,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getDashboard(client, dashboardId, timeout) {
+  const messageId = `dashboards_getone_${Date.now()}`;
+  const message = DashboardsRequestMessageSchema.parse({
+    id: messageId,
+    type: "DASHBOARDS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        dashboardId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    dashboardId: payload.data?.dashboardId,
+    dashboard: payload.data?.dashboard,
+    message: payload.data?.message
+  };
+}
+
+// src/services/reports/index.ts
+async function createReport(client, reportId, report, timeout) {
+  const messageId = `reports_create_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "create",
+      data: {
+        reportId,
+        report
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report
+  };
+}
+async function updateReport(client, reportId, report, timeout) {
+  const messageId = `reports_update_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "update",
+      data: {
+        reportId,
+        report
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report
+  };
+}
+async function deleteReport(client, reportId, timeout) {
+  const messageId = `reports_delete_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "delete",
+      data: {
+        reportId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    message: payload.data?.message,
+    reportId: payload.data?.reportId
+  };
+}
+async function getAllReports(client, timeout) {
+  const messageId = `reports_getall_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getAll"
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    reports: payload.data?.reports,
+    count: payload.data?.count,
+    message: payload.data?.message
+  };
+}
+async function getReport(client, reportId, timeout) {
+  const messageId = `reports_getone_${Date.now()}`;
+  const message = ReportsRequestMessageSchema.parse({
+    id: messageId,
+    type: "REPORTS",
+    from: { type: "admin" },
+    to: { type: "data-agent" },
+    payload: {
+      operation: "getOne",
+      data: {
+        reportId
+      }
+    }
+  });
+  const response = await client.sendWithResponse(message, timeout);
+  const payload = response.payload;
+  return {
+    success: payload.success,
+    error: payload.error,
+    reportId: payload.data?.reportId,
+    report: payload.data?.report,
+    message: payload.data?.message
+  };
+}
+
+// src/client.ts
+var SuperatomClient = class {
+  constructor(config) {
+    this.socket = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.shouldReconnect = true;
+    this.messageHandlers = /* @__PURE__ */ new Set();
+    this.connectionHandlers = /* @__PURE__ */ new Set();
+    this.disconnectionHandlers = /* @__PURE__ */ new Set();
+    this.errorHandlers = /* @__PURE__ */ new Set();
+    this.connectPromise = null;
+    this.connectResolve = null;
+    const parsed = ClientConfigSchema.parse(config);
+    this.config = parsed;
+  }
+  /**
+   * Get WebSocket URL with query parameters
+   */
+  getWebSocketUrl() {
+    const params = new URLSearchParams({
+      userId: this.config.userId,
+      projectId: this.config.projectId,
+      type: this.config.type
+    });
+    return `${this.config.baseUrl}?${params.toString()}`;
+  }
+  /**
+   * Calculate reconnection delay with exponential backoff
+   */
+  calculateReconnectDelay() {
+    const delay = Math.min(
+      this.config.initialReconnectDelay * Math.pow(2, this.reconnectAttempts),
+      this.config.maxReconnectDelay
+    );
+    return delay + Math.random() * 1e3;
+  }
+  /**
+   * Schedule reconnection attempt
+   */
+  scheduleReconnect() {
+    if (!this.shouldReconnect) {
+      return;
+    }
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      const error = new Error("Max reconnection attempts reached");
+      this.log("error", error.message);
+      this.errorHandlers.forEach((handler) => handler(error));
+      return;
+    }
+    const delay = this.calculateReconnectDelay();
+    this.log("info", `Scheduling reconnection attempt ${this.reconnectAttempts + 1} in ${delay}ms`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectAttempts++;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Setup WebSocket event handlers
+   */
+  setupSocketHandlers() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.onopen = () => {
+      this.log("info", "Connected to SuperAtom");
+      this.reconnectAttempts = 0;
+      if (this.connectResolve) {
+        this.connectResolve();
+        this.connectResolve = null;
+      }
+      this.connectionHandlers.forEach((handler) => handler());
+    };
+    this.socket.onmessage = (event) => {
+      try {
+        const parsed = JSON.parse(event.data);
+        const message = MessageSchema.parse(parsed);
+        this.messageHandlers.forEach((handler) => handler(message));
+      } catch (error) {
+        this.log("error", "Failed to parse message:", error);
+        const err = error instanceof Error ? error : new Error("Parse error");
+        this.errorHandlers.forEach((handler) => handler(err));
+      }
+    };
+    this.socket.onclose = (event) => {
+      this.log("info", "Disconnected from SuperAtom", {
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      this.disconnectionHandlers.forEach((handler) => handler());
+      if (this.shouldReconnect && !event.wasClean) {
+        this.scheduleReconnect();
+      }
+    };
+    this.socket.onerror = (error) => {
+      this.log("error", "WebSocket error:", error);
+      this.errorHandlers.forEach((handler) => handler(error));
+    };
+  }
+  /**
+   * Connect to SuperAtom WebSocket server
+   * Returns a Promise that resolves when the connection is established
+   * The Promise never rejects - failures are logged silently and auto-reconnect is triggered
+   */
+  connect() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.log("warn", "Already connected");
+      return Promise.resolve();
+    }
+    if (this.socket?.readyState === WebSocket.CONNECTING && this.connectPromise) {
+      this.log("warn", "Connection already in progress");
+      return this.connectPromise;
+    }
+    this.connectPromise = new Promise((resolve) => {
+      this.connectResolve = resolve;
+    });
+    try {
+      this.socket = new WebSocket(this.getWebSocketUrl());
+      this.setupSocketHandlers();
+    } catch (error) {
+      this.log("error", "Failed to create WebSocket:", error);
+      const err = error instanceof Error ? error : new Error("Connection failed");
+      this.errorHandlers.forEach((handler) => handler(err));
+      this.scheduleReconnect();
+    }
+    return this.connectPromise;
+  }
+  /**
+   * Disconnect from WebSocket server
+   */
+  disconnect() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      this.socket.close(1e3, "Client disconnect");
+      this.socket = null;
+    }
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Update client configuration
+   */
+  updateConfig(config) {
+    const merged = { ...this.config, ...config };
+    const parsed = ClientConfigSchema.parse(merged);
+    this.config = parsed;
+  }
+  /**
+   * Reconnect with new configuration
+   * Disconnects from existing connection and reconnects with updated config
+   * Returns a Promise that resolves when the new connection is established
+   */
+  reconnectWithConfig(config) {
+    this.updateConfig(config);
+    if (this.socket) {
+      this.disconnect();
+    }
+    this.shouldReconnect = true;
+    return this.connect();
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    const fullMessage = {
+      ...message,
+      from: message.from || { type: "runtime" }
+    };
+    try {
+      this.socket.send(JSON.stringify(fullMessage));
+    } catch (error) {
+      this.log("error", "Failed to send message:", error);
+      throw error;
+    }
+  }
+  /**
+   * Send a message and wait for a response with the same ID
+   * Uses closure-based approach - no global state management needed
+   */
+  async sendWithResponse(message, timeout) {
+    const messageId = message.id || `msg_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const messageWithId = { ...message, id: messageId };
+    const timeoutMs = timeout ?? this.config.defaultTimeout;
+    this.send(messageWithId);
+    return new Promise((resolve, reject) => {
+      let isResolved = false;
+      const responseHandler = (msg) => {
+        if (msg.id === messageId && !isResolved) {
+          isResolved = true;
+          clearTimeout(timer);
+          unsubscribe();
+          resolve(msg);
+        }
+      };
+      const unsubscribe = this.onMessage(responseHandler);
+      const timer = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          unsubscribe();
+          reject(new Error(`Request timeout after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Register message handler
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Register connection handler
+   */
+  onConnect(handler) {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+  /**
+   * Register disconnection handler
+   */
+  onDisconnect(handler) {
+    this.disconnectionHandlers.add(handler);
+    return () => this.disconnectionHandlers.delete(handler);
+  }
+  /**
+   * Register error handler
+   */
+  onError(handler) {
+    this.errorHandlers.add(handler);
+    return () => this.errorHandlers.delete(handler);
+  }
+  /**
+   * Check if client is connected
+   */
+  isConnected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Get current reconnection attempts
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Send a message and wait for response with timeout (alias for sendWithResponse)
+   */
+  async ask(message, options) {
+    return this.sendWithResponse(message, options?.timeout);
+  }
+  // ==================== Service Methods ====================
+  // These methods delegate to service functions for better code organization
+  /**
+   * Send authentication login request
+   * Delegates to auth service
+   */
+  async sendAuthLoginRequest(loginDataBase64, timeout) {
+    this.log("info", "Sending auth login request");
+    return sendAuthLoginRequest(this, loginDataBase64, timeout);
+  }
+  /**
+   * Send authentication verify request
+   * Delegates to auth service
+   */
+  async sendAuthVerifyRequest(token, timeout) {
+    this.log("info", "Sending auth verify request");
+    return sendAuthVerifyRequest(this, token, timeout);
+  }
+  /**
+   * Send a user prompt request
+   * Delegates to user prompt service
+   */
+  async sendUserPromptRequest(prompt, threadId, uiBlockId, timeout) {
+    this.log("info", "Sending user prompt request");
+    return sendUserPromptRequest(this, prompt, threadId, uiBlockId, timeout);
+  }
+  /**
+   * Send a user prompt suggestions request
+   * Delegates to user prompt service
+   */
+  async sendUserPromptSuggestionsRequest(prompt, limit = 5, timeout) {
+    this.log("info", "Sending user prompt suggestions request");
+    return sendUserPromptSuggestionsRequest(this, prompt, limit, timeout);
+  }
+  /**
+   * Request bundle from server
+   * Delegates to bundle service
+   */
+  async requestBundle(options) {
+    this.log("info", "Requesting bundle from server");
+    return requestBundle(this, options);
+  }
+  /**
+   * Request data from a collection
+   * Delegates to data service
+   */
+  async requestData(options) {
+    this.log("info", `Requesting data from collection: ${options.collection}, operation: ${options.operation}`);
+    return requestData(this, options);
+  }
+  /**
+   * Get AI-powered component suggestions based on a query
+   * Delegates to component service
+   */
+  async getComponentSuggestions(query, options) {
+    this.log("info", "Requesting component suggestions for query:", query);
+    return getComponentSuggestions(this, query, options);
+  }
+  // ==================== User Management Methods ====================
+  // These methods delegate to user service for admin user CRUD operations
+  /**
+   * Create a new user
+   * Delegates to users service
+   */
+  async createUser(username, password, timeout) {
+    this.log("info", "Creating user:", username);
+    return createUser(this, username, password, timeout);
+  }
+  /**
+   * Update an existing user
+   * Delegates to users service
+   */
+  async updateUser(username, password, timeout) {
+    this.log("info", "Updating user:", username);
+    return updateUser(this, username, password, timeout);
+  }
+  /**
+   * Delete a user
+   * Delegates to users service
+   */
+  async deleteUser(username, timeout) {
+    this.log("info", "Deleting user:", username);
+    return deleteUser(this, username, timeout);
+  }
+  /**
+   * Get all users
+   * Delegates to users service
+   */
+  async getAllUsers(timeout) {
+    this.log("info", "Fetching all users");
+    return getAllUsers(this, timeout);
+  }
+  /**
+   * Get a specific user by username
+   * Delegates to users service
+   */
+  async getUser(username, timeout) {
+    this.log("info", "Fetching user:", username);
+    return getUser(this, username, timeout);
+  }
+  // ==================== Dashboard Management Methods ====================
+  // These methods delegate to dashboard service for admin dashboard CRUD operations
+  /**
+   * Create a new dashboard
+   * Delegates to dashboards service
+   */
+  async createDashboard(dashboardId, dashboard, timeout) {
+    this.log("info", "Creating dashboard:", dashboardId);
+    return createDashboard(this, dashboardId, dashboard, timeout);
+  }
+  /**
+   * Update an existing dashboard
+   * Delegates to dashboards service
+   */
+  async updateDashboard(dashboardId, dashboard, timeout) {
+    this.log("info", "Updating dashboard:", dashboardId);
+    return updateDashboard(this, dashboardId, dashboard, timeout);
+  }
+  /**
+   * Delete a dashboard
+   * Delegates to dashboards service
+   */
+  async deleteDashboard(dashboardId, timeout) {
+    this.log("info", "Deleting dashboard:", dashboardId);
+    return deleteDashboard(this, dashboardId, timeout);
+  }
+  /**
+   * Get all dashboards
+   * Delegates to dashboards service
+   */
+  async getAllDashboards(timeout) {
+    this.log("info", "Fetching all dashboards");
+    return getAllDashboards(this, timeout);
+  }
+  /**
+   * Get a specific dashboard by ID
+   * Delegates to dashboards service
+   */
+  async getDashboard(dashboardId, timeout) {
+    this.log("info", "Fetching dashboard:", dashboardId);
+    return getDashboard(this, dashboardId, timeout);
+  }
+  // ==================== Report Management Methods ====================
+  // These methods delegate to report service for admin report CRUD operations
+  /**
+   * Create a new report
+   * Delegates to reports service
+   */
+  async createReport(reportId, report, timeout) {
+    this.log("info", "Creating report:", reportId);
+    return createReport(this, reportId, report, timeout);
+  }
+  /**
+   * Update an existing report
+   * Delegates to reports service
+   */
+  async updateReport(reportId, report, timeout) {
+    this.log("info", "Updating report:", reportId);
+    return updateReport(this, reportId, report, timeout);
+  }
+  /**
+   * Delete a report
+   * Delegates to reports service
+   */
+  async deleteReport(reportId, timeout) {
+    this.log("info", "Deleting report:", reportId);
+    return deleteReport(this, reportId, timeout);
+  }
+  /**
+   * Get all reports
+   * Delegates to reports service
+   */
+  async getAllReports(timeout) {
+    this.log("info", "Fetching all reports");
+    return getAllReports(this, timeout);
+  }
+  /**
+   * Get a specific report by ID
+   * Delegates to reports service
+   */
+  async getReport(reportId, timeout) {
+    this.log("info", "Fetching report:", reportId);
+    return getReport(this, reportId, timeout);
+  }
+  /**
+   * Internal logging
+   */
+  log(level, ...args) {
+    if (!this.config.debug && level === "debug") {
+      return;
+    }
+    console[level]("[SuperAtom]", ...args);
+  }
+};
+
+// src/setup.ts
+function setup(components) {
+  if (typeof window === "undefined") {
+    throw new Error("setup() can only be called in a browser environment");
+  }
+  window.SUPERATOM = window.SUPERATOM || {};
+  window.SA = window.SUPERATOM;
+  window.SUPERATOM.COMPONENTS = components;
+  if (window.SUPERATOM.runtime?.componentsLoaded) {
+    window.SUPERATOM.runtime.componentsLoaded();
+  }
+}
+function getComponents() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.SUPERATOM?.COMPONENTS;
+}
+function getComponent(name) {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window.SUPERATOM?.COMPONENTS?.[name];
+}
+function hasComponents() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return !!window.SUPERATOM?.COMPONENTS;
+}
+
+// src/index.ts
+var SDK_VERSION = "0.1.0";
+
+export { AuthLoginPayloadSchema, AuthLoginRequestMessageSchema, AuthLoginResponseMessageSchema, AuthLoginResponsePayloadSchema, AuthVerifyPayloadSchema, AuthVerifyRequestMessageSchema, AuthVerifyResponseMessageSchema, AuthVerifyResponsePayloadSchema, BundleChunkMessageSchema, BundleChunkPayloadSchema, BundleErrorMessageSchema, BundleErrorPayloadSchema, BundleRequestMessageSchema, BundleRequestPayloadSchema, ClientConfigSchema, ComponentSchema, DataRequestMessageSchema, DataRequestPayloadSchema, DataResponseMessageSchema, DataResponsePayloadSchema, MessageParticipantSchema, MessageSchema, SDK_VERSION, SuperatomClient, UILogEntrySchema, UILogsMessageSchema, UILogsPayloadSchema, UserPromptRequestMessageSchema, UserPromptRequestPayloadSchema, UserPromptResponseMessageSchema, UserPromptResponsePayloadSchema, UserPromptSuggestionsRequestMessageSchema, UserPromptSuggestionsRequestPayloadSchema, UserPromptSuggestionsResponseMessageSchema, UserPromptSuggestionsResponsePayloadSchema, getComponent, getComponents, hasComponents, services_exports as services, setup };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map