@temboplus/afloat 0.1.57 → 0.1.59

package/esm/src/features/admin/schemas.js

@@ -0,0 +1,206 @@
+import { z } from "zod";
+// ====================== Custom Schema Definitions ====================== //
+/**
+ * Custom password schema that enforces strong password requirements.
+ * Password must contain:
+ * - At least 8 characters
+ * - At least one uppercase letter
+ * - At least one lowercase letter
+ * - At least one number
+ * - At least one special character (!@#$%^&*()_+-=[]{}|;:,.<>?)
+ * - No common passwords or sequential patterns
+ */
+const passwordSchema = z
+    .string()
+    .min(8, "Password must be at least 8 characters long")
+    .max(128, "Password must not exceed 128 characters")
+    .regex(/[A-Z]/, "Password must contain at least one uppercase letter")
+    .regex(/[a-z]/, "Password must contain at least one lowercase letter")
+    .regex(/[0-9]/, "Password must contain at least one number")
+    .regex(/[!@#$%^&*()_+\-=\[\]{}|;:,.<>?]/, "Password must contain at least one special character (!@#$%^&*()_+-=[]{}|;:,.<>?)")
+    .refine((password) => {
+    // Check for common weak patterns
+    const weakPatterns = [
+        /(.)\1{2,}/, // Three or more consecutive identical characters
+        /123456|654321|abcdef|qwerty|password|admin|user/i, // Common passwords
+        /^[0-9]+$/, // Only numbers
+        /^[a-zA-Z]+$/, // Only letters
+    ];
+    return !weakPatterns.some((pattern) => pattern.test(password));
+}, "Password contains weak patterns. Avoid repeated characters, common words, or simple sequences")
+    .refine((password) => {
+    // Check for sequential characters (e.g., "abcd", "1234")
+    const hasSequential = /(?:abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i
+        .test(password);
+    return !hasSequential;
+}, "Password should not contain sequential characters")
+    .refine((password) => {
+    // Check for keyboard patterns (e.g., "qwer", "asdf")
+    const keyboardPatterns = /(?:qwer|wert|erty|rtyu|tyui|yuio|uiop|asdf|sdfg|dfgh|fghj|ghjk|hjkl|zxcv|xcvb|cvbn|vbnm)/i;
+    return !keyboardPatterns.test(password);
+}, "Password should not contain keyboard patterns");
+// ====================== Schema Definitions ====================== //
+/**
+ * Schema definition for a role.
+ * Represents a user role with permissions in the system.
+ *
+ * @property {string} id - Unique identifier for the role
+ * @property {string} name - Display name of the role
+ * @property {string} description - Optional description of the role
+ * @property {string[]} access - Array of permission strings
+ * @property {string} createdAt - ISO datetime string of role creation
+ * @property {string} updatedAt - ISO datetime string of last role update
+ */
+const roleSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1, "Role name is required"),
+    description: z.string().optional(),
+    access: z.array(z.string()),
+    createdAt: z.string().datetime("Invalid creation timestamp"),
+    updatedAt: z.string().datetime("Invalid update timestamp"),
+});
+/**
+ * Schema definition for a managed user account.
+ * Represents a user account from the admin management perspective.
+ *
+ * @property {string} id - Unique identifier for the user account
+ * @property {string} name - Full name of the user
+ * @property {string} identity - User's email address or phone number
+ * @property {string} type - Type of user account
+ * @property {string} profileId - ID of the associated profile
+ * @property {string} roleId - ID of the assigned role
+ * @property {boolean} resetPassword - Whether user must reset password on next login
+ * @property {boolean} isActive - Whether the account is currently active
+ * @property {Role} role - Full role object with permissions
+ * @property {string} createdAt - ISO datetime string of account creation
+ * @property {string} updatedAt - ISO datetime string of last account update
+ */
+const managedUserSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1, "User name is required"),
+    identity: z.string().email("Invalid email address"),
+    type: z.string().min(1, "User type is required"),
+    profileId: z.string().min(1, "Profile ID is required"),
+    roleId: z.string().min(1, "Role ID is required"),
+    resetPassword: z.boolean(),
+    isActive: z.boolean(),
+    isArchived: z.boolean(),
+    role: roleSchema.optional(),
+    createdAt: z.string().datetime("Invalid creation timestamp"),
+    updatedAt: z.string().datetime("Invalid update timestamp"),
+});
+/**
+ * Schema definition for managed user query parameters.
+ * Contains all primitive fields from ManagedUserData for filtering/searching users.
+ * Excludes complex object fields like 'role' which are not suitable for query parameters.
+ *
+ * @property {string} id - Optional filter by user ID
+ * @property {string} name - Optional filter by user name (partial match)
+ * @property {string} identity - Optional filter by user identity (email/phone)
+ * @property {string} type - Optional filter by user type
+ * @property {string} profileId - Optional filter by profile ID
+ * @property {string} roleId - Optional filter by role ID
+ * @property {number} resetPassword - Optional filter by password reset requirement
+ * @property {number} isActive - Optional filter by account active status
+ * @property {number} isArchived - Optional filter by account archived status
+ * @property {string} createdAt - Optional filter by creation date (ISO datetime)
+ * @property {string} updatedAt - Optional filter by last update date (ISO datetime)
+ */
+const managedUserQueryParamsSchema = z.object({
+    id: z.string().min(1).optional(),
+    name: z.string().min(1).optional(),
+    identity: z.string().email("Invalid email address").optional(),
+    type: z.string().min(1).optional(),
+    profileId: z.string().min(1).optional(),
+    roleId: z.string().min(1).optional(),
+    resetPassword: z.number().optional(),
+    isActive: z.number().optional(),
+    isArchived: z.number().optional(),
+    createdAt: z.string().datetime("Invalid creation timestamp").optional(),
+    updatedAt: z.string().datetime("Invalid update timestamp").optional(),
+    eager: z.string().optional(),
+});
+/**
+ * Schema definition for creating a new user account.
+ * Defines the required and optional fields for user creation.
+ *
+ * @property {string} name - Full name of the user
+ * @property {string} identity - User's email address
+ * @property {string} password - Initial password for the account
+ * @property {string} roleId - Optional role ID (defaults to system default)
+ * @property {boolean} resetPassword - Optional flag to force password reset (defaults to true)
+ */
+const createUserRequestSchema = z.object({
+    name: z.string().min(1, "User name is required"),
+    identity: z.string().email("Valid email address is required"),
+    password: passwordSchema.optional(),
+    roleId: z.string().optional(),
+    resetPassword: z.boolean().optional(),
+});
+/**
+ * Schema definition for updating a user account.
+ * All fields are optional for partial updates.
+ *
+ * @property {string} name - Optional updated name
+ * @property {string} roleId - Optional updated role ID
+ * @property {string} password - Optional new password
+ * @property {boolean} resetPassword - Optional flag to force password reset
+ * @property {boolean} isActive - Optional account activation status
+ */
+const updateUserRequestSchema = z.object({
+    name: z.string().min(1, "User name cannot be empty").optional(),
+    roleId: z.string().min(1, "Role ID cannot be empty").optional(),
+    password: passwordSchema.optional(),
+    resetPassword: z.boolean().optional(),
+    isActive: z.boolean().optional(),
+});
+/**
+ * Schema definition for resetting a user's password.
+ * Both fields are optional with system defaults.
+ *
+ * @property {string} newPassword - Optional new password (random generated if not provided)
+ * @property {boolean} sendNotification - Optional flag to send notification to user
+ */
+const resetPasswordRequestSchema = z.object({
+    newPassword: passwordSchema.optional(),
+    sendNotification: z.boolean().optional(),
+});
+/**
+ * Schema definition for the response when creating a user.
+ * Returns basic user information without sensitive data.
+ *
+ * @property {string} id - Unique identifier for the created user
+ * @property {string} name - Full name of the user
+ * @property {string} identity - User's email address
+ * @property {string} type - Type of user account
+ * @property {string} profileId - ID of the associated profile
+ * @property {string} roleId - ID of the assigned role
+ * @property {boolean} isActive - Whether the account is active
+ * @property {string} createdAt - ISO datetime string of account creation
+ */
+const createUserResponseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    identity: z.string(),
+    type: z.string(),
+    profileId: z.string(),
+    roleId: z.string(),
+    isActive: z.boolean(),
+    isArchived: z.boolean(),
+    createdAt: z.string().datetime(),
+});
+// ====================== Schema Collections ====================== //
+/**
+ * Collection of user management schemas for export.
+ * Provides access to all user and role validation schemas.
+ */
+export const UserManagementSchemas = {
+    role: roleSchema,
+    managedUser: managedUserSchema,
+    managedUserQueryParams: managedUserQueryParamsSchema,
+    createUserRequest: createUserRequestSchema,
+    updateUserRequest: updateUserRequestSchema,
+    resetPasswordRequest: resetPasswordRequestSchema,
+    createUserResponse: createUserResponseSchema,
+    password: passwordSchema, // Export password schema for reuse
+};

package/{dist/features/auth/access/access.api-contract.d.ts → esm/src/features/auth/access/contract.d.ts}

@@ -11,3 +11,4 @@ export declare const accessContract: {
         };
     };
 };
+//# sourceMappingURL=contract.d.ts.map

package/esm/src/features/auth/access/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/access/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;CAQzB,CAAC"}

package/esm/src/features/auth/access/contract.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { initContract } from "@ts-rest/core";
+/**
+ * Auth API contract
+ */
+export const accessContract = initContract().router({
+    getAccessList: {
+        method: "GET",
+        path: "/access",
+        responses: {
+            200: z.string().array(),
+        },
+    },
+});

package/esm/src/features/auth/access/repository.d.ts

@@ -0,0 +1,11 @@
+import { Profile } from "../../../models/index.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+import { accessContract } from "./contract.js";
+export declare class AccessRepository extends TokenRequiredRepository<typeof accessContract> {
+    /**
+     * Initializes an instance of ProfileRepository.
+     */
+    constructor();
+    getCurrentProfile(token: string): Promise<Profile>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/esm/src/features/auth/access/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/access/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,gBACX,SAAQ,uBAAuB,CAAC,OAAO,cAAc,CAAC;IACtD;;OAEG;;IAKG,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAazD"}

package/esm/src/features/auth/access/repository.js

@@ -0,0 +1,25 @@
+import { Profile } from "../../../models/index.js";
+import { APIError } from "../../../errors/api_error.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+import { accessContract } from "./contract.js";
+export class AccessRepository extends TokenRequiredRepository {
+    /**
+     * Initializes an instance of ProfileRepository.
+     */
+    constructor() {
+        super("auth", accessContract, "");
+    }
+    async getCurrentProfile(token) {
+        this.setToken(token);
+        const result = await this.client.getAccessList();
+        if (result.status === 200) {
+            const profile = Profile.from(result.body);
+            if (profile)
+                return profile;
+        }
+        throw new APIError({
+            message: "An error occurred while trying to get the current access list",
+            statusCode: 502,
+        });
+    }
+}

package/{dist/features/auth/auth.contract.d.ts → esm/src/features/auth/contract.d.ts}

@@ -23,14 +23,13 @@ export declare const authContract: {
             201: z.ZodObject<{
                 profile: z.ZodObject<{
                     id: z.ZodString;
-                    firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    firstName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                    lastName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                     displayName: z.ZodString;
-                    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    phone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                     accountNo: z.ZodString;
-                    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-                    autoApprove: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-                }, "strip", z.ZodTypeAny, {
+                    email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                }, z.UnknownKeysParam, z.ZodTypeAny, {
                     id: string;
                     displayName: string;
                     accountNo: string;
@@ -38,7 +37,6 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
-                    autoApprove?: boolean | null | undefined;
                 }, {
                     id: string;
                     displayName: string;
@@ -47,7 +45,6 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
-                    autoApprove?: boolean | null | undefined;
                 }>;
                 token: z.ZodString;
                 access: z.ZodArray<z.ZodString, "many">;
@@ -62,7 +59,6 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
-                    autoApprove?: boolean | null | undefined;
                 };
                 token: string;
                 access: string[];
@@ -76,7 +72,6 @@ export declare const authContract: {
                     lastName?: string | null | undefined;
                     phone?: string | null | undefined;
                     email?: string | null | undefined;
-                    autoApprove?: boolean | null | undefined;
                 };
                 token: string;
                 access: string[];
@@ -104,13 +99,14 @@ export declare const authContract: {
             currentPassword: z.ZodString;
             newPassword: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            newPassword: string;
             currentPassword: string;
-        }, {
             newPassword: string;
+        }, {
             currentPassword: string;
+            newPassword: string;
         }>;
         path: "/password";
         responses: {};
     };
 };
+//# sourceMappingURL=contract.d.ts.map

package/esm/src/features/auth/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/src/features/auth/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCvB,CAAC"}

package/esm/src/features/auth/contract.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { initContract } from "@ts-rest/core";
+import { Profile } from "../../models/index.js";
+/**
+ * Auth API contract
+ */
+export const authContract = initContract().router({
+    logIn: {
+        method: "POST",
+        path: "/login",
+        body: z.object({
+            type: z.string().default("password"),
+            identity: z.string().email(),
+            password: z.string(),
+        }),
+        responses: {
+            201: z.object({
+                profile: Profile.schema,
+                token: z.string(),
+                access: z.array(z.string()),
+                resetPassword: z.boolean(),
+            }),
+            400: z.object({}),
+        },
+    },
+    access: {
+        method: "GET",
+        path: "/access",
+        headers: z.object({ token: z.string() }),
+        responses: {
+            200: z.string().array(),
+        },
+    },
+    resetPassword: {
+        method: "PUT",
+        path: "/password",
+        body: z.object({
+            currentPassword: z.string(),
+            newPassword: z.string(),
+        }),
+        responses: {},
+    },
+});

package/{dist/features/auth/identity/identity.api-contract.d.ts → esm/src/features/auth/identity/contract.d.ts}

@@ -20,3 +20,4 @@ export declare const identityContract: {
         };
     };
 };
+//# sourceMappingURL=contract.d.ts.map

package/esm/src/features/auth/identity/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/identity/contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAW3B,CAAC"}

package/esm/src/features/auth/identity/contract.js

@@ -0,0 +1,17 @@
+import { initContract } from "@ts-rest/core";
+import { z } from "zod";
+/**
+ * Identity API contract
+ */
+export const identityContract = initContract().router({
+    getUserCredentials: {
+        method: "GET",
+        path: "/me",
+        responses: {
+            200: z.object({
+                name: z.string(),
+                identity: z.string(),
+            }),
+        },
+    },
+});

package/esm/src/features/auth/identity/repository.d.ts

@@ -0,0 +1,22 @@
+import { identityContract } from "./contract.js";
+import type { ClientInferResponseBody } from "@ts-rest/core";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+type GetUserIdentityResponse = ClientInferResponseBody<typeof identityContract.getUserCredentials>;
+/**
+ * Class representing the LoginRepository.
+ * Provides methods to retrieve user identity-related information.
+ */
+export declare class LoginRepository extends TokenRequiredRepository<typeof identityContract> {
+    /**
+     * Initializes an instance of LoginRepository.
+     */
+    constructor();
+    /**
+     * Retrieves the user's login credentials.
+     * @returns A promise that resolves to the user's login credentials on success.
+     * @throws {APIError} If an error occurs while retrieving the credentials.
+     */
+    getIdentity(token: string): Promise<GetUserIdentityResponse>;
+}
+export {};
+//# sourceMappingURL=repository.d.ts.map

package/esm/src/features/auth/identity/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../../src/src/features/auth/identity/repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8CAA8C,CAAC;AAEvF,KAAK,uBAAuB,GAAG,uBAAuB,CACpD,OAAO,gBAAgB,CAAC,kBAAkB,CAC3C,CAAC;AAEF;;;GAGG;AACH,qBAAa,eACX,SAAQ,uBAAuB,CAAC,OAAO,gBAAgB,CAAC;IACxD;;OAEG;;IAKH;;;;OAIG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAUnE"}

package/esm/src/features/auth/identity/repository.js

@@ -0,0 +1,30 @@
+import { APIError } from "../../../errors/api_error.js";
+import { identityContract } from "./contract.js";
+import { TokenRequiredRepository } from "../../../shared/token_required_repository.js";
+/**
+ * Class representing the LoginRepository.
+ * Provides methods to retrieve user identity-related information.
+ */
+export class LoginRepository extends TokenRequiredRepository {
+    /**
+     * Initializes an instance of LoginRepository.
+     */
+    constructor() {
+        super("login", identityContract, "");
+    }
+    /**
+     * Retrieves the user's login credentials.
+     * @returns A promise that resolves to the user's login credentials on success.
+     * @throws {APIError} If an error occurs while retrieving the credentials.
+     */
+    async getIdentity(token) {
+        this.setToken(token);
+        const result = await this.client.getUserCredentials();
+        if (result.status === 200)
+            return result.body;
+        throw new APIError({
+            message: "An error occurred while trying to get login credentials",
+            statusCode: 502,
+        });
+    }
+}

package/esm/src/features/auth/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./manager.js";
+export * from "./repository.js";
+export * from "./profile/repository.js";
+export * from "./identity/repository.js";
+export * from "./access/repository.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/features/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/features/auth/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA"}

package/esm/src/features/auth/index.js

@@ -0,0 +1,5 @@
+export * from "./manager.js";
+export * from "./repository.js";
+export * from "./profile/repository.js";
+export * from "./identity/repository.js";
+export * from "./access/repository.js";

package/esm/src/features/auth/manager.d.ts

@@ -0,0 +1,105 @@
+import type { User } from "../../models/index.js";
+import type { Permission } from "../../models/permission.js";
+/**
+ * Global context to hold the current auth instance reference.
+ * This provides a way to access the auth instance across the application
+ * without directly coupling to the singleton pattern.
+ */
+export declare const AuthContext: {
+    current: AfloatAuth | undefined;
+};
+/**
+ * Main authentication class that works in both client and server environments.
+ * Provides authentication functionality and user management.
+ */
+export declare class AfloatAuth {
+    /** The auth store implementation */
+    private store;
+    /** The token handler implementation */
+    private tokenHandler;
+    /** client AfloatAuth instance */
+    private static _instance;
+    /**
+     * Private constructor to maintain control over instantiation.
+     * @param {AuthStore} store - The auth store implementation to use
+     * @param {TokenHandler} tokenHandler - The token handler implementation to use
+     */
+    private constructor();
+    /**
+     * Gets or creates the client-side singleton instance of AfloatAuth.
+     * This getter will automatically initialize the client instance if it hasn't been created yet.
+     * For server-side usage, use initializeServer() instead.
+     *
+     * @returns {AfloatAuth} The client-side singleton instance
+     * @example
+     * // Client-side usage
+     * const auth = AfloatAuth.instance;
+     *
+     * // Server-side usage (don't use .instance)
+     * const serverAuth = await AfloatAuth.initializeServer(token);
+     */
+    static get instance(): AfloatAuth;
+    /**
+     * Creates a new server-side instance of AfloatAuth.
+     * Unlike the client-side instance getter, this creates a new instance each time.
+     *
+     * @param {string} token - Authentication token
+     * @returns {Promise<AfloatAuth>} A new server-side instance
+     * @throws {Error} If token is invalid or required data cannot be fetched
+     */
+    static initializeServer(token: string): Promise<AfloatAuth>;
+    /**
+     * Gets the authentication repository instance.
+     * @private
+     * @returns {AuthRepository} The repository for auth operations
+     */
+    private get repo();
+    /**
+     * Gets the current authentication token.
+     * @returns {string | undefined} The current token or undefined if not authenticated
+     */
+    getUserToken(): string | undefined;
+    /**
+     * Gets the currently authenticated user.
+     * @returns {User | undefined} The current user or undefined if not authenticated
+     */
+    get currentUser(): User | undefined;
+    /**
+     * React hook for accessing the current user in client-side code.
+     * @throws {Error} If called in a server environment
+     * @returns {User | undefined} The current user or undefined if not authenticated
+     */
+    useCurrentUser(): User | undefined;
+    /**
+     * Checks if the current user has a specific permission.
+     * @param {Permission} perm - The permission to check
+     * @returns {boolean} True if the user has the permission, false otherwise
+     */
+    checkPermission(perm: Permission): boolean;
+    /**
+     * Authenticates a user with email and password.
+     * @param {string} email - The user's email
+     * @param {string} password - The user's password
+     * @returns {Promise<User>} Promise resolving to the authenticated user
+     * @throws Will throw an error if authentication fails
+     */
+    logIn(email: string, password: string): Promise<User>;
+    /**
+     * Updates the user's password.
+     * @param {string} current - The current password
+     * @param {string} updated - The new password
+     * @returns {Promise<boolean>} Promise resolving to true if successful
+     * @throws Will throw an error if the password update fails
+     */
+    resetPassword(current: string, updated: string): Promise<boolean>;
+    /**
+     * Logs out the current user.
+     */
+    logOut(): void;
+    /**
+     * Clears all authentication data.
+     * @private
+     */
+    private clearSavedData;
+}
+//# sourceMappingURL=manager.d.ts.map

package/esm/src/features/auth/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/src/features/auth/manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAU7D;;;;GAIG;AACH,eAAO,MAAM,WAAW;aAEA,UAAU,GAAG,SAAS;CAC7C,CAAC;AAEF;;;GAGG;AACH,qBAAa,UAAU;IACrB,oCAAoC;IACpC,OAAO,CAAC,KAAK,CAAY;IAEzB,uCAAuC;IACvC,OAAO,CAAC,YAAY,CAAe;IAEnC,iCAAiC;IACjC,OAAO,CAAC,MAAM,CAAC,SAAS,CAA2B;IAEnD;;;;OAIG;IACH,OAAO;IAKP;;;;;;;;;;;;OAYG;IACH,WAAkB,QAAQ,IAAI,UAAU,CAYvC;IAED;;;;;;;OAOG;WACiB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IA8BxE;;;;OAIG;IACH,OAAO,KAAK,IAAI,GAEf;IAED;;;OAGG;IACH,YAAY,IAAI,MAAM,GAAG,SAAS;IAIlC;;;OAGG;IACH,IAAI,WAAW,IAAI,IAAI,GAAG,SAAS,CAElC;IAED;;;;OAIG;IACH,cAAc,IAAI,IAAI,GAAG,SAAS;IAIlC;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAI1C;;;;;;OAMG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3D;;;;;;OAMG;IACG,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMvE;;OAEG;IACH,MAAM,IAAI,IAAI;IAId;;;OAGG;IACH,OAAO,CAAC,cAAc;CAIvB"}