@veruna/api-contracts 1.0.3 → 1.0.4

package/build/v1/blog/admin/commands/update-post.command.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogUpdatePostCommand {
+    const Request: z.ZodObject<{
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        metaTitle: z.ZodOptional<z.ZodString>;
+        metaDescription: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        categoryIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        status: z.ZodOptional<z.ZodEnum<typeof import("../../schemas").BlogPostStatus>>;
+    }, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        uuid: z.ZodString;
+        alias: z.ZodString;
+        title: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        content: z.ZodString;
+        image: z.ZodString;
+        author: z.ZodString;
+        categories: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+            status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        viewsCount: z.ZodNumber;
+        status: z.ZodEnum<typeof import("../../schemas").BlogPostStatus>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: ":uuid";
+    const URL: (uuid: string) => string;
+    const METHOD = HttpMethod.PATCH;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/commands/update-post.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogUpdatePostCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const blog_admin_posts_routes_1 = require("../../routes/blog-admin-posts.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+var AdminBlogUpdatePostCommand;
+(function (AdminBlogUpdatePostCommand) {
+    // Request/Response
+    AdminBlogUpdatePostCommand.Request = schemas_1.UpdatePostRequestSchema;
+    AdminBlogUpdatePostCommand.Response = zod_1.z.union([schemas_1.PostResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    AdminBlogUpdatePostCommand.PATH = blog_admin_posts_routes_1.BLOG_ADMIN_POSTS_ROUTES.UPDATE;
+    AdminBlogUpdatePostCommand.URL = (uuid) => rest_api_1.REST_API.V1.BLOG.ADMIN.POSTS.UPDATE(uuid);
+    AdminBlogUpdatePostCommand.METHOD = http_method_1.HttpMethod.PATCH;
+})(AdminBlogUpdatePostCommand || (exports.AdminBlogUpdatePostCommand = AdminBlogUpdatePostCommand = {}));

package/build/v1/blog/admin/queries/get-categories.query.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { BlogCategoryStatus } from '../../schemas';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogGetCategoriesQuery {
+    const Request: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<typeof BlogCategoryStatus>>;
+    }, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        categories: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+            status: z.ZodEnum<typeof BlogCategoryStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: "";
+    const URL: "/api/v1/admin/blog/categories/";
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/queries/get-categories.query.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogGetCategoriesQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const blog_admin_categories_routes_1 = require("../../routes/blog-admin-categories.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+const CategoriesListAdminResponseSchema = zod_1.z.object({
+    categories: zod_1.z.array(schemas_1.CategoryResponseSchema),
+});
+const GetCategoriesQueryAdminSchema = zod_1.z.object({
+    status: zod_1.z.nativeEnum(schemas_1.BlogCategoryStatus).optional(),
+});
+var AdminBlogGetCategoriesQuery;
+(function (AdminBlogGetCategoriesQuery) {
+    // Request/Response
+    AdminBlogGetCategoriesQuery.Request = GetCategoriesQueryAdminSchema;
+    AdminBlogGetCategoriesQuery.Response = zod_1.z.union([CategoriesListAdminResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    AdminBlogGetCategoriesQuery.PATH = blog_admin_categories_routes_1.BLOG_ADMIN_CATEGORIES_ROUTES.GET_ALL;
+    AdminBlogGetCategoriesQuery.URL = rest_api_1.REST_API.V1.BLOG.ADMIN.CATEGORIES.GET_ALL;
+    AdminBlogGetCategoriesQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AdminBlogGetCategoriesQuery || (exports.AdminBlogGetCategoriesQuery = AdminBlogGetCategoriesQuery = {}));

package/build/v1/blog/admin/queries/get-category.query.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogGetCategoryQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        uuid: z.ZodString;
+        alias: z.ZodString;
+        title: z.ZodString;
+        order: z.ZodNumber;
+        status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: ":uuid";
+    const URL: (uuid: string) => string;
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/queries/get-category.query.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogGetCategoryQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const blog_admin_categories_routes_1 = require("../../routes/blog-admin-categories.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+var AdminBlogGetCategoryQuery;
+(function (AdminBlogGetCategoryQuery) {
+    // Request/Response
+    AdminBlogGetCategoryQuery.Request = zod_1.z.object({});
+    AdminBlogGetCategoryQuery.Response = zod_1.z.union([schemas_1.CategoryResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    AdminBlogGetCategoryQuery.PATH = blog_admin_categories_routes_1.BLOG_ADMIN_CATEGORIES_ROUTES.GET_BY_UUID;
+    AdminBlogGetCategoryQuery.URL = (uuid) => rest_api_1.REST_API.V1.BLOG.ADMIN.CATEGORIES.GET_BY_UUID(uuid);
+    AdminBlogGetCategoryQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AdminBlogGetCategoryQuery || (exports.AdminBlogGetCategoryQuery = AdminBlogGetCategoryQuery = {}));

package/build/v1/blog/admin/queries/get-post.query.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogGetPostQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        uuid: z.ZodString;
+        alias: z.ZodString;
+        title: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        content: z.ZodString;
+        image: z.ZodString;
+        author: z.ZodString;
+        categories: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+            status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        viewsCount: z.ZodNumber;
+        status: z.ZodEnum<typeof import("../../schemas").BlogPostStatus>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: ":uuid";
+    const URL: (uuid: string) => string;
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/queries/get-post.query.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogGetPostQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const blog_admin_posts_routes_1 = require("../../routes/blog-admin-posts.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+var AdminBlogGetPostQuery;
+(function (AdminBlogGetPostQuery) {
+    // Request/Response
+    AdminBlogGetPostQuery.Request = zod_1.z.object({});
+    AdminBlogGetPostQuery.Response = zod_1.z.union([schemas_1.PostResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    AdminBlogGetPostQuery.PATH = blog_admin_posts_routes_1.BLOG_ADMIN_POSTS_ROUTES.GET_BY_UUID;
+    AdminBlogGetPostQuery.URL = (uuid) => rest_api_1.REST_API.V1.BLOG.ADMIN.POSTS.GET_BY_UUID(uuid);
+    AdminBlogGetPostQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AdminBlogGetPostQuery || (exports.AdminBlogGetPostQuery = AdminBlogGetPostQuery = {}));

package/build/v1/blog/admin/queries/get-posts.query.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare const PostsListAdminResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        alias: z.ZodString;
+        title: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        content: z.ZodString;
+        image: z.ZodString;
+        author: z.ZodString;
+        categories: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+            status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        viewsCount: z.ZodNumber;
+        status: z.ZodEnum<typeof import("../../schemas").BlogPostStatus>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        page: z.ZodNumber;
+        limit: z.ZodNumber;
+        total: z.ZodNumber;
+        totalPages: z.ZodNumber;
+        hasNext: z.ZodBoolean;
+        hasPrev: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare namespace AdminBlogGetPostsQuery {
+    const Request: z.ZodObject<{
+        page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        status: z.ZodOptional<z.ZodEnum<typeof import("../../schemas").BlogPostStatus>>;
+        categoryAliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            metaTitle: z.ZodString;
+            metaDescription: z.ZodString;
+            content: z.ZodString;
+            image: z.ZodString;
+            author: z.ZodString;
+            categories: z.ZodArray<z.ZodObject<{
+                uuid: z.ZodString;
+                alias: z.ZodString;
+                title: z.ZodString;
+                order: z.ZodNumber;
+                status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+            }, z.core.$strip>>;
+            viewsCount: z.ZodNumber;
+            status: z.ZodEnum<typeof import("../../schemas").BlogPostStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        meta: z.ZodObject<{
+            page: z.ZodNumber;
+            limit: z.ZodNumber;
+            total: z.ZodNumber;
+            totalPages: z.ZodNumber;
+            hasNext: z.ZodBoolean;
+            hasPrev: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: "";
+    const URL: "/api/v1/admin/blog/posts/";
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/queries/get-posts.query.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogGetPostsQuery = exports.PostsListAdminResponseSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const pagination_schema_1 = require("../../../../shared/pagination.schema");
+const blog_admin_posts_routes_1 = require("../../routes/blog-admin-posts.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+exports.PostsListAdminResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(schemas_1.PostResponseSchema),
+    meta: pagination_schema_1.PaginationMetaSchema,
+});
+var AdminBlogGetPostsQuery;
+(function (AdminBlogGetPostsQuery) {
+    // Request/Response
+    AdminBlogGetPostsQuery.Request = schemas_1.GetPostsQueryAdminSchema;
+    AdminBlogGetPostsQuery.Response = zod_1.z.union([exports.PostsListAdminResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    AdminBlogGetPostsQuery.PATH = blog_admin_posts_routes_1.BLOG_ADMIN_POSTS_ROUTES.GET_ALL;
+    AdminBlogGetPostsQuery.URL = rest_api_1.REST_API.V1.BLOG.ADMIN.POSTS.GET_ALL;
+    AdminBlogGetPostsQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AdminBlogGetPostsQuery || (exports.AdminBlogGetPostsQuery = AdminBlogGetPostsQuery = {}));

package/build/v1/blog/admin/queries/index.d.ts

@@ -0,0 +1,4 @@
+export * from './get-category.query';
+export * from './get-categories.query';
+export * from './get-post.query';
+export * from './get-posts.query';

package/build/v1/blog/admin/queries/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-category.query"), exports);
+__exportStar(require("./get-categories.query"), exports);
+__exportStar(require("./get-post.query"), exports);
+__exportStar(require("./get-posts.query"), exports);

package/build/v1/blog/blog.paths.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Blog Admin API Paths (UUID-based, requires admin role)
+ */
+export declare const BLOG_ADMIN_PATHS: {
+    readonly BASE: "v1/admin/blog";
+    readonly CATEGORIES: "categories";
+    readonly CATEGORY_BY_UUID: "categories/:uuid";
+    readonly POSTS: "posts";
+    readonly POST_BY_UUID: "posts/:uuid";
+};
+/**
+ * Blog Public API Paths (alias-based, public access)
+ */
+export declare const BLOG_PUBLIC_PATHS: {
+    readonly BASE: "v1/blog";
+    readonly CATEGORIES: "categories";
+    readonly POSTS: "posts";
+    readonly POST_BY_ALIAS: "posts/:alias";
+};
+/**
+ * Full Admin API URLs
+ */
+export declare const BLOG_ADMIN_API_PATHS: {
+    readonly CATEGORIES: "/api/v1/admin/blog/categories";
+    readonly CATEGORY_BY_UUID: (uuid: string) => string;
+    readonly POSTS: "/api/v1/admin/blog/posts";
+    readonly POST_BY_UUID: (uuid: string) => string;
+};
+/**
+ * Full Public API URLs
+ */
+export declare const BLOG_PUBLIC_API_PATHS: {
+    readonly CATEGORIES: "/api/v1/blog/categories";
+    readonly POSTS: "/api/v1/blog/posts";
+    readonly POST_BY_ALIAS: (alias: string) => string;
+};

package/build/v1/blog/blog.paths.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOG_PUBLIC_API_PATHS = exports.BLOG_ADMIN_API_PATHS = exports.BLOG_PUBLIC_PATHS = exports.BLOG_ADMIN_PATHS = void 0;
+/**
+ * Blog Admin API Paths (UUID-based, requires admin role)
+ */
+exports.BLOG_ADMIN_PATHS = {
+    BASE: 'v1/admin/blog',
+    // Categories
+    CATEGORIES: 'categories',
+    CATEGORY_BY_UUID: 'categories/:uuid',
+    // Posts
+    POSTS: 'posts',
+    POST_BY_UUID: 'posts/:uuid',
+};
+/**
+ * Blog Public API Paths (alias-based, public access)
+ */
+exports.BLOG_PUBLIC_PATHS = {
+    BASE: 'v1/blog',
+    // Categories
+    CATEGORIES: 'categories',
+    // Posts
+    POSTS: 'posts',
+    POST_BY_ALIAS: 'posts/:alias',
+};
+/**
+ * Full Admin API URLs
+ */
+exports.BLOG_ADMIN_API_PATHS = {
+    // Categories
+    CATEGORIES: `/api/${exports.BLOG_ADMIN_PATHS.BASE}/${exports.BLOG_ADMIN_PATHS.CATEGORIES}`,
+    CATEGORY_BY_UUID: (uuid) => `/api/${exports.BLOG_ADMIN_PATHS.BASE}/categories/${uuid}`,
+    // Posts
+    POSTS: `/api/${exports.BLOG_ADMIN_PATHS.BASE}/${exports.BLOG_ADMIN_PATHS.POSTS}`,
+    POST_BY_UUID: (uuid) => `/api/${exports.BLOG_ADMIN_PATHS.BASE}/posts/${uuid}`,
+};
+/**
+ * Full Public API URLs
+ */
+exports.BLOG_PUBLIC_API_PATHS = {
+    // Categories
+    CATEGORIES: `/api/${exports.BLOG_PUBLIC_PATHS.BASE}/${exports.BLOG_PUBLIC_PATHS.CATEGORIES}`,
+    // Posts
+    POSTS: `/api/${exports.BLOG_PUBLIC_PATHS.BASE}/${exports.BLOG_PUBLIC_PATHS.POSTS}`,
+    POST_BY_ALIAS: (alias) => `/api/${exports.BLOG_PUBLIC_PATHS.BASE}/posts/${alias}`,
+};

package/build/v1/blog/blog.types.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { CategoryResponseSchema, CreateCategoryRequestSchema, UpdateCategoryRequestSchema, PostResponseSchema, CreatePostRequestSchema, UpdatePostRequestSchema, GetPostsQueryAdminSchema, GetPostsQueryPublicSchema } from './schemas';
+export { BlogCategoryStatus } from './schemas/blog-category-status.enum';
+export { BlogPostStatus } from './schemas/blog-post-status.enum';
+export type CategoryResponse = z.infer<typeof CategoryResponseSchema>;
+export type CreateCategoryRequest = z.infer<typeof CreateCategoryRequestSchema>;
+export type UpdateCategoryRequest = z.infer<typeof UpdateCategoryRequestSchema>;
+export type PostResponse = z.infer<typeof PostResponseSchema>;
+export type CreatePostRequest = z.infer<typeof CreatePostRequestSchema>;
+export type UpdatePostRequest = z.infer<typeof UpdatePostRequestSchema>;
+export type GetPostsQueryAdmin = z.infer<typeof GetPostsQueryAdminSchema>;
+export type GetPostsQueryPublic = z.infer<typeof GetPostsQueryPublicSchema>;

package/build/v1/blog/blog.types.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlogPostStatus = exports.BlogCategoryStatus = void 0;
+var blog_category_status_enum_1 = require("./schemas/blog-category-status.enum");
+Object.defineProperty(exports, "BlogCategoryStatus", { enumerable: true, get: function () { return blog_category_status_enum_1.BlogCategoryStatus; } });
+var blog_post_status_enum_1 = require("./schemas/blog-post-status.enum");
+Object.defineProperty(exports, "BlogPostStatus", { enumerable: true, get: function () { return blog_post_status_enum_1.BlogPostStatus; } });

package/build/v1/blog/controllers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Blog Controller paths for NestJS @Controller decorator
+ */
+export declare const BLOG_ADMIN_CATEGORIES_CONTROLLER: "v1/admin/blog/categories";
+export declare const BLOG_ADMIN_POSTS_CONTROLLER: "v1/admin/blog/posts";
+export declare const BLOG_PUBLIC_CATEGORIES_CONTROLLER: "v1/blog/categories";
+export declare const BLOG_PUBLIC_POSTS_CONTROLLER: "v1/blog/posts";

package/build/v1/blog/controllers.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOG_PUBLIC_POSTS_CONTROLLER = exports.BLOG_PUBLIC_CATEGORIES_CONTROLLER = exports.BLOG_ADMIN_POSTS_CONTROLLER = exports.BLOG_ADMIN_CATEGORIES_CONTROLLER = void 0;
+/**
+ * Blog Controller paths for NestJS @Controller decorator
+ */
+exports.BLOG_ADMIN_CATEGORIES_CONTROLLER = 'v1/admin/blog/categories';
+exports.BLOG_ADMIN_POSTS_CONTROLLER = 'v1/admin/blog/posts';
+exports.BLOG_PUBLIC_CATEGORIES_CONTROLLER = 'v1/blog/categories';
+exports.BLOG_PUBLIC_POSTS_CONTROLLER = 'v1/blog/posts';

package/build/v1/blog/index.d.ts

@@ -0,0 +1,6 @@
+export * from './schemas';
+export * from './blog.types';
+export * from './blog.paths';
+export * from './admin/commands';
+export * from './admin/queries';
+export * from './public/queries';

package/build/v1/blog/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./blog.types"), exports);
+__exportStar(require("./blog.paths"), exports);
+__exportStar(require("./admin/commands"), exports);
+__exportStar(require("./admin/queries"), exports);
+__exportStar(require("./public/queries"), exports);

package/build/v1/blog/public/queries/get-categories.query.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace BlogGetCategoriesQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        categories: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+            status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: "";
+    const URL: "/api/v1/blog/categories/";
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/public/queries/get-categories.query.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlogGetCategoriesQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const blog_public_routes_1 = require("../../routes/blog-public.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+const CategoriesListPublicResponseSchema = zod_1.z.object({
+    categories: zod_1.z.array(schemas_1.CategoryResponseSchema),
+});
+var BlogGetCategoriesQuery;
+(function (BlogGetCategoriesQuery) {
+    // Request/Response
+    BlogGetCategoriesQuery.Request = zod_1.z.object({});
+    BlogGetCategoriesQuery.Response = zod_1.z.union([CategoriesListPublicResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    BlogGetCategoriesQuery.PATH = blog_public_routes_1.BLOG_PUBLIC_CATEGORIES_ROUTES.GET_ALL;
+    BlogGetCategoriesQuery.URL = rest_api_1.REST_API.V1.BLOG.PUBLIC.CATEGORIES.GET_ALL;
+    BlogGetCategoriesQuery.METHOD = http_method_1.HttpMethod.GET;
+})(BlogGetCategoriesQuery || (exports.BlogGetCategoriesQuery = BlogGetCategoriesQuery = {}));

package/build/v1/blog/public/queries/get-post-by-alias.query.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace BlogGetPostByAliasQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        uuid: z.ZodString;
+        alias: z.ZodString;
+        title: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        content: z.ZodString;
+        image: z.ZodString;
+        author: z.ZodString;
+        categories: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            alias: z.ZodString;
+            title: z.ZodString;
+            order: z.ZodNumber;
+            status: z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        viewsCount: z.ZodNumber;
+        status: z.ZodEnum<typeof import("../../schemas").BlogPostStatus>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const PATH: ":alias";
+    const URL: (alias: string) => string;
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/public/queries/get-post-by-alias.query.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlogGetPostByAliasQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const blog_public_routes_1 = require("../../routes/blog-public.routes");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const common_schemas_1 = require("../../../../shared/common-schemas");
+var BlogGetPostByAliasQuery;
+(function (BlogGetPostByAliasQuery) {
+    // Request/Response
+    BlogGetPostByAliasQuery.Request = zod_1.z.object({});
+    BlogGetPostByAliasQuery.Response = zod_1.z.union([schemas_1.PostResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    BlogGetPostByAliasQuery.PATH = blog_public_routes_1.BLOG_PUBLIC_POSTS_ROUTES.GET_BY_ALIAS;
+    BlogGetPostByAliasQuery.URL = (alias) => rest_api_1.REST_API.V1.BLOG.PUBLIC.POSTS.GET_BY_ALIAS(alias);
+    BlogGetPostByAliasQuery.METHOD = http_method_1.HttpMethod.GET;
+})(BlogGetPostByAliasQuery || (exports.BlogGetPostByAliasQuery = BlogGetPostByAliasQuery = {}));