irismail 0.1.0

package/dist/index.js

@@ -0,0 +1,446 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EmailService: () => EmailService,
+  InputOTP: () => InputOTP,
+  InputOTPGroup: () => InputOTPGroup,
+  InputOTPSeparator: () => InputOTPSeparator,
+  InputOTPSlot: () => InputOTPSlot,
+  IrisMailService: () => IrisMailService,
+  OTPService: () => OTPService,
+  OTP_DEFAULTS: () => OTP_DEFAULTS,
+  cn: () => cn,
+  decrypt: () => decrypt,
+  encrypt: () => encrypt,
+  useOTP: () => useOTP
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server/email.ts
+var import_nodemailer = __toESM(require("nodemailer"));
+var EmailService = class {
+  constructor(config) {
+    __publicField(this, "transporter");
+    __publicField(this, "config");
+    this.config = config;
+    this.transporter = import_nodemailer.default.createTransport(config.transport);
+  }
+  /**
+   * Verify SMTP connection configuration
+   */
+  async verifyConnection() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch (error) {
+      console.error("SMTP connection verification failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Send an email
+   * @param options - Email options (to, subject, html, text, from)
+   * @returns - Result of the send operation
+   */
+  async sendEmail(options) {
+    const from = options.from || this.config.defaults?.from;
+    if (!from) {
+      throw new Error("From address is required either in options or config defaults");
+    }
+    const mailOptions = {
+      from: {
+        name: from.name,
+        address: from.address
+      },
+      to: options.to,
+      subject: options.subject,
+      html: options.html,
+      text: options.text || options.html.replace(/<[^>]*>/g, "")
+      // Simple HTML to text fallback
+    };
+    try {
+      const info = await this.transporter.sendMail(mailOptions);
+      return {
+        success: true,
+        messageId: info.messageId
+      };
+    } catch (error) {
+      console.error("Error sending email:", error);
+      throw error;
+    }
+  }
+};
+
+// src/server/crypto.ts
+var import_crypto = __toESM(require("crypto"));
+var ALGORITHM = "aes-256-cbc";
+function encrypt(text, secretKey) {
+  try {
+    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
+    const iv = import_crypto.default.randomBytes(16);
+    const cipher = import_crypto.default.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(text, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    return iv.toString("hex") + ":" + encrypted;
+  } catch (error) {
+    console.error("Encryption error:", error);
+    throw new Error("Failed to encrypt data");
+  }
+}
+function decrypt(encryptedText, secretKey) {
+  try {
+    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
+    const parts = encryptedText.split(":");
+    if (parts.length !== 2) {
+      throw new Error("Invalid encrypted text format");
+    }
+    const iv = Buffer.from(parts[0], "hex");
+    const encrypted = parts[1];
+    const decipher = import_crypto.default.createDecipheriv(ALGORITHM, key, iv);
+    let decrypted = decipher.update(encrypted, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch (error) {
+    console.error("Decryption error:", error);
+    throw new Error("Failed to decrypt data");
+  }
+}
+
+// src/server/otp.ts
+var OTPService = class {
+  constructor(secretKey) {
+    __publicField(this, "secretKey");
+    if (!secretKey) {
+      throw new Error("OTPService: secretKey is required");
+    }
+    this.secretKey = secretKey;
+  }
+  /**
+   * Generate a numeric OTP of specified length
+   * @param length - Length of the OTP (default: 6)
+   * @returns - The generated OTP string
+   */
+  generateOTP(length = 6) {
+    const min = Math.pow(10, length - 1);
+    const max = Math.pow(10, length) - 1;
+    return Math.floor(min + Math.random() * (max - min + 1)).toString();
+  }
+  /**
+   * Encrypt OTP data for secure storage/transmission
+   * @param otp - The OTP string
+   * @param timestamp - The timestamp when OTP was generated (default: now)
+   * @returns - Encrypted OTP data string
+   */
+  encryptOTP(otp, timestamp = Date.now()) {
+    const data = JSON.stringify({ otp, timestamp });
+    return encrypt(data, this.secretKey);
+  }
+  /**
+   * Decrypt OTP data
+   * @param encryptedData - The encrypted OTP string
+   * @returns - Decrypted OTP data object or null if failed
+   */
+  decryptOTP(encryptedData) {
+    try {
+      const decryptedData = decrypt(encryptedData, this.secretKey);
+      return JSON.parse(decryptedData);
+    } catch (error) {
+      console.error("Error decrypting OTP data:", error);
+      return null;
+    }
+  }
+  /**
+   * Verify an OTP against encrypted data
+   * @param inputOtp - The OTP provided by the user
+   * @param encryptedData - The encrypted OTP data
+   * @param expiryMinutes - Expiry time in minutes (default: 5)
+   * @returns - Object containing valid status and message
+   */
+  verifyOTP(inputOtp, encryptedData, expiryMinutes = 5) {
+    const data = this.decryptOTP(encryptedData);
+    if (!data) {
+      return { valid: false, message: "Invalid OTP data" };
+    }
+    const { otp, timestamp } = data;
+    const currentTime = Date.now();
+    const otpAge = currentTime - timestamp;
+    const expiryTime = expiryMinutes * 60 * 1e3;
+    if (otpAge > expiryTime) {
+      return { valid: false, message: "OTP has expired" };
+    }
+    if (otp !== inputOtp) {
+      return { valid: false, message: "Incorrect OTP" };
+    }
+    return { valid: true, message: "OTP verified successfully" };
+  }
+};
+
+// src/server/index.ts
+var IrisMailService = class {
+  constructor(config) {
+    __publicField(this, "email");
+    __publicField(this, "otp");
+    this.email = new EmailService(config.email);
+    this.otp = new OTPService(config.secretKey);
+  }
+};
+
+// src/react/components/input-otp.tsx
+var React = __toESM(require("react"));
+var import_input_otp = require("input-otp");
+
+// src/utils/constants.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+var OTP_DEFAULTS = {
+  LENGTH: 6,
+  EXPIRY_MINUTES: 5,
+  RESEND_COOLDOWN_SECONDS: 120,
+  // 2 minutes
+  MAX_ATTEMPTS: 5,
+  RATE_LIMIT_RESET_HOURS: 1
+};
+
+// src/react/components/input-otp.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var Dot = () => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+  "svg",
+  {
+    width: "15",
+    height: "15",
+    viewBox: "0 0 15 15",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    className: "h-4 w-4",
+    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "path",
+      {
+        d: "M7.5 7.5C7.5 8.32843 6.82843 9 6 9C5.17157 9 4.5 8.32843 4.5 7.5C4.5 6.67157 5.17157 6 6 6C6.82843 6 7.5 6.67157 7.5 7.5Z",
+        fill: "currentColor",
+        fillRule: "evenodd",
+        clipRule: "evenodd"
+      }
+    )
+  }
+);
+var InputOTP = React.forwardRef(
+  ({ className, containerClassName, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_input_otp.OTPInput,
+    {
+      ref,
+      containerClassName: cn("flex items-center gap-2 has-[:disabled]:opacity-50", containerClassName),
+      className: cn("disabled:cursor-not-allowed", className),
+      ...props
+    }
+  )
+);
+InputOTP.displayName = "InputOTP";
+var InputOTPGroup = React.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, className: cn("flex items-center", className), ...props })
+);
+InputOTPGroup.displayName = "InputOTPGroup";
+var InputOTPSlot = React.forwardRef(({ index, className, ...props }, ref) => {
+  const inputOTPContext = React.useContext(import_input_otp.OTPInputContext);
+  const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+    "div",
+    {
+      ref,
+      className: cn(
+        "relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all first:rounded-l-md first:border-l last:rounded-r-md",
+        isActive && "z-10 ring-2 ring-ring ring-offset-background",
+        className
+      ),
+      ...props,
+      children: [
+        char,
+        hasFakeCaret && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "h-4 w-px animate-caret-blink bg-foreground duration-1000" }) })
+      ]
+    }
+  );
+});
+InputOTPSlot.displayName = "InputOTPSlot";
+var InputOTPSeparator = React.forwardRef(
+  ({ ...props }, ref) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref, role: "separator", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Dot, {}) })
+);
+InputOTPSeparator.displayName = "InputOTPSeparator";
+
+// src/react/hooks/use-otp.ts
+var import_react = require("react");
+function useOTP({ email, onRateLimit }) {
+  const [otpTimeLeft, setOtpTimeLeft] = (0, import_react.useState)(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
+  const [resendTimeLeft, setResendTimeLeft] = (0, import_react.useState)(0);
+  const [attemptsLeft, setAttemptsLeft] = (0, import_react.useState)(OTP_DEFAULTS.MAX_ATTEMPTS);
+  const [isRateLimited, setIsRateLimited] = (0, import_react.useState)(false);
+  const [rateLimitResetTime, setRateLimitResetTime] = (0, import_react.useState)(null);
+  const getStorageKey = (prefix) => `${prefix}_${email}`;
+  const getStoredData = (key) => {
+    if (typeof window === "undefined") return null;
+    const data = sessionStorage.getItem(key);
+    return data ? JSON.parse(data) : null;
+  };
+  const setStoredData = (key, data) => {
+    if (typeof window !== "undefined") {
+      sessionStorage.setItem(key, JSON.stringify(data));
+    }
+  };
+  const removeStoredData = (key) => {
+    if (typeof window !== "undefined") {
+      sessionStorage.removeItem(key);
+    }
+  };
+  const checkRateLimit = () => {
+    const key = getStorageKey("rate_limit");
+    const data = getStoredData(key);
+    if (!data) {
+      setAttemptsLeft(OTP_DEFAULTS.MAX_ATTEMPTS);
+      setIsRateLimited(false);
+      return { limited: false, attemptsLeft: OTP_DEFAULTS.MAX_ATTEMPTS };
+    }
+    const currentTime = Date.now();
+    const resetTime = OTP_DEFAULTS.RATE_LIMIT_RESET_HOURS * 60 * 60 * 1e3;
+    if (currentTime - data.firstAttemptTime > resetTime) {
+      removeStoredData(key);
+      setAttemptsLeft(OTP_DEFAULTS.MAX_ATTEMPTS);
+      setIsRateLimited(false);
+      return { limited: false, attemptsLeft: OTP_DEFAULTS.MAX_ATTEMPTS };
+    }
+    const attempts = OTP_DEFAULTS.MAX_ATTEMPTS - data.attempts;
+    const limited = data.attempts >= OTP_DEFAULTS.MAX_ATTEMPTS;
+    const limitResetTime = data.firstAttemptTime + resetTime;
+    setAttemptsLeft(Math.max(0, attempts));
+    setIsRateLimited(limited);
+    setRateLimitResetTime(limited ? limitResetTime : null);
+    if (limited && onRateLimit) {
+      onRateLimit(limitResetTime);
+    }
+    return { limited, attemptsLeft: Math.max(0, attempts), resetTime: limited ? limitResetTime : void 0 };
+  };
+  const updateRateLimit = () => {
+    const key = getStorageKey("rate_limit");
+    const data = getStoredData(key);
+    const currentTime = Date.now();
+    let newData;
+    if (!data) {
+      newData = {
+        attempts: 1,
+        firstAttemptTime: currentTime,
+        lastAttemptTime: currentTime
+      };
+    } else {
+      const resetTime = OTP_DEFAULTS.RATE_LIMIT_RESET_HOURS * 60 * 60 * 1e3;
+      if (currentTime - data.firstAttemptTime > resetTime) {
+        newData = {
+          attempts: 1,
+          firstAttemptTime: currentTime,
+          lastAttemptTime: currentTime
+        };
+      } else {
+        newData = {
+          ...data,
+          attempts: data.attempts + 1,
+          lastAttemptTime: currentTime
+        };
+      }
+    }
+    setStoredData(key, newData);
+    checkRateLimit();
+    return newData;
+  };
+  const checkResendCooldown = () => {
+    const key = getStorageKey("last_sent");
+    const lastSentTime = getStoredData(key);
+    if (!lastSentTime) {
+      setResendTimeLeft(0);
+      return { canResend: true, timeLeft: 0 };
+    }
+    const currentTime = Date.now();
+    const timeSinceLastSent = currentTime - lastSentTime;
+    const cooldown = OTP_DEFAULTS.RESEND_COOLDOWN_SECONDS * 1e3;
+    const canResend = timeSinceLastSent >= cooldown;
+    const timeLeft = canResend ? 0 : Math.ceil((cooldown - timeSinceLastSent) / 1e3);
+    setResendTimeLeft(timeLeft);
+    return { canResend, timeLeft };
+  };
+  const recordSentOTP = () => {
+    const key = getStorageKey("last_sent");
+    setStoredData(key, Date.now());
+    updateRateLimit();
+    setOtpTimeLeft(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
+    setResendTimeLeft(OTP_DEFAULTS.RESEND_COOLDOWN_SECONDS);
+  };
+  (0, import_react.useEffect)(() => {
+    checkRateLimit();
+    checkResendCooldown();
+    const timer = setInterval(() => {
+      setOtpTimeLeft((prev) => Math.max(0, prev - 1));
+      const { timeLeft } = checkResendCooldown();
+      setResendTimeLeft(timeLeft);
+    }, 1e3);
+    return () => clearInterval(timer);
+  }, [email]);
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  };
+  return {
+    otpTimeLeft,
+    resendTimeLeft,
+    attemptsLeft,
+    isRateLimited,
+    rateLimitResetTime,
+    formatTime,
+    recordSentOTP,
+    checkRateLimit
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmailService,
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSeparator,
+  InputOTPSlot,
+  IrisMailService,
+  OTPService,
+  OTP_DEFAULTS,
+  cn,
+  decrypt,
+  encrypt,
+  useOTP
+});

package/dist/index.mjs

@@ -0,0 +1,31 @@
+import {
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSeparator,
+  InputOTPSlot,
+  OTP_DEFAULTS,
+  cn,
+  useOTP
+} from "./chunk-FTNSOYOW.mjs";
+import {
+  EmailService,
+  IrisMailService,
+  OTPService,
+  decrypt,
+  encrypt
+} from "./chunk-XGASTZZ6.mjs";
+import "./chunk-QZ7TP4HQ.mjs";
+export {
+  EmailService,
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSeparator,
+  InputOTPSlot,
+  IrisMailService,
+  OTPService,
+  OTP_DEFAULTS,
+  cn,
+  decrypt,
+  encrypt,
+  useOTP
+};

package/dist/react/index.d.mts

@@ -0,0 +1,60 @@
+import * as input_otp from 'input-otp';
+import * as React from 'react';
+
+declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "maxLength" | "value" | "onChange" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render: (props: input_otp.RenderProps) => React.ReactNode;
+    children?: never;
+} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "maxLength" | "value" | "onChange" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render?: never;
+    children: React.ReactNode;
+} & React.RefAttributes<HTMLInputElement>, "ref">) & React.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    index: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface UseOTPOptions {
+    email: string;
+    onRateLimit?: (resetTime: number) => void;
+}
+declare function useOTP({ email, onRateLimit }: UseOTPOptions): {
+    otpTimeLeft: number;
+    resendTimeLeft: number;
+    attemptsLeft: number;
+    isRateLimited: boolean;
+    rateLimitResetTime: number | null;
+    formatTime: (seconds: number) => string;
+    recordSentOTP: () => void;
+    checkRateLimit: () => {
+        limited: boolean;
+        attemptsLeft: number;
+        resetTime?: undefined;
+    } | {
+        limited: boolean;
+        attemptsLeft: number;
+        resetTime: number | undefined;
+    };
+};
+
+export { InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, useOTP };

package/dist/react/index.d.ts

@@ -0,0 +1,60 @@
+import * as input_otp from 'input-otp';
+import * as React from 'react';
+
+declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "maxLength" | "value" | "onChange" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render: (props: input_otp.RenderProps) => React.ReactNode;
+    children?: never;
+} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "maxLength" | "value" | "onChange" | "textAlign" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "containerClassName" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render?: never;
+    children: React.ReactNode;
+} & React.RefAttributes<HTMLInputElement>, "ref">) & React.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    index: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface UseOTPOptions {
+    email: string;
+    onRateLimit?: (resetTime: number) => void;
+}
+declare function useOTP({ email, onRateLimit }: UseOTPOptions): {
+    otpTimeLeft: number;
+    resendTimeLeft: number;
+    attemptsLeft: number;
+    isRateLimited: boolean;
+    rateLimitResetTime: number | null;
+    formatTime: (seconds: number) => string;
+    recordSentOTP: () => void;
+    checkRateLimit: () => {
+        limited: boolean;
+        attemptsLeft: number;
+        resetTime?: undefined;
+    } | {
+        limited: boolean;
+        attemptsLeft: number;
+        resetTime: number | undefined;
+    };
+};
+
+export { InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, useOTP };