@yimingliao/cms 0.0.78 → 0.0.79

package/dist/create-verify-action-DBwWOXPO.d.ts

@@ -0,0 +1,862 @@
+import { T as TocItem, i as AdminRole, y as SingleItem, B as BaseTranslation, e as Admin, g as AdminFull, j as AdminSafe, D as DeviceInfo, h as AdminRefreshToken, p as File, b as FileFull, r as FileType, a as Folder, F as FolderFull, M as MultiItems, m as ExternalLink, o as Faq, t as Post, w as PostType, u as PostListCard, v as PostTranslation, P as PostFull, l as Alternate, S as SuccessResult, R as Result } from './types-BGsFazJr.js';
+import { S as StorageService } from './types-J25u1G6t.js';
+import jwt from 'jsonwebtoken';
+import { BinaryLike } from 'node:crypto';
+import { cookies } from 'next/headers';
+import { PrismaClient } from '@prisma/client';
+import zod__default, { z, ZodType } from 'zod';
+import { Transporter, SentMessageInfo } from 'nodemailer';
+import { Logger } from 'logry';
+import { BaseTranslator, LocaleMessages } from 'intor';
+import Keyv from 'keyv';
+import * as zod_v4_core from 'zod/v4/core';
+
+interface CreateJwtServiceParams {
+    defaultSecret: string;
+    issuer?: string;
+    audience?: string;
+}
+declare function createJwtService({ defaultSecret, ...options }: CreateJwtServiceParams): {
+    sign: ({ payload, secret, expiresIn, }: {
+        payload: object;
+        secret: string;
+        expiresIn: number;
+    }) => string;
+    verify: ({ token, secret, }: {
+        token: string;
+        secret: string;
+    }) => jwt.JwtPayload;
+};
+
+declare function createArgon2Service(): {
+    hash: (password: string) => Promise<string>;
+    verify: (digest: string, password: string) => Promise<boolean>;
+};
+
+interface CreateCryptoServiceParams {
+    defaultSecret: string;
+}
+declare function createCryptoService({ defaultSecret, }: CreateCryptoServiceParams): {
+    generateToken: () => string;
+    hash: (value: BinaryLike) => string;
+    hashBuffer: (value: BinaryLike) => Buffer;
+    encrypt: (data: string) => string;
+    decrypt: (data: string) => string;
+    sign: ({ value, expireSeconds, createdAt, }: {
+        value: string;
+        expireSeconds: number;
+        createdAt?: number;
+    }) => {
+        signed: string;
+        signature: string;
+    };
+};
+
+declare function createCookieService(nextCookies: () => Promise<Awaited<ReturnType<typeof cookies>>>, cryptoService: ReturnType<typeof createCryptoService>): {
+    set: ({ name, value, expireSeconds, }: {
+        name: string;
+        value: string;
+        expireSeconds: number;
+    }) => Promise<void>;
+    setSignedCookie: ({ name, value, expireSeconds, }: {
+        name: string;
+        value: string;
+        expireSeconds: number;
+    }) => Promise<void>;
+    get: ({ name }: {
+        name: string;
+    }) => Promise<string | undefined>;
+    getSignedCookie: ({ name }: {
+        name: string;
+    }) => Promise<string>;
+    verifySignedCookie: ({ signed }: {
+        signed: string | undefined;
+    }) => string;
+    delete: ({ name }: {
+        name: string;
+    }) => Promise<void>;
+};
+
+type RawCacheKey = string | Array<string | number | boolean | undefined | null>;
+declare const normalizeCacheKey: (key?: RawCacheKey, delimiter?: string) => string | null;
+
+interface CacheResultOptions<T> {
+    key: RawCacheKey;
+    ttl?: number;
+    load: () => Promise<T>;
+}
+declare function createCacheResult(cache: Keyv<unknown>, logger: Logger): <T>({ key: rawKey, ttl, load, }: CacheResultOptions<T>) => Promise<T>;
+
+interface RateLimiterOptions {
+    key: RawCacheKey;
+    maxAttempts?: number;
+    timeWindow?: number;
+}
+declare function createIpRateLimiter({ appName, cache, headers, }: {
+    cache: Keyv<unknown>;
+    appName: string;
+    headers: () => Promise<Headers>;
+}): ({ key: rawKey, maxAttempts, timeWindow, }: RateLimiterOptions) => Promise<boolean>;
+
+type ExistOptions = {
+    table: string;
+    column?: string;
+};
+declare function createExist(prisma: PrismaClient): (value: string | number, options: ExistOptions) => Promise<boolean>;
+
+type Scope = {
+    name: string;
+    value: string;
+    cast?: string;
+};
+type UniqueOptions = {
+    table: string;
+    column: string;
+    scope?: Scope[];
+    excludeSelf?: Scope;
+};
+declare function createUnique(prisma: PrismaClient): (value: string, options: UniqueOptions) => Promise<boolean>;
+
+declare module "zod" {
+    interface ZodString {
+        unique(options: UniqueOptions): this;
+        exist(options: ExistOptions): this;
+        bcp47(): this;
+        ogLocale(): this;
+    }
+    interface ZodEmail {
+        unique(options: UniqueOptions): this;
+    }
+}
+declare function createZod({ unique, exist, }: {
+    unique: ReturnType<typeof createUnique>;
+    exist: ReturnType<typeof createExist>;
+}): typeof z;
+
+declare function createSchemas({ z, localeArray, exist, }: {
+    z: ReturnType<typeof createZod>;
+    localeArray: string[];
+    exist: ReturnType<typeof createExist>;
+}): {
+    z: typeof zod__default;
+    text: () => zod__default.ZodString;
+    positiveNumber: () => zod__default.ZodPipe<zod__default.ZodTransform<number | undefined, unknown>, zod__default.ZodNumber>;
+    url: () => zod__default.ZodPipe<zod__default.ZodTransform<{} | null | undefined, unknown>, zod__default.ZodNullable<zod__default.ZodURL>>;
+    email: () => zod__default.ZodEmail;
+    password: () => zod__default.ZodString;
+    isoString: () => zod__default.ZodString;
+    array: <T extends ZodType>(schema: T) => zod__default.ZodPipe<zod__default.ZodArray<T>, zod__default.ZodTransform<NonNullable<zod__default.core.output<T>>[], zod__default.core.output<T>[]>>;
+    id: () => zod__default.ZodString;
+    key: () => zod__default.ZodString;
+    sha256Hash: () => zod__default.ZodString;
+    slug: () => zod__default.ZodString;
+    pathSegment: () => zod__default.ZodString;
+    locale: () => zod__default.ZodString;
+    singleItem: (options: ExistOptions) => zod__default.ZodNullable<zod__default.ZodObject<{
+        id: zod__default.ZodString;
+    }, zod__default.core.$strip>>;
+    multiItems: (options: ExistOptions) => zod__default.ZodPipe<zod__default.ZodArray<zod__default.ZodObject<{
+        id: zod__default.ZodString;
+    }, zod__default.core.$strip>>, zod__default.ZodTransform<{
+        id: string;
+    }[], {
+        id: string;
+    }[]>>;
+};
+
+declare function createTocItemSchema({ z, schemas, }: {
+    z: ReturnType<typeof createZod>;
+    schemas: ReturnType<typeof createSchemas>;
+}): ZodType<TocItem, unknown, zod_v4_core.$ZodTypeInternals<TocItem, unknown>>;
+
+interface SendEmailOptions {
+    to: string;
+    subject: string;
+    html: string;
+}
+declare function createSendEmail({ transporter, config, }: {
+    transporter: Transporter;
+    config: {
+        fromName: string;
+        fromAddress: string;
+        replyToName: string;
+        replyToaddress: string;
+    };
+}): (options: SendEmailOptions) => Promise<SentMessageInfo>;
+
+declare function createRenderEmailTemplate({ siteName, webUrl, logoUrl, logger, }: {
+    siteName: string;
+    webUrl: string;
+    logoUrl: string;
+    logger: Logger;
+}): (templateKey: string, replacements?: Record<string, string>) => Promise<string>;
+
+interface CreateParams$4 {
+    role: AdminRole;
+    email: string;
+    passwordHash: string;
+    socialLinks: string[];
+    avatarImage: SingleItem;
+    translations: (BaseTranslation & {
+        name: string | null;
+        authorName: string | null;
+        description: string | null;
+        jobTitle: string | null;
+        url: string | null;
+        worksFor: string | null;
+        knowsAbout: string[];
+        homeLocation: string | null;
+        nationality: string | null;
+    })[];
+}
+interface UpdateParams$3 {
+    id: string;
+    role: AdminRole;
+    email?: string;
+    socialLinks: string[];
+    avatarImage: SingleItem;
+    translations: (BaseTranslation & {
+        name: string | null;
+        authorName: string | null;
+        description: string | null;
+        jobTitle: string | null;
+        url: string | null;
+        worksFor: string | null;
+        knowsAbout: string[];
+        homeLocation: string | null;
+        nationality: string | null;
+    })[];
+    emailVerifiedAt: Date | null;
+}
+
+declare function createAdminCommandRepository(prisma: PrismaClient): {
+    create: ({ role, email, passwordHash, socialLinks, avatarImage, translations, }: CreateParams$4) => Promise<Admin>;
+    update: ({ id, role, email, socialLinks, avatarImage, translations, emailVerifiedAt, }: UpdateParams$3) => Promise<Admin>;
+    delete: ({ id }: {
+        id: string;
+    }) => Promise<Admin>;
+};
+
+interface FindListCardsParams$3 {
+    locale: string;
+    searchString?: string;
+    role?: AdminRole;
+    adminIds?: string[];
+    page?: number;
+    pageSize?: number;
+}
+interface FindParams$2 {
+    id?: string;
+    email?: string;
+}
+
+declare function createAdminQueryRepository(prisma: PrismaClient): {
+    findListCards: ({ locale, searchString, role, adminIds, page, pageSize, }: FindListCardsParams$3) => Promise<{
+        items: AdminFull[];
+        total: number;
+    }>;
+    find: (params: FindParams$2) => Promise<AdminSafe | null>;
+    findFull: (params: FindParams$2) => Promise<AdminFull | null>;
+    findWithPasswordHash: (params: FindParams$2) => Promise<Admin | null>;
+};
+
+interface CreateParams$3 {
+    tokenHash: string;
+    email: string;
+    ip: string;
+    deviceInfo?: DeviceInfo;
+    adminId: string;
+    expiresAt: Date;
+}
+interface DeleteParams {
+    id?: string;
+    tokenHash?: string;
+}
+
+declare function createAdminRefreshTokenCommandRepository(prisma: PrismaClient): {
+    create: ({ adminId, ...params }: CreateParams$3) => Promise<AdminRefreshToken>;
+    delete: ({ id, tokenHash }: DeleteParams) => Promise<void>;
+    deleteManyByExpired: () => Promise<number>;
+};
+
+declare function createAdminRefreshTokenQueryRepository(prisma: PrismaClient): {
+    findManyByAdminId: ({ adminId, }: {
+        adminId: string;
+    }) => Promise<AdminRefreshToken[]>;
+    findByToken: ({ tokenHash, }: {
+        tokenHash: string;
+    }) => Promise<AdminRefreshToken | null>;
+};
+
+interface CreateParams$2 {
+    key: string;
+    checksum: string;
+    fileMeta: {
+        type?: string;
+        size?: number;
+        name?: string;
+    };
+    width?: number | null;
+    height?: number | null;
+    duration?: number | null;
+    folder?: SingleItem;
+    translations: (BaseTranslation & {
+        name: string | null;
+        alt: string | null;
+    })[];
+}
+interface UpdateParams$2 {
+    id: string;
+    file: File;
+    key: string;
+    checksum: string;
+    fileMeta: {
+        type?: string;
+        size?: number;
+        name?: string;
+    };
+    width?: number | null;
+    height?: number | null;
+    duration?: number | null;
+    folder?: SingleItem;
+    translations: (BaseTranslation & {
+        name: string | null;
+        alt: string | null;
+    })[];
+}
+
+declare function createFileCommandRepository(prisma: PrismaClient): {
+    create: ({ key, checksum, fileMeta, width, height, duration, folder, translations, }: CreateParams$2) => Promise<FileFull>;
+    update: ({ file, id, key, checksum, fileMeta, width, height, duration, folder, translations, }: UpdateParams$2) => Promise<File>;
+    softDelete: ({ id }: {
+        id: string;
+    }) => Promise<File>;
+    softDeleteMany: ({ ids }: {
+        ids: string[];
+    }) => Promise<number>;
+    restoreMany: ({ ids }: {
+        ids: string[];
+    }) => Promise<number>;
+    delete: ({ id }: {
+        id: string;
+    }) => Promise<File>;
+};
+
+interface FindListCardsParams$2 {
+    locale: string;
+    searchString?: string;
+    type?: FileType | null;
+    isDeleted?: boolean;
+    isLocked?: boolean | null;
+    folderId?: string;
+    fileIds?: string[];
+    page?: number;
+    pageSize?: number;
+}
+
+declare function createFileQueryRepository(prisma: PrismaClient): {
+    findListCards: ({ locale, page, pageSize, searchString, type, folderId, isLocked, isDeleted, fileIds, }: FindListCardsParams$2) => Promise<{
+        items: FileFull[];
+        total: number;
+    }>;
+    findManyByIds: ({ ids, }: {
+        ids: string[];
+    }) => Promise<FileFull[]>;
+    findFull: ({ id }: {
+        id: string;
+    }) => Promise<FileFull | null>;
+};
+
+interface CreateParams$1 {
+    key: string;
+    name: string;
+    parentFolder: Folder | null;
+}
+interface UpdateParams$1 {
+    id: string;
+    key: string;
+    name: string;
+    parentFolder: Folder | null;
+}
+
+declare function createFolderCommandRepository(prisma: PrismaClient): {
+    create: ({ key, name, parentFolder, }: CreateParams$1) => Promise<Folder>;
+    update: ({ id, key, name, parentFolder, }: UpdateParams$1) => Promise<Folder>;
+    delete: ({ id }: {
+        id: string;
+    }) => Promise<Folder>;
+};
+
+interface FindListCardsParams$1 {
+    searchString?: string;
+    parentFolderId?: string;
+    folderIds?: string[];
+    page?: number;
+    pageSize?: number;
+}
+interface FindParams$1 {
+    id?: string;
+    key?: string;
+}
+
+declare function createFolderQueryRepository(prisma: PrismaClient): {
+    findListCards: ({ searchString, parentFolderId, folderIds, page, pageSize, }: FindListCardsParams$1) => Promise<{
+        items: FolderFull[];
+        total: number;
+    }>;
+    findFull: (params: FindParams$1) => Promise<FolderFull | null>;
+};
+
+interface CreateParams {
+    type: string;
+    isLocked: boolean;
+    isActive: boolean;
+    isIndexActive: boolean;
+    index: number | null;
+    isSlugActive: boolean;
+    slug: string | null;
+    isFeatured: boolean;
+    isShownOnHome: boolean;
+    author: SingleItem;
+    topicId: string | null;
+    parents: MultiItems;
+    tags: MultiItems;
+    relatedPosts: MultiItems;
+    coverImage: SingleItem;
+    contentImageIds: string[];
+    state1: boolean;
+    state2: boolean;
+    state3: boolean;
+    state4: boolean;
+    state5: boolean;
+    state6: boolean;
+    state7: boolean;
+    state8: boolean;
+    state9: boolean;
+    state10: boolean;
+    images1: MultiItems;
+    images2: MultiItems;
+    image1: SingleItem;
+    image2: SingleItem;
+    image3: SingleItem;
+    image4: SingleItem;
+    text1: string | null;
+    text2: string | null;
+    text3: string | null;
+    text4: string | null;
+    text5: string | null;
+    text6: string | null;
+    text7: string | null;
+    text8: string | null;
+    text9: string | null;
+    text10: string | null;
+    data1: any[];
+    data2: any[];
+    data3: any[];
+    data4: any[];
+    translations: (BaseTranslation & {
+        title: string | null;
+        subtitle: string | null;
+        summary: string | null;
+        description: string | null;
+        content: string | null;
+        externalLinks: ExternalLink[];
+        faq: Faq[];
+        toc: TocItem[];
+        readTime: number | null;
+        wordCount: number;
+        text1: string | null;
+        text2: string | null;
+        text3: string | null;
+        text4: string | null;
+        text5: string | null;
+        text6: string | null;
+        text7: string | null;
+        text8: string | null;
+        text9: string | null;
+        text10: string | null;
+        data1: any[];
+        data2: any[];
+        data3: any[];
+        data4: any[];
+    })[];
+}
+interface UpdateParams {
+    id: string;
+    type: string;
+    isLocked: boolean;
+    isActive: boolean;
+    isIndexActive: boolean;
+    index: number | null;
+    isSlugActive: boolean;
+    slug: string | null;
+    isFeatured: boolean;
+    isShownOnHome: boolean;
+    author: SingleItem;
+    topicId: string | null;
+    parents: MultiItems;
+    tags: MultiItems;
+    relatedPosts: MultiItems;
+    coverImage: SingleItem;
+    contentImageIds: string[];
+    state1: boolean;
+    state2: boolean;
+    state3: boolean;
+    state4: boolean;
+    state5: boolean;
+    state6: boolean;
+    state7: boolean;
+    state8: boolean;
+    state9: boolean;
+    state10: boolean;
+    images1: MultiItems;
+    images2: MultiItems;
+    image1: SingleItem;
+    image2: SingleItem;
+    image3: SingleItem;
+    image4: SingleItem;
+    text1: string | null;
+    text2: string | null;
+    text3: string | null;
+    text4: string | null;
+    text5: string | null;
+    text6: string | null;
+    text7: string | null;
+    text8: string | null;
+    text9: string | null;
+    text10: string | null;
+    data1: any[];
+    data2: any[];
+    data3: any[];
+    data4: any[];
+    translations: (BaseTranslation & {
+        title: string | null;
+        subtitle: string | null;
+        summary: string | null;
+        description: string | null;
+        content: string | null;
+        externalLinks: ExternalLink[];
+        faq: Faq[];
+        toc: TocItem[];
+        readTime: number | null;
+        wordCount: number;
+        text1: string | null;
+        text2: string | null;
+        text3: string | null;
+        text4: string | null;
+        text5: string | null;
+        text6: string | null;
+        text7: string | null;
+        text8: string | null;
+        text9: string | null;
+        text10: string | null;
+        data1: any[];
+        data2: any[];
+        data3: any[];
+        data4: any[];
+    })[];
+}
+
+declare function createPostCommandRepository(prisma: PrismaClient): {
+    create: ({ slug, type, author, topicId, parents, tags, relatedPosts, coverImage, contentImageIds, images1, images2, image1, image2, image3, image4, translations, ...params }: CreateParams) => Promise<Post>;
+    update: ({ id, slug, type, author, topicId, parents, tags, relatedPosts, coverImage, contentImageIds, images1, images2, image1, image2, image3, image4, translations, ...params }: UpdateParams) => Promise<Post>;
+    delete: ({ id }: {
+        id: string;
+    }) => Promise<Post>;
+};
+
+interface FindListCardsParams {
+    locale: string;
+    searchString?: string;
+    type: PostType | null;
+    isActive?: boolean;
+    isIndexActive?: boolean;
+    isSlugActive?: boolean;
+    isFeatured?: boolean;
+    isShownOnHome?: boolean;
+    state1?: boolean;
+    state2?: boolean;
+    state3?: boolean;
+    state4?: boolean;
+    state5?: boolean;
+    state6?: boolean;
+    state7?: boolean;
+    state8?: boolean;
+    state9?: boolean;
+    state10?: boolean;
+    topicId?: string;
+    topicSlug?: string;
+    categoryId?: string;
+    categorySlug?: string;
+    postIds?: string[];
+    excludeIds?: string[];
+    page?: number;
+    pageSize?: number;
+}
+interface FindParams {
+    id?: string;
+    type?: PostType;
+    slug?: string;
+    isActive?: boolean;
+    topicSlug?: string;
+}
+interface FindManyParams {
+    type: PostType;
+    topicId?: string;
+}
+
+declare function createPostQueryRepository(prisma: PrismaClient): {
+    findListCards: ({ locale, searchString, type, isActive, isIndexActive, isSlugActive, isFeatured, isShownOnHome, state1, state2, state3, state4, state5, state6, state7, state8, state9, state10, topicId, topicSlug, categoryId, categorySlug, postIds, excludeIds, page, pageSize, }: FindListCardsParams) => Promise<{
+        items: PostListCard[];
+        total: number;
+    }>;
+    findMany: ({ type, topicId, }: FindManyParams) => Promise<(Post & {
+        translations: PostTranslation[];
+    })[]>;
+    find: ({ isActive, ...rest }: FindParams) => Promise<(Post & {
+        translations: PostTranslation[];
+    }) | null>;
+    findFull: ({ isActive, topicSlug, ...rest }: FindParams) => Promise<{
+        post: PostFull | undefined;
+        prev: PostListCard | undefined;
+        next: PostListCard | undefined;
+    }>;
+};
+
+interface UpsertParams {
+    postId: string;
+    translations: (BaseTranslation & {
+        title: string | null;
+        description: string | null;
+        author: string | null;
+        canonical: string | null;
+        alternate: Alternate[];
+        robots: string | null;
+        ogTitle: string | null;
+        ogDescription: string | null;
+        ogUrl: string | null;
+        ogType: string | null;
+        ogSiteName: string | null;
+        ogImage: string | null;
+        ogImageAlt: string | null;
+        ogImageType: string | null;
+        ogImageWidth: number | null;
+        ogImageHeight: number | null;
+        ogLocale: string | null;
+        ogLocaleAlternate: string[];
+        ogArticlePublishedTime: string | null;
+        ogArticleModifiedTime: string | null;
+        ogArticleAuthor: string | null;
+        ogArticleSection: string | null;
+        ogArticleTag: string[];
+        twitterCard: string | null;
+        twitterSite: string | null;
+        twitterCreator: string | null;
+        jsonLd: object[];
+    })[];
+}
+
+declare function createSeoMetadataCommandRepository(prisma: PrismaClient): {
+    upsert: ({ postId, translations, }: UpsertParams) => Promise<void>;
+};
+
+type Action<D> = (translator: BaseTranslator<LocaleMessages>) => Promise<Omit<SuccessResult<D>, "success"> & {
+    i18nKey?: string;
+}>;
+interface CreateExecuteActionParams {
+    initI18n: () => Promise<BaseTranslator<LocaleMessages>>;
+    cacheResult: <T>({ key, ttl, load }: CacheResultOptions<T>) => Promise<T>;
+    cache: Keyv<unknown>;
+    logger: Logger;
+}
+interface ServerActionParams {
+    type?: "command" | "query";
+    key?: RawCacheKey;
+    ttl?: number;
+}
+declare function createExecuteAction({ initI18n, cacheResult, cache, logger, }: CreateExecuteActionParams): <D = void>(fn: Action<D>, options?: ServerActionParams) => Promise<Result<D>>;
+
+interface CreateVerifyAccessTokenParams {
+    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
+    jwtService: ReturnType<typeof createJwtService>;
+    cryptoService: ReturnType<typeof createCryptoService>;
+    cookieService: ReturnType<typeof createCookieService>;
+    config: {
+        accessTokenName: string;
+        accessTokenSecret: string;
+    };
+}
+declare function createVerifyAccessToken({ adminQueryRepository, jwtService, cryptoService, cookieService, config, }: CreateVerifyAccessTokenParams): () => Promise<{
+    admin: AdminFull;
+} | null>;
+
+interface CreateVerifyRefreshTokenParams {
+    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
+    adminRefreshTokenQueryRepository: ReturnType<typeof createAdminRefreshTokenQueryRepository>;
+    cryptoService: ReturnType<typeof createCryptoService>;
+    cookieService: ReturnType<typeof createCookieService>;
+    config: {
+        refreshTokenName: string;
+    };
+}
+declare function createVerifyRefreshToken({ adminQueryRepository, adminRefreshTokenQueryRepository, cryptoService, cookieService, config, }: CreateVerifyRefreshTokenParams): () => Promise<{
+    adminRefreshToken: AdminRefreshToken;
+    admin: AdminFull;
+} | null>;
+
+interface CreateAuthUseCases {
+    prisma: PrismaClient;
+    adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
+    adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
+    jwtService: ReturnType<typeof createJwtService>;
+    argon2Service: ReturnType<typeof createArgon2Service>;
+    cryptoService: ReturnType<typeof createCryptoService>;
+    cookieService: ReturnType<typeof createCookieService>;
+    config: {
+        refreshTokenName: string;
+        refreshTokenTtl: number;
+        accessTokenName: string;
+        accessTokenSecret: string;
+        accessTokenTtl: number;
+        resetPasswordSecret: string;
+        resetPasswordTtl: number;
+        verifyEmailSecret: string;
+        verifyEmailTtl: number;
+    };
+}
+declare function createAuthUseCases({ prisma, adminQueryRepository, adminRefreshTokenCommandRepository, jwtService, argon2Service, cryptoService, cookieService, config, }: CreateAuthUseCases): {
+    verifyCredentials: ({ email, password, }: {
+        email: string;
+        password: string;
+    }) => Promise<Admin>;
+    updatePassword: ({ email, password, }: {
+        email: string;
+        password: string;
+    }) => Promise<Admin>;
+    createRefreshToken: ({ admin, deviceInfo, ip, }: {
+        admin: {
+            id: string;
+            email: string;
+        };
+        deviceInfo: DeviceInfo;
+        ip: string;
+    }) => Promise<string>;
+    refreshTokens: ({ admin, deviceInfo, ip, }: {
+        admin: {
+            id: string;
+            email: string;
+        };
+        deviceInfo: DeviceInfo;
+        ip: string;
+    }) => Promise<void>;
+    signPasswordResetToken: ({ admin }: {
+        admin: AdminSafe;
+    }) => string;
+    verifyPasswordResetToken: ({ token }: {
+        token: string;
+    }) => {
+        email: string;
+    };
+    signEmailVerificationToken: () => string;
+    verifyEmailAndUpdate: ({ token, admin, }: {
+        token: string;
+        admin: AdminSafe;
+    }) => Promise<AdminSafe>;
+};
+
+interface SendParams$1 {
+    translator: BaseTranslator<LocaleMessages>;
+    admin: AdminSafe;
+    newEmail?: string;
+}
+declare function createEmailVerificationEmail({ renderEmailTemplate, sendEmail, authUseCases, webUrl, }: {
+    renderEmailTemplate: ReturnType<typeof createRenderEmailTemplate>;
+    sendEmail: ReturnType<typeof createSendEmail>;
+    authUseCases: ReturnType<typeof createAuthUseCases>;
+    webUrl: string;
+}): {
+    generateHtml: (replacements?: {
+        emailVerificationUrl: string;
+    }) => Promise<string>;
+    send: ({ translator, admin, newEmail }: SendParams$1) => Promise<any>;
+};
+
+interface SendParams {
+    translator: BaseTranslator<LocaleMessages>;
+    admin: AdminSafe;
+}
+declare function createForgotPasswordEmail({ renderEmailTemplate, sendEmail, authUseCases, webUrl, }: {
+    renderEmailTemplate: ReturnType<typeof createRenderEmailTemplate>;
+    sendEmail: ReturnType<typeof createSendEmail>;
+    authUseCases: ReturnType<typeof createAuthUseCases>;
+    webUrl: string;
+}): {
+    generateHtml: (replacements?: {
+        passwordResetUrl: string;
+    }) => Promise<string>;
+    send: ({ translator, admin }: SendParams) => Promise<any>;
+};
+
+interface CreateAuthMiddlewareParams {
+    adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
+    authUseCases: ReturnType<typeof createAuthUseCases>;
+    verifyAccessToken: ReturnType<typeof createVerifyAccessToken>;
+    verifyRefreshToken: ReturnType<typeof createVerifyRefreshToken>;
+    headers: () => Promise<Headers>;
+}
+declare function createAuthMiddleware({ adminRefreshTokenCommandRepository, authUseCases, verifyAccessToken, verifyRefreshToken, headers, }: CreateAuthMiddlewareParams): {
+    authenticate(): Promise<AdminFull>;
+};
+
+interface ActionContext {
+    services: {
+        cryptoService: ReturnType<typeof createCryptoService>;
+        argon2Service: ReturnType<typeof createArgon2Service>;
+        cookieService: ReturnType<typeof createCookieService>;
+        storageService: StorageService;
+    };
+    repositories: {
+        adminQueryRepository: ReturnType<typeof createAdminQueryRepository>;
+        adminCommandRepository: ReturnType<typeof createAdminCommandRepository>;
+        adminRefreshTokenQueryRepository: ReturnType<typeof createAdminRefreshTokenQueryRepository>;
+        adminRefreshTokenCommandRepository: ReturnType<typeof createAdminRefreshTokenCommandRepository>;
+        folderQueryRepository: ReturnType<typeof createFolderQueryRepository>;
+        folderCommandRepository: ReturnType<typeof createFolderCommandRepository>;
+        fileQueryRepository: ReturnType<typeof createFileQueryRepository>;
+        fileCommandRepository: ReturnType<typeof createFileCommandRepository>;
+        postCommandRepository: ReturnType<typeof createPostCommandRepository>;
+        postQueryRepository: ReturnType<typeof createPostQueryRepository>;
+        seoMetadataCommandRepository: ReturnType<typeof createSeoMetadataCommandRepository>;
+    };
+    useCases: {
+        authUseCases: ReturnType<typeof createAuthUseCases>;
+    };
+    middlewares: {
+        authMiddleware: ReturnType<typeof createAuthMiddleware>;
+    };
+    action: {
+        executeAction: ReturnType<typeof createExecuteAction>;
+        ipRateLimiter: (options: RateLimiterOptions) => Promise<void>;
+    };
+    emails: {
+        emailVerificationEmail: ReturnType<typeof createEmailVerificationEmail>;
+        forgotPasswordEmail: ReturnType<typeof createForgotPasswordEmail>;
+    };
+    http: {
+        headers: () => Promise<Headers>;
+    };
+    schemas: {
+        schemas: ReturnType<typeof createSchemas>;
+        tocItemSchema: ReturnType<typeof createTocItemSchema>;
+    };
+    config: {
+        accessTokenName: string;
+        refreshTokenName: string;
+    };
+}
+
+declare function createVerifyAction(ctx: ActionContext): () => Promise<Result<{
+    admin: AdminFull;
+}>>;
+
+export { type ActionContext as A, createRenderEmailTemplate as B, createSendEmail as C, createSeoMetadataCommandRepository as D, createUnique as E, createVerifyAccessToken as F, createVerifyRefreshToken as G, normalizeCacheKey as H, type RawCacheKey as R, createZod as a, createSchemas as b, createVerifyAction as c, createTocItemSchema as d, createAdminCommandRepository as e, createAdminQueryRepository as f, createAdminRefreshTokenCommandRepository as g, createAdminRefreshTokenQueryRepository as h, createArgon2Service as i, createAuthMiddleware as j, createAuthUseCases as k, createCacheResult as l, createCookieService as m, createCryptoService as n, createEmailVerificationEmail as o, createExecuteAction as p, createExist as q, createFileCommandRepository as r, createFileQueryRepository as s, createFolderCommandRepository as t, createFolderQueryRepository as u, createForgotPasswordEmail as v, createIpRateLimiter as w, createJwtService as x, createPostCommandRepository as y, createPostQueryRepository as z };