@devlider001/washlab-backend 1.0.4 → 1.0.5

package/convex/_generated/api.d.ts

@@ -19,6 +19,7 @@ import type * as lib_audit from "../lib/audit.js";
 import type * as lib_auth from "../lib/auth.js";
 import type * as lib_utils from "../lib/utils.js";
 import type * as loyalty from "../loyalty.js";
+import type * as notifications from "../notifications.js";
 import type * as orders from "../orders.js";
 import type * as payments from "../payments.js";
 import type * as resources from "../resources.js";
@@ -42,6 +43,7 @@ declare const fullApi: ApiFromModules<{
   "lib/auth": typeof lib_auth;
   "lib/utils": typeof lib_utils;
   loyalty: typeof loyalty;
+  notifications: typeof notifications;
   orders: typeof orders;
   payments: typeof payments;
   resources: typeof resources;

package/convex/audit.d.ts

@@ -122,4 +122,43 @@ export declare const getByTimeRange: import("convex/server").RegisteredQuery<"pu
     entityType: string;
     timestamp: number;
 }[]>>;
+/**
+ * Get all audit logs with filters - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export declare const getAll: import("convex/server").RegisteredQuery<"public", {
+    actorType?: "admin" | "customer" | "attendant" | undefined;
+    action?: string | undefined;
+    entityType?: string | undefined;
+    startTimestamp?: number | undefined;
+    endTimestamp?: number | undefined;
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"auditLogs">;
+        _creationTime: number;
+        branchId?: import("convex/values").GenericId<"branches"> | undefined;
+        deviceId?: string | undefined;
+        entityId?: string | undefined;
+        ipAddress?: string | undefined;
+        details?: string | undefined;
+        oldValue?: string | undefined;
+        newValue?: string | undefined;
+        actorId: string;
+        actorType: "admin" | "customer" | "attendant";
+        actorRole: string;
+        action: string;
+        entityType: string;
+        timestamp: number;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
 //# sourceMappingURL=audit.d.ts.map

package/convex/notifications.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Notification Functions
+ *
+ * Handles creating, reading, and managing system notifications
+ * for customers, attendants, and admins.
+ */
+/**
+ * Get notifications for current user - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export declare const getMyNotifications: import("convex/server").RegisteredQuery<"public", {
+    type?: "info" | "success" | "warning" | "error" | "order" | "payment" | "system" | undefined;
+    isRead?: boolean | undefined;
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<{
+    page: never[];
+    isDone: boolean;
+    continueCursor: null;
+} | {
+    page: {
+        _id: import("convex/values").GenericId<"notifications">;
+        _creationTime: number;
+        branchId?: import("convex/values").GenericId<"branches"> | undefined;
+        entityType?: string | undefined;
+        entityId?: string | undefined;
+        actionUrl?: string | undefined;
+        actionLabel?: string | undefined;
+        readAt?: number | undefined;
+        senderId?: string | undefined;
+        senderType?: "admin" | "attendant" | "system" | undefined;
+        expiresAt?: number | undefined;
+        scheduledFor?: number | undefined;
+        sentAt?: number | undefined;
+        type: "info" | "success" | "warning" | "error" | "order" | "payment" | "system";
+        createdAt: number;
+        isDeleted: boolean;
+        recipientId: string;
+        recipientType: "admin" | "customer" | "attendant" | "all";
+        title: string;
+        message: string;
+        priority: "low" | "normal" | "high" | "urgent";
+        isRead: boolean;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+/**
+ * Get unread notification count for current user
+ */
+export declare const getUnreadCount: import("convex/server").RegisteredQuery<"public", {}, Promise<number>>;
+/**
+ * Mark notification as read
+ */
+export declare const markAsRead: import("convex/server").RegisteredMutation<"public", {
+    notificationId: import("convex/values").GenericId<"notifications">;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Mark all notifications as read for current user
+ */
+export declare const markAllAsRead: import("convex/server").RegisteredMutation<"public", {}, Promise<{
+    success: boolean;
+    count: number;
+}>>;
+/**
+ * Delete notification (soft delete)
+ */
+export declare const deleteNotification: import("convex/server").RegisteredMutation<"public", {
+    notificationId: import("convex/values").GenericId<"notifications">;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Get all notifications (admin only) - Paginated
+ */
+export declare const getAllNotifications: import("convex/server").RegisteredQuery<"public", {
+    type?: "info" | "success" | "warning" | "error" | "order" | "payment" | "system" | undefined;
+    recipientType?: "admin" | "customer" | "attendant" | "all" | undefined;
+    isRead?: boolean | undefined;
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"notifications">;
+        _creationTime: number;
+        branchId?: import("convex/values").GenericId<"branches"> | undefined;
+        entityType?: string | undefined;
+        entityId?: string | undefined;
+        actionUrl?: string | undefined;
+        actionLabel?: string | undefined;
+        readAt?: number | undefined;
+        senderId?: string | undefined;
+        senderType?: "admin" | "attendant" | "system" | undefined;
+        expiresAt?: number | undefined;
+        scheduledFor?: number | undefined;
+        sentAt?: number | undefined;
+        type: "info" | "success" | "warning" | "error" | "order" | "payment" | "system";
+        createdAt: number;
+        isDeleted: boolean;
+        recipientId: string;
+        recipientType: "admin" | "customer" | "attendant" | "all";
+        title: string;
+        message: string;
+        priority: "low" | "normal" | "high" | "urgent";
+        isRead: boolean;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+/**
+ * Create notification (admin only)
+ */
+export declare const createNotification: import("convex/server").RegisteredMutation<"public", {
+    branchId?: import("convex/values").GenericId<"branches"> | undefined;
+    entityType?: string | undefined;
+    entityId?: string | undefined;
+    recipientId?: string | undefined;
+    actionUrl?: string | undefined;
+    actionLabel?: string | undefined;
+    priority?: "low" | "normal" | "high" | "urgent" | undefined;
+    expiresAt?: number | undefined;
+    scheduledFor?: number | undefined;
+    type: "info" | "success" | "warning" | "error" | "order" | "payment" | "system";
+    recipientType: "admin" | "customer" | "attendant" | "all";
+    title: string;
+    message: string;
+}, Promise<{
+    notificationId: import("convex/values").GenericId<"notifications">;
+    success: boolean;
+}>>;
+/**
+ * Delete notification (admin only - hard delete)
+ */
+export declare const adminDeleteNotification: import("convex/server").RegisteredMutation<"public", {
+    notificationId: import("convex/values").GenericId<"notifications">;
+}, Promise<{
+    success: boolean;
+}>>;
+/**
+ * Create notification (internal - for system use)
+ */
+export declare const createSystemNotification: import("convex/server").RegisteredMutation<"internal", {
+    branchId?: import("convex/values").GenericId<"branches"> | undefined;
+    entityType?: string | undefined;
+    entityId?: string | undefined;
+    actionUrl?: string | undefined;
+    actionLabel?: string | undefined;
+    priority?: "low" | "normal" | "high" | "urgent" | undefined;
+    expiresAt?: number | undefined;
+    type: "info" | "success" | "warning" | "error" | "order" | "payment" | "system";
+    recipientId: string;
+    recipientType: "admin" | "customer" | "attendant" | "all";
+    title: string;
+    message: string;
+}, Promise<import("convex/values").GenericId<"notifications">>>;
+//# sourceMappingURL=notifications.d.ts.map

package/convex/schema.d.ts

@@ -445,6 +445,57 @@ declare const _default: import("convex/server").SchemaDefinition<{
         by_customer: ["customerId", "_creationTime"];
         by_used_at: ["usedAt", "_creationTime"];
     }, {}, {}>;
+    notifications: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        branchId?: import("convex/values").GenericId<"branches"> | undefined;
+        entityType?: string | undefined;
+        entityId?: string | undefined;
+        actionUrl?: string | undefined;
+        actionLabel?: string | undefined;
+        readAt?: number | undefined;
+        senderId?: string | undefined;
+        senderType?: "admin" | "attendant" | "system" | undefined;
+        expiresAt?: number | undefined;
+        scheduledFor?: number | undefined;
+        sentAt?: number | undefined;
+        type: "info" | "success" | "warning" | "error" | "order" | "payment" | "system";
+        createdAt: number;
+        isDeleted: boolean;
+        recipientId: string;
+        recipientType: "admin" | "customer" | "attendant" | "all";
+        title: string;
+        message: string;
+        priority: "low" | "normal" | "high" | "urgent";
+        isRead: boolean;
+    }, {
+        recipientId: import("convex/values").VString<string, "required">;
+        recipientType: import("convex/values").VUnion<"admin" | "customer" | "attendant" | "all", [import("convex/values").VLiteral<"customer", "required">, import("convex/values").VLiteral<"attendant", "required">, import("convex/values").VLiteral<"admin", "required">, import("convex/values").VLiteral<"all", "required">], "required", never>;
+        title: import("convex/values").VString<string, "required">;
+        message: import("convex/values").VString<string, "required">;
+        type: import("convex/values").VUnion<"info" | "success" | "warning" | "error" | "order" | "payment" | "system", [import("convex/values").VLiteral<"info", "required">, import("convex/values").VLiteral<"success", "required">, import("convex/values").VLiteral<"warning", "required">, import("convex/values").VLiteral<"error", "required">, import("convex/values").VLiteral<"order", "required">, import("convex/values").VLiteral<"payment", "required">, import("convex/values").VLiteral<"system", "required">], "required", never>;
+        actionUrl: import("convex/values").VString<string | undefined, "optional">;
+        actionLabel: import("convex/values").VString<string | undefined, "optional">;
+        entityType: import("convex/values").VString<string | undefined, "optional">;
+        entityId: import("convex/values").VString<string | undefined, "optional">;
+        priority: import("convex/values").VUnion<"low" | "normal" | "high" | "urgent", [import("convex/values").VLiteral<"low", "required">, import("convex/values").VLiteral<"normal", "required">, import("convex/values").VLiteral<"high", "required">, import("convex/values").VLiteral<"urgent", "required">], "required", never>;
+        isRead: import("convex/values").VBoolean<boolean, "required">;
+        readAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        senderId: import("convex/values").VString<string | undefined, "optional">;
+        senderType: import("convex/values").VUnion<"admin" | "attendant" | "system" | undefined, [import("convex/values").VLiteral<"admin", "required">, import("convex/values").VLiteral<"attendant", "required">, import("convex/values").VLiteral<"system", "required">], "optional", never>;
+        branchId: import("convex/values").VId<import("convex/values").GenericId<"branches"> | undefined, "optional">;
+        expiresAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        scheduledFor: import("convex/values").VFloat64<number | undefined, "optional">;
+        createdAt: import("convex/values").VFloat64<number, "required">;
+        sentAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        isDeleted: import("convex/values").VBoolean<boolean, "required">;
+    }, "required", "type" | "createdAt" | "isDeleted" | "branchId" | "entityType" | "entityId" | "recipientId" | "recipientType" | "title" | "message" | "actionUrl" | "actionLabel" | "priority" | "isRead" | "readAt" | "senderId" | "senderType" | "expiresAt" | "scheduledFor" | "sentAt">, {
+        by_recipient: ["recipientId", "recipientType", "_creationTime"];
+        by_recipient_read: ["recipientId", "recipientType", "isRead", "_creationTime"];
+        by_type: ["type", "_creationTime"];
+        by_priority: ["priority", "_creationTime"];
+        by_created: ["createdAt", "_creationTime"];
+        by_branch: ["branchId", "_creationTime"];
+        by_entity: ["entityType", "entityId", "_creationTime"];
+    }, {}, {}>;
 }, true>;
 export default _default;
 //# sourceMappingURL=schema.d.ts.map

package/dist/convex/admin.d.ts

@@ -0,0 +1,377 @@
+import { Id } from "./_generated/dataModel";
+/**
+ * Admin Functions
+ *
+ * Handles admin operations: branch management, attendant management,
+ * system-wide order viewing, analytics, and customer management.
+ */
+/**
+ * Get current admin profile (from authenticated Clerk session)
+ */
+export declare const getCurrentUser: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    _id: import("convex/values").GenericId<"admins">;
+    _creationTime: number;
+    lastLoginAt?: number | undefined;
+    email: string;
+    name: string;
+    clerkUserId: string;
+    createdAt: number;
+    isDeleted: boolean;
+    role: "super_admin" | "admin";
+}>>;
+/**
+ * Get all branches - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export declare const getBranches: import("convex/server").RegisteredQuery<"public", {
+    includeInactive?: boolean | undefined;
+    cursor?: string | undefined;
+    numItems?: number | undefined;
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"branches">;
+        _creationTime: number;
+        email?: string | undefined;
+        phoneNumber: string;
+        name: string;
+        createdAt: number;
+        isDeleted: boolean;
+        isActive: boolean;
+        code: string;
+        address: string;
+        city: string;
+        country: string;
+        pricingPerKg: number;
+        deliveryFee: number;
+        createdBy: import("convex/values").GenericId<"admins">;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+/**
+ * Get branch by code
+ */
+export declare const getBranchByCode: import("convex/server").RegisteredQuery<"public", {
+    code: string;
+}, Promise<{
+    _id: import("convex/values").GenericId<"branches">;
+    _creationTime: number;
+    email?: string | undefined;
+    phoneNumber: string;
+    name: string;
+    createdAt: number;
+    isDeleted: boolean;
+    isActive: boolean;
+    code: string;
+    address: string;
+    city: string;
+    country: string;
+    pricingPerKg: number;
+    deliveryFee: number;
+    createdBy: import("convex/values").GenericId<"admins">;
+} | null>>;
+/**
+ * Get single branch by ID
+ */
+export declare const getBranch: import("convex/server").RegisteredQuery<"public", {
+    branchId: import("convex/values").GenericId<"branches">;
+}, Promise<{
+    _id: import("convex/values").GenericId<"branches">;
+    _creationTime: number;
+    email?: string | undefined;
+    phoneNumber: string;
+    name: string;
+    createdAt: number;
+    isDeleted: boolean;
+    isActive: boolean;
+    code: string;
+    address: string;
+    city: string;
+    country: string;
+    pricingPerKg: number;
+    deliveryFee: number;
+    createdBy: import("convex/values").GenericId<"admins">;
+} | null>>;
+/**
+ * Get all attendants - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export declare const getAttendants: import("convex/server").RegisteredQuery<"public", {
+    branchId?: import("convex/values").GenericId<"branches"> | undefined;
+    includeInactive?: boolean | undefined;
+    cursor?: string | undefined;
+    numItems?: number | undefined;
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"attendants">;
+        _creationTime: number;
+        lastLoginAt?: number | undefined;
+        passcode?: string | undefined;
+        phoneNumber: string;
+        email: string;
+        name: string;
+        clerkUserId: string;
+        createdAt: number;
+        isDeleted: boolean;
+        branchId: import("convex/values").GenericId<"branches">;
+        isActive: boolean;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+/**
+ * Get all orders (with filters) - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export declare const getOrders: import("convex/server").RegisteredQuery<"public", {
+    status?: "pending" | "in_progress" | "ready_for_pickup" | "delivered" | "completed" | "cancelled" | undefined;
+    branchId?: import("convex/values").GenericId<"branches"> | undefined;
+    cursor?: string | undefined;
+    numItems?: number | undefined;
+    startDate?: number | undefined;
+    endDate?: number | undefined;
+}, Promise<{
+    page: {
+        _id: import("convex/values").GenericId<"orders">;
+        _creationTime: number;
+        createdBy?: import("convex/values").GenericId<"attendants"> | undefined;
+        estimatedWeight?: number | undefined;
+        actualWeight?: number | undefined;
+        itemCount?: number | undefined;
+        estimatedLoads?: number | undefined;
+        whitesSeparate?: boolean | undefined;
+        bagCardNumber?: string | undefined;
+        notes?: string | undefined;
+        deliveryAddress?: string | undefined;
+        deliveryPhoneNumber?: string | undefined;
+        deliveryHall?: string | undefined;
+        deliveryRoom?: string | undefined;
+        paymentMethod?: "mobile_money" | "card" | "cash" | undefined;
+        paymentId?: import("convex/values").GenericId<"payments"> | undefined;
+        fulfilledBy?: import("convex/values").GenericId<"attendants"> | undefined;
+        status: "pending" | "in_progress" | "ready_for_pickup" | "delivered" | "completed" | "cancelled";
+        createdAt: number;
+        isDeleted: boolean;
+        branchId: import("convex/values").GenericId<"branches">;
+        deliveryFee: number;
+        customerId: import("convex/values").GenericId<"users">;
+        customerPhoneNumber: string;
+        orderNumber: string;
+        orderType: "walk_in" | "online";
+        serviceType: "wash_only" | "wash_and_dry" | "dry_only";
+        isDelivery: boolean;
+        basePrice: number;
+        totalPrice: number;
+        finalPrice: number;
+        paymentStatus: "pending" | "paid" | "failed" | "refunded";
+        updatedAt: number;
+        statusHistory: {
+            notes?: string | undefined;
+            status: string;
+            changedAt: number;
+            changedBy: import("convex/values").GenericId<"attendants">;
+        }[];
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+/**
+ * Get analytics dashboard data
+ */
+export declare const getAnalytics: import("convex/server").RegisteredQuery<"public", {
+    branchId?: import("convex/values").GenericId<"branches"> | undefined;
+    startDate?: number | undefined;
+    endDate?: number | undefined;
+}, Promise<{
+    totalOrders: number;
+    totalRevenue: number;
+    averageOrderValue: number;
+    ordersByStatus: Record<string, number>;
+    ordersByDay: Record<string, number>;
+    topCustomers: {
+        customerId: Id<"users">;
+        name: string;
+        phoneNumber: string;
+        orderCount: number;
+    }[];
+    dateRange: {
+        start: number | undefined;
+        end: number | undefined;
+    };
+}>>;
+/**
+ * Get all customers (with filters) - Paginated
+ * Supports usePaginatedQuery for infinite scroll
+ */
+export declare const getCustomers: import("convex/server").RegisteredQuery<"public", {
+    isRegistered?: boolean | undefined;
+    status?: "active" | "blocked" | "suspended" | "restricted" | undefined;
+    search?: string | undefined;
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<{
+    page: {
+        orderCount: number;
+        completedOrderCount: number;
+        totalSpent: number;
+        lastOrderDate: number;
+        lastOrderNumber: string;
+        _id: import("convex/values").GenericId<"users">;
+        _creationTime: number;
+        email?: string | undefined;
+        clerkUserId?: string | undefined;
+        statusNote?: string | undefined;
+        statusChangedBy?: import("convex/values").GenericId<"admins"> | undefined;
+        statusChangedAt?: number | undefined;
+        lastLoginAt?: number | undefined;
+        preferredBranchId?: import("convex/values").GenericId<"branches"> | undefined;
+        phoneNumber: string;
+        name: string;
+        isRegistered: boolean;
+        isVerified: boolean;
+        status: "active" | "blocked" | "suspended" | "restricted";
+        createdAt: number;
+        isDeleted: boolean;
+    }[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+/**
+ * Get customer statistics/aggregations
+ */
+export declare const getCustomerStats: import("convex/server").RegisteredQuery<"public", {}, Promise<{
+    totalCustomers: number;
+    registeredCustomers: number;
+    walkInCustomers: number;
+    activeCustomers: number;
+    blockedCustomers: number;
+    suspendedCustomers: number;
+    restrictedCustomers: number;
+    verifiedCustomers: number;
+    customersWithActiveOrders: number;
+    totalRevenue: number;
+}>>;
+/**
+ * Change customer status (with required note)
+ */
+export declare const changeCustomerStatus: import("convex/server").RegisteredMutation<"public", {
+    status: "active" | "blocked" | "suspended" | "restricted";
+    customerId: import("convex/values").GenericId<"users">;
+    note: string;
+}, Promise<import("convex/values").GenericId<"users">>>;
+/**
+ * Delete a customer (soft delete)
+ */
+export declare const deleteCustomer: import("convex/server").RegisteredMutation<"public", {
+    customerId: import("convex/values").GenericId<"users">;
+}, Promise<import("convex/values").GenericId<"users">>>;
+/**
+ * Create new branch
+ */
+export declare const createBranch: import("convex/server").RegisteredMutation<"public", {
+    email?: string | undefined;
+    phoneNumber: string;
+    name: string;
+    code: string;
+    address: string;
+    city: string;
+    country: string;
+    pricingPerKg: number;
+    deliveryFee: number;
+}, Promise<import("convex/values").GenericId<"branches">>>;
+/**
+ * Update branch details
+ */
+export declare const updateBranch: import("convex/server").RegisteredMutation<"public", {
+    phoneNumber?: string | undefined;
+    email?: string | undefined;
+    name?: string | undefined;
+    isActive?: boolean | undefined;
+    code?: string | undefined;
+    address?: string | undefined;
+    city?: string | undefined;
+    country?: string | undefined;
+    pricingPerKg?: number | undefined;
+    deliveryFee?: number | undefined;
+    branchId: import("convex/values").GenericId<"branches">;
+}, Promise<import("convex/values").GenericId<"branches">>>;
+/**
+ * Toggle branch active status (enable/disable)
+ */
+export declare const toggleBranchStatus: import("convex/server").RegisteredMutation<"public", {
+    branchId: import("convex/values").GenericId<"branches">;
+}, Promise<{
+    branchId: import("convex/values").GenericId<"branches">;
+    isActive: boolean;
+}>>;
+/**
+ * Delete branch (soft delete)
+ */
+export declare const deleteBranch: import("convex/server").RegisteredMutation<"public", {
+    branchId: import("convex/values").GenericId<"branches">;
+}, Promise<import("convex/values").GenericId<"branches">>>;
+/**
+ * Create attendant account
+ * Note: Clerk user must be created separately, then link clerkUserId
+ */
+export declare const createAttendant: import("convex/server").RegisteredMutation<"public", {
+    passcode?: string | undefined;
+    phoneNumber: string;
+    email: string;
+    name: string;
+    clerkUserId: string;
+    branchId: import("convex/values").GenericId<"branches">;
+}, Promise<import("convex/values").GenericId<"attendants">>>;
+/**
+ * Update attendant details
+ */
+export declare const updateAttendant: import("convex/server").RegisteredMutation<"public", {
+    phoneNumber?: string | undefined;
+    email?: string | undefined;
+    name?: string | undefined;
+    passcode?: string | undefined;
+    branchId?: import("convex/values").GenericId<"branches"> | undefined;
+    isActive?: boolean | undefined;
+    attendantId: import("convex/values").GenericId<"attendants">;
+}, Promise<import("convex/values").GenericId<"attendants">>>;
+/**
+ * Assign attendant to branch
+ */
+export declare const assignAttendantToBranch: import("convex/server").RegisteredMutation<"public", {
+    branchId: import("convex/values").GenericId<"branches">;
+    attendantId: import("convex/values").GenericId<"attendants">;
+}, Promise<import("convex/values").GenericId<"attendants">>>;
+/**
+ * Delete attendant (soft delete)
+ */
+export declare const deleteAttendant: import("convex/server").RegisteredMutation<"public", {
+    attendantId: import("convex/values").GenericId<"attendants">;
+}, Promise<import("convex/values").GenericId<"attendants">>>;
+/**
+ * Create admin account
+ * Only super admins can create other admins
+ * Note: Clerk user must be created separately, then link clerkUserId
+ */
+export declare const createAdmin: import("convex/server").RegisteredMutation<"public", {
+    email: string;
+    name: string;
+    clerkUserId: string;
+    role: "super_admin" | "admin";
+}, Promise<import("convex/values").GenericId<"admins">>>;
+/**
+ * Create the first super admin (one-time setup)
+ * This function can only be used when no super admins exist in the database
+ * After the first super admin is created, use createAdmin instead
+ */
+export declare const createFirstSuperAdmin: import("convex/server").RegisteredMutation<"public", {
+    email: string;
+    name: string;
+    clerkUserId: string;
+}, Promise<import("convex/values").GenericId<"admins">>>;
+//# sourceMappingURL=admin.d.ts.map

package/dist/convex/admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../convex/admin.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAE5C;;;;;GAKG;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;GAMzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;GA+BtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;UAuB1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;UAoBpB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;GAwCxB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;GAqFvB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;GA6D3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;uDA2D/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;uDA6CzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;0DA+DvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;0DA2EvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;GAiC7B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;0DAgDvB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;4DAiE1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;4DA6C1B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;4DAuClC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe;;4DAgD1B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;wDAsDtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;wDAqDhC,CAAC"}