@elqnt/admin 2.0.5 → 2.2.0

package/dist/hooks/index.js

@@ -0,0 +1,1493 @@
+// hooks/use-org-admin.ts
+import { useState, useCallback } from "react";
+
+// api/index.ts
+import { browserApiRequest as browserApiRequest6, clearGatewayTokenCache } from "@elqnt/api-client/browser";
+
+// api/orgs.ts
+import { browserApiRequest } from "@elqnt/api-client/browser";
+async function listOrgsApi(filter, options) {
+  const params = new URLSearchParams();
+  if (filter?.product) params.set("product", filter.product);
+  if (filter?.status) params.set("status", filter.status);
+  if (filter?.type) params.set("type", filter.type);
+  const queryString = params.toString();
+  const url = queryString ? `/api/v1/admin/orgs?${queryString}` : "/api/v1/admin/orgs";
+  return browserApiRequest(url, {
+    method: "GET",
+    ...options
+  });
+}
+async function createOrgApi(org, options) {
+  return browserApiRequest("/api/v1/admin/orgs", {
+    method: "POST",
+    body: org,
+    ...options
+  });
+}
+async function getOrgApi(orgId, options) {
+  return browserApiRequest(`/api/v1/admin/orgs/${orgId}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function updateOrgApi(orgId, updates, options) {
+  return browserApiRequest(`/api/v1/admin/orgs/${orgId}`, {
+    method: "PUT",
+    body: updates,
+    ...options
+  });
+}
+async function deleteOrgApi(orgId, options) {
+  return browserApiRequest(`/api/v1/admin/orgs/${orgId}`, {
+    method: "DELETE",
+    ...options
+  });
+}
+async function getOrgInfoApi(orgId, options) {
+  return browserApiRequest(`/api/v1/admin/orgs/${orgId}/info`, {
+    method: "GET",
+    ...options
+  });
+}
+async function createOrgWithSchemasApi(org, schemas, options) {
+  return browserApiRequest("/api/v1/admin/orgs/with-schemas", {
+    method: "POST",
+    body: { org, schemas },
+    ...options
+  });
+}
+
+// api/users.ts
+import { browserApiRequest as browserApiRequest2 } from "@elqnt/api-client/browser";
+async function listUsersApi(options) {
+  return browserApiRequest2("/api/v1/admin/users", {
+    method: "GET",
+    ...options
+  });
+}
+async function createUserApi(user, options) {
+  return browserApiRequest2("/api/v1/admin/users", {
+    method: "POST",
+    body: user,
+    ...options
+  });
+}
+async function getUserApi(userId, options) {
+  return browserApiRequest2(`/api/v1/admin/users/${userId}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getUserByEmailApi(email, options) {
+  return browserApiRequest2(`/api/v1/admin/users/by-email?email=${encodeURIComponent(email)}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getUserByPhoneApi(phone, options) {
+  return browserApiRequest2(`/api/v1/admin/users/by-phone?phone=${encodeURIComponent(phone)}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function updateUserApi(userId, updates, options) {
+  return browserApiRequest2(`/api/v1/admin/users/${userId}`, {
+    method: "PUT",
+    body: updates,
+    ...options
+  });
+}
+async function deleteUserApi(userId, options) {
+  return browserApiRequest2(`/api/v1/admin/users/${userId}`, {
+    method: "DELETE",
+    ...options
+  });
+}
+async function getUserSettingsApi(userId, options) {
+  return browserApiRequest2(`/api/v1/admin/users/${userId}/settings`, {
+    method: "GET",
+    ...options
+  });
+}
+async function updateUserSettingsApi(userId, settings, options) {
+  return browserApiRequest2(`/api/v1/admin/users/${userId}/settings`, {
+    method: "PUT",
+    body: settings,
+    ...options
+  });
+}
+
+// api/invites.ts
+import { browserApiRequest as browserApiRequest3 } from "@elqnt/api-client/browser";
+async function listInvitesApi(options) {
+  return browserApiRequest3("/api/v1/admin/invites", {
+    method: "GET",
+    ...options
+  });
+}
+async function sendInvitesApi(invites, options) {
+  return browserApiRequest3("/api/v1/admin/invites", {
+    method: "POST",
+    body: { invites },
+    ...options
+  });
+}
+async function sendInviteApi(invite, options) {
+  return browserApiRequest3("/api/v1/admin/invites/single", {
+    method: "POST",
+    body: invite,
+    ...options
+  });
+}
+async function getInviteApi(inviteId, options) {
+  return browserApiRequest3(`/api/v1/admin/invites/${inviteId}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function resendInviteApi(inviteId, options) {
+  return browserApiRequest3(`/api/v1/admin/invites/${inviteId}/resend`, {
+    method: "POST",
+    ...options
+  });
+}
+async function revokeInviteApi(inviteId, options) {
+  return browserApiRequest3(`/api/v1/admin/invites/${inviteId}`, {
+    method: "DELETE",
+    ...options
+  });
+}
+async function acceptInviteApi(inviteId, options) {
+  return browserApiRequest3(`/api/v1/admin/invites/${inviteId}/accept`, {
+    method: "POST",
+    ...options
+  });
+}
+
+// api/analytics.ts
+import { browserApiRequest as browserApiRequest4 } from "@elqnt/api-client/browser";
+function buildDateFilterParams(filter) {
+  if (!filter) return "";
+  const params = new URLSearchParams();
+  if (filter.from) params.set("from", filter.from);
+  if (filter.to) params.set("to", filter.to);
+  const queryString = params.toString();
+  return queryString ? `?${queryString}` : "";
+}
+async function getAnalyticsSummaryApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/summary${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getChatsAnalyticsApi(filter, agentId, options) {
+  const params = new URLSearchParams();
+  if (filter?.from) params.set("from", filter.from);
+  if (filter?.to) params.set("to", filter.to);
+  if (agentId) params.set("agent_id", agentId);
+  const queryString = params.toString();
+  return browserApiRequest4(`/api/v1/analytics/chats${queryString ? `?${queryString}` : ""}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getAgentsAnalyticsApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/agents${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getUsageAnalyticsApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/usage${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getDailyAnalyticsApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/daily${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getAnalyticsEventsApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/events${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function logAnalyticsEventApi(event, options) {
+  return browserApiRequest4("/api/v1/analytics/events", {
+    method: "POST",
+    body: event,
+    ...options
+  });
+}
+async function getGlobalSummaryApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/global/summary${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+async function getGlobalOrgsAnalyticsApi(filter, options) {
+  const queryString = buildDateFilterParams(filter);
+  return browserApiRequest4(`/api/v1/analytics/global/orgs${queryString}`, {
+    method: "GET",
+    ...options
+  });
+}
+
+// api/provisioning.ts
+import { browserApiRequest as browserApiRequest5 } from "@elqnt/api-client/browser";
+async function createOrgWithProvisioningApi(request, options) {
+  return browserApiRequest5("/api/v1/admin/provisioning/orgs", {
+    method: "POST",
+    body: request,
+    ...options
+  });
+}
+async function getProvisioningStatusApi(orgId, options) {
+  return browserApiRequest5(`/api/v1/admin/orgs/${orgId}/provisioning`, {
+    method: "GET",
+    ...options
+  });
+}
+async function retryProvisioningApi(orgId, request, options) {
+  return browserApiRequest5(`/api/v1/admin/orgs/${orgId}/provisioning/retry`, {
+    method: "POST",
+    body: request || {},
+    ...options
+  });
+}
+async function validateProvisioningApi(orgId, options) {
+  return browserApiRequest5(
+    `/api/v1/admin/orgs/${orgId}/provisioning/validate`,
+    {
+      method: "POST",
+      ...options
+    }
+  );
+}
+async function cancelProvisioningApi(orgId, options) {
+  return browserApiRequest5(
+    `/api/v1/admin/orgs/${orgId}/provisioning/cancel`,
+    {
+      method: "POST",
+      ...options
+    }
+  );
+}
+async function cleanupProvisioningApi(orgId, options) {
+  return browserApiRequest5(`/api/v1/admin/orgs/${orgId}/provisioning`, {
+    method: "DELETE",
+    ...options
+  });
+}
+function streamProvisioningProgress(orgId, callbacks, options) {
+  const url = new URL(
+    `/api/v1/admin/orgs/${orgId}/provisioning/stream`,
+    options.baseUrl
+  );
+  if (options.token) {
+    url.searchParams.set("token", options.token);
+  }
+  const eventSource = new EventSource(url.toString());
+  eventSource.addEventListener("connected", (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      callbacks.onConnected?.(data.orgId);
+    } catch (e) {
+      console.error("Failed to parse connected event", e);
+    }
+  });
+  eventSource.addEventListener("progress", (event) => {
+    try {
+      const progress = JSON.parse(event.data);
+      callbacks.onProgress?.(progress);
+    } catch (e) {
+      console.error("Failed to parse progress event", e);
+    }
+  });
+  eventSource.addEventListener("done", () => {
+    callbacks.onDone?.();
+    eventSource.close();
+  });
+  eventSource.addEventListener("timeout", () => {
+    callbacks.onTimeout?.();
+    eventSource.close();
+  });
+  eventSource.onerror = (error) => {
+    callbacks.onError?.(new Error("SSE connection error"));
+    eventSource.close();
+  };
+  return () => {
+    eventSource.close();
+  };
+}
+function calculateProgressPercentage(progress) {
+  if (progress.totalArtifacts === 0) return 0;
+  return Math.round(
+    progress.completedArtifacts / progress.totalArtifacts * 100
+  );
+}
+function isProvisioningComplete(progress) {
+  return progress.status === "completed" || progress.status === "failed" || progress.status === "partial";
+}
+function isProvisioningSuccessful(progress) {
+  return progress.status === "completed";
+}
+function getFailedArtifacts(progress) {
+  return progress.artifacts.filter((a) => a.status === "failed");
+}
+function hasCriticalFailures(progress) {
+  return progress.artifacts.some(
+    (a) => a.status === "failed" && a.critical
+  );
+}
+
+// api/index.ts
+async function getOrgSettingsApi(options) {
+  return browserApiRequest6("/api/v1/org/settings", {
+    method: "GET",
+    ...options
+  });
+}
+async function createOrgSettingsApi(settings, options) {
+  return browserApiRequest6("/api/v1/org/settings", {
+    method: "POST",
+    body: settings,
+    ...options
+  });
+}
+async function updateOrgSettingsApi(settings, options) {
+  return browserApiRequest6("/api/v1/org/settings", {
+    method: "PUT",
+    body: settings,
+    ...options
+  });
+}
+
+// hooks/use-org-admin.ts
+function useOrgAdmin(options) {
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const listOrgs = useCallback(async (filter) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await listOrgsApi(filter, options);
+      if (response.error) {
+        setError(response.error);
+        return [];
+      }
+      return response.data?.orgs || [];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to list organizations";
+      setError(message);
+      return [];
+    } finally {
+      setLoading(false);
+    }
+  }, [options]);
+  const getOrg = useCallback(
+    async (orgId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getOrgApi(orgId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.org || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get organization";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const getOrgInfo = useCallback(
+    async (orgId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getOrgInfoApi(orgId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.orgInfo || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get organization info";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const createOrg = useCallback(
+    async (org) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await createOrgApi(org, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.org || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create organization";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const createOrgWithSchemas = useCallback(
+    async (org, schemas) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await createOrgWithSchemasApi(org, schemas, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create organization with schemas";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const updateOrg = useCallback(
+    async (orgId, updates) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await updateOrgApi(orgId, updates, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.org || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to update organization";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const deleteOrg = useCallback(
+    async (orgId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await deleteOrgApi(orgId, options);
+        if (response.error) {
+          setError(response.error);
+          return false;
+        }
+        return response.data?.success || false;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to delete organization";
+        setError(message);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  return {
+    loading,
+    error,
+    listOrgs,
+    getOrg,
+    getOrgInfo,
+    createOrg,
+    createOrgWithSchemas,
+    updateOrg,
+    deleteOrg
+  };
+}
+
+// hooks/use-users-admin.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+function useUsersAdmin(options) {
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const listUsers = useCallback2(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await listUsersApi(options);
+      if (response.error) {
+        setError(response.error);
+        return [];
+      }
+      return response.data?.users || [];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to list users";
+      setError(message);
+      return [];
+    } finally {
+      setLoading(false);
+    }
+  }, [options]);
+  const getUser = useCallback2(
+    async (userId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getUserApi(userId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.user || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get user";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const getUserByEmail = useCallback2(
+    async (email) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getUserByEmailApi(email, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.user || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get user by email";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const getUserByPhone = useCallback2(
+    async (phone) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getUserByPhoneApi(phone, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.user || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get user by phone";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const createUser = useCallback2(
+    async (user) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await createUserApi(user, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.user || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create user";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const updateUser = useCallback2(
+    async (userId, updates) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await updateUserApi(userId, updates, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.user || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to update user";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const deleteUser = useCallback2(
+    async (userId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await deleteUserApi(userId, options);
+        if (response.error) {
+          setError(response.error);
+          return false;
+        }
+        return response.data?.success || false;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to delete user";
+        setError(message);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const getUserSettings = useCallback2(
+    async (userId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getUserSettingsApi(userId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get user settings";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const updateUserSettings = useCallback2(
+    async (userId, settings) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await updateUserSettingsApi(userId, settings, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to update user settings";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  return {
+    loading,
+    error,
+    listUsers,
+    getUser,
+    getUserByEmail,
+    getUserByPhone,
+    createUser,
+    updateUser,
+    deleteUser,
+    getUserSettings,
+    updateUserSettings
+  };
+}
+
+// hooks/use-invites-admin.ts
+import { useState as useState3, useCallback as useCallback3 } from "react";
+function useInvitesAdmin(options) {
+  const [loading, setLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const listInvites = useCallback3(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await listInvitesApi(options);
+      if (response.error) {
+        setError(response.error);
+        return [];
+      }
+      return response.data?.invites || [];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to list invites";
+      setError(message);
+      return [];
+    } finally {
+      setLoading(false);
+    }
+  }, [options]);
+  const getInvite = useCallback3(
+    async (inviteId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await getInviteApi(inviteId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.invite || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get invite";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const sendInvite = useCallback3(
+    async (invite) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await sendInviteApi(invite, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.invite || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to send invite";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const sendInvites = useCallback3(
+    async (invites) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await sendInvitesApi(invites, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to send invites";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const resendInvite = useCallback3(
+    async (inviteId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await resendInviteApi(inviteId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.invite || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to resend invite";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const revokeInvite = useCallback3(
+    async (inviteId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await revokeInviteApi(inviteId, options);
+        if (response.error) {
+          setError(response.error);
+          return false;
+        }
+        return response.data?.success || false;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to revoke invite";
+        setError(message);
+        return false;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const acceptInvite = useCallback3(
+    async (inviteId) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await acceptInviteApi(inviteId, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.invite || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to accept invite";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  return {
+    loading,
+    error,
+    listInvites,
+    getInvite,
+    sendInvite,
+    sendInvites,
+    resendInvite,
+    revokeInvite,
+    acceptInvite
+  };
+}
+
+// hooks/use-org-settings.ts
+import { useState as useState4, useCallback as useCallback4 } from "react";
+function useOrgSettings(options) {
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const getSettings = useCallback4(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await getOrgSettingsApi(options);
+      if (response.error) {
+        setError(response.error);
+        return null;
+      }
+      return response.data?.settings || null;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to get organization settings";
+      setError(message);
+      return null;
+    } finally {
+      setLoading(false);
+    }
+  }, [options]);
+  const createSettings = useCallback4(
+    async (settings) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await createOrgSettingsApi(settings, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.settings || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create organization settings";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  const updateSettings = useCallback4(
+    async (settings) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await updateOrgSettingsApi(settings, options);
+        if (response.error) {
+          setError(response.error);
+          return null;
+        }
+        return response.data?.settings || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to update organization settings";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [options]
+  );
+  return {
+    loading,
+    error,
+    getSettings,
+    createSettings,
+    updateSettings
+  };
+}
+
+// hooks/use-product-analytics.ts
+import { useState as useState5, useCallback as useCallback5, useRef, useEffect } from "react";
+function useProductAnalytics(options) {
+  const [state, setState] = useState5({
+    summary: null,
+    chats: [],
+    agents: [],
+    usage: [],
+    daily: [],
+    events: [],
+    loading: false,
+    error: null
+  });
+  const sessionIdRef = useRef("");
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      let sessionId = sessionStorage.getItem("analytics_session_id");
+      if (!sessionId) {
+        sessionId = crypto.randomUUID();
+        sessionStorage.setItem("analytics_session_id", sessionId);
+      }
+      sessionIdRef.current = sessionId;
+    }
+  }, []);
+  const getSummary = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getAnalyticsSummaryApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return null;
+        }
+        const summary = response.data?.data || null;
+        setState((prev) => ({ ...prev, loading: false, summary }));
+        return summary;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get analytics summary";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return null;
+      }
+    },
+    [options]
+  );
+  const getChats = useCallback5(
+    async (filter, agentId) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getChatsAnalyticsApi(filter, agentId, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return [];
+        }
+        const chats = response.data?.data || [];
+        setState((prev) => ({ ...prev, loading: false, chats }));
+        return chats;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get chat analytics";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return [];
+      }
+    },
+    [options]
+  );
+  const getAgents = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getAgentsAnalyticsApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return [];
+        }
+        const agents = response.data?.data || [];
+        setState((prev) => ({ ...prev, loading: false, agents }));
+        return agents;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get agent analytics";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return [];
+      }
+    },
+    [options]
+  );
+  const getUsage = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getUsageAnalyticsApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return [];
+        }
+        const usage = response.data?.data || [];
+        setState((prev) => ({ ...prev, loading: false, usage }));
+        return usage;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get usage analytics";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return [];
+      }
+    },
+    [options]
+  );
+  const getDaily = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getDailyAnalyticsApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return [];
+        }
+        const daily = response.data?.data || [];
+        setState((prev) => ({ ...prev, loading: false, daily }));
+        return daily;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get daily analytics";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return [];
+      }
+    },
+    [options]
+  );
+  const getEvents = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getAnalyticsEventsApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return [];
+        }
+        const events = response.data?.data || [];
+        setState((prev) => ({ ...prev, loading: false, events }));
+        return events;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get analytics events";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return [];
+      }
+    },
+    [options]
+  );
+  const trackEvent = useCallback5(
+    async (eventType, eventCategory, properties) => {
+      try {
+        const event = {
+          sessionId: sessionIdRef.current,
+          userId: options.userId || "",
+          eventType,
+          eventCategory,
+          pagePath: typeof window !== "undefined" ? window.location.pathname : void 0,
+          properties
+        };
+        await logAnalyticsEventApi(event, options);
+      } catch {
+        console.debug("Failed to track analytics event:", eventType);
+      }
+    },
+    [options]
+  );
+  const trackPageView = useCallback5(
+    async (pageName) => {
+      await trackEvent("page_view", "navigation", {
+        pageName: pageName || (typeof window !== "undefined" ? document.title : "")
+      });
+    },
+    [trackEvent]
+  );
+  const getGlobalSummary = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getGlobalSummaryApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return null;
+        }
+        setState((prev) => ({ ...prev, loading: false }));
+        return response.data?.data || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get global summary";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return null;
+      }
+    },
+    [options]
+  );
+  const getGlobalOrgs = useCallback5(
+    async (filter) => {
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const response = await getGlobalOrgsAnalyticsApi(filter, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, loading: false, error: response.error || null }));
+          return [];
+        }
+        setState((prev) => ({ ...prev, loading: false }));
+        return response.data?.data || [];
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get org analytics";
+        setState((prev) => ({ ...prev, loading: false, error: message }));
+        return [];
+      }
+    },
+    [options]
+  );
+  return {
+    // State
+    ...state,
+    // Query functions
+    getSummary,
+    getChats,
+    getAgents,
+    getUsage,
+    getDaily,
+    getEvents,
+    // Event tracking
+    trackEvent,
+    trackPageView,
+    // Global analytics (admin)
+    getGlobalSummary,
+    getGlobalOrgs
+  };
+}
+var useAnalyticsContext = useProductAnalytics;
+
+// hooks/use-org-provisioning.ts
+import { useState as useState6, useCallback as useCallback6, useEffect as useEffect2, useRef as useRef2 } from "react";
+function useOrgProvisioning(options) {
+  const [state, setState] = useState6({
+    status: "idle",
+    progress: null,
+    org: null,
+    error: null,
+    percentage: 0
+  });
+  const cleanupRef = useRef2(null);
+  useEffect2(() => {
+    return () => {
+      if (cleanupRef.current) {
+        cleanupRef.current();
+      }
+    };
+  }, []);
+  const createOrgWithProvisioning = useCallback6(
+    async (request) => {
+      setState((prev) => ({
+        ...prev,
+        status: "creating",
+        error: null,
+        progress: null,
+        percentage: 0
+      }));
+      try {
+        const response = await createOrgWithProvisioningApi(request, options);
+        if (response.error) {
+          setState((prev) => ({
+            ...prev,
+            status: "failed",
+            error: response.error || "Failed to create organization"
+          }));
+          return null;
+        }
+        const org = response.data?.organization || response.data?.org;
+        if (!org) {
+          setState((prev) => ({
+            ...prev,
+            status: "failed",
+            error: "No organization returned"
+          }));
+          return null;
+        }
+        setState((prev) => ({
+          ...prev,
+          status: "provisioning",
+          org
+        }));
+        const cleanup = streamProvisioningProgress(
+          org.id,
+          {
+            onProgress: (progress) => {
+              const percentage = calculateProgressPercentage(progress);
+              const status = isProvisioningComplete(progress) ? isProvisioningSuccessful(progress) ? "completed" : progress.status === "partial" ? "partial" : "failed" : "provisioning";
+              setState((prev) => ({
+                ...prev,
+                status,
+                progress,
+                percentage,
+                error: progress.error || null
+              }));
+            },
+            onDone: () => {
+              cleanupRef.current = null;
+            },
+            onError: (error) => {
+              setState((prev) => ({
+                ...prev,
+                status: "failed",
+                error: error.message
+              }));
+              cleanupRef.current = null;
+            },
+            onTimeout: () => {
+              setState((prev) => ({
+                ...prev,
+                error: "Provisioning timed out"
+              }));
+              cleanupRef.current = null;
+            }
+          },
+          { baseUrl: options.baseUrl }
+        );
+        cleanupRef.current = cleanup;
+        return org;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to create organization";
+        setState((prev) => ({
+          ...prev,
+          status: "failed",
+          error: message
+        }));
+        return null;
+      }
+    },
+    [options]
+  );
+  const getProvisioningStatus = useCallback6(
+    async (orgId) => {
+      try {
+        const response = await getProvisioningStatusApi(orgId, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, error: response.error || null }));
+          return null;
+        }
+        const progress = response.data?.progress || null;
+        if (progress) {
+          setState((prev) => ({
+            ...prev,
+            progress,
+            percentage: calculateProgressPercentage(progress),
+            status: isProvisioningComplete(progress) ? isProvisioningSuccessful(progress) ? "completed" : progress.status === "partial" ? "partial" : "failed" : "provisioning"
+          }));
+        }
+        return progress;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to get provisioning status";
+        setState((prev) => ({ ...prev, error: message }));
+        return null;
+      }
+    },
+    [options]
+  );
+  const retryProvisioning = useCallback6(
+    async (orgId, artifacts) => {
+      setState((prev) => ({
+        ...prev,
+        status: "provisioning",
+        error: null
+      }));
+      try {
+        const request = artifacts ? { artifacts } : void 0;
+        const response = await retryProvisioningApi(orgId, request, options);
+        if (response.error) {
+          setState((prev) => ({
+            ...prev,
+            status: "failed",
+            error: response.error || "Failed to retry provisioning"
+          }));
+          return false;
+        }
+        const cleanup = streamProvisioningProgress(
+          orgId,
+          {
+            onProgress: (progress) => {
+              const percentage = calculateProgressPercentage(progress);
+              const status = isProvisioningComplete(progress) ? isProvisioningSuccessful(progress) ? "completed" : progress.status === "partial" ? "partial" : "failed" : "provisioning";
+              setState((prev) => ({
+                ...prev,
+                status,
+                progress,
+                percentage,
+                error: progress.error || null
+              }));
+            },
+            onDone: () => {
+              cleanupRef.current = null;
+            },
+            onError: (error) => {
+              setState((prev) => ({
+                ...prev,
+                status: "failed",
+                error: error.message
+              }));
+              cleanupRef.current = null;
+            }
+          },
+          { baseUrl: options.baseUrl }
+        );
+        cleanupRef.current = cleanup;
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to retry provisioning";
+        setState((prev) => ({
+          ...prev,
+          status: "failed",
+          error: message
+        }));
+        return false;
+      }
+    },
+    [options]
+  );
+  const validateProvisioning = useCallback6(
+    async (orgId) => {
+      try {
+        const response = await validateProvisioningApi(orgId, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, error: response.error || null }));
+          return null;
+        }
+        return response.data || null;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to validate provisioning";
+        setState((prev) => ({ ...prev, error: message }));
+        return null;
+      }
+    },
+    [options]
+  );
+  const cancelProvisioning = useCallback6(
+    async (orgId) => {
+      try {
+        if (cleanupRef.current) {
+          cleanupRef.current();
+          cleanupRef.current = null;
+        }
+        const response = await cancelProvisioningApi(orgId, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, error: response.error || null }));
+          return false;
+        }
+        setState((prev) => ({
+          ...prev,
+          status: "failed",
+          error: "Provisioning cancelled"
+        }));
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to cancel provisioning";
+        setState((prev) => ({ ...prev, error: message }));
+        return false;
+      }
+    },
+    [options]
+  );
+  const cleanupOrg = useCallback6(
+    async (orgId) => {
+      try {
+        const response = await cleanupProvisioningApi(orgId, options);
+        if (response.error) {
+          setState((prev) => ({ ...prev, error: response.error || null }));
+          return false;
+        }
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to cleanup organization";
+        setState((prev) => ({ ...prev, error: message }));
+        return false;
+      }
+    },
+    [options]
+  );
+  const reset = useCallback6(() => {
+    if (cleanupRef.current) {
+      cleanupRef.current();
+      cleanupRef.current = null;
+    }
+    setState({
+      status: "idle",
+      progress: null,
+      org: null,
+      error: null,
+      percentage: 0
+    });
+  }, []);
+  return {
+    state,
+    createOrgWithProvisioning,
+    getProvisioningStatus,
+    retryProvisioning,
+    validateProvisioning,
+    cancelProvisioning,
+    cleanupOrg,
+    reset,
+    // Helper functions
+    isComplete: state.status === "completed",
+    isFailed: state.status === "failed",
+    isPartial: state.status === "partial",
+    isProvisioning: state.status === "provisioning" || state.status === "creating",
+    failedArtifacts: state.progress ? getFailedArtifacts(state.progress) : [],
+    hasCriticalFailures: state.progress ? hasCriticalFailures(state.progress) : false
+  };
+}
+export {
+  useAnalyticsContext,
+  useInvitesAdmin,
+  useOrgAdmin,
+  useOrgProvisioning,
+  useOrgSettings,
+  useProductAnalytics,
+  useUsersAdmin
+};
+//# sourceMappingURL=index.js.map