@elevasis/ui 1.7.5 → 1.8.0

package/dist/chunk-QWYJHM3S.js

@@ -0,0 +1,1068 @@
+import { CredentialNameSchema, UuidSchema, useErrorNotification } from './chunk-BWZMI4KP.js';
+import { getTimeRangeDates } from './chunk-ARZM3OTI.js';
+import { useNotificationAdapter } from './chunk-JRJW2H57.js';
+import { GC_TIME_SHORT, STALE_TIME_MONITORING, GC_TIME_MEDIUM, STALE_TIME_DEFAULT, getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-Z4TPHMRD.js';
+import { useElevasisServices } from './chunk-GZVH423C.js';
+import { z } from 'zod';
+import { create } from 'zustand';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { persist } from 'zustand/middleware';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { notifications } from '@mantine/notifications';
+
+var MembershipRoleSchema = z.enum(["admin", "member"]);
+z.enum(["active", "inactive"]);
+var MembershipIdParamSchema = z.object({
+  id: z.string().min(1)
+  // WorkOS membership IDs can be various formats
+}).strict();
+var CreateMembershipSchema = z.object({
+  userId: z.string().min(1),
+  organizationId: z.string().min(1),
+  roleSlug: MembershipRoleSchema.default("member")
+}).strict();
+var UpdateMembershipSchema = z.object({
+  roleSlug: MembershipRoleSchema
+}).strict();
+var ListMembershipsQuerySchema = z.object({
+  userId: z.string().optional(),
+  organizationId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  before: z.string().optional(),
+  // WorkOS pagination cursor
+  after: z.string().optional()
+  // WorkOS pagination cursor
+}).strict().refine(
+  (data) => data.userId || data.organizationId,
+  {
+    message: "Either userId or organizationId must be provided"
+  }
+);
+var CredentialTypeSchema = z.enum(["oauth", "api-key", "webhook-secret", "api-key-secret"]);
+var CredentialValueSchema = z.record(z.string(), z.unknown()).refine((val) => Object.keys(val).length > 0, { message: "Credential value must not be empty" }).refine((val) => Object.keys(val).length <= 50, { message: "Credential value has too many keys (max 50)" }).refine(
+  (val) => {
+    for (const v of Object.values(val)) {
+      if (typeof v === "string" && v.length > 10240) {
+        return false;
+      }
+    }
+    return true;
+  },
+  { message: "Individual credential values too large (max 10KB per string)" }
+);
+var CreateCredentialRequestSchema = z.object({
+  name: CredentialNameSchema,
+  type: CredentialTypeSchema,
+  value: CredentialValueSchema,
+  provider: z.string().optional()
+  // OAuth provider ID ('dropbox', 'notion', 'google-sheets')
+}).strict();
+z.object({
+  id: UuidSchema,
+  name: z.string()
+});
+z.object({
+  credentials: z.array(
+    z.object({
+      id: UuidSchema,
+      name: z.string(),
+      type: z.string(),
+      provider: z.string().nullable(),
+      // OAuth provider or null for non-OAuth
+      createdAt: z.string().datetime()
+    })
+  )
+});
+var UpdateCredentialParamsSchema = z.object({
+  credentialId: UuidSchema
+});
+var UpdateCredentialRequestSchema = z.object({
+  value: CredentialValueSchema.optional(),
+  name: CredentialNameSchema.optional()
+}).strict().refine((data) => data.value !== void 0 || data.name !== void 0, {
+  message: "At least one field (value or name) must be provided"
+});
+var DeleteCredentialParamsSchema = z.object({
+  credentialId: UuidSchema
+});
+z.object({
+  credentialName: CredentialNameSchema
+});
+z.object({
+  value: z.record(z.string(), z.unknown())
+});
+var CredentialSchemas = {
+  CreateRequest: CreateCredentialRequestSchema,
+  UpdateParams: UpdateCredentialParamsSchema,
+  UpdateRequest: UpdateCredentialRequestSchema,
+  DeleteParams: DeleteCredentialParamsSchema};
+var useResourceSearch = create((set) => ({
+  query: "",
+  set: (query) => set({ query })
+}));
+var useStatusFilter = create((set) => ({
+  value: "all",
+  set: (value) => set({ value })
+}));
+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 FILTER_CYCLE = ["neutral", "include", "exclude"];
+function createDomainFiltersStore(storageKey) {
+  return create()(
+    persist(
+      (set) => ({
+        filters: {},
+        cycle: (domainId) => set((state) => {
+          const current = state.filters[domainId] || "neutral";
+          const next = FILTER_CYCLE[(FILTER_CYCLE.indexOf(current) + 1) % FILTER_CYCLE.length];
+          return { filters: { ...state.filters, [domainId]: next } };
+        }),
+        reset: () => set({ filters: {} })
+      }),
+      { name: storageKey }
+    )
+  );
+}
+var useResourcesDomainFilters = createDomainFiltersStore("resources-domain-filters");
+var useCommandViewDomainFilters = createDomainFiltersStore("command-view-domain-filters");
+function filterByDomainFilters(items, filters) {
+  const includes = Object.entries(filters).filter(([, v]) => v === "include").map(([k]) => k);
+  const excludes = Object.entries(filters).filter(([, v]) => v === "exclude").map(([k]) => k);
+  if (includes.length === 0 && excludes.length === 0) return items;
+  return items.filter((r) => {
+    const domains = r.domains || [];
+    if (includes.length > 0 && !domains.some((d) => includes.includes(d))) return false;
+    if (excludes.length > 0 && domains.some((d) => excludes.includes(d))) return false;
+    return true;
+  });
+}
+var RANGE_MS = {
+  "1h": 60 * 60 * 1e3,
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3,
+  "30d": 30 * 24 * 60 * 60 * 1e3
+};
+function useTimeRangeDates(timeRange) {
+  return useMemo(() => {
+    const now = /* @__PURE__ */ new Date();
+    const start = new Date(now.getTime() - RANGE_MS[timeRange]);
+    return {
+      startDate: start.toISOString(),
+      endDate: now.toISOString()
+    };
+  }, [timeRange]);
+}
+function useActivityFilters(timeRange) {
+  const [filters, setFilters] = useState({
+    activityType: "all",
+    status: "all"
+  });
+  const updateFilter = useCallback((key, value) => {
+    setFilters((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const resetFilters = useCallback(() => {
+    setFilters({
+      activityType: "all",
+      status: "all"
+    });
+  }, []);
+  const getApiParams = useCallback(() => {
+    const params = {};
+    if (filters.activityType && filters.activityType !== "all") {
+      params.activityType = filters.activityType;
+    }
+    const { startDate } = getTimeRangeDates(timeRange);
+    params.startDate = startDate;
+    if (filters.status && filters.status !== "all") {
+      params.status = filters.status;
+    }
+    if (filters.search?.trim()) {
+      params.search = filters.search.trim();
+    }
+    return params;
+  }, [filters, timeRange]);
+  return {
+    filters,
+    updateFilter,
+    resetFilters,
+    getApiParams
+  };
+}
+var DEFAULT_FILTERS = {
+  resourceId: void 0,
+  status: "all",
+  resourceStatus: "all"
+};
+function useExecutionLogsFilters(_timeRange) {
+  const [filters, setFilters] = useState(DEFAULT_FILTERS);
+  const updateFilter = useCallback((key, value) => {
+    setFilters((prev) => ({ ...prev, [key]: value }));
+  }, []);
+  const resetFilters = useCallback(() => {
+    setFilters(DEFAULT_FILTERS);
+  }, []);
+  return { filters, updateFilter, resetFilters };
+}
+function useOrganizationMembers(organizationId, params) {
+  const { apiRequest } = useElevasisServices();
+  return useQuery({
+    queryKey: ["organization-members", organizationId, params],
+    queryFn: async () => {
+      const searchParams = new URLSearchParams();
+      searchParams.append("organizationId", organizationId);
+      const response = await apiRequest(`/memberships?${searchParams.toString()}`);
+      return response.data.map((membership) => ({
+        ...membership,
+        createdAt: membership.createdAt,
+        updatedAt: membership.updatedAt
+      }));
+    },
+    enabled: !!organizationId,
+    staleTime: STALE_TIME_MONITORING,
+    gcTime: GC_TIME_SHORT,
+    refetchOnWindowFocus: false
+  });
+}
+
+// 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, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["api-keys", organizationId],
+    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/credentials/credentialService.ts
+var CredentialService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * List credentials for the current organization
+   * Organization context is provided via workos-organization-id header
+   */
+  async listCredentials() {
+    const response = await this.apiRequest("/credentials");
+    return response.credentials;
+  }
+  /**
+   * Create a new credential
+   * Organization context is provided via workos-organization-id header
+   */
+  async createCredential(data) {
+    const validated = CredentialSchemas.CreateRequest.parse(data);
+    return await this.apiRequest(`/credentials`, {
+      method: "POST",
+      body: JSON.stringify(validated)
+    });
+  }
+  /**
+   * Update a credential value or metadata
+   * Organization context is provided via workos-organization-id header
+   */
+  async updateCredential(credentialId, updates) {
+    CredentialSchemas.UpdateParams.parse({ credentialId });
+    const validated = CredentialSchemas.UpdateRequest.parse(updates);
+    await this.apiRequest(`/credentials/${credentialId}`, {
+      method: "PATCH",
+      body: JSON.stringify(validated)
+    });
+  }
+  /**
+   * Delete a credential
+   * Organization context is provided via workos-organization-id header
+   */
+  async deleteCredential(credentialId) {
+    CredentialSchemas.DeleteParams.parse({ credentialId });
+    await this.apiRequest(`/credentials/${credentialId}`, {
+      method: "DELETE"
+    });
+  }
+};
+function useCredentials() {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["credentials", organizationId],
+    queryFn: async () => {
+      const service = new CredentialService(apiRequest);
+      return await service.listCredentials();
+    },
+    enabled: isReady
+  });
+}
+function useCreateCredential() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (data) => {
+      const service = new CredentialService(apiRequest);
+      return await service.createCredential(data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["credentials"] });
+      notifications.show({
+        title: "Success",
+        message: "Credential created successfully",
+        color: "green"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to create credential:", error);
+      adapter.apiError(error);
+    }
+  });
+}
+function useDeleteCredential() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (credentialId) => {
+      const service = new CredentialService(apiRequest);
+      return await service.deleteCredential(credentialId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["credentials"] });
+      notifications.show({
+        title: "Success",
+        message: "Credential deleted successfully",
+        color: "green"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to delete credential:", error);
+      adapter.apiError(error);
+    }
+  });
+}
+function useUpdateCredential() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ credentialId, updates }) => {
+      const service = new CredentialService(apiRequest);
+      return await service.updateCredential(credentialId, updates);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["credentials"] });
+      notifications.show({
+        title: "Success",
+        message: "Credential updated successfully",
+        color: "green"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to update credential:", 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" });
+  }
+};
+function useListDeployments() {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["deployments", organizationId],
+    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 useActivateDeployment() {
+  const { apiRequest, organizationId } = 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", organizationId] });
+      notifications.show({ title: "Success", message: "Deployment activated", color: "teal" });
+    },
+    onError: (error) => {
+      console.error("Failed to activate deployment:", error);
+      showError(error);
+    }
+  });
+}
+function useDeactivateDeployment() {
+  const { apiRequest, organizationId } = 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", organizationId] });
+      notifications.show({ title: "Success", message: "Deployment deactivated", color: "teal" });
+    },
+    onError: (error) => {
+      console.error("Failed to deactivate deployment:", error);
+      showError(error);
+    }
+  });
+}
+function useDeleteDeployment() {
+  const { apiRequest, organizationId } = 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", organizationId] });
+      notifications.show({ title: "Success", message: "Deployment deleted", color: "teal" });
+    },
+    onError: (error) => {
+      console.error("Failed to delete deployment:", error);
+      showError(error);
+    }
+  });
+}
+
+// src/hooks/settings/organization/organizationMembershipService.ts
+var OrganizationMembershipService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * Get user's organization memberships
+   */
+  async getUserMemberships(userId) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("userId", userId);
+    const url = `/memberships?${searchParams.toString()}`;
+    const response = await this.apiRequest(url);
+    return response.data.map((membership) => ({
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    }));
+  }
+  /**
+   * Get organization members
+   */
+  async getOrganizationMembers(organizationId) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("organizationId", organizationId);
+    const url = `/memberships?${searchParams.toString()}`;
+    const response = await this.apiRequest(url);
+    return response.data.map((membership) => ({
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    }));
+  }
+  /**
+   * List memberships with filtering
+   */
+  async listMemberships(params) {
+    if (params) {
+      ListMembershipsQuerySchema.parse(params);
+    }
+    const searchParams = new URLSearchParams();
+    if (params?.userId) {
+      searchParams.append("userId", params.userId);
+    }
+    if (params?.organizationId) {
+      searchParams.append("organizationId", params.organizationId);
+    }
+    if (params?.statuses) {
+      params.statuses.forEach((status) => searchParams.append("statuses", status));
+    }
+    if (params?.limit) {
+      searchParams.append("limit", params.limit.toString());
+    }
+    if (params?.before) {
+      searchParams.append("before", params.before);
+    }
+    if (params?.after) {
+      searchParams.append("after", params.after);
+    }
+    if (params?.order) {
+      searchParams.append("order", params.order);
+    }
+    const url = `/memberships${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    const response = await this.apiRequest(url);
+    return {
+      ...response,
+      data: response.data.map((membership) => ({
+        ...membership,
+        createdAt: membership.createdAt,
+        updatedAt: membership.updatedAt
+      }))
+    };
+  }
+  /**
+   * Get a single membership by ID
+   */
+  async getMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}`);
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Create a new organization membership
+   */
+  async createMembership(data) {
+    const validated = CreateMembershipSchema.parse(data);
+    const membership = await this.apiRequest("/memberships", {
+      method: "POST",
+      body: JSON.stringify(validated)
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Update an existing membership
+   */
+  async updateMembership(membershipId, data) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const validated = UpdateMembershipSchema.parse(data);
+    const membership = await this.apiRequest(`/memberships/${membershipId}`, {
+      method: "PUT",
+      body: JSON.stringify(validated)
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Delete a membership
+   */
+  async deleteMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    await this.apiRequest(`/memberships/${membershipId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Deactivate a membership (soft delete)
+   */
+  async deactivateMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}/deactivate`, {
+      method: "POST"
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+  /**
+   * Reactivate a membership
+   */
+  async reactivateMembership(membershipId) {
+    MembershipIdParamSchema.parse({ id: membershipId });
+    const membership = await this.apiRequest(`/memberships/${membershipId}/reactivate`, {
+      method: "POST"
+    });
+    return {
+      ...membership,
+      createdAt: membership.createdAt,
+      updatedAt: membership.updatedAt
+    };
+  }
+};
+function useUserMemberships(userId, params) {
+  const { apiRequest, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["memberships", "user", userId, params],
+    queryFn: async () => {
+      const membershipService = new OrganizationMembershipService(apiRequest);
+      return await membershipService.getUserMemberships(userId);
+    },
+    enabled: isReady && !!userId,
+    refetchOnWindowFocus: false,
+    staleTime: STALE_TIME_DEFAULT,
+    gcTime: GC_TIME_MEDIUM
+  });
+}
+function useUpdateMemberConfig() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ membershipId, config }) => {
+      return apiRequest(`/memberships/${membershipId}/config`, {
+        method: "PATCH",
+        body: JSON.stringify({ config })
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+      notifications.show({
+        title: "Success",
+        message: "Member config updated",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      adapter.apiError(error);
+    }
+  });
+}
+function useDeactivateMembership() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ membershipId }) => {
+      const membershipService = new OrganizationMembershipService(apiRequest);
+      return await membershipService.deactivateMembership(membershipId);
+    },
+    onMutate: async (variables) => {
+      await queryClient.cancelQueries({ queryKey: ["memberships"] });
+      const previousData = queryClient.getQueryData(["memberships"]);
+      if (variables.userId) {
+        queryClient.setQueryData(
+          ["memberships", "user", variables.userId],
+          (old) => {
+            if (!old) return old;
+            return old.map(
+              (membership) => membership.id === variables.membershipId ? { ...membership, status: "inactive", updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : membership
+            );
+          }
+        );
+      }
+      if (variables.organizationId) {
+        queryClient.setQueryData(
+          ["memberships", "organization", variables.organizationId],
+          (old) => {
+            if (!old) return old;
+            return old.map(
+              (membership) => membership.id === variables.membershipId ? { ...membership, status: "inactive", updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : membership
+            );
+          }
+        );
+      }
+      return { previousData };
+    },
+    onError: (error, _variables, context) => {
+      if (context?.previousData) {
+        queryClient.setQueryData(["memberships"], context.previousData);
+      }
+      adapter.apiError(error);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+    }
+  });
+}
+function useReactivateMembership() {
+  const { apiRequest } = useElevasisServices();
+  const adapter = useNotificationAdapter();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ membershipId }) => {
+      const membershipService = new OrganizationMembershipService(apiRequest);
+      return await membershipService.reactivateMembership(membershipId);
+    },
+    onMutate: async (variables) => {
+      await queryClient.cancelQueries({ queryKey: ["memberships"] });
+      const previousData = queryClient.getQueryData(["memberships"]);
+      if (variables.userId) {
+        queryClient.setQueryData(
+          ["memberships", "user", variables.userId],
+          (old) => {
+            if (!old) return old;
+            return old.map(
+              (membership) => membership.id === variables.membershipId ? { ...membership, status: "active", updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : membership
+            );
+          }
+        );
+      }
+      if (variables.organizationId) {
+        queryClient.setQueryData(
+          ["memberships", "organization", variables.organizationId],
+          (old) => {
+            if (!old) return old;
+            return old.map(
+              (membership) => membership.id === variables.membershipId ? { ...membership, status: "active", updatedAt: (/* @__PURE__ */ new Date()).toISOString() } : membership
+            );
+          }
+        );
+      }
+      return { previousData };
+    },
+    onError: (error, _variables, context) => {
+      if (context?.previousData) {
+        queryClient.setQueryData(["memberships"], context.previousData);
+      }
+      adapter.apiError(error);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: ["memberships"] });
+    }
+  });
+}
+
+// src/hooks/settings/webhooks/webhookEndpointService.ts
+var WebhookEndpointService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * List webhook endpoints for the current organization
+   */
+  async listEndpoints() {
+    const response = await this.apiRequest("/webhook-endpoints");
+    return response.data;
+  }
+  /**
+   * Create a new webhook endpoint
+   */
+  async createEndpoint(data) {
+    return await this.apiRequest("/webhook-endpoints", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Update an existing webhook endpoint (e.g., toggle status, rename)
+   */
+  async updateEndpoint(endpointId, data) {
+    return await this.apiRequest(`/webhook-endpoints/${endpointId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Delete a webhook endpoint
+   */
+  async deleteEndpoint(endpointId) {
+    await this.apiRequest(`/webhook-endpoints/${endpointId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/hooks/settings/webhooks/useListWebhookEndpoints.ts
+function useListWebhookEndpoints() {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: ["webhook-endpoints", organizationId],
+    queryFn: async () => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.listEndpoints();
+    },
+    enabled: isReady
+  });
+}
+var showInfoNotification = (message) => {
+  notifications.show({
+    title: "Info",
+    message,
+    autoClose: 5e3,
+    color: "blue",
+    position: "top-right"
+  });
+};
+var showSuccessNotification = (message) => {
+  notifications.show({
+    title: "Action Successful",
+    message,
+    autoClose: 5e3,
+    color: "green",
+    position: "top-right"
+  });
+};
+var showErrorNotification = (error) => {
+  if (error instanceof Error) {
+    error = error.message;
+  }
+  notifications.show({
+    title: "Action Failed",
+    message: error,
+    autoClose: 5e3,
+    color: "red",
+    position: "top-right"
+  });
+};
+var showWarningNotification = (message) => {
+  notifications.show({
+    title: "Warning",
+    message,
+    autoClose: 5e3,
+    color: "orange",
+    position: "top-right"
+  });
+};
+var showApiErrorNotification = (error) => {
+  const { message, code, requestId, fields, retryAfter } = getErrorInfo(error);
+  notifications.show({
+    title: getErrorTitle(code),
+    message: formatErrorMessage(message, requestId, fields, retryAfter),
+    autoClose: retryAfter ? retryAfter * 1e3 : 5e3,
+    color: "red",
+    position: "top-right"
+  });
+};
+
+// src/hooks/settings/webhooks/useCreateWebhookEndpoint.ts
+function useCreateWebhookEndpoint() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (data) => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.createEndpoint(data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["webhook-endpoints"] });
+    },
+    onError: (error) => {
+      console.error("Failed to create webhook endpoint:", error);
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useDeleteWebhookEndpoint() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (endpointId) => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.deleteEndpoint(endpointId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["webhook-endpoints"] });
+      notifications.show({
+        title: "Success",
+        message: "Webhook endpoint deleted",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to delete webhook endpoint:", error);
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useUpdateWebhookEndpoint() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ endpointId, data }) => {
+      const service = new WebhookEndpointService(apiRequest);
+      return await service.updateEndpoint(endpointId, data);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["webhook-endpoints"] });
+      notifications.show({
+        title: "Success",
+        message: "Webhook endpoint updated",
+        color: "teal"
+      });
+    },
+    onError: (error) => {
+      console.error("Failed to update webhook endpoint:", error);
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+export { ApiKeyService, CredentialService, DeploymentService, OrganizationMembershipService, WebhookEndpointService, filterByDomainFilters, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, useActivateDeployment, useActivityFilters, useCommandViewDomainFilters, useCreateApiKey, useCreateCredential, useCreateWebhookEndpoint, useCredentials, useDeactivateDeployment, useDeactivateMembership, useDeleteApiKey, useDeleteCredential, useDeleteDeployment, useDeleteWebhookEndpoint, useExecutionLogsFilters, useListApiKeys, useListDeployments, useListWebhookEndpoints, useOrganizationMembers, useReactivateMembership, useResourceSearch, useResourcesDomainFilters, useStatusFilter, useTimeRangeDates, useUpdateApiKey, useUpdateCredential, useUpdateMemberConfig, useUpdateWebhookEndpoint, useUserMemberships, useVisibleResources };