@nextsparkjs/core 0.1.0-beta.68 → 0.1.0-beta.69

package/dist/hooks/usePrefetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrefetch.d.ts","sourceRoot":"","sources":["../../src/hooks/usePrefetch.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB;;;EAuBlC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,cAgBnD"}

package/dist/hooks/usePrefetch.js

@@ -0,0 +1,56 @@
+"use client";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { TEAMS_QUERY_KEY, fetchUserTeams } from "../contexts/TeamContext.js";
+const USER_PROFILE_QUERY_KEY = ["user-profile"];
+async function fetchUserProfile() {
+  const response = await fetch("/api/user/profile");
+  if (!response.ok) {
+    throw new Error("Failed to fetch profile");
+  }
+  return response.json();
+}
+function usePrefetchSettings() {
+  const queryClient = useQueryClient();
+  const prefetchProfile = useCallback(() => {
+    queryClient.prefetchQuery({
+      queryKey: USER_PROFILE_QUERY_KEY,
+      queryFn: fetchUserProfile,
+      staleTime: 1e3 * 60 * 5
+      // 5 minutes
+    });
+  }, [queryClient]);
+  const prefetchTeams = useCallback(() => {
+    queryClient.prefetchQuery({
+      queryKey: TEAMS_QUERY_KEY,
+      queryFn: fetchUserTeams,
+      staleTime: 1e3 * 60 * 5
+      // 5 minutes
+    });
+  }, [queryClient]);
+  return {
+    prefetchProfile,
+    prefetchTeams
+  };
+}
+function usePrefetchEntity(entitySlug) {
+  const queryClient = useQueryClient();
+  return useCallback(() => {
+    queryClient.prefetchQuery({
+      queryKey: ["entity", entitySlug, "list"],
+      queryFn: async () => {
+        const response = await fetch(`/api/v1/${entitySlug}?limit=20`);
+        if (!response.ok) {
+          throw new Error(`Failed to fetch ${entitySlug}`);
+        }
+        return response.json();
+      },
+      staleTime: 1e3 * 60 * 2
+      // 2 minutes for entity lists
+    });
+  }, [queryClient, entitySlug]);
+}
+export {
+  usePrefetchEntity,
+  usePrefetchSettings
+};

package/dist/lib/actions/index.d.ts

@@ -1,7 +1,7 @@
 /**
- * Entity Server Actions
+ * NextSpark Server Actions
  *
- * Generic Server Actions for CRUD operations on any registered entity.
+ * Server Actions for CRUD operations, user management, and team management.
  * Auth (userId/teamId) is obtained automatically from session and cookies.
  *
  * Import from '@nextsparkjs/core/actions' or '@nextsparkjs/core/lib/actions'.
@@ -9,31 +9,44 @@
  * @example
  * ```typescript
  * import {
+ *   // Entity actions
  *   createEntity,
  *   updateEntity,
  *   deleteEntity,
  *   getEntity,
  *   listEntities,
+ *   // User actions
+ *   updateProfile,
+ *   updateAvatar,
+ *   deleteAccount,
+ *   // Team actions
+ *   updateTeam,
+ *   inviteMember,
+ *   removeMember,
+ *   updateMemberRole,
  * } from '@nextsparkjs/core/actions'
  *
- * // Create - auth obtained from server session
+ * // Entity operations - auth obtained from server session
  * const result = await createEntity('schools', { name: 'MIT' })
- *
- * // Update with revalidation
- * await updateEntity('campaigns', id, { status: 'paused' }, {
- *   revalidatePaths: ['/dashboard']
- * })
- *
- * // Delete with redirect
+ * await updateEntity('campaigns', id, { status: 'paused' })
  * await deleteEntity('leads', id, { redirectTo: '/leads' })
  *
- * // Get by ID
- * const entity = await getEntity('schools', id)
+ * // User profile operations
+ * await updateProfile({ firstName: 'John', lastName: 'Doe' })
+ * await updateAvatar(formData)
+ * await deleteAccount()
  *
- * // List with filters
- * const list = await listEntities('campaigns', { limit: 20, where: { status: 'active' } })
+ * // Team operations
+ * await updateTeam('team-id', { name: 'New Name' })
+ * await inviteMember('team-id', 'user@example.com', 'member')
+ * await removeMember('team-id', 'member-id')
+ * await updateMemberRole('team-id', 'member-id', 'admin')
  * ```
  */
 export { createEntity, updateEntity, deleteEntity, getEntity, listEntities, deleteEntities, entityExists, countEntities, } from './entity.actions';
+export { updateProfile, updateAvatar, deleteAccount, } from './user.actions';
+export type { UpdateProfileData, ProfileUpdateResult, } from './user.actions';
+export { updateTeam, inviteMember, removeMember, updateMemberRole, } from './team.actions';
+export type { UpdateTeamData, InviteMemberResult, } from './team.actions';
 export type { EntityActionResult, EntityActionVoidResult, CreateEntityInput, UpdateEntityInput, ListEntityOptions, ListEntityResult, ActionConfig, ActionAuthContext, BatchDeleteResult, } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/lib/actions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,aAAa,GACd,MAAM,kBAAkB,CAAA;AAGzB,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAMH,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,aAAa,GACd,MAAM,kBAAkB,CAAA;AAMzB,OAAO,EACL,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,gBAAgB,CAAA;AAMvB,OAAO,EACL,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AAMvB,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,SAAS,CAAA"}

package/dist/lib/actions/index.js

@@ -8,13 +8,31 @@ import {
   entityExists,
   countEntities
 } from "./entity.actions.js";
+import {
+  updateProfile,
+  updateAvatar,
+  deleteAccount
+} from "./user.actions.js";
+import {
+  updateTeam,
+  inviteMember,
+  removeMember,
+  updateMemberRole
+} from "./team.actions.js";
 export {
   countEntities,
   createEntity,
+  deleteAccount,
   deleteEntities,
   deleteEntity,
   entityExists,
   getEntity,
+  inviteMember,
   listEntities,
-  updateEntity
+  removeMember,
+  updateAvatar,
+  updateEntity,
+  updateMemberRole,
+  updateProfile,
+  updateTeam
 };

package/dist/lib/actions/team.actions.d.ts

@@ -0,0 +1,107 @@
+import type { Team, TeamRole, TeamMember } from '../teams/types';
+import type { EntityActionResult, EntityActionVoidResult } from './types';
+/**
+ * Team update data that can be passed to updateTeam
+ */
+export interface UpdateTeamData {
+    name?: string;
+    slug?: string;
+    description?: string;
+    avatarUrl?: string;
+    settings?: Record<string, unknown>;
+}
+/**
+ * Result of invite member action
+ */
+export interface InviteMemberResult {
+    memberId: string;
+    userId: string;
+    teamId: string;
+    role: TeamRole;
+}
+/**
+ * Update a team's information
+ *
+ * Requires owner or admin role in the team.
+ *
+ * @param teamId - The team ID to update
+ * @param data - Team fields to update
+ * @returns Updated team data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateTeam('team-123', {
+ *   name: 'New Team Name',
+ *   description: 'Updated description'
+ * })
+ *
+ * if (result.success) {
+ *   console.log('Team updated:', result.data.name)
+ * }
+ * ```
+ */
+export declare function updateTeam(teamId: string, data: UpdateTeamData): Promise<EntityActionResult<Team>>;
+/**
+ * Invite a user to join the team
+ *
+ * Requires owner or admin role in the team.
+ * The user must already exist in the system.
+ *
+ * @param teamId - The team ID
+ * @param email - Email of the user to invite
+ * @param role - Role to assign (member, admin, viewer)
+ * @returns Created membership data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await inviteMember('team-123', 'user@example.com', 'member')
+ *
+ * if (result.success) {
+ *   console.log('Member invited:', result.data.memberId)
+ * }
+ * ```
+ */
+export declare function inviteMember(teamId: string, email: string, role?: TeamRole): Promise<EntityActionResult<InviteMemberResult>>;
+/**
+ * Remove a member from the team
+ *
+ * Requires owner or admin role in the team.
+ * Cannot remove the team owner (must transfer ownership first).
+ *
+ * @param teamId - The team ID
+ * @param memberId - The member ID to remove (from team_members table)
+ * @returns Success status
+ *
+ * @example
+ * ```typescript
+ * const result = await removeMember('team-123', 'member-id-456')
+ *
+ * if (result.success) {
+ *   console.log('Member removed')
+ * }
+ * ```
+ */
+export declare function removeMember(teamId: string, memberId: string): Promise<EntityActionVoidResult>;
+/**
+ * Update a team member's role
+ *
+ * Requires owner role to change to/from admin.
+ * Admins can change member/viewer roles.
+ * Cannot change owner role (must transfer ownership).
+ *
+ * @param teamId - The team ID
+ * @param memberId - The member's user ID
+ * @param role - New role to assign
+ * @returns Updated membership data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateMemberRole('team-123', 'user-456', 'admin')
+ *
+ * if (result.success) {
+ *   console.log('Role updated:', result.data.role)
+ * }
+ * ```
+ */
+export declare function updateMemberRole(teamId: string, memberId: string, role: TeamRole): Promise<EntityActionResult<TeamMember>>;
+//# sourceMappingURL=team.actions.d.ts.map

package/dist/lib/actions/team.actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team.actions.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/team.actions.ts"],"names":[],"mappings":"AA4CA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAMzE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,QAAQ,CAAA;CACf;AAgDD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CA4DnC;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,QAAmB,GACxB,OAAO,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAqEjD;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,CAAC,CAgEjC;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAsEzC"}

package/dist/lib/actions/team.actions.js

@@ -0,0 +1,220 @@
+"use server";
+import { revalidatePath } from "next/cache";
+import { headers } from "next/headers";
+import { getTypedSession } from "../auth.js";
+import { TeamService } from "../services/team.service.js";
+import { TeamMemberService } from "../services/team-member.service.js";
+async function getAuthUser() {
+  var _a;
+  const headersList = await headers();
+  const session = await getTypedSession(headersList);
+  if (!((_a = session == null ? void 0 : session.user) == null ? void 0 : _a.id)) {
+    return { success: false, error: "Authentication required" };
+  }
+  return { success: true, userId: session.user.id };
+}
+async function verifyTeamPermission(userId, teamId, requiredRoles = ["owner", "admin"]) {
+  const hasPermission = await TeamMemberService.hasPermission(
+    userId,
+    teamId,
+    requiredRoles
+  );
+  if (!hasPermission) {
+    return { success: false, error: "Permission denied. Required role: " + requiredRoles.join(" or ") };
+  }
+  return { success: true };
+}
+async function updateTeam(teamId, data) {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!data || Object.keys(data).length === 0) {
+      return { success: false, error: "No fields provided for update" };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const permResult = await verifyTeamPermission(userId, teamId, ["owner", "admin"]);
+    if (!permResult.success) {
+      return { success: false, error: permResult.error };
+    }
+    const updatePayload = {};
+    if (data.name !== void 0) updatePayload.name = data.name;
+    if (data.slug !== void 0) updatePayload.slug = data.slug;
+    if (data.description !== void 0) updatePayload.description = data.description;
+    if (data.avatarUrl !== void 0) updatePayload.avatarUrl = data.avatarUrl;
+    if (data.settings !== void 0) updatePayload.settings = data.settings;
+    if (Object.keys(updatePayload).length === 0) {
+      return { success: false, error: "No valid fields provided for update" };
+    }
+    if (updatePayload.slug) {
+      const isAvailable = await TeamService.isSlugAvailable(updatePayload.slug, teamId);
+      if (!isAvailable) {
+        return { success: false, error: "Team slug is already taken" };
+      }
+    }
+    const updatedTeam = await TeamService.update(teamId, updatePayload, userId);
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard");
+    return { success: true, data: updatedTeam };
+  } catch (error) {
+    console.error("[updateTeam] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update team"
+    };
+  }
+}
+async function inviteMember(teamId, email, role = "member") {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!(email == null ? void 0 : email.trim())) {
+      return { success: false, error: "Email is required" };
+    }
+    const validRoles = ["admin", "member", "viewer"];
+    if (!validRoles.includes(role)) {
+      return { success: false, error: "Invalid role. Must be admin, member, or viewer" };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const permResult = await verifyTeamPermission(userId, teamId, ["owner", "admin"]);
+    if (!permResult.success) {
+      return { success: false, error: permResult.error };
+    }
+    const { UserService } = await import("../services/user.service.js");
+    const targetUser = await UserService.getUserByEmail(email, userId);
+    if (!targetUser) {
+      return { success: false, error: "User not found. They must create an account first." };
+    }
+    const existingMember = await TeamMemberService.getByTeamAndUser(teamId, targetUser.id);
+    if (existingMember) {
+      return { success: false, error: "User is already a member of this team" };
+    }
+    const member = await TeamMemberService.add(teamId, targetUser.id, role, {
+      invitedBy: userId
+    });
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard/settings/team/members");
+    return {
+      success: true,
+      data: {
+        memberId: member.id,
+        userId: member.userId,
+        teamId: member.teamId,
+        role: member.role
+      }
+    };
+  } catch (error) {
+    console.error("[inviteMember] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to invite member"
+    };
+  }
+}
+async function removeMember(teamId, memberId) {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!(memberId == null ? void 0 : memberId.trim())) {
+      return { success: false, error: "Member ID is required" };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const permResult = await verifyTeamPermission(userId, teamId, ["owner", "admin"]);
+    if (!permResult.success) {
+      return { success: false, error: permResult.error };
+    }
+    const targetUserId = memberId;
+    if (targetUserId === userId) {
+      const selfRole = await TeamMemberService.getRole(teamId, userId);
+      if (selfRole === "owner") {
+        return { success: false, error: "Cannot remove yourself as owner. Transfer ownership first." };
+      }
+    }
+    const targetRole = await TeamMemberService.getRole(teamId, targetUserId);
+    if (targetRole === "owner") {
+      return { success: false, error: "Cannot remove team owner. Transfer ownership first." };
+    }
+    const requestorRole = await TeamMemberService.getRole(teamId, userId);
+    if (requestorRole === "admin" && targetRole === "admin" && targetUserId !== userId) {
+      return { success: false, error: "Admins cannot remove other admins. Only the owner can do that." };
+    }
+    await TeamMemberService.remove(teamId, targetUserId);
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard/settings/team/members");
+    return { success: true };
+  } catch (error) {
+    console.error("[removeMember] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to remove member"
+    };
+  }
+}
+async function updateMemberRole(teamId, memberId, role) {
+  try {
+    if (!(teamId == null ? void 0 : teamId.trim())) {
+      return { success: false, error: "Team ID is required" };
+    }
+    if (!(memberId == null ? void 0 : memberId.trim())) {
+      return { success: false, error: "Member ID is required" };
+    }
+    const validRoles = ["admin", "member", "viewer"];
+    if (!validRoles.includes(role)) {
+      return { success: false, error: "Invalid role. Must be admin, member, or viewer. Use transferOwnership for owner." };
+    }
+    const authResult = await getAuthUser();
+    if (!authResult.success) {
+      return { success: false, error: authResult.error };
+    }
+    const { userId } = authResult;
+    const requestorRole = await TeamMemberService.getRole(teamId, userId);
+    if (!requestorRole) {
+      return { success: false, error: "You are not a member of this team" };
+    }
+    const targetUserId = memberId;
+    const currentRole = await TeamMemberService.getRole(teamId, targetUserId);
+    if (!currentRole) {
+      return { success: false, error: "Member not found in this team" };
+    }
+    if (currentRole === "owner") {
+      return { success: false, error: "Cannot change owner role. Use transferOwnership instead." };
+    }
+    if ((role === "admin" || currentRole === "admin") && requestorRole !== "owner") {
+      return { success: false, error: "Only the team owner can promote to or demote from admin" };
+    }
+    if (requestorRole === "admin" && (role === "member" || role === "viewer")) {
+    } else if (requestorRole !== "owner" && requestorRole !== "admin") {
+      return { success: false, error: "Permission denied. You must be an owner or admin." };
+    }
+    const updatedMember = await TeamMemberService.updateRole(teamId, targetUserId, role);
+    revalidatePath("/dashboard/settings/team");
+    revalidatePath("/dashboard/settings/team/members");
+    return { success: true, data: updatedMember };
+  } catch (error) {
+    console.error("[updateMemberRole] Error:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to update member role"
+    };
+  }
+}
+export {
+  inviteMember,
+  removeMember,
+  updateMemberRole,
+  updateTeam
+};

package/dist/lib/actions/user.actions.d.ts

@@ -0,0 +1,99 @@
+import type { EntityActionResult, EntityActionVoidResult } from './types';
+/**
+ * Profile update data that can be passed to updateProfile
+ */
+export interface UpdateProfileData {
+    firstName?: string;
+    lastName?: string;
+    name?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+}
+/**
+ * Result of profile update with user data
+ */
+export interface ProfileUpdateResult {
+    id: string;
+    email: string;
+    name?: string;
+    firstName?: string;
+    lastName?: string;
+    image?: string;
+    country?: string;
+    timezone?: string;
+    language?: string;
+}
+/**
+ * Update the current user's profile information
+ *
+ * Auth is automatically obtained from session - users can only update their own profile.
+ *
+ * @param data - Profile fields to update
+ * @returns Updated user data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * const result = await updateProfile({
+ *   firstName: 'John',
+ *   lastName: 'Doe',
+ *   timezone: 'America/New_York'
+ * })
+ *
+ * if (result.success) {
+ *   console.log('Profile updated:', result.data)
+ * } else {
+ *   console.error('Error:', result.error)
+ * }
+ * ```
+ */
+export declare function updateProfile(data: UpdateProfileData): Promise<EntityActionResult<ProfileUpdateResult>>;
+/**
+ * Update the current user's avatar image
+ *
+ * Accepts FormData with an 'avatar' or 'image' field containing the image URL or file path.
+ * For actual file uploads, the file should be uploaded to storage first and the URL passed here.
+ *
+ * @param formData - FormData with 'avatar' or 'image' field containing the image URL
+ * @returns Updated user data wrapped in EntityActionResult
+ *
+ * @example
+ * ```typescript
+ * // After uploading file to storage
+ * const formData = new FormData()
+ * formData.append('avatar', imageUrl)
+ * const result = await updateAvatar(formData)
+ *
+ * if (result.success) {
+ *   console.log('Avatar updated:', result.data.image)
+ * }
+ * ```
+ */
+export declare function updateAvatar(formData: FormData): Promise<EntityActionResult<ProfileUpdateResult>>;
+/**
+ * Delete the current user's account
+ *
+ * This is a destructive operation that:
+ * - Removes the user from all teams
+ * - Deletes user metadata
+ * - Deletes the user account
+ *
+ * Teams owned by the user must have ownership transferred first or be deleted.
+ *
+ * @returns Success status
+ *
+ * @example
+ * ```typescript
+ * // Show confirmation dialog first!
+ * const confirmed = window.confirm('Are you sure? This cannot be undone.')
+ * if (confirmed) {
+ *   const result = await deleteAccount()
+ *   if (result.success) {
+ *     // Redirect to goodbye page or login
+ *     router.push('/goodbye')
+ *   }
+ * }
+ * ```
+ */
+export declare function deleteAccount(): Promise<EntityActionVoidResult>;
+//# sourceMappingURL=user.actions.d.ts.map

package/dist/lib/actions/user.actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.actions.d.ts","sourceRoot":"","sources":["../../../src/lib/actions/user.actions.ts"],"names":[],"mappings":"AAoCA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAMzE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAMD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC,CA2DlD;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,CAAC,CAsElD;AAMD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,aAAa,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAsDrE"}