hazo_auth 1.4.2 → 1.6.0

package/dist/app/api/hazo_auth/upload_profile_picture/route.js

@@ -0,0 +1,204 @@
+// file_description: API route for uploading profile pictures
+// section: imports
+import { NextResponse } from "next/server";
+import { get_hazo_connect_instance } from "../../../../lib/hazo_connect_instance.server";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { get_profile_picture_config } from "../../../../lib/profile_picture_config.server";
+import { get_file_types_config } from "../../../../lib/file_types_config.server";
+import { update_user_profile_picture } from "../../../../lib/services/profile_picture_service";
+import { createCrudService } from "hazo_connect/server";
+import { map_db_source_to_ui } from "../../../../lib/services/profile_picture_source_mapper";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+import fs from "fs";
+import path from "path";
+// section: api_handler
+export async function POST(request) {
+    const logger = create_app_logger();
+    try {
+        // Use centralized auth check
+        let user_id;
+        try {
+            const { require_auth } = await import("../../../../lib/auth/auth_utils.server");
+            const user = await require_auth(request);
+            user_id = user.user_id;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "Authentication required") {
+                logger.warn("profile_picture_upload_authentication_failed", {
+                    filename: get_filename(),
+                    line_number: get_line_number(),
+                    error: "User not authenticated",
+                });
+                return NextResponse.json({ error: "Authentication required" }, { status: 401 });
+            }
+            throw error;
+        }
+        // Check if upload is enabled
+        const config = get_profile_picture_config();
+        if (!config.allow_photo_upload) {
+            logger.warn("profile_picture_upload_disabled", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+            });
+            return NextResponse.json({ error: "Photo upload is not enabled" }, { status: 403 });
+        }
+        if (!config.upload_photo_path) {
+            logger.warn("profile_picture_upload_path_not_configured", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+            });
+            return NextResponse.json({ error: "Upload path is not configured" }, { status: 500 });
+        }
+        // Get FormData
+        const formData = await request.formData();
+        const file = formData.get("file");
+        if (!file) {
+            logger.warn("profile_picture_upload_no_file", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+            });
+            return NextResponse.json({ error: "No file provided" }, { status: 400 });
+        }
+        // Validate file type
+        const fileTypes = get_file_types_config();
+        const fileType = file.type;
+        if (!fileTypes.allowed_image_mime_types.includes(fileType)) {
+            logger.warn("profile_picture_upload_invalid_type", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+                fileType,
+            });
+            return NextResponse.json({ error: "Invalid file type. Only JPG and PNG files are allowed." }, { status: 400 });
+        }
+        // Validate file size (should already be compressed client-side, but check server-side too)
+        const fileSize = file.size;
+        if (fileSize > config.max_photo_size) {
+            logger.warn("profile_picture_upload_too_large", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+                fileSize,
+                maxSize: config.max_photo_size,
+            });
+            return NextResponse.json({ error: `File size exceeds maximum allowed size of ${config.max_photo_size} bytes` }, { status: 400 });
+        }
+        // Get current user profile picture info before updating
+        const hazoConnect = get_hazo_connect_instance();
+        const users_service = createCrudService(hazoConnect, "hazo_users");
+        const current_users = await users_service.findBy({ id: user_id });
+        let oldProfilePictureUrl = null;
+        let oldProfileSource = null;
+        if (Array.isArray(current_users) && current_users.length > 0) {
+            const current_user = current_users[0];
+            oldProfilePictureUrl = current_user.profile_picture_url || null;
+            oldProfileSource = current_user.profile_source || null;
+        }
+        // Determine file extension from MIME type
+        const mimeToExt = {
+            "image/jpeg": "jpg",
+            "image/jpg": "jpg",
+            "image/png": "png",
+        };
+        const fileExtension = mimeToExt[fileType] || "jpg";
+        const fileName = `${user_id}.${fileExtension}`;
+        // Resolve upload path
+        const uploadPath = path.isAbsolute(config.upload_photo_path)
+            ? config.upload_photo_path
+            : path.resolve(process.cwd(), config.upload_photo_path);
+        // Create upload directory if it doesn't exist
+        if (!fs.existsSync(uploadPath)) {
+            fs.mkdirSync(uploadPath, { recursive: true });
+        }
+        // Save file
+        const filePath = path.join(uploadPath, fileName);
+        const arrayBuffer = await file.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        fs.writeFileSync(filePath, buffer);
+        // Generate URL (relative to public or absolute)
+        // For Next.js, we'll serve from a public route or use absolute path
+        // For now, use a relative path that can be served via API or static file serving
+        const profilePictureUrl = `/api/hazo_auth/profile_picture/${fileName}`;
+        // Update user record
+        const updateResult = await update_user_profile_picture(hazoConnect, user_id, profilePictureUrl, "upload");
+        if (!updateResult.success) {
+            // Clean up uploaded file
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch (error) {
+                // Ignore cleanup errors
+            }
+            logger.warn("profile_picture_upload_update_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                user_id,
+                error: updateResult.error,
+            });
+            return NextResponse.json({ error: updateResult.error || "Failed to update profile picture" }, { status: 500 });
+        }
+        // Delete old profile picture file if it exists and was an uploaded file
+        if (oldProfilePictureUrl && oldProfileSource) {
+            const oldSourceUI = map_db_source_to_ui(oldProfileSource);
+            // Only delete if the old profile picture was an uploaded file
+            if (oldSourceUI === "upload") {
+                try {
+                    // Extract filename from URL (e.g., /api/hazo_auth/profile_picture/user_id.jpg)
+                    const oldFileName = oldProfilePictureUrl.split("/").pop();
+                    if (oldFileName) {
+                        // Check if it's a user-specific file (starts with user_id)
+                        if (oldFileName.startsWith(user_id)) {
+                            const oldFilePath = path.join(uploadPath, oldFileName);
+                            // Only delete if it's a different file (different extension)
+                            if (oldFilePath !== filePath && fs.existsSync(oldFilePath)) {
+                                fs.unlinkSync(oldFilePath);
+                                logger.info("profile_picture_old_file_deleted", {
+                                    filename: get_filename(),
+                                    line_number: get_line_number(),
+                                    user_id,
+                                    oldFileName,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Log error but don't fail the request
+                    logger.warn("profile_picture_old_file_delete_failed", {
+                        filename: get_filename(),
+                        line_number: get_line_number(),
+                        user_id,
+                        oldProfilePictureUrl,
+                        error: error instanceof Error ? error.message : "Unknown error",
+                    });
+                }
+            }
+        }
+        logger.info("profile_picture_upload_successful", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            user_id,
+            fileName,
+            fileSize,
+        });
+        return NextResponse.json({
+            success: true,
+            profile_picture_url: profilePictureUrl,
+            message: "Profile picture uploaded successfully",
+        }, { status: 200 });
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("profile_picture_upload_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: "Failed to upload profile picture. Please try again." }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/validate_reset_token/route.d.ts

@@ -0,0 +1,6 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    success: boolean;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/validate_reset_token/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/validate_reset_token/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;IAqE7C"}

package/dist/app/api/hazo_auth/validate_reset_token/route.js

@@ -0,0 +1,58 @@
+// file_description: API route for validating password reset token without resetting password
+// section: imports
+import { NextResponse } from "next/server";
+import { get_hazo_connect_instance } from "../../../../lib/hazo_connect_instance.server";
+import { validate_password_reset_token } from "../../../../lib/services/password_reset_service";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+// section: route_config
+export const dynamic = 'force-dynamic';
+// section: api_handler
+export async function GET(request) {
+    const logger = create_app_logger();
+    try {
+        const { searchParams } = new URL(request.url);
+        const token = searchParams.get("token");
+        // Validate input
+        if (!token) {
+            logger.warn("password_reset_token_validation_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                error: "Token is required",
+            });
+            return NextResponse.json({ success: false, error: "Token is required" }, { status: 400 });
+        }
+        // Get singleton hazo_connect instance (reuses same connection across all routes)
+        const hazoConnect = get_hazo_connect_instance();
+        // Validate token using the password reset service
+        const result = await validate_password_reset_token(hazoConnect, {
+            token,
+        });
+        if (!result.success) {
+            logger.warn("password_reset_token_validation_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                error: result.error,
+            });
+            return NextResponse.json({
+                success: false,
+                error: result.error || "Invalid or expired reset token",
+            }, { status: 400 });
+        }
+        return NextResponse.json({
+            success: true,
+        }, { status: 200 });
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        logger.error("password_reset_token_validation_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error: error_message,
+        });
+        return NextResponse.json({
+            success: false,
+            error: "An error occurred while validating the reset token",
+        }, { status: 500 });
+    }
+}

package/dist/app/api/hazo_auth/verify_email/route.d.ts

@@ -0,0 +1,11 @@
+import { NextRequest, NextResponse } from "next/server";
+export declare const dynamic = "force-dynamic";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    error: string;
+}> | NextResponse<{
+    success: boolean;
+    message: string;
+    user_id: string | undefined;
+    email: string | undefined;
+}>>;
+//# sourceMappingURL=route.d.ts.map

package/dist/app/api/hazo_auth/verify_email/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../../src/app/api/hazo_auth/verify_email/route.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOxD,eAAO,MAAM,OAAO,kBAAkB,CAAC;AAGvC,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;IA0E7C"}

package/dist/app/api/hazo_auth/verify_email/route.js

@@ -0,0 +1,63 @@
+// file_description: API route for email verification using hazo_connect
+// section: imports
+import { NextResponse } from "next/server";
+import { get_hazo_connect_instance } from "../../../../lib/hazo_connect_instance.server";
+import { create_app_logger } from "../../../../lib/app_logger";
+import { verify_email_token } from "../../../../lib/services/email_verification_service";
+import { get_filename, get_line_number } from "../../../../lib/utils/api_route_helpers";
+// section: route_config
+export const dynamic = 'force-dynamic';
+// section: api_handler
+export async function GET(request) {
+    const logger = create_app_logger();
+    try {
+        const { searchParams } = new URL(request.url);
+        const token = searchParams.get("token");
+        // Validate input
+        if (!token) {
+            logger.warn("email_verification_validation_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                has_token: false,
+            });
+            return NextResponse.json({ error: "Verification token is required" }, { status: 400 });
+        }
+        // Get singleton hazo_connect instance (reuses same connection across all routes)
+        const hazoConnect = get_hazo_connect_instance();
+        // Verify email token using the email verification service
+        const result = await verify_email_token(hazoConnect, {
+            token,
+        });
+        if (!result.success) {
+            logger.warn("email_verification_failed", {
+                filename: get_filename(),
+                line_number: get_line_number(),
+                error: result.error,
+            });
+            return NextResponse.json({ error: result.error || "Email verification failed" }, { status: 400 });
+        }
+        logger.info("email_verification_successful", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            user_id: result.user_id,
+            email: result.email,
+        });
+        return NextResponse.json({
+            success: true,
+            message: "Email verified successfully",
+            user_id: result.user_id,
+            email: result.email,
+        }, { status: 200 });
+    }
+    catch (error) {
+        const error_message = error instanceof Error ? error.message : "Unknown error";
+        const error_stack = error instanceof Error ? error.stack : undefined;
+        logger.error("email_verification_error", {
+            filename: get_filename(),
+            line_number: get_line_number(),
+            error_message,
+            error_stack,
+        });
+        return NextResponse.json({ error: "Email verification failed. Please try again." }, { status: 500 });
+    }
+}

package/dist/cli/generate.d.ts

@@ -0,0 +1,2 @@
+export declare function generate_routes(custom_app_dir?: string): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/cli/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/cli/generate.ts"],"names":[],"mappings":"AA0EA,wBAAgB,eAAe,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAwE7D"}

package/dist/cli/generate.js

@@ -0,0 +1,117 @@
+// file_description: route generation logic for hazo_auth
+// This module creates API route files in consuming projects
+import * as fs from "fs";
+import * as path from "path";
+// section: constants
+const ROUTES = [
+    { name: "login", path: "api/hazo_auth/login", method: "POST", export_name: "loginPOST" },
+    { name: "register", path: "api/hazo_auth/register", method: "POST", export_name: "registerPOST" },
+    { name: "logout", path: "api/hazo_auth/logout", method: "POST", export_name: "logoutPOST" },
+    { name: "me", path: "api/hazo_auth/me", method: "GET", export_name: "meGET" },
+    { name: "forgot_password", path: "api/hazo_auth/forgot_password", method: "POST", export_name: "forgotPasswordPOST" },
+    { name: "reset_password", path: "api/hazo_auth/reset_password", method: "POST", export_name: "resetPasswordPOST" },
+    { name: "verify_email", path: "api/hazo_auth/verify_email", method: "GET", export_name: "verifyEmailGET" },
+    { name: "resend_verification", path: "api/hazo_auth/resend_verification", method: "POST", export_name: "resendVerificationPOST" },
+    { name: "update_user", path: "api/hazo_auth/update_user", method: "PATCH", export_name: "updateUserPATCH" },
+    { name: "change_password", path: "api/hazo_auth/change_password", method: "POST", export_name: "changePasswordPOST" },
+    { name: "upload_profile_picture", path: "api/hazo_auth/upload_profile_picture", method: "POST", export_name: "uploadProfilePicturePOST" },
+    { name: "remove_profile_picture", path: "api/hazo_auth/remove_profile_picture", method: "DELETE", export_name: "removeProfilePictureDELETE" },
+    { name: "library_photos", path: "api/hazo_auth/library_photos", method: "GET", export_name: "libraryPhotosGET" },
+    { name: "get_auth", path: "api/hazo_auth/get_auth", method: "POST", export_name: "getAuthPOST" },
+    { name: "validate_reset_token", path: "api/hazo_auth/validate_reset_token", method: "GET", export_name: "validateResetTokenGET" },
+    { name: "profile_picture_filename", path: "api/hazo_auth/profile_picture/[filename]", method: "GET", export_name: "profilePictureFilenameGET" },
+    { name: "invalidate_cache", path: "api/hazo_auth/invalidate_cache", method: "POST", export_name: "invalidateCachePOST" },
+];
+// section: helpers
+function get_project_root() {
+    return process.cwd();
+}
+function find_app_dir(project_root) {
+    const possible_dirs = [
+        path.join(project_root, "app"),
+        path.join(project_root, "src", "app"),
+    ];
+    for (const dir of possible_dirs) {
+        if (fs.existsSync(dir)) {
+            return dir;
+        }
+    }
+    return null;
+}
+function ensure_dir(dir_path) {
+    if (!fs.existsSync(dir_path)) {
+        fs.mkdirSync(dir_path, { recursive: true });
+    }
+}
+function generate_route_content(route) {
+    return `// Generated by hazo_auth - do not edit manually
+// Route: /${route.path}
+// Method: ${route.method}
+export { ${route.export_name} as ${route.method} } from "hazo_auth/server/routes";
+`;
+}
+function file_exists(filepath) {
+    return fs.existsSync(filepath);
+}
+// section: main
+export function generate_routes(custom_app_dir) {
+    const project_root = get_project_root();
+    console.log("\n\x1b[1m🐸 hazo_auth Route Generator\x1b[0m");
+    console.log("=".repeat(50));
+    console.log(`Project root: ${project_root}\n`);
+    let app_dir = custom_app_dir
+        ? path.join(project_root, custom_app_dir)
+        : find_app_dir(project_root);
+    if (!app_dir) {
+        console.error("\x1b[31mError: Could not find app directory.\x1b[0m");
+        console.log("Try specifying it with: npx hazo_auth generate-routes --dir=src/app");
+        process.exit(1);
+    }
+    if (!fs.existsSync(app_dir)) {
+        console.error(`\x1b[31mError: App directory not found: ${app_dir}\x1b[0m`);
+        process.exit(1);
+    }
+    console.log(`App directory: ${app_dir.replace(project_root, ".")}\n`);
+    let created = 0;
+    let skipped = 0;
+    let errors = 0;
+    console.log("\x1b[1mGenerating routes...\x1b[0m\n");
+    for (const route of ROUTES) {
+        const route_dir = path.join(app_dir, route.path);
+        const route_file = path.join(route_dir, "route.ts");
+        if (file_exists(route_file)) {
+            console.log(`\x1b[33m[SKIP]\x1b[0m ${route.path}/route.ts (already exists)`);
+            skipped++;
+            continue;
+        }
+        try {
+            ensure_dir(route_dir);
+            const content = generate_route_content(route);
+            fs.writeFileSync(route_file, content, "utf-8");
+            console.log(`\x1b[32m[CREATE]\x1b[0m ${route.path}/route.ts`);
+            created++;
+        }
+        catch (err) {
+            console.log(`\x1b[31m[ERROR]\x1b[0m ${route.path}/route.ts - ${err instanceof Error ? err.message : "Unknown error"}`);
+            errors++;
+        }
+    }
+    console.log("\n" + "=".repeat(50));
+    console.log("\x1b[1mSummary:\x1b[0m");
+    console.log(`  \x1b[32m✓ Created: ${created}\x1b[0m`);
+    console.log(`  \x1b[33m⊘ Skipped: ${skipped}\x1b[0m`);
+    if (errors > 0) {
+        console.log(`  \x1b[31m✗ Errors:  ${errors}\x1b[0m`);
+    }
+    console.log();
+    if (created > 0) {
+        console.log("\x1b[32m🦊 Routes generated successfully!\x1b[0m");
+        console.log("\nNext steps:");
+        console.log("  1. Run `npm run dev` to start your development server");
+        console.log("  2. Test the routes with `curl http://localhost:3000/api/hazo_auth/me`");
+        console.log("  3. Visit http://localhost:3000/api/hazo_auth/health to check setup status\n");
+    }
+    else if (skipped === ROUTES.length) {
+        console.log("\x1b[33m🦊 All routes already exist. No changes made.\x1b[0m\n");
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// file_description: main CLI entry point for hazo_auth commands
+// This file is the bin entry for the hazo_auth package
+// section: imports
+import { run_validation } from "./validate.js";
+import { generate_routes } from "./generate.js";
+// section: constants
+const VERSION = "1.5.0";
+const HELP_TEXT = `
+\x1b[1m🐸 hazo_auth CLI v${VERSION}\x1b[0m
+
+Usage: hazo_auth <command> [options]
+
+Commands:
+  validate           Check your hazo_auth setup and configuration
+  generate-routes    Generate API route files in your project
+
+Options:
+  --help, -h         Show this help message
+  --version, -v      Show version number
+
+Examples:
+  npx hazo_auth validate
+  npx hazo_auth generate-routes
+  npx hazo_auth generate-routes --dir=src/app
+
+Documentation:
+  https://github.com/your-repo/hazo_auth/blob/main/SETUP_CHECKLIST.md
+
+🦊
+`;
+// section: helpers
+function parse_args() {
+    const argv = process.argv.slice(2);
+    const result = { args: [] };
+    for (const arg of argv) {
+        if (arg === "--help" || arg === "-h") {
+            result.help = true;
+        }
+        else if (arg === "--version" || arg === "-v") {
+            result.version = true;
+        }
+        else if (!arg.startsWith("-") && !result.command) {
+            result.command = arg;
+        }
+        else {
+            result.args.push(arg);
+        }
+    }
+    return result;
+}
+function show_help() {
+    console.log(HELP_TEXT);
+}
+function show_version() {
+    console.log(`hazo_auth v${VERSION}`);
+}
+// section: command_handlers
+async function handle_validate() {
+    const summary = run_validation();
+    process.exit(summary.failed > 0 ? 1 : 0);
+}
+function handle_generate_routes(args) {
+    // Parse --dir argument
+    let dir;
+    for (const arg of args) {
+        if (arg.startsWith("--dir=")) {
+            dir = arg.replace("--dir=", "");
+        }
+        else if (arg === "--help" || arg === "-h") {
+            console.log(`
+hazo_auth generate-routes
+
+Generate API route files in your Next.js project.
+
+Usage:
+  hazo_auth generate-routes [options]
+
+Options:
+  --dir=<path>    Specify the app directory (default: auto-detect)
+  --help, -h      Show this help message
+
+Examples:
+  hazo_auth generate-routes
+  hazo_auth generate-routes --dir=src/app
+`);
+            return;
+        }
+    }
+    generate_routes(dir);
+}
+// section: main
+async function main() {
+    const { command, args, help, version } = parse_args();
+    if (version) {
+        show_version();
+        return;
+    }
+    if (help || !command) {
+        show_help();
+        return;
+    }
+    switch (command) {
+        case "validate":
+            await handle_validate();
+            break;
+        case "generate-routes":
+            handle_generate_routes(args);
+            break;
+        default:
+            console.error(`\x1b[31mUnknown command: ${command}\x1b[0m\n`);
+            console.log("Run 'hazo_auth --help' for usage information.");
+            process.exit(1);
+    }
+}
+// Run main
+main().catch((error) => {
+    console.error("\x1b[31mError:\x1b[0m", error.message);
+    process.exit(1);
+});

package/dist/cli/validate.d.ts

@@ -0,0 +1,15 @@
+type CheckStatus = "pass" | "fail" | "warn";
+type CheckResult = {
+    name: string;
+    status: CheckStatus;
+    message: string;
+};
+export type ValidationSummary = {
+    passed: number;
+    failed: number;
+    warnings: number;
+    results: CheckResult[];
+};
+export declare function run_validation(): ValidationSummary;
+export {};
+//# sourceMappingURL=validate.d.ts.map

package/dist/cli/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/cli/validate.ts"],"names":[],"mappings":"AAOA,KAAK,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAE5C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB,CAAC;AA4dF,wBAAgB,cAAc,IAAI,iBAAiB,CAqElD"}