@withwiz/toolkit 0.1.0

package/dist/chunk-IAJNC34M.js

@@ -0,0 +1,102 @@
+import {
+  getErrorDisplayInfo
+} from "./chunk-POKGHK3L.js";
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  ERROR_CODES
+} from "./chunk-Y3OTJH2S.js";
+
+// src/error/hooks/useErrorHandler.ts
+import { useState, useCallback } from "react";
+function useErrorHandler(locale = "ko") {
+  const [errorState, setErrorState] = useState({
+    hasError: false
+  });
+  const handleError = useCallback(
+    (error) => {
+      console.error("[useErrorHandler] Error occurred:", error);
+      if (error instanceof AppError) {
+        const displayInfo2 = getErrorDisplayInfo(error.code, locale);
+        setErrorState({
+          hasError: true,
+          code: error.code,
+          message: error.message,
+          displayInfo: displayInfo2,
+          timestamp: Date.now()
+        });
+        return;
+      }
+      if (error && typeof error === "object" && "error" in error && typeof error.error === "object") {
+        const apiError = error.error;
+        const code = apiError.code || ERROR_CODES.INTERNAL_SERVER_ERROR.code;
+        const displayInfo2 = getErrorDisplayInfo(code, locale);
+        setErrorState({
+          hasError: true,
+          code,
+          message: apiError.message || "Unknown error",
+          displayInfo: displayInfo2,
+          timestamp: Date.now()
+        });
+        return;
+      }
+      if (error instanceof Error) {
+        const displayInfo2 = getErrorDisplayInfo(
+          ERROR_CODES.INTERNAL_SERVER_ERROR.code,
+          locale
+        );
+        setErrorState({
+          hasError: true,
+          code: ERROR_CODES.INTERNAL_SERVER_ERROR.code,
+          message: error.message,
+          displayInfo: displayInfo2,
+          timestamp: Date.now()
+        });
+        return;
+      }
+      const displayInfo = getErrorDisplayInfo(
+        ERROR_CODES.INTERNAL_SERVER_ERROR.code,
+        locale
+      );
+      setErrorState({
+        hasError: true,
+        code: ERROR_CODES.INTERNAL_SERVER_ERROR.code,
+        message: String(error),
+        displayInfo,
+        timestamp: Date.now()
+      });
+    },
+    [locale]
+  );
+  const clearError = useCallback(() => {
+    setErrorState({
+      hasError: false
+    });
+  }, []);
+  const handleAuthError = useCallback(
+    (error, redirectUrl = "/login") => {
+      handleError(error);
+      if (error instanceof AppError) {
+        const httpStatus = Math.floor(error.code / 100);
+        if (httpStatus === 401 || httpStatus === 403) {
+          setTimeout(() => {
+            window.location.href = redirectUrl;
+          }, 1e3);
+        }
+      }
+    },
+    [handleError]
+  );
+  return {
+    errorState,
+    handleError,
+    clearError,
+    handleAuthError,
+    hasError: errorState.hasError
+  };
+}
+
+export {
+  useErrorHandler
+};

package/dist/chunk-IHXRF3BH.js

@@ -0,0 +1,215 @@
+// src/auth/core/password/index.ts
+import { z } from "zod";
+import bcrypt from "bcryptjs";
+var _PasswordValidator = class _PasswordValidator {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * 비밀번호 유효성 검사
+   */
+  validate(password) {
+    const errors = [];
+    if (password.length < this.config.minLength) {
+      errors.push(
+        `Password must be at least ${this.config.minLength} characters long`
+      );
+    }
+    if (password.length > this.config.maxLength) {
+      errors.push(
+        `Password cannot exceed ${this.config.maxLength} characters`
+      );
+    }
+    if (this.config.requireNumber && !/\d/.test(password)) {
+      errors.push("Password must contain at least one number");
+    }
+    if (this.config.requireUppercase && !/[A-Z]/.test(password)) {
+      errors.push("Password must contain at least one uppercase letter");
+    }
+    if (this.config.requireLowercase && !/[a-z]/.test(password)) {
+      errors.push("Password must contain at least one lowercase letter");
+    }
+    if (this.config.requireSpecialChar && !_PasswordValidator.SPECIAL_CHARS.test(password)) {
+      errors.push("Password must contain at least one special character");
+    }
+    const strength = this.calculateStrength(password);
+    const score = this.calculateScore(password);
+    return {
+      isValid: errors.length === 0,
+      errors,
+      strength,
+      score
+    };
+  }
+  /**
+   * 비밀번호 확인 검증
+   */
+  validateConfirmation(password, confirmPassword) {
+    const errors = [];
+    if (password !== confirmPassword) {
+      errors.push("Passwords do not match");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      strength: "WEAK" /* WEAK */,
+      score: 0
+    };
+  }
+  /**
+   * 비밀번호 강도 계산
+   */
+  calculateStrength(password) {
+    const score = this.calculateScore(password);
+    if (score < 20) return "VERY_WEAK" /* VERY_WEAK */;
+    if (score < 40) return "WEAK" /* WEAK */;
+    if (score < 60) return "MEDIUM" /* MEDIUM */;
+    if (score < 80) return "STRONG" /* STRONG */;
+    return "VERY_STRONG" /* VERY_STRONG */;
+  }
+  /**
+   * 비밀번호 점수 계산 (0-100)
+   */
+  calculateScore(password) {
+    let score = 0;
+    if (password.length >= 8) score += 10;
+    if (password.length >= 12) score += 10;
+    if (password.length >= 16) score += 5;
+    if (/[a-z]/.test(password)) score += 10;
+    if (/[A-Z]/.test(password)) score += 10;
+    if (/\d/.test(password)) score += 10;
+    if (_PasswordValidator.SPECIAL_CHARS.test(password)) score += 10;
+    const uniqueChars = new Set(password).size;
+    if (uniqueChars >= password.length * 0.7) score += 20;
+    if (password.length >= 12 && uniqueChars >= 8) score += 15;
+    return Math.min(score, 100);
+  }
+  /**
+   * Zod 스키마 생성
+   */
+  createZodSchema() {
+    let schema = z.string().min(
+      this.config.minLength,
+      `Password must be at least ${this.config.minLength} characters long`
+    ).max(
+      this.config.maxLength,
+      `Password cannot exceed ${this.config.maxLength} characters`
+    );
+    if (this.config.requireNumber) {
+      schema = schema.regex(
+        /\d/,
+        "Password must contain at least one number"
+      );
+    }
+    if (this.config.requireUppercase) {
+      schema = schema.regex(
+        /[A-Z]/,
+        "Password must contain at least one uppercase letter"
+      );
+    }
+    if (this.config.requireLowercase) {
+      schema = schema.regex(
+        /[a-z]/,
+        "Password must contain at least one lowercase letter"
+      );
+    }
+    if (this.config.requireSpecialChar) {
+      schema = schema.regex(
+        _PasswordValidator.SPECIAL_CHARS,
+        "Password must contain at least one special character"
+      );
+    }
+    return schema;
+  }
+  /**
+   * 비밀번호 힌트 생성
+   */
+  generateHint(password) {
+    const hints = [];
+    if (password.length < this.config.minLength) {
+      hints.push(`Enter at least ${this.config.minLength} characters`);
+    }
+    if (this.config.requireNumber && !/\d/.test(password)) {
+      hints.push("Include numbers");
+    }
+    if (this.config.requireUppercase && !/[A-Z]/.test(password)) {
+      hints.push("Include uppercase letters");
+    }
+    if (this.config.requireLowercase && !/[a-z]/.test(password)) {
+      hints.push("Include lowercase letters");
+    }
+    if (this.config.requireSpecialChar && !_PasswordValidator.SPECIAL_CHARS.test(password)) {
+      hints.push("Include special characters");
+    }
+    return hints;
+  }
+  /**
+   * 비밀번호 강도 메시지 반환
+   */
+  static getStrengthMessage(strength) {
+    switch (strength) {
+      case "VERY_WEAK" /* VERY_WEAK */:
+        return "Very Weak";
+      case "WEAK" /* WEAK */:
+        return "Weak";
+      case "MEDIUM" /* MEDIUM */:
+        return "Medium";
+      case "STRONG" /* STRONG */:
+        return "Strong";
+      case "VERY_STRONG" /* VERY_STRONG */:
+        return "Very Strong";
+      default:
+        return "Unknown";
+    }
+  }
+  /**
+   * 비밀번호 강도 색상 반환 (Tailwind CSS)
+   */
+  static getStrengthColor(strength) {
+    switch (strength) {
+      case "VERY_WEAK" /* VERY_WEAK */:
+        return "text-red-600";
+      case "WEAK" /* WEAK */:
+        return "text-orange-600";
+      case "MEDIUM" /* MEDIUM */:
+        return "text-yellow-600";
+      case "STRONG" /* STRONG */:
+        return "text-blue-600";
+      case "VERY_STRONG" /* VERY_STRONG */:
+        return "text-green-600";
+      default:
+        return "text-gray-600";
+    }
+  }
+};
+_PasswordValidator.SPECIAL_CHARS = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/;
+var PasswordValidator = _PasswordValidator;
+var PasswordHasher = class {
+  constructor(rounds = 12) {
+    this.rounds = rounds;
+  }
+  /**
+   * 비밀번호 해싱
+   */
+  async hash(password) {
+    return bcrypt.hash(password, this.rounds);
+  }
+  /**
+   * 비밀번호 검증
+   */
+  async verify(password, hash) {
+    return bcrypt.compare(password, hash);
+  }
+};
+var defaultPasswordSchema = z.string().min(8, "Password must be at least 8 characters long").max(128, "Password cannot exceed 128 characters").regex(/\d/, "Password must contain at least one number");
+var strongPasswordSchema = z.string().min(12, "Password must be at least 12 characters long").max(128, "Password cannot exceed 128 characters").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/\d/, "Password must contain at least one number").regex(
+  /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/,
+  "Password must contain at least one special character"
+);
+
+export {
+  PasswordValidator,
+  PasswordHasher,
+  defaultPasswordSchema,
+  strongPasswordSchema
+};

package/dist/chunk-IJEZ7G7S.js

@@ -0,0 +1,26 @@
+import {
+  cn
+} from "./chunk-62FLBG6B.js";
+import {
+  __objRest,
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/components/ui/Label.tsx
+import { jsx } from "react/jsx-runtime";
+function Label(_a) {
+  var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
+  return /* @__PURE__ */ jsx(
+    "label",
+    __spreadValues({
+      className: cn(
+        "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
+        className
+      )
+    }, props)
+  );
+}
+
+export {
+  Label
+};

package/dist/chunk-IQQKKUAV.js

@@ -0,0 +1,151 @@
+// src/cache/cache-defaults.ts
+var ONE_MINUTE = 60;
+var FIVE_MINUTES = 300;
+var TEN_MINUTES = 600;
+var FIFTEEN_MINUTES = 900;
+var THIRTY_MINUTES = 1800;
+var ONE_HOUR = 3600;
+var ONE_DAY = 86400;
+var THIRTY_DAYS = 2592e3;
+var INMEMORY_CACHE_DEFAULTS = {
+  /** 최대 캐시 항목 수 */
+  MAX_SIZE: 1e5,
+  /** 최대 메모리 사용량 (MB) */
+  MAX_MB: 200,
+  /** 제거 정책: 'lru' | 'fifo' | 'ttl' */
+  EVICTION: "lru",
+  /** 정리 간격 (밀리초) */
+  CLEANUP_INTERVAL: 6e4
+};
+var CACHE_TTL_DEFAULTS = {
+  /** 기본 TTL (1시간) */
+  DEFAULT: ONE_HOUR,
+  /** 짧은 TTL (5분) - 자주 변경되는 데이터 */
+  SHORT: FIVE_MINUTES,
+  /** 긴 TTL (24시간) - 거의 변경되지 않는 데이터 */
+  LONG: ONE_DAY,
+  /** GeoIP TTL (30일) - IP 위치 정보는 거의 변경되지 않음 */
+  GEOIP: THIRTY_DAYS,
+  /** 설정 TTL (1시간) */
+  SETTINGS: ONE_HOUR,
+  /** 분석 데이터 TTL (30분) */
+  ANALYTICS: THIRTY_MINUTES,
+  /** 사용자 데이터 TTL (30분) */
+  USER: THIRTY_MINUTES,
+  /** 링크 데이터 TTL (30분) */
+  LINK: THIRTY_MINUTES,
+  /** 별칭 TTL (5분) - 자주 확인되는 데이터 */
+  ALIAS: FIVE_MINUTES,
+  /** 커뮤니티 TTL (15분) */
+  COMMUNITY: FIFTEEN_MINUTES,
+  /** 예약어 TTL (30분) */
+  RESERVED_WORDS: THIRTY_MINUTES
+};
+var CACHE_DURATION_DEFAULTS = {
+  /** 분석 데이터 (30분) */
+  ANALYTICS: THIRTY_MINUTES,
+  /** 사용자 데이터 (10분) */
+  USER: TEN_MINUTES,
+  /** GeoIP 데이터 (30일) */
+  GEOIP: THIRTY_DAYS,
+  /** 설정 데이터 (30분) */
+  SETTINGS: THIRTY_MINUTES,
+  /** 예약어 데이터 (30분) */
+  RESERVED_WORDS: THIRTY_MINUTES,
+  /** 별칭 데이터 (5분) */
+  ALIAS: FIVE_MINUTES,
+  /** 커뮤니티 데이터 (15분) */
+  COMMUNITY: FIFTEEN_MINUTES,
+  /** 링크 데이터 (30분) */
+  LINK: THIRTY_MINUTES,
+  /** Rate Limit (1분) */
+  RATE_LIMIT: ONE_MINUTE,
+  /** URL 토큰 (5분) */
+  URL_TOKEN: FIVE_MINUTES,
+  /** API 키 (5분) */
+  API_KEY: FIVE_MINUTES,
+  /** API 설정 (10분) */
+  API_CONFIG: TEN_MINUTES
+};
+var CACHE_FALLBACK_DEFAULTS = {
+  /** 전역 Redis 에러 임계값 (이 값 이상이면 즉시 전역 비활성화) */
+  REDIS_ERROR_THRESHOLD_GLOBAL: 1,
+  /** 인스턴스별 Redis 에러 임계값 (이 값 이상이면 해당 인스턴스만 일시 비활성화) */
+  REDIS_ERROR_THRESHOLD_LOCAL: 5,
+  /** Redis 재연결 시도 간격 (밀리초) */
+  REDIS_RECONNECT_INTERVAL: 3e4,
+  /** Redis 에러 시 인메모리 폴백 허용 여부 */
+  FALLBACK_ON_REDIS_ERROR: true,
+  /** hybrid 모드에서 인메모리에도 저장 여부 */
+  WRITE_TO_MEMORY: true
+};
+var CACHE_HEALTH_DEFAULTS = {
+  /** 건강상태 판단: 에러율 임계값 (%) - 이 값 이상이면 unhealthy */
+  ERROR_RATE_THRESHOLD: 10,
+  /** 건강상태 판단: 히트율 임계값 (%) - 이 값 미만이면 unhealthy */
+  HIT_RATE_THRESHOLD: 50,
+  /** 성능 리포트: 권장 히트율 (%) - 이 값 미만이면 TTL 조정 권장 */
+  REPORT_HIT_RATE_THRESHOLD: 70,
+  /** 성능 리포트: 응답시간 임계값 (ms) - 이 값 초과 시 성능 확인 권장 */
+  REPORT_RESPONSE_TIME_THRESHOLD: 500,
+  /** 성능 리포트: 무효화 빈도 임계값 (/분) - 이 값 초과 시 최적화 권장 */
+  REPORT_INVALIDATION_THRESHOLD: 100,
+  /** 성능 리포트: 최소 요청 수 - 이 값 미만이면 리포트 판단 생략 */
+  REPORT_MIN_REQUESTS: 100
+};
+var CACHE_ENV_VARS = {
+  // 전역 설정
+  CACHE_ENABLED: "CACHE_ENABLED",
+  CACHE_REDIS_ENABLED: "CACHE_REDIS_ENABLED",
+  CACHE_INMEMORY_ENABLED: "CACHE_INMEMORY_ENABLED",
+  // 인메모리 설정
+  CACHE_INMEMORY_MAX_SIZE: "CACHE_INMEMORY_MAX_SIZE",
+  CACHE_INMEMORY_MAX_MB: "CACHE_INMEMORY_MAX_MB",
+  CACHE_INMEMORY_EVICTION: "CACHE_INMEMORY_EVICTION",
+  CACHE_INMEMORY_CLEANUP_INTERVAL: "CACHE_INMEMORY_CLEANUP_INTERVAL",
+  // Redis 설정
+  UPSTASH_REDIS_REST_URL: "UPSTASH_REDIS_REST_URL",
+  UPSTASH_REDIS_REST_TOKEN: "UPSTASH_REDIS_REST_TOKEN",
+  // TTL 설정
+  CACHE_TTL_DEFAULT: "CACHE_TTL_DEFAULT",
+  CACHE_TTL_SHORT: "CACHE_TTL_SHORT",
+  CACHE_TTL_LONG: "CACHE_TTL_LONG",
+  CACHE_TTL_GEOIP: "CACHE_TTL_GEOIP",
+  CACHE_TTL_SETTINGS: "CACHE_TTL_SETTINGS",
+  CACHE_TTL_ANALYTICS: "CACHE_TTL_ANALYTICS",
+  CACHE_TTL_USER: "CACHE_TTL_USER",
+  CACHE_TTL_LINK: "CACHE_TTL_LINK",
+  CACHE_TTL_ALIAS: "CACHE_TTL_ALIAS",
+  CACHE_TTL_COMMUNITY: "CACHE_TTL_COMMUNITY",
+  CACHE_TTL_RESERVED_WORDS: "CACHE_TTL_RESERVED_WORDS",
+  // 폴백 설정
+  CACHE_REDIS_ERROR_THRESHOLD_GLOBAL: "CACHE_REDIS_ERROR_THRESHOLD_GLOBAL",
+  CACHE_REDIS_ERROR_THRESHOLD_LOCAL: "CACHE_REDIS_ERROR_THRESHOLD_LOCAL",
+  CACHE_REDIS_RECONNECT_INTERVAL: "CACHE_REDIS_RECONNECT_INTERVAL",
+  CACHE_FALLBACK_ON_REDIS_ERROR: "CACHE_FALLBACK_ON_REDIS_ERROR",
+  CACHE_WRITE_TO_MEMORY: "CACHE_WRITE_TO_MEMORY",
+  // 건강상태 평가 설정
+  CACHE_HEALTH_ERROR_RATE_THRESHOLD: "CACHE_HEALTH_ERROR_RATE_THRESHOLD",
+  CACHE_HEALTH_HIT_RATE_THRESHOLD: "CACHE_HEALTH_HIT_RATE_THRESHOLD",
+  CACHE_REPORT_HIT_RATE_THRESHOLD: "CACHE_REPORT_HIT_RATE_THRESHOLD",
+  CACHE_REPORT_RESPONSE_TIME_THRESHOLD: "CACHE_REPORT_RESPONSE_TIME_THRESHOLD",
+  CACHE_REPORT_INVALIDATION_THRESHOLD: "CACHE_REPORT_INVALIDATION_THRESHOLD",
+  CACHE_REPORT_MIN_REQUESTS: "CACHE_REPORT_MIN_REQUESTS"
+};
+
+export {
+  ONE_MINUTE,
+  FIVE_MINUTES,
+  TEN_MINUTES,
+  FIFTEEN_MINUTES,
+  THIRTY_MINUTES,
+  ONE_HOUR,
+  ONE_DAY,
+  THIRTY_DAYS,
+  INMEMORY_CACHE_DEFAULTS,
+  CACHE_TTL_DEFAULTS,
+  CACHE_DURATION_DEFAULTS,
+  CACHE_FALLBACK_DEFAULTS,
+  CACHE_HEALTH_DEFAULTS,
+  CACHE_ENV_VARS
+};

package/dist/chunk-JBCDEAMW.js

@@ -0,0 +1,35 @@
+// src/cache/cache-keys-legacy.ts
+var cacheKeys = {
+  // 분석 데이터 캐시 키
+  geographyStats: (linkId) => `geography:${linkId}`,
+  timelineStats: (linkId) => `timeline:${linkId}`,
+  deviceStats: (linkId) => `devices:${linkId}`,
+  browserStats: (linkId) => `browsers:${linkId}`,
+  osStats: (linkId) => `os:${linkId}`,
+  // 관리자 통계 캐시 키
+  adminCountryStats: () => "admin:stats:country",
+  adminCityStats: () => "admin:stats:city",
+  adminDailyStats: () => "admin:stats:daily",
+  adminDeviceStats: () => "admin:stats:device",
+  adminBrowserStats: () => "admin:stats:browser",
+  // 사용자 데이터 캐시 키
+  userLinks: (userId) => `user:links:${userId}`,
+  userStats: (userId) => `user:stats:${userId}`,
+  // 링크 데이터 캐시 키
+  linkInfo: (linkId) => `link:info:${linkId}`,
+  linkClicks: (linkId) => `link:clicks:${linkId}`,
+  // GeoLocation 캐시 키
+  geoLocation: (ipAddress) => `geo:${ipAddress}`,
+  // 커뮤니티 캐시 키
+  community: {
+    popularTags: (period, limit) => `popular-tags:${period}:${limit}`,
+    tagLinks: (tagId, page, pageSize, sortBy, period) => `tag-links:${tagId}:${page}:${pageSize}:${sortBy}:${period}`,
+    recentLinks: (page, pageSize) => `recent-links:${page}:${pageSize}`,
+    trendingLinks: (period, algorithm, limit) => `trending-links:${period}:${algorithm}:${limit}`,
+    searchLinks: (query, tagIds, sortBy, page, pageSize) => `search:${query}:${tagIds}:${sortBy}:${page}:${pageSize}`
+  }
+};
+
+export {
+  cacheKeys
+};

package/dist/chunk-JLLMTTQ4.js

@@ -0,0 +1,75 @@
+// src/constants/security.ts
+var JWT_DEFAULTS = {
+  /** 알고리즘 */
+  ALGORITHM: "HS256",
+  /** 기본 액세스 토큰 만료 기간 */
+  DEFAULT_ACCESS_TOKEN_EXPIRES: "7d",
+  /** 기본 리프레시 토큰 만료 기간 */
+  DEFAULT_REFRESH_TOKEN_EXPIRES: "30d",
+  /** 토큰 타입 */
+  TOKEN_TYPE: "Bearer"
+};
+var EMAIL_VERIFICATION = {
+  /** 토큰 만료 시간 (시간 단위) */
+  TOKEN_EXPIRES_HOURS: 24,
+  /** 토큰 길이 (바이트) */
+  TOKEN_LENGTH: 32
+};
+var PASSWORD_RESET = {
+  /** 토큰 만료 시간 (시간 단위) */
+  TOKEN_EXPIRES_HOURS: 1,
+  /** 토큰 길이 (바이트) */
+  TOKEN_LENGTH: 32
+};
+var MAGIC_LINK = {
+  /** 토큰 만료 시간 (분 단위) */
+  TOKEN_EXPIRES_MINUTES: 15,
+  /** 토큰 길이 (바이트) */
+  TOKEN_LENGTH: 32
+};
+var API_KEY = {
+  /** 키 길이 (문자) */
+  LENGTH: 32,
+  /** 키 접두사 */
+  PREFIX: "tlog_"
+};
+var SESSION = {
+  /** 세션 쿠키 이름 */
+  COOKIE_NAME: "session",
+  /** 세션 만료 시간 (일 단위) */
+  EXPIRES_DAYS: 30
+};
+var OAUTH = {
+  /** 상태 토큰 길이 */
+  STATE_LENGTH: 32,
+  /** 상태 토큰 만료 시간 (분) */
+  STATE_EXPIRES_MINUTES: 10
+};
+var CSRF = {
+  /** 토큰 길이 */
+  TOKEN_LENGTH: 32,
+  /** 헤더 이름 */
+  HEADER_NAME: "X-CSRF-Token"
+};
+var SECURITY_HEADERS = {
+  /** Content Security Policy */
+  CSP: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline';",
+  /** X-Frame-Options */
+  X_FRAME_OPTIONS: "DENY",
+  /** X-Content-Type-Options */
+  X_CONTENT_TYPE_OPTIONS: "nosniff",
+  /** Referrer-Policy */
+  REFERRER_POLICY: "strict-origin-when-cross-origin"
+};
+
+export {
+  JWT_DEFAULTS,
+  EMAIL_VERIFICATION,
+  PASSWORD_RESET,
+  MAGIC_LINK,
+  API_KEY,
+  SESSION,
+  OAUTH,
+  CSRF,
+  SECURITY_HEADERS
+};