@veruna/api-contracts 1.0.8 → 1.0.10

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

@@ -0,0 +1,5 @@
+export * from './signup.command';
+export * from './signin.command';
+export * from './logout.command';
+export * from './logout-all.command';
+export * from './delete-session.command';

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

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./signup.command"), exports);
-__exportStar(require("./login.command"), exports);
+__exportStar(require("./signin.command"), exports);
 __exportStar(require("./logout.command"), exports);
 __exportStar(require("./logout-all.command"), exports);
 __exportStar(require("./delete-session.command"), exports);

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthLogoutAllCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{
+        sessionIds: z.ZodArray<z.ZodString>;
+    }, 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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthLogoutAllCommand = void 0;
 const zod_1 = require("zod");
-const auth_routes_1 = require("../routes/auth.routes");
 const rest_api_1 = require("../../../rest-api");
 const http_method_1 = require("../../../shared/http-method");
 var AuthLogoutAllCommand;
@@ -12,8 +11,7 @@ var AuthLogoutAllCommand;
     AuthLogoutAllCommand.Response = zod_1.z.object({
         sessionIds: zod_1.z.array(zod_1.z.string().uuid()),
     });
-    // Path/URL/Method
-    AuthLogoutAllCommand.PATH = auth_routes_1.AUTH_ROUTES.LOGOUT_ALL;
+    // URL/Method
     AuthLogoutAllCommand.URL = rest_api_1.REST_API.V1.AUTH.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,12 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthLogoutCommand {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{
+        sessionId: z.ZodString;
+    }, 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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthLogoutCommand = void 0;
 const zod_1 = require("zod");
-const auth_routes_1 = require("../routes/auth.routes");
 const rest_api_1 = require("../../../rest-api");
 const http_method_1 = require("../../../shared/http-method");
 var AuthLogoutCommand;
@@ -12,8 +11,7 @@ var AuthLogoutCommand;
     AuthLogoutCommand.Response = zod_1.z.object({
         sessionId: zod_1.z.string().uuid(),
     });
-    // Path/URL/Method
-    AuthLogoutCommand.PATH = auth_routes_1.AUTH_ROUTES.LOGOUT;
+    // URL/Method
     AuthLogoutCommand.URL = rest_api_1.REST_API.V1.AUTH.LOGOUT;
     AuthLogoutCommand.METHOD = http_method_1.HttpMethod.POST;
 })(AuthLogoutCommand || (exports.AuthLogoutCommand = AuthLogoutCommand = {}));

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthSignInCommand {
+    const Request: z.ZodObject<{
+        email: z.ZodString;
+        password: z.ZodString;
+    }, z.core.$strip>;
+    const Response: 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>;
+    const URL: "/api/v1/auth/signin";
+    const METHOD = HttpMethod.POST;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthSignInCommand = void 0;
+const signin_request_schema_1 = require("../schemas/signin-request.schema");
+const auth_response_schema_1 = require("../schemas/auth-response.schema");
+const rest_api_1 = require("../../../rest-api");
+const http_method_1 = require("../../../shared/http-method");
+var AuthSignInCommand;
+(function (AuthSignInCommand) {
+    // Request/Response
+    AuthSignInCommand.Request = signin_request_schema_1.SignInRequestSchema;
+    AuthSignInCommand.Response = auth_response_schema_1.AuthResponseSchema;
+    // URL/Method
+    AuthSignInCommand.URL = rest_api_1.REST_API.V1.AUTH.SIGNIN;
+    AuthSignInCommand.METHOD = http_method_1.HttpMethod.POST;
+})(AuthSignInCommand || (exports.AuthSignInCommand = AuthSignInCommand = {}));

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

@@ -0,0 +1,33 @@
+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>;
+    }, z.core.$strip>;
+    const Response: 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>;
+    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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthSignupCommand = void 0;
 const signup_request_schema_1 = require("../schemas/signup-request.schema");
 const auth_response_schema_1 = require("../schemas/auth-response.schema");
-const auth_routes_1 = require("../routes/auth.routes");
 const rest_api_1 = require("../../../rest-api");
 const http_method_1 = require("../../../shared/http-method");
 var AuthSignupCommand;
@@ -11,8 +10,7 @@ var AuthSignupCommand;
     // Request/Response
     AuthSignupCommand.Request = signup_request_schema_1.SignUpRequestSchema;
     AuthSignupCommand.Response = auth_response_schema_1.AuthResponseSchema;
-    // Path/URL/Method
-    AuthSignupCommand.PATH = auth_routes_1.AUTH_ROUTES.SIGNUP;
+    // URL/Method
     AuthSignupCommand.URL = rest_api_1.REST_API.V1.AUTH.SIGNUP;
     AuthSignupCommand.METHOD = http_method_1.HttpMethod.POST;
 })(AuthSignupCommand || (exports.AuthSignupCommand = AuthSignupCommand = {}));

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

@@ -0,0 +1,8 @@
+export * from './schemas';
+export * from './auth.types';
+export * from './auth.paths';
+export * from './auth.errors';
+export * from './commands';
+export * from './queries';
+export { AUTH_CONTROLLER } from '../../controllers';
+export { AUTH_ROUTES } from '../../routes';

package/build/v1/auth/index.js

@@ -14,11 +14,15 @@ 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 });
+exports.AUTH_ROUTES = exports.AUTH_CONTROLLER = void 0;
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./auth.types"), exports);
 __exportStar(require("./auth.paths"), exports);
 __exportStar(require("./auth.errors"), exports);
-__exportStar(require("./controllers"), exports);
-__exportStar(require("./routes/auth.routes"), exports);
 __exportStar(require("./commands"), exports);
 __exportStar(require("./queries"), exports);
+// Re-export from centralized locations
+var controllers_1 = require("../../controllers");
+Object.defineProperty(exports, "AUTH_CONTROLLER", { enumerable: true, get: function () { return controllers_1.AUTH_CONTROLLER; } });
+var routes_1 = require("../../routes");
+Object.defineProperty(exports, "AUTH_ROUTES", { enumerable: true, get: function () { return routes_1.AUTH_ROUTES; } });

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../shared/http-method';
+export declare namespace AuthGetSessionsQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: 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>;
+    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

@@ -3,7 +3,6 @@ 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_routes_1 = require("../routes/auth.routes");
 const rest_api_1 = require("../../../rest-api");
 const http_method_1 = require("../../../shared/http-method");
 var AuthGetSessionsQuery;
@@ -11,8 +10,7 @@ var AuthGetSessionsQuery;
     // Request/Response
     AuthGetSessionsQuery.Request = zod_1.z.object({});
     AuthGetSessionsQuery.Response = auth_response_schema_1.SessionsListResponseSchema;
-    // Path/URL/Method
-    AuthGetSessionsQuery.PATH = auth_routes_1.AUTH_ROUTES.SESSIONS;
+    // URL/Method
     AuthGetSessionsQuery.URL = rest_api_1.REST_API.V1.AUTH.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/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/index.d.ts

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

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

@@ -16,6 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 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("./signin-request.schema"), exports);
 __exportStar(require("./session-response.schema"), exports);
 __exportStar(require("./auth-response.schema"), exports);

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/signin-request.schema.d.ts

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

package/build/v1/auth/schemas/{login-request.schema.js → signin-request.schema.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoginRequestSchema = void 0;
+exports.SignInRequestSchema = void 0;
 const zod_1 = require("zod");
 const regex_1 = require("../../../shared/regex");
 /**
- * Login Request Schema
+ * SignIn Request Schema
  * Error messages are in locales (en.ts, ru.ts)
  */
-exports.LoginRequestSchema = zod_1.z.object({
+exports.SignInRequestSchema = 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/signup-request.schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/**
+ * 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>;
+}, z.core.$strip>;

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

@@ -1,18 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignUpRequestSchema = exports.UtmSchema = void 0;
+exports.SignUpRequestSchema = 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)
@@ -22,5 +12,4 @@ exports.SignUpRequestSchema = zod_1.z.object({
     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/blog/admin/commands/create-category.command.d.ts

@@ -0,0 +1,23 @@
+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 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

@@ -2,14 +2,12 @@
 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,42 @@
+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 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

@@ -2,14 +2,12 @@
 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,10 @@
+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 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

@@ -2,7 +2,6 @@
 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");
@@ -10,7 +9,6 @@ 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,10 @@
+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 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

@@ -2,7 +2,6 @@
 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");
@@ -10,7 +9,6 @@ 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/update-category.command.d.ts

@@ -0,0 +1,23 @@
+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 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

@@ -2,14 +2,12 @@
 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 = {}));