@veruna/api-contracts 1.0.3 → 1.0.7

package/build/v1/blog/admin/commands/create-category.command.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogCreateCategoryCommand {
+    const Request: z.ZodObject<{
+        alias: z.ZodString;
+        title: z.ZodString;
+        order: z.ZodDefault<z.ZodNumber>;
+        status: z.ZodDefault<z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>>;
+    }, z.core.$strip>;
+    const Response: 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>;
+    const PATH: "";
+    const URL: "/api/v1/admin/blog/categories/";
+    const METHOD = HttpMethod.POST;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/commands/create-category.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogCreateCategoryCommand = void 0;
+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");
+var AdminBlogCreateCategoryCommand;
+(function (AdminBlogCreateCategoryCommand) {
+    AdminBlogCreateCategoryCommand.Request = schemas_1.CreateCategoryRequestSchema;
+    AdminBlogCreateCategoryCommand.Response = schemas_1.CategoryResponseSchema;
+    AdminBlogCreateCategoryCommand.PATH = blog_admin_categories_routes_1.BLOG_ADMIN_CATEGORIES_ROUTES.CREATE;
+    AdminBlogCreateCategoryCommand.URL = rest_api_1.REST_API.V1.BLOG.ADMIN.CATEGORIES.CREATE;
+    AdminBlogCreateCategoryCommand.METHOD = http_method_1.HttpMethod.POST;
+})(AdminBlogCreateCategoryCommand || (exports.AdminBlogCreateCategoryCommand = AdminBlogCreateCategoryCommand = {}));

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogCreatePostCommand {
+    const Request: z.ZodObject<{
+        alias: z.ZodString;
+        title: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        content: z.ZodString;
+        image: z.ZodString;
+        author: z.ZodString;
+        categoryIds: z.ZodArray<z.ZodString>;
+        status: z.ZodDefault<z.ZodEnum<typeof import("../../schemas").BlogPostStatus>>;
+    }, z.core.$strip>;
+    const Response: 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>;
+    const PATH: "";
+    const URL: "/api/v1/admin/blog/posts/";
+    const METHOD = HttpMethod.POST;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogCreatePostCommand = void 0;
+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");
+var AdminBlogCreatePostCommand;
+(function (AdminBlogCreatePostCommand) {
+    AdminBlogCreatePostCommand.Request = schemas_1.CreatePostRequestSchema;
+    AdminBlogCreatePostCommand.Response = schemas_1.PostResponseSchema;
+    AdminBlogCreatePostCommand.PATH = blog_admin_posts_routes_1.BLOG_ADMIN_POSTS_ROUTES.CREATE;
+    AdminBlogCreatePostCommand.URL = rest_api_1.REST_API.V1.BLOG.ADMIN.POSTS.CREATE;
+    AdminBlogCreatePostCommand.METHOD = http_method_1.HttpMethod.POST;
+})(AdminBlogCreatePostCommand || (exports.AdminBlogCreatePostCommand = AdminBlogCreatePostCommand = {}));

package/build/v1/blog/admin/commands/delete-category.command.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogDeleteCategoryCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: ":uuid";
+    const URL: (uuid: string) => string;
+    const METHOD = HttpMethod.DELETE;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/blog/admin/commands/delete-category.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogDeleteCategoryCommand = void 0;
+const zod_1 = require("zod");
+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 AdminBlogDeleteCategoryCommand;
+(function (AdminBlogDeleteCategoryCommand) {
+    AdminBlogDeleteCategoryCommand.Request = zod_1.z.object({});
+    AdminBlogDeleteCategoryCommand.Response = common_schemas_1.EmptyResponseSchema;
+    AdminBlogDeleteCategoryCommand.PATH = blog_admin_categories_routes_1.BLOG_ADMIN_CATEGORIES_ROUTES.DELETE;
+    AdminBlogDeleteCategoryCommand.URL = (uuid) => rest_api_1.REST_API.V1.BLOG.ADMIN.CATEGORIES.DELETE(uuid);
+    AdminBlogDeleteCategoryCommand.METHOD = http_method_1.HttpMethod.DELETE;
+})(AdminBlogDeleteCategoryCommand || (exports.AdminBlogDeleteCategoryCommand = AdminBlogDeleteCategoryCommand = {}));

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogDeletePostCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: ":uuid";
+    const URL: (uuid: string) => string;
+    const METHOD = HttpMethod.DELETE;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogDeletePostCommand = void 0;
+const zod_1 = require("zod");
+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 AdminBlogDeletePostCommand;
+(function (AdminBlogDeletePostCommand) {
+    AdminBlogDeletePostCommand.Request = zod_1.z.object({});
+    AdminBlogDeletePostCommand.Response = common_schemas_1.EmptyResponseSchema;
+    AdminBlogDeletePostCommand.PATH = blog_admin_posts_routes_1.BLOG_ADMIN_POSTS_ROUTES.DELETE;
+    AdminBlogDeletePostCommand.URL = (uuid) => rest_api_1.REST_API.V1.BLOG.ADMIN.POSTS.DELETE(uuid);
+    AdminBlogDeletePostCommand.METHOD = http_method_1.HttpMethod.DELETE;
+})(AdminBlogDeletePostCommand || (exports.AdminBlogDeletePostCommand = AdminBlogDeletePostCommand = {}));

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

@@ -0,0 +1,6 @@
+export * from './create-category.command';
+export * from './update-category.command';
+export * from './delete-category.command';
+export * from './create-post.command';
+export * from './update-post.command';
+export * from './delete-post.command';

package/build/v1/blog/admin/commands/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("./create-category.command"), exports);
+__exportStar(require("./update-category.command"), exports);
+__exportStar(require("./delete-category.command"), exports);
+__exportStar(require("./create-post.command"), exports);
+__exportStar(require("./update-post.command"), exports);
+__exportStar(require("./delete-post.command"), exports);

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogUpdateCategoryCommand {
+    const Request: z.ZodObject<{
+        alias: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>>;
+    }, z.core.$strip>;
+    const Response: 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>;
+    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-category.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogUpdateCategoryCommand = void 0;
+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");
+var AdminBlogUpdateCategoryCommand;
+(function (AdminBlogUpdateCategoryCommand) {
+    AdminBlogUpdateCategoryCommand.Request = schemas_1.UpdateCategoryRequestSchema;
+    AdminBlogUpdateCategoryCommand.Response = schemas_1.CategoryResponseSchema;
+    AdminBlogUpdateCategoryCommand.PATH = blog_admin_categories_routes_1.BLOG_ADMIN_CATEGORIES_ROUTES.UPDATE;
+    AdminBlogUpdateCategoryCommand.URL = (uuid) => rest_api_1.REST_API.V1.BLOG.ADMIN.CATEGORIES.UPDATE(uuid);
+    AdminBlogUpdateCategoryCommand.METHOD = http_method_1.HttpMethod.PATCH;
+})(AdminBlogUpdateCategoryCommand || (exports.AdminBlogUpdateCategoryCommand = AdminBlogUpdateCategoryCommand = {}));

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

@@ -0,0 +1,43 @@
+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.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>;
+    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,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogUpdatePostCommand = void 0;
+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");
+var AdminBlogUpdatePostCommand;
+(function (AdminBlogUpdatePostCommand) {
+    AdminBlogUpdatePostCommand.Request = schemas_1.UpdatePostRequestSchema;
+    AdminBlogUpdatePostCommand.Response = schemas_1.PostResponseSchema;
+    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,24 @@
+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.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>;
+    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,22 @@
+"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 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) {
+    AdminBlogGetCategoriesQuery.Request = GetCategoriesQueryAdminSchema;
+    AdminBlogGetCategoriesQuery.Response = CategoriesListAdminResponseSchema;
+    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,19 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogGetCategoryQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: 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>;
+    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,16 @@
+"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");
+var AdminBlogGetCategoryQuery;
+(function (AdminBlogGetCategoryQuery) {
+    AdminBlogGetCategoryQuery.Request = zod_1.z.object({});
+    AdminBlogGetCategoryQuery.Response = schemas_1.CategoryResponseSchema;
+    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,33 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogGetPostQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: 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>;
+    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,16 @@
+"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");
+var AdminBlogGetPostQuery;
+(function (AdminBlogGetPostQuery) {
+    AdminBlogGetPostQuery.Request = zod_1.z.object({});
+    AdminBlogGetPostQuery.Response = schemas_1.PostResponseSchema;
+    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,48 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+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.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>;
+    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,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogGetPostsQuery = 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 PostsListAdminResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(schemas_1.PostResponseSchema),
+    meta: pagination_schema_1.PaginationMetaSchema,
+});
+var AdminBlogGetPostsQuery;
+(function (AdminBlogGetPostsQuery) {
+    AdminBlogGetPostsQuery.Request = schemas_1.GetPostsQueryAdminSchema;
+    AdminBlogGetPostsQuery.Response = PostsListAdminResponseSchema;
+    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; } });