@mohasinac/appkit 2.3.0 → 2.3.2

package/dist/features/blog/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./hooks/useBlog";
+export * from "./components";
+export * from "./schemas";
+export * from "./columns";
+export { manifest } from "./manifest";

package/dist/features/blog/index.js

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./hooks/useBlog";
+export * from "./components";
+export * from "./schemas";
+export * from "./columns";
+export { manifest } from "./manifest";

package/dist/features/blog/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureManifest } from "../../contracts";
+export declare const manifest: FeatureManifest;

package/dist/features/blog/manifest.js

@@ -0,0 +1,14 @@
+export const manifest = {
+    name: "blog",
+    i18nNamespace: "blog",
+    envKeys: [],
+    routes: [
+        { segment: "[locale]/blog", exports: { default: "BlogListView" } },
+        { segment: "[locale]/blog/[slug]", exports: { default: "BlogPostView" } },
+    ],
+    apiRoutes: [
+        { segment: "api/blog", methods: ["GET", "POST"] },
+        { segment: "api/blog/[slug]", methods: ["GET", "PATCH", "DELETE"] },
+        { segment: "api/blog/[slug]/related", methods: ["GET"] },
+    ],
+};

package/dist/features/blog/messages/en.json

@@ -0,0 +1,14 @@
+{
+  "title": "Blog",
+  "all": "All",
+  "readMore": "Read More",
+  "minRead": "{{count}} min read",
+  "noPostsFound": "No posts found",
+  "category": {
+    "news": "News",
+    "tips": "Tips",
+    "guides": "Guides",
+    "updates": "Updates",
+    "community": "Community"
+  }
+}

package/dist/features/blog/repository/blog.repository.d.ts

@@ -0,0 +1,78 @@
+import type { FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
+import { BaseRepository } from "../../../providers/db-firebase";
+import { type BlogPostCreateInput, type BlogPostDocument, type BlogPostUpdateInput } from "../schemas";
+import type { BlogPostCategory } from "../types";
+declare class BlogRepository extends BaseRepository<BlogPostDocument> {
+    constructor();
+    findBySlug(slug: string): Promise<BlogPostDocument | null>;
+    create(input: BlogPostCreateInput): Promise<BlogPostDocument>;
+    update(id: string, input: BlogPostUpdateInput): Promise<BlogPostDocument>;
+    delete(id: string): Promise<void>;
+    incrementViews(id: string): Promise<void>;
+    findRelated(category: BlogPostCategory, excludeId: string, limit?: number): Promise<BlogPostDocument[]>;
+    static readonly SIEVE_FIELDS: {
+        id: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        title: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        slug: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        status: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        category: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        authorName: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        authorId: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        isFeatured: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        readTimeMinutes: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        views: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        publishedAt: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        updatedAt: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        tags: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+        createdAt: {
+            canFilter: boolean;
+            canSort: boolean;
+        };
+    };
+    listPublished(opts: {
+        category?: BlogPostCategory;
+        featuredOnly?: boolean;
+    }, model: SieveModel): Promise<FirebaseSieveResult<BlogPostDocument>>;
+    listAll(model: SieveModel): Promise<FirebaseSieveResult<BlogPostDocument>>;
+}
+declare const blogRepository: BlogRepository;
+export { BlogRepository, blogRepository };

package/dist/features/blog/repository/blog.repository.js

@@ -0,0 +1,129 @@
+import { DatabaseError } from "../../../errors";
+import { BaseRepository, prepareForFirestore, } from "../../../providers/db-firebase";
+import { BLOG_POST_FIELDS, BLOG_POSTS_COLLECTION, } from "../schemas";
+import { createBlogPostId } from "../schemas";
+import { increment } from "../../../contracts/field-ops";
+class BlogRepository extends BaseRepository {
+    constructor() {
+        super(BLOG_POSTS_COLLECTION);
+    }
+    async findBySlug(slug) {
+        try {
+            const snapshot = await this.db
+                .collection(this.collection)
+                .where(BLOG_POST_FIELDS.SLUG, "==", slug)
+                .limit(1)
+                .get();
+            if (snapshot.empty)
+                return null;
+            const doc = snapshot.docs[0];
+            return this.mapDoc(doc);
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to find blog post by slug: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async create(input) {
+        try {
+            const now = new Date();
+            const id = createBlogPostId(input.title, input.category);
+            const data = prepareForFirestore({
+                ...input,
+                views: input.views ?? 0,
+                createdAt: now,
+                updatedAt: now,
+            });
+            await this.db.collection(this.collection).doc(id).set(data);
+            return { id, ...data };
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to create blog post: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async update(id, input) {
+        try {
+            const data = prepareForFirestore({ ...input, updatedAt: new Date() });
+            await this.db.collection(this.collection).doc(id).update(data);
+            const doc = await this.findByIdOrFail(id);
+            return doc;
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to update blog post: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async delete(id) {
+        try {
+            await this.db.collection(this.collection).doc(id).delete();
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to delete blog post: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async incrementViews(id) {
+        try {
+            await this.db
+                .collection(this.collection)
+                .doc(id)
+                .update({ [BLOG_POST_FIELDS.VIEWS]: increment(1) });
+        }
+        catch {
+            // Fire-and-forget by design.
+        }
+    }
+    async findRelated(category, excludeId, limit = 3) {
+        try {
+            const snapshot = await this.db
+                .collection(this.collection)
+                .where(BLOG_POST_FIELDS.STATUS, "==", "published")
+                .where(BLOG_POST_FIELDS.CATEGORY, "==", category)
+                .orderBy(BLOG_POST_FIELDS.PUBLISHED_AT, "desc")
+                .limit(limit + 1)
+                .get();
+            return snapshot.docs
+                .map((doc) => this.mapDoc(doc))
+                .filter((post) => post.id !== excludeId)
+                .slice(0, limit);
+        }
+        catch (error) {
+            throw new DatabaseError(`Failed to find related posts: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async listPublished(opts, model) {
+        let baseQuery = this.getCollection().where(BLOG_POST_FIELDS.STATUS, "==", "published");
+        if (opts?.category) {
+            baseQuery = baseQuery.where(BLOG_POST_FIELDS.CATEGORY, "==", opts.category);
+        }
+        if (opts?.featuredOnly) {
+            baseQuery = baseQuery.where(BLOG_POST_FIELDS.IS_FEATURED, "==", true);
+        }
+        return this.sieveQuery(model, BlogRepository.SIEVE_FIELDS, {
+            baseQuery,
+            defaultPageSize: 12,
+            maxPageSize: 50,
+        });
+    }
+    async listAll(model) {
+        return this.sieveQuery(model, BlogRepository.SIEVE_FIELDS, {
+            defaultPageSize: 50,
+            maxPageSize: 200,
+        });
+    }
+}
+BlogRepository.SIEVE_FIELDS = {
+    id: { canFilter: true, canSort: false },
+    title: { canFilter: true, canSort: true },
+    slug: { canFilter: true, canSort: false },
+    status: { canFilter: true, canSort: true },
+    category: { canFilter: true, canSort: true },
+    authorName: { canFilter: true, canSort: true },
+    authorId: { canFilter: true, canSort: false },
+    isFeatured: { canFilter: true, canSort: false },
+    readTimeMinutes: { canFilter: true, canSort: true },
+    views: { canFilter: true, canSort: true },
+    publishedAt: { canFilter: true, canSort: true },
+    updatedAt: { canFilter: true, canSort: true },
+    tags: { canFilter: true, canSort: false },
+    createdAt: { canFilter: true, canSort: true },
+};
+const blogRepository = new BlogRepository();
+export { BlogRepository, blogRepository };

package/dist/features/blog/schemas/firestore.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Blog Posts Firestore Document Types & Constants
+ */
+import type { MediaFieldInput, MediaField } from "../../media/types";
+import type { BlogPostStatus, BlogPostCategory } from "../types";
+/** Runtime-accessible blog post status values — use instead of bare string literals. */
+export declare const BlogPostStatusValues: {
+    readonly DRAFT: BlogPostStatus;
+    readonly PUBLISHED: BlogPostStatus;
+    readonly ARCHIVED: BlogPostStatus;
+};
+export interface BlogPostDocument {
+    id: string;
+    title: string;
+    slug: string;
+    excerpt: string;
+    content: string;
+    coverImage?: MediaFieldInput;
+    contentImages?: MediaField[];
+    additionalImages?: MediaField[];
+    category: BlogPostCategory;
+    tags: string[];
+    isFeatured: boolean;
+    status: BlogPostStatus;
+    publishedAt?: Date;
+    authorId: string;
+    authorName: string;
+    authorAvatar?: string;
+    readTimeMinutes: number;
+    views: number;
+    metaTitle?: string;
+    metaDescription?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export declare const BLOG_POSTS_COLLECTION: "blogPosts";
+export declare const BLOG_POSTS_INDEXED_FIELDS: readonly ["status", "publishedAt", "isFeatured", "category", "slug"];
+export declare const BLOG_POST_FIELDS: {
+    readonly ID: "id";
+    readonly TITLE: "title";
+    readonly SLUG: "slug";
+    readonly EXCERPT: "excerpt";
+    readonly CONTENT: "content";
+    readonly COVER_IMAGE: "coverImage";
+    readonly CONTENT_IMAGES: "contentImages";
+    readonly ADDITIONAL_IMAGES: "additionalImages";
+    readonly CATEGORY: "category";
+    readonly TAGS: "tags";
+    readonly IS_FEATURED: "isFeatured";
+    readonly STATUS: "status";
+    readonly PUBLISHED_AT: "publishedAt";
+    readonly AUTHOR_ID: "authorId";
+    readonly AUTHOR_NAME: "authorName";
+    readonly AUTHOR_AVATAR: "authorAvatar";
+    readonly READ_TIME_MINUTES: "readTimeMinutes";
+    readonly VIEWS: "views";
+    readonly META_TITLE: "metaTitle";
+    readonly META_DESCRIPTION: "metaDescription";
+    readonly CREATED_AT: "createdAt";
+    readonly UPDATED_AT: "updatedAt";
+    readonly STATUS_VALUES: {
+        readonly DRAFT: BlogPostStatus;
+        readonly PUBLISHED: BlogPostStatus;
+        readonly ARCHIVED: BlogPostStatus;
+    };
+    readonly CATEGORY_VALUES: {
+        readonly NEWS: BlogPostCategory;
+        readonly TIPS: BlogPostCategory;
+        readonly GUIDES: BlogPostCategory;
+        readonly UPDATES: BlogPostCategory;
+        readonly COMMUNITY: BlogPostCategory;
+    };
+};
+export declare const DEFAULT_BLOG_POST_DATA: Omit<BlogPostDocument, "id" | "createdAt" | "updatedAt">;
+export declare const BLOG_POST_PUBLIC_FIELDS: (keyof BlogPostDocument)[];
+export type BlogPostCreateInput = Omit<BlogPostDocument, "id" | "views" | "createdAt" | "updatedAt"> & {
+    views?: number;
+};
+export type BlogPostUpdateInput = Partial<Omit<BlogPostDocument, "id" | "createdAt" | "updatedAt">>;
+export declare const blogPostQueryHelpers: {
+    readonly published: () => readonly ["status", "==", BlogPostStatus];
+    readonly featured: () => readonly ["isFeatured", "==", true];
+    readonly byCategory: (category: BlogPostCategory) => readonly ["category", "==", BlogPostCategory];
+    readonly bySlug: (slug: string) => readonly ["slug", "==", string];
+    readonly byAuthor: (authorId: string) => readonly ["authorId", "==", string];
+};
+export declare function createBlogPostId(title: string, category?: string): string;

package/dist/features/blog/schemas/firestore.js

@@ -0,0 +1,99 @@
+/**
+ * Blog Posts Firestore Document Types & Constants
+ */
+import { generateBlogPostId } from "../../../utils/id-generators";
+/** Runtime-accessible blog post status values — use instead of bare string literals. */
+export const BlogPostStatusValues = {
+    DRAFT: "draft",
+    PUBLISHED: "published",
+    ARCHIVED: "archived",
+};
+export const BLOG_POSTS_COLLECTION = "blogPosts";
+export const BLOG_POSTS_INDEXED_FIELDS = [
+    "status",
+    "publishedAt",
+    "isFeatured",
+    "category",
+    "slug",
+];
+export const BLOG_POST_FIELDS = {
+    ID: "id",
+    TITLE: "title",
+    SLUG: "slug",
+    EXCERPT: "excerpt",
+    CONTENT: "content",
+    COVER_IMAGE: "coverImage",
+    CONTENT_IMAGES: "contentImages",
+    ADDITIONAL_IMAGES: "additionalImages",
+    CATEGORY: "category",
+    TAGS: "tags",
+    IS_FEATURED: "isFeatured",
+    STATUS: "status",
+    PUBLISHED_AT: "publishedAt",
+    AUTHOR_ID: "authorId",
+    AUTHOR_NAME: "authorName",
+    AUTHOR_AVATAR: "authorAvatar",
+    READ_TIME_MINUTES: "readTimeMinutes",
+    VIEWS: "views",
+    META_TITLE: "metaTitle",
+    META_DESCRIPTION: "metaDescription",
+    CREATED_AT: "createdAt",
+    UPDATED_AT: "updatedAt",
+    STATUS_VALUES: {
+        DRAFT: "draft",
+        PUBLISHED: "published",
+        ARCHIVED: "archived",
+    },
+    CATEGORY_VALUES: {
+        NEWS: "news",
+        TIPS: "tips",
+        GUIDES: "guides",
+        UPDATES: "updates",
+        COMMUNITY: "community",
+    },
+};
+export const DEFAULT_BLOG_POST_DATA = {
+    title: "",
+    slug: "",
+    excerpt: "",
+    content: "",
+    category: "news",
+    tags: [],
+    isFeatured: false,
+    status: "draft",
+    authorId: "",
+    authorName: "",
+    readTimeMinutes: 5,
+    views: 0,
+};
+export const BLOG_POST_PUBLIC_FIELDS = [
+    "id",
+    "title",
+    "slug",
+    "excerpt",
+    "content",
+    "coverImage",
+    "category",
+    "tags",
+    "isFeatured",
+    "status",
+    "publishedAt",
+    "authorName",
+    "authorAvatar",
+    "readTimeMinutes",
+    "views",
+    "metaTitle",
+    "metaDescription",
+    "createdAt",
+    "updatedAt",
+];
+export const blogPostQueryHelpers = {
+    published: () => ["status", "==", "published"],
+    featured: () => ["isFeatured", "==", true],
+    byCategory: (category) => ["category", "==", category],
+    bySlug: (slug) => ["slug", "==", slug],
+    byAuthor: (authorId) => ["authorId", "==", authorId],
+};
+export function createBlogPostId(title, category = "news") {
+    return generateBlogPostId({ title, category });
+}

package/dist/features/blog/schemas/index.d.ts

@@ -0,0 +1,207 @@
+export * from "./firestore";
+import { z } from "zod";
+export declare const blogPostCategorySchema: z.ZodEnum<["news", "tips", "guides", "updates", "community"]>;
+export declare const blogPostStatusSchema: z.ZodEnum<["draft", "published", "archived"]>;
+/**
+ * Base Zod schema for a blog post.
+ * Apps can extend this to add their own fields:
+ *
+ * @example
+ * import { blogPostSchema } from "@mohasinac/feat-blog";
+ *
+ * const myPostSchema = blogPostSchema.extend({
+ *   series: z.string().optional(),
+ *   sponsoredBy: z.string().optional(),
+ * });
+ * type MyPost = z.infer<typeof myPostSchema>;
+ */
+export declare const blogPostSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    slug: z.ZodString;
+    excerpt: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    coverImage: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodObject<{
+        url: z.ZodString;
+        type: z.ZodEnum<["image", "video", "file"]>;
+        alt: z.ZodOptional<z.ZodString>;
+        thumbnailUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }>, z.ZodEffects<z.ZodString, {
+        url: string;
+        type: "image";
+    }, string>]>>>, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    } | {
+        url: string;
+        type: "image";
+    } | null, string | {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    } | null | undefined>;
+    contentImages: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        type: z.ZodEnum<["image", "video", "file"]>;
+        alt: z.ZodOptional<z.ZodString>;
+        thumbnailUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }>, "many">>>;
+    additionalImages: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        type: z.ZodEnum<["image", "video", "file"]>;
+        alt: z.ZodOptional<z.ZodString>;
+        thumbnailUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }, {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }>, "many">>>;
+    category: z.ZodEnum<["news", "tips", "guides", "updates", "community"]>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    isFeatured: z.ZodOptional<z.ZodBoolean>;
+    status: z.ZodEnum<["draft", "published", "archived"]>;
+    publishedAt: z.ZodOptional<z.ZodString>;
+    authorId: z.ZodOptional<z.ZodString>;
+    authorName: z.ZodOptional<z.ZodString>;
+    authorAvatar: z.ZodOptional<z.ZodString>;
+    readTimeMinutes: z.ZodOptional<z.ZodNumber>;
+    views: z.ZodOptional<z.ZodNumber>;
+    metaTitle: z.ZodOptional<z.ZodString>;
+    metaDescription: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    status: "draft" | "published" | "archived";
+    category: "news" | "tips" | "guides" | "updates" | "community";
+    coverImage: {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    } | {
+        url: string;
+        type: "image";
+    } | null;
+    additionalImages: {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }[];
+    slug: string;
+    contentImages: {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }[];
+    content?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    tags?: string[] | undefined;
+    authorName?: string | undefined;
+    isFeatured?: boolean | undefined;
+    publishedAt?: string | undefined;
+    views?: number | undefined;
+    excerpt?: string | undefined;
+    authorId?: string | undefined;
+    authorAvatar?: string | undefined;
+    readTimeMinutes?: number | undefined;
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+}, {
+    id: string;
+    title: string;
+    status: "draft" | "published" | "archived";
+    category: "news" | "tips" | "guides" | "updates" | "community";
+    slug: string;
+    content?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    coverImage?: string | {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    } | null | undefined;
+    additionalImages?: {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }[] | undefined;
+    tags?: string[] | undefined;
+    authorName?: string | undefined;
+    isFeatured?: boolean | undefined;
+    publishedAt?: string | undefined;
+    views?: number | undefined;
+    excerpt?: string | undefined;
+    contentImages?: {
+        url: string;
+        type: "video" | "image" | "file";
+        alt?: string | undefined;
+        thumbnailUrl?: string | undefined;
+    }[] | undefined;
+    authorId?: string | undefined;
+    authorAvatar?: string | undefined;
+    readTimeMinutes?: number | undefined;
+    metaTitle?: string | undefined;
+    metaDescription?: string | undefined;
+}>;
+/** Base Zod schema for list-query parameters. */
+export declare const blogListParamsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodEnum<["news", "tips", "guides", "updates", "community"]>>;
+    tags: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodString>;
+    featured: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sort?: string | undefined;
+    q?: string | undefined;
+    page?: number | undefined;
+    category?: "news" | "tips" | "guides" | "updates" | "community" | undefined;
+    perPage?: number | undefined;
+    tags?: string | undefined;
+    featured?: boolean | undefined;
+}, {
+    sort?: string | undefined;
+    q?: string | undefined;
+    page?: number | undefined;
+    category?: "news" | "tips" | "guides" | "updates" | "community" | undefined;
+    perPage?: number | undefined;
+    tags?: string | undefined;
+    featured?: boolean | undefined;
+}>;