@elevasis/ui 2.73.0 → 2.75.0

package/dist/chunk-DTEGVSJ6.js

@@ -0,0 +1,645 @@
+import { projectKeys, noteKeys, taskKeys, milestoneKeys } from './chunk-IYATYH5I.js';
+import { leadGenListMemberKeys } from './chunk-DVAOCHIF.js';
+import { companyKeys, contactKeys } from './chunk-NYIIRZSA.js';
+import { useErrorNotification } from './chunk-DMSTDZCJ.js';
+import { useNotificationAdapter, dealKeys, acquisitionListKeys, useListsTelemetry, useOptionalElevasisSystems, useSSEConnection } from './chunk-SB3IHM5Y.js';
+import { HTTP_HEADERS } from './chunk-ZG6YJUT4.js';
+import { showApiErrorNotification, showSuccessNotification } from './chunk-ICHDIVQO.js';
+import { OrganizationContext, useOrganization } from './chunk-DD3CCMCZ.js';
+import { STALE_TIME_DEFAULT, STALE_TIME_ADMIN } from './chunk-A2SB32YV.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { useAuthContext } from './chunk-BRJ3QZ4E.js';
+import { useContext, useEffect, useState, useRef, useCallback, useMemo } from 'react';
+import { useQueryClient, useMutation, useQuery } from '@tanstack/react-query';
+import { notifications } from '@mantine/notifications';
+import { createClient } from '@supabase/supabase-js';
+
+function useCreateOrgRole() {
+  const { apiRequest } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const orgId = organization?.currentSupabaseOrganizationId ?? null;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (input) => apiRequest(`/organizations/${orgId}/roles`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["org-roles", orgId] });
+    }
+  });
+}
+
+// src/hooks/settings/api-keys/apiKeyService.ts
+var ApiKeyService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * List API keys for the current organization
+   */
+  async listApiKeys() {
+    const response = await this.apiRequest("/api-keys");
+    return response.keys;
+  }
+  /**
+   * Create a new API key
+   */
+  async createApiKey(data) {
+    return await this.apiRequest("/api-keys", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Update an API key's name
+   */
+  async updateApiKey(keyId, data) {
+    await this.apiRequest(`/api-keys/${keyId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Delete an API key
+   */
+  async deleteApiKey(keyId) {
+    await this.apiRequest(`/api-keys/${keyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+function useListApiKeys() {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["api-keys", workOSOrganizationId],
+    queryFn: async () => {
+      const service = new ApiKeyService(apiRequest);
+      return await service.listApiKeys();
+    },
+    enabled: isReady
+  });
+}
+function useCreateApiKey() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (data) => {
+      const service = new ApiKeyService(apiRequest);
+      return await service.createApiKey(data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["api-keys"] });
+      notifications.show({
+        title: "Success",
+        message: "API key created successfully. Please save it immediately!",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to create API key:", error);
+      adapter.apiError(error);
+    }
+  });
+}
+function useDeleteApiKey() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (keyId) => {
+      const service = new ApiKeyService(apiRequest);
+      return await service.deleteApiKey(keyId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["api-keys"] });
+      notifications.show({
+        title: "Success",
+        message: "API key deleted successfully",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to delete API key:", error);
+      adapter.apiError(error);
+    }
+  });
+}
+function useUpdateApiKey() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ keyId, name }) => {
+      const service = new ApiKeyService(apiRequest);
+      return await service.updateApiKey(keyId, { name });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["api-keys"] });
+      notifications.show({
+        title: "Success",
+        message: "API key renamed successfully",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to update API key:", error);
+      adapter.apiError(error);
+    }
+  });
+}
+
+// src/hooks/settings/deployments/deploymentService.ts
+var DeploymentService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  async listDeployments() {
+    const response = await this.apiRequest("/deployments");
+    return response.deployments;
+  }
+  async getDeployment(id) {
+    return await this.apiRequest(`/deployments/${id}`);
+  }
+  async activateDeployment(id) {
+    return await this.apiRequest(`/deployments/${id}/activate`, { method: "POST" });
+  }
+  async deactivateDeployment(id) {
+    return await this.apiRequest(`/deployments/${id}/deactivate`, { method: "POST" });
+  }
+  async deleteDeployment(id) {
+    await this.apiRequest(`/deployments/${id}`, { method: "DELETE" });
+  }
+};
+
+// src/hooks/settings/deployments/useDeploymentActions.ts
+function useActivateDeployment() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  const showError = useErrorNotification();
+  return useMutation({
+    mutationFn: (deploymentId) => {
+      const service = new DeploymentService(apiRequest);
+      return service.activateDeployment(deploymentId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deployments", workOSOrganizationId] });
+      notifications.show({ title: "Success", message: "Deployment activated", color: "teal" });
+    },
+    onError: (error) => {
+      console.error("Failed to activate deployment:", error);
+      showError(error);
+    }
+  });
+}
+function useDeactivateDeployment() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  const showError = useErrorNotification();
+  return useMutation({
+    mutationFn: (deploymentId) => {
+      const service = new DeploymentService(apiRequest);
+      return service.deactivateDeployment(deploymentId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deployments", workOSOrganizationId] });
+      notifications.show({ title: "Success", message: "Deployment deactivated", color: "teal" });
+    },
+    onError: (error) => {
+      console.error("Failed to deactivate deployment:", error);
+      showError(error);
+    }
+  });
+}
+function useDeleteDeployment() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  const showError = useErrorNotification();
+  return useMutation({
+    mutationFn: (deploymentId) => {
+      const service = new DeploymentService(apiRequest);
+      return service.deleteDeployment(deploymentId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["deployments", workOSOrganizationId] });
+      notifications.show({ title: "Success", message: "Deployment deleted", color: "teal" });
+    },
+    onError: (error) => {
+      console.error("Failed to delete deployment:", error);
+      showError(error);
+    }
+  });
+}
+function useListDeployments() {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["deployments", workOSOrganizationId],
+    queryFn: async () => {
+      const service = new DeploymentService(apiRequest);
+      return await service.listDeployments();
+    },
+    enabled: isReady,
+    refetchInterval: (query) => {
+      const deployments = query.state.data ?? [];
+      return deployments.some((d) => d.status === "deploying") ? 5e3 : false;
+    }
+  });
+}
+function useTransitionItem() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input) => {
+      const { dealId, pipelineKey, stageKey, stateKey, reason, expectedUpdatedAt } = input;
+      await apiRequest(`/deals/${dealId}/transition`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          pipelineKey,
+          stageKey,
+          ...stateKey !== void 0 ? { stateKey } : {},
+          ...reason !== void 0 ? { reason } : {},
+          ...expectedUpdatedAt !== void 0 ? { expectedUpdatedAt } : {}
+        })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: dealKeys.summaries() });
+      queryClient.invalidateQueries({ queryKey: ["deal-detail", workOSOrganizationId, variables.dealId] });
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+function getSupabaseConfig() {
+  const url = import.meta.env?.VITE_SUPABASE_URL;
+  const anonKey = import.meta.env?.VITE_SUPABASE_ANON_KEY;
+  if (!url || !anonKey) {
+    throw new Error("Missing Supabase environment variables (VITE_SUPABASE_URL, VITE_SUPABASE_ANON_KEY)");
+  }
+  return { url, anonKey };
+}
+var useSupabase = () => {
+  const { getAccessToken } = useAuthContext();
+  const { url, anonKey } = getSupabaseConfig();
+  return useMemo(
+    () => createClient(url, anonKey, {
+      global: {
+        headers: {
+          // Additional headers if needed
+        }
+      },
+      accessToken: async () => {
+        try {
+          const token = await getAccessToken();
+          if (!token) {
+            return null;
+          }
+          return token;
+        } catch {
+          return null;
+        }
+      }
+    }),
+    [getAccessToken, url, anonKey]
+  );
+};
+var projectActivityKeys = {
+  all: ["project-activities"],
+  list: (projectId) => [...projectActivityKeys.all, "list", projectId]
+};
+function useProjectActivities(projectId, enabled = true) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: [...projectActivityKeys.list(projectId), workOSOrganizationId],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      params.set("entityType", "project");
+      params.set("entityId", projectId);
+      params.set("limit", "50");
+      const res = await apiRequest(`/activities?${params.toString()}`);
+      return res.activities.map((activity) => ({
+        ...activity,
+        occurredAt: new Date(activity.occurredAt),
+        createdAt: new Date(activity.createdAt)
+      }));
+    },
+    enabled: isReady && !!projectId && enabled
+  });
+}
+function useUpdateOrgRole() {
+  const { apiRequest } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const orgId = organization?.currentSupabaseOrganizationId ?? null;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ roleId, input }) => apiRequest(`/organizations/${orgId}/roles/${roleId}`, {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    }),
+    onSettled: (_data, _error, { roleId }) => {
+      queryClient.invalidateQueries({ queryKey: ["org-roles", orgId] });
+      queryClient.invalidateQueries({ queryKey: ["org-role", orgId, roleId] });
+    }
+  });
+}
+function useDeleteOrgRole() {
+  const { apiRequest } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const orgId = organization?.currentSupabaseOrganizationId ?? null;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (roleId) => apiRequest(`/organizations/${orgId}/roles/${roleId}`, {
+      method: "DELETE"
+    }),
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["org-roles", orgId] });
+    }
+  });
+}
+function useEffectivePermissions(membershipId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const organization = useContext(OrganizationContext);
+  const orgId = organization?.currentSupabaseOrganizationId ?? null;
+  return useQuery({
+    queryKey: ["member-roles", orgId, membershipId],
+    queryFn: () => apiRequest(`/memberships/${membershipId}/effective-permissions`),
+    enabled: isReady && !!membershipId,
+    staleTime: STALE_TIME_DEFAULT
+  });
+}
+function useActivitiesRealtime(organizationId, enabled) {
+  const queryClient = useQueryClient();
+  const supabase = useSupabase();
+  useEffect(() => {
+    if (!enabled || !organizationId) {
+      return;
+    }
+    const channel = supabase.channel(`activities-realtime-${organizationId}`).on(
+      "postgres_changes",
+      {
+        event: "INSERT",
+        schema: "public",
+        table: "activities",
+        filter: `organization_id=eq.${organizationId}`
+      },
+      () => {
+        queryClient.invalidateQueries({ queryKey: ["activities"] });
+      }
+    ).subscribe();
+    return () => {
+      void supabase.removeChannel(channel);
+    };
+  }, [organizationId, enabled, queryClient, supabase]);
+}
+function useResourceErrors({ resourceId, timeRange, hasFailures }) {
+  const { apiRequest, workOSOrganizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["resource-errors", workOSOrganizationId, resourceId, timeRange],
+    queryFn: async () => {
+      return apiRequest(
+        `/command-view/resource-errors?resourceId=${resourceId}&timeRange=${timeRange}`
+      );
+    },
+    // Only fetch when: org ready, resource selected, and resource has failures
+    enabled: isReady && !!resourceId && hasFailures,
+    staleTime: STALE_TIME_ADMIN
+  });
+}
+function useTransitionState() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (input) => {
+      const { dealId, stateKey, reason, expectedUpdatedAt } = input;
+      await apiRequest(`/deals/${dealId}/state`, {
+        method: "PATCH",
+        body: JSON.stringify({
+          stateKey,
+          ...reason !== void 0 ? { reason } : {},
+          ...expectedUpdatedAt !== void 0 ? { expectedUpdatedAt } : {}
+        })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: dealKeys.summaries() });
+      queryClient.invalidateQueries({ queryKey: ["deal-detail", workOSOrganizationId, variables.dealId] });
+    },
+    onError: (error) => {
+      queryClient.invalidateQueries({ queryKey: dealKeys.all });
+      showApiErrorNotification(error);
+    }
+  });
+}
+var dealNoteKeys = {
+  all: ["deal-notes"],
+  list: (organizationId, dealId) => ["deal-notes", organizationId, dealId]
+};
+function useDealNotes(dealId) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: dealNoteKeys.list(workOSOrganizationId, dealId),
+    queryFn: async () => {
+      return apiRequest(`/deals/${dealId}/notes`);
+    },
+    enabled: isReady && !!dealId
+  });
+}
+function useCreateDealNote() {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ dealId, body }) => {
+      return apiRequest(`/deals/${dealId}/notes`, {
+        method: "POST",
+        body: JSON.stringify({ body })
+      });
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({ queryKey: dealNoteKeys.list(workOSOrganizationId, variables.dealId) });
+      queryClient.invalidateQueries({ queryKey: ["recent-crm-activity", workOSOrganizationId] });
+      showSuccessNotification("Note added");
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useAddCompaniesToList(listId) {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body) => apiRequest(`/acquisition/lists/${listId}/companies`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: companyKeys.all });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.detail(workOSOrganizationId, listId) });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.progress(workOSOrganizationId, listId) });
+      queryClient.invalidateQueries({ queryKey: leadGenListMemberKeys.list(workOSOrganizationId, listId) });
+      showSuccessNotification("Companies added to list");
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useRemoveCompaniesFromList(listId) {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body) => apiRequest(`/acquisition/lists/${listId}/companies`, {
+      method: "DELETE",
+      body: JSON.stringify(body)
+    }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: companyKeys.all });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.detail(workOSOrganizationId, listId) });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.progress(workOSOrganizationId, listId) });
+      queryClient.invalidateQueries({ queryKey: leadGenListMemberKeys.list(workOSOrganizationId, listId) });
+      showSuccessNotification("Companies removed from list");
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useAddContactsToList(listId) {
+  const { apiRequest, workOSOrganizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body) => apiRequest(`/acquisition/lists/${listId}/contacts`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: contactKeys.all });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.detail(workOSOrganizationId, listId) });
+      queryClient.invalidateQueries({ queryKey: acquisitionListKeys.progress(workOSOrganizationId, listId) });
+      queryClient.invalidateQueries({ queryKey: leadGenListMemberKeys.list(workOSOrganizationId, listId) });
+      showSuccessNotification("Contacts added to list");
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+// src/hooks/acquisition/useBatchTelemetry.ts
+function useBatchTelemetry() {
+  return useListsTelemetry();
+}
+function useVisibleResources() {
+  const [visibleIds, setVisibleIds] = useState(/* @__PURE__ */ new Set());
+  const observerRef = useRef(null);
+  const containerRef = useRef(null);
+  useEffect(() => {
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        setVisibleIds((prev) => {
+          const next = new Set(prev);
+          for (const entry of entries) {
+            const id = entry.target.dataset.resourceId;
+            if (!id) continue;
+            if (entry.isIntersecting) {
+              next.add(id);
+            } else {
+              next.delete(id);
+            }
+          }
+          return next;
+        });
+      },
+      { threshold: 0.5 }
+    );
+    return () => {
+      observerRef.current?.disconnect();
+    };
+  }, []);
+  useEffect(() => {
+    const observer = observerRef.current;
+    const container = containerRef.current;
+    if (!observer || !container) return;
+    const cards = container.querySelectorAll("[data-resource-id]");
+    cards.forEach((card) => observer.observe(card));
+    return () => {
+      cards.forEach((card) => observer.unobserve(card));
+    };
+  });
+  const setContainerRef = useCallback((node) => {
+    containerRef.current = node;
+  }, []);
+  return { visibleIds, setContainerRef };
+}
+var noopSSEManager = {
+  subscribe: () => () => {
+  },
+  closeConnection: () => {
+  },
+  getConnectionInfo: () => /* @__PURE__ */ new Map()
+};
+function useProjectRealtime(projectId) {
+  const queryClient = useQueryClient();
+  const systems = useOptionalElevasisSystems();
+  const { isReady, workOSOrganizationId } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const deliveryApiUrl = systems?.deliveryApiUrl;
+  const deliverySSEManager = systems?.deliverySSEManager ?? noopSSEManager;
+  const currentWorkOSOrganizationId = currentMembership?.organization?.workos_org_id;
+  const headers = useMemo(() => {
+    if (!currentWorkOSOrganizationId) {
+      return {};
+    }
+    const nextHeaders = {};
+    nextHeaders[HTTP_HEADERS.WORKOS_ORGANIZATION_ID] = currentWorkOSOrganizationId;
+    return nextHeaders;
+  }, [currentWorkOSOrganizationId]);
+  const handleMessage = useCallback(
+    (rawData) => {
+      try {
+        const event = JSON.parse(rawData);
+        if (event.type !== "entity_changed") {
+          return;
+        }
+        const { entityType, projectId: changedProjectId } = event.data;
+        queryClient.invalidateQueries({ queryKey: projectKeys.all });
+        queryClient.invalidateQueries({ queryKey: projectKeys.detail(changedProjectId) });
+        queryClient.invalidateQueries({ queryKey: projectActivityKeys.list(changedProjectId) });
+        switch (entityType) {
+          case "milestone":
+            queryClient.invalidateQueries({ queryKey: milestoneKeys.all });
+            queryClient.invalidateQueries({ queryKey: projectKeys.milestones(changedProjectId) });
+            break;
+          case "task":
+            queryClient.invalidateQueries({ queryKey: taskKeys.all });
+            queryClient.invalidateQueries({ queryKey: projectKeys.tasks(changedProjectId) });
+            break;
+          case "note":
+            queryClient.invalidateQueries({ queryKey: noteKeys.all });
+            break;
+          case "activity":
+          case "project":
+            break;
+        }
+      } catch {
+      }
+    },
+    [queryClient]
+  );
+  useSSEConnection({
+    manager: deliverySSEManager,
+    connectionKey: `delivery-${currentWorkOSOrganizationId ?? workOSOrganizationId ?? projectId ?? "unknown"}`,
+    url: deliveryApiUrl ? `${deliveryApiUrl}/api/projects/sse` : "",
+    enabled: Boolean(deliveryApiUrl && systems?.deliverySSEManager && currentWorkOSOrganizationId && isReady),
+    headers,
+    onmessage: handleMessage,
+    onopen: (response) => response.status === 403 ? "Organization access denied" : void 0
+  });
+}
+
+export { ApiKeyService, DeploymentService, dealNoteKeys, projectActivityKeys, useActivateDeployment, useActivitiesRealtime, useAddCompaniesToList, useAddContactsToList, useBatchTelemetry, useCreateApiKey, useCreateDealNote, useCreateOrgRole, useDeactivateDeployment, useDealNotes, useDeleteApiKey, useDeleteDeployment, useDeleteOrgRole, useEffectivePermissions, useListApiKeys, useListDeployments, useProjectActivities, useProjectRealtime, useRemoveCompaniesFromList, useResourceErrors, useTransitionItem, useTransitionState, useUpdateApiKey, useUpdateOrgRole, useVisibleResources };