@veruna/api-contracts 1.0.2 → 1.0.4

package/build/v1/auth/commands/logout-all.command.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthLogoutAllCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const URL: "/api/v1/auth/logout-all";
+    const METHOD = HttpMethod.POST;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/auth/commands/logout-all.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthLogoutAllCommand = void 0;
+const zod_1 = require("zod");
+const auth_paths_1 = require("../auth.paths");
+const http_method_1 = require("../../../shared/http-method");
+const common_schemas_1 = require("../../../shared/common-schemas");
+var AuthLogoutAllCommand;
+(function (AuthLogoutAllCommand) {
+    AuthLogoutAllCommand.Request = zod_1.z.object({}); // No request body
+    AuthLogoutAllCommand.Response = zod_1.z.union([common_schemas_1.EmptyResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    AuthLogoutAllCommand.URL = auth_paths_1.AUTH_API_PATHS.LOGOUT_ALL;
+    AuthLogoutAllCommand.METHOD = http_method_1.HttpMethod.POST;
+})(AuthLogoutAllCommand || (exports.AuthLogoutAllCommand = AuthLogoutAllCommand = {}));

package/build/v1/auth/commands/logout.command.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthLogoutCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        code: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>]>;
+    const URL: "/api/v1/auth/logout";
+    const METHOD = HttpMethod.POST;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/auth/commands/logout.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthLogoutCommand = void 0;
+const zod_1 = require("zod");
+const auth_paths_1 = require("../auth.paths");
+const http_method_1 = require("../../../shared/http-method");
+const common_schemas_1 = require("../../../shared/common-schemas");
+var AuthLogoutCommand;
+(function (AuthLogoutCommand) {
+    AuthLogoutCommand.Request = zod_1.z.object({}); // No request body
+    AuthLogoutCommand.Response = zod_1.z.union([common_schemas_1.EmptyResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    AuthLogoutCommand.URL = auth_paths_1.AUTH_API_PATHS.LOGOUT;
+    AuthLogoutCommand.METHOD = http_method_1.HttpMethod.POST;
+})(AuthLogoutCommand || (exports.AuthLogoutCommand = AuthLogoutCommand = {}));

package/build/v1/auth/commands/signup.command.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthSignupCommand {
+    const Request: z.ZodObject<{
+        email: z.ZodString;
+        password: z.ZodString;
+        name: z.ZodString;
+        marketingConsent: z.ZodDefault<z.ZodBoolean>;
+        utm: z.ZodOptional<z.ZodObject<{
+            utmSource: z.ZodOptional<z.ZodString>;
+            utmMedium: z.ZodOptional<z.ZodString>;
+            utmCampaign: z.ZodOptional<z.ZodString>;
+            utmContent: z.ZodOptional<z.ZodString>;
+            utmTerm: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        user: z.ZodObject<{
+            uuid: z.ZodString;
+            email: z.ZodString;
+            name: z.ZodString;
+            role: z.ZodString;
+            marketingConsent: z.ZodBoolean;
+            createdAt: z.ZodString;
+        }, z.core.$strip>;
+        accessToken: z.ZodString;
+        session: z.ZodObject<{
+            uuid: z.ZodString;
+            deviceName: z.ZodString;
+            ip: z.ZodString;
+            isCurrent: z.ZodBoolean;
+            createdAt: z.ZodString;
+            lastUsedAt: 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 URL: "/api/v1/auth/signup";
+    const METHOD = HttpMethod.POST;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/auth/commands/signup.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthSignupCommand = void 0;
+const zod_1 = require("zod");
+const signup_request_schema_1 = require("../schemas/signup-request.schema");
+const auth_response_schema_1 = require("../schemas/auth-response.schema");
+const auth_paths_1 = require("../auth.paths");
+const http_method_1 = require("../../../shared/http-method");
+const common_schemas_1 = require("../../../shared/common-schemas");
+var AuthSignupCommand;
+(function (AuthSignupCommand) {
+    AuthSignupCommand.Request = signup_request_schema_1.SignUpRequestSchema;
+    AuthSignupCommand.Response = zod_1.z.union([auth_response_schema_1.AuthResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    AuthSignupCommand.URL = auth_paths_1.AUTH_API_PATHS.SIGNUP;
+    AuthSignupCommand.METHOD = http_method_1.HttpMethod.POST;
+})(AuthSignupCommand || (exports.AuthSignupCommand = AuthSignupCommand = {}));

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

@@ -0,0 +1,4 @@
+/**
+ * Auth Controller paths for NestJS @Controller decorator
+ */
+export declare const AUTH_CONTROLLER: "v1/auth";

package/build/v1/auth/controllers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_CONTROLLER = void 0;
+/**
+ * Auth Controller paths for NestJS @Controller decorator
+ */
+exports.AUTH_CONTROLLER = 'v1/auth';

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

@@ -1,4 +1,6 @@
-export * from './auth.schemas';
+export * from './schemas';
 export * from './auth.types';
 export * from './auth.paths';
 export * from './auth.errors';
+export * from './commands';
+export * from './queries';

package/build/v1/auth/index.js

@@ -14,7 +14,9 @@ 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("./auth.schemas"), exports);
+__exportStar(require("./schemas"), exports);
 __exportStar(require("./auth.types"), exports);
 __exportStar(require("./auth.paths"), exports);
 __exportStar(require("./auth.errors"), exports);
+__exportStar(require("./commands"), exports);
+__exportStar(require("./queries"), exports);

package/build/v1/auth/queries/get-sessions.query.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthGetSessionsQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{
+        sessions: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            deviceName: z.ZodString;
+            ip: z.ZodString;
+            isCurrent: z.ZodBoolean;
+            createdAt: z.ZodString;
+            lastUsedAt: 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 URL: "/api/v1/auth/sessions";
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/auth/queries/get-sessions.query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthGetSessionsQuery = void 0;
+const zod_1 = require("zod");
+const auth_response_schema_1 = require("../schemas/auth-response.schema");
+const auth_paths_1 = require("../auth.paths");
+const http_method_1 = require("../../../shared/http-method");
+const common_schemas_1 = require("../../../shared/common-schemas");
+var AuthGetSessionsQuery;
+(function (AuthGetSessionsQuery) {
+    AuthGetSessionsQuery.Request = zod_1.z.object({}); // No request body for GET
+    AuthGetSessionsQuery.Response = zod_1.z.union([auth_response_schema_1.SessionsListResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    AuthGetSessionsQuery.URL = auth_paths_1.AUTH_API_PATHS.SESSIONS;
+    AuthGetSessionsQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AuthGetSessionsQuery || (exports.AuthGetSessionsQuery = AuthGetSessionsQuery = {}));

package/build/v1/auth/queries/index.d.ts

@@ -0,0 +1 @@
+export * from './get-sessions.query';

package/build/v1/auth/queries/index.js

@@ -0,0 +1,17 @@
+"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-sessions.query"), exports);

package/build/v1/auth/routes/auth.routes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Auth Routes
+ * For NestJS method decorators (@Get, @Post, etc.)
+ */
+export declare const AUTH_ROUTES: {
+    readonly SIGNUP: "signup";
+    readonly LOGIN: "login";
+    readonly LOGOUT: "logout";
+    readonly LOGOUT_ALL: "logout-all";
+    readonly SESSIONS: "sessions";
+    readonly SESSION_BY_ID: "sessions/:id";
+};

package/build/v1/auth/routes/auth.routes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_ROUTES = void 0;
+/**
+ * Auth Routes
+ * For NestJS method decorators (@Get, @Post, etc.)
+ */
+exports.AUTH_ROUTES = {
+    SIGNUP: 'signup',
+    LOGIN: 'login',
+    LOGOUT: 'logout',
+    LOGOUT_ALL: 'logout-all',
+    SESSIONS: 'sessions',
+    SESSION_BY_ID: 'sessions/:id',
+};

package/build/v1/auth/schemas/auth-response.schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+/**
+ * Auth Response Schema (signup/login)
+ */
+export declare const AuthResponseSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        uuid: z.ZodString;
+        email: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodString;
+        marketingConsent: z.ZodBoolean;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+    accessToken: z.ZodString;
+    session: z.ZodObject<{
+        uuid: z.ZodString;
+        deviceName: z.ZodString;
+        ip: z.ZodString;
+        isCurrent: z.ZodBoolean;
+        createdAt: z.ZodString;
+        lastUsedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Sessions List Response Schema
+ */
+export declare const SessionsListResponseSchema: z.ZodObject<{
+    sessions: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        deviceName: z.ZodString;
+        ip: z.ZodString;
+        isCurrent: z.ZodBoolean;
+        createdAt: z.ZodString;
+        lastUsedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/build/v1/auth/schemas/auth-response.schema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionsListResponseSchema = exports.AuthResponseSchema = void 0;
+const zod_1 = require("zod");
+const user_response_schema_1 = require("../../users/schemas/user-response.schema");
+const session_response_schema_1 = require("./session-response.schema");
+/**
+ * Auth Response Schema (signup/login)
+ */
+exports.AuthResponseSchema = zod_1.z.object({
+    user: user_response_schema_1.UserResponseSchema,
+    accessToken: zod_1.z.string(),
+    session: session_response_schema_1.SessionResponseSchema,
+});
+/**
+ * Sessions List Response Schema
+ */
+exports.SessionsListResponseSchema = zod_1.z.object({
+    sessions: zod_1.z.array(session_response_schema_1.SessionResponseSchema),
+});

package/build/v1/auth/schemas/index.d.ts

@@ -0,0 +1,5 @@
+export * from './user-role.enum';
+export * from './signup-request.schema';
+export * from './login-request.schema';
+export * from './session-response.schema';
+export * from './auth-response.schema';

package/build/v1/auth/schemas/index.js

@@ -0,0 +1,21 @@
+"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("./user-role.enum"), exports);
+__exportStar(require("./signup-request.schema"), exports);
+__exportStar(require("./login-request.schema"), exports);
+__exportStar(require("./session-response.schema"), exports);
+__exportStar(require("./auth-response.schema"), exports);

package/build/v1/auth/schemas/login-request.schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+/**
+ * Login Request Schema
+ * Error messages are in locales (en.ts, ru.ts)
+ */
+export declare const LoginRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;

package/build/v1/auth/schemas/login-request.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginRequestSchema = void 0;
+const zod_1 = require("zod");
+const regex_1 = require("../../../shared/regex");
+/**
+ * Login Request Schema
+ * Error messages are in locales (en.ts, ru.ts)
+ */
+exports.LoginRequestSchema = zod_1.z.object({
+    email: zod_1.z.string().regex(regex_1.EMAIL_REGEX),
+    password: zod_1.z.string().min(1),
+});

package/build/v1/auth/schemas/session-response.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/**
+ * Session Response Schema
+ * Error messages are in locales (en.ts, ru.ts)
+ */
+export declare const SessionResponseSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    deviceName: z.ZodString;
+    ip: z.ZodString;
+    isCurrent: z.ZodBoolean;
+    createdAt: z.ZodString;
+    lastUsedAt: z.ZodString;
+}, z.core.$strip>;

package/build/v1/auth/schemas/session-response.schema.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionResponseSchema = void 0;
+const zod_1 = require("zod");
+const regex_1 = require("../../../shared/regex");
+/**
+ * Session Response Schema
+ * Error messages are in locales (en.ts, ru.ts)
+ */
+exports.SessionResponseSchema = zod_1.z.object({
+    uuid: zod_1.z.string().regex(regex_1.UUID_REGEX),
+    deviceName: zod_1.z.string(),
+    ip: zod_1.z.string(),
+    isCurrent: zod_1.z.boolean(),
+    createdAt: zod_1.z.string().regex(regex_1.DATETIME_REGEX),
+    lastUsedAt: zod_1.z.string().regex(regex_1.DATETIME_REGEX),
+});

package/build/v1/auth/schemas/signup-request.schema.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+/**
+ * UTM Schema
+ */
+export declare const UtmSchema: z.ZodObject<{
+    utmSource: z.ZodOptional<z.ZodString>;
+    utmMedium: z.ZodOptional<z.ZodString>;
+    utmCampaign: z.ZodOptional<z.ZodString>;
+    utmContent: z.ZodOptional<z.ZodString>;
+    utmTerm: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Sign Up Request Schema
+ * Error messages are in locales (en.ts, ru.ts)
+ */
+export declare const SignUpRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    name: z.ZodString;
+    marketingConsent: z.ZodDefault<z.ZodBoolean>;
+    utm: z.ZodOptional<z.ZodObject<{
+        utmSource: z.ZodOptional<z.ZodString>;
+        utmMedium: z.ZodOptional<z.ZodString>;
+        utmCampaign: z.ZodOptional<z.ZodString>;
+        utmContent: z.ZodOptional<z.ZodString>;
+        utmTerm: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;

package/build/v1/auth/schemas/signup-request.schema.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignUpRequestSchema = exports.UtmSchema = void 0;
+const zod_1 = require("zod");
+const regex_1 = require("../../../shared/regex");
+/**
+ * UTM Schema
+ */
+exports.UtmSchema = zod_1.z.object({
+    utmSource: zod_1.z.string().optional(),
+    utmMedium: zod_1.z.string().optional(),
+    utmCampaign: zod_1.z.string().optional(),
+    utmContent: zod_1.z.string().optional(),
+    utmTerm: zod_1.z.string().optional(),
+});
+/**
+ * Sign Up Request Schema
+ * Error messages are in locales (en.ts, ru.ts)
+ */
+exports.SignUpRequestSchema = zod_1.z.object({
+    email: zod_1.z.string().regex(regex_1.EMAIL_REGEX),
+    password: zod_1.z.string().min(8).max(128).regex(regex_1.PASSWORD_STRENGTH_REGEX),
+    name: zod_1.z.string().min(2),
+    marketingConsent: zod_1.z.boolean().default(false),
+    utm: exports.UtmSchema.optional(),
+});

package/build/v1/auth/schemas/user-role.enum.d.ts

@@ -0,0 +1,7 @@
+/**
+ * User Role enum
+ */
+export declare enum UserRole {
+    USER = "user",
+    ADMIN = "admin"
+}

package/build/v1/auth/schemas/user-role.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRole = void 0;
+/**
+ * User Role enum
+ */
+var UserRole;
+(function (UserRole) {
+    UserRole["USER"] = "user";
+    UserRole["ADMIN"] = "admin";
+})(UserRole || (exports.UserRole = UserRole = {}));

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

@@ -0,0 +1,27 @@
+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.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: "";
+    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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogCreateCategoryCommand = 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 AdminBlogCreateCategoryCommand;
+(function (AdminBlogCreateCategoryCommand) {
+    // Request/Response
+    AdminBlogCreateCategoryCommand.Request = schemas_1.CreateCategoryRequestSchema;
+    AdminBlogCreateCategoryCommand.Response = zod_1.z.union([schemas_1.CategoryResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    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,46 @@
+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.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: "";
+    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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminBlogCreatePostCommand = 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 AdminBlogCreatePostCommand;
+(function (AdminBlogCreatePostCommand) {
+    // Request/Response
+    AdminBlogCreatePostCommand.Request = schemas_1.CreatePostRequestSchema;
+    AdminBlogCreatePostCommand.Response = zod_1.z.union([schemas_1.PostResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    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,14 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogDeleteCategoryCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{}, 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.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,18 @@
+"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) {
+    // Request/Response
+    AdminBlogDeleteCategoryCommand.Request = zod_1.z.object({});
+    AdminBlogDeleteCategoryCommand.Response = zod_1.z.union([common_schemas_1.EmptyResponseSchema, common_schemas_1.ErrorResponseSchema]);
+    // Path/URL/Method
+    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,14 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminBlogDeletePostCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodUnion<readonly [z.ZodObject<{}, 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.DELETE;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}