@veruna/api-contracts 1.0.4 → 1.0.7

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

@@ -7,7 +7,7 @@ export declare namespace AdminBlogUpdateCategoryCommand {
         order: z.ZodOptional<z.ZodNumber>;
         status: z.ZodOptional<z.ZodEnum<typeof import("../../schemas").BlogCategoryStatus>>;
     }, z.core.$strip>;
-    const Response: z.ZodUnion<readonly [z.ZodObject<{
+    const Response: z.ZodObject<{
         uuid: z.ZodString;
         alias: z.ZodString;
         title: z.ZodString;
@@ -15,10 +15,7 @@ export declare namespace AdminBlogUpdateCategoryCommand {
         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>]>;
+    }, z.core.$strip>;
     const PATH: ":uuid";
     const URL: (uuid: string) => string;
     const METHOD = HttpMethod.PATCH;

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

@@ -1,18 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminBlogUpdateCategoryCommand = 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 AdminBlogUpdateCategoryCommand;
 (function (AdminBlogUpdateCategoryCommand) {
-    // Request/Response
     AdminBlogUpdateCategoryCommand.Request = schemas_1.UpdateCategoryRequestSchema;
-    AdminBlogUpdateCategoryCommand.Response = zod_1.z.union([schemas_1.CategoryResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    // Path/URL/Method
+    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;

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

@@ -12,7 +12,7 @@ export declare namespace AdminBlogUpdatePostCommand {
         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<{
+    const Response: z.ZodObject<{
         uuid: z.ZodString;
         alias: z.ZodString;
         title: z.ZodString;
@@ -34,10 +34,7 @@ export declare namespace AdminBlogUpdatePostCommand {
         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>]>;
+    }, z.core.$strip>;
     const PATH: ":uuid";
     const URL: (uuid: string) => string;
     const METHOD = HttpMethod.PATCH;

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

@@ -1,18 +1,14 @@
 "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.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;

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

@@ -5,7 +5,7 @@ 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<{
+    const Response: z.ZodObject<{
         categories: z.ZodArray<z.ZodObject<{
             uuid: z.ZodString;
             alias: z.ZodString;
@@ -15,10 +15,7 @@ export declare namespace AdminBlogGetCategoriesQuery {
             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>]>;
+    }, z.core.$strip>;
     const PATH: "";
     const URL: "/api/v1/admin/blog/categories/";
     const METHOD = HttpMethod.GET;

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

@@ -6,7 +6,6 @@ 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),
 });
@@ -15,10 +14,8 @@ const GetCategoriesQueryAdminSchema = zod_1.z.object({
 });
 var AdminBlogGetCategoriesQuery;
 (function (AdminBlogGetCategoriesQuery) {
-    // Request/Response
     AdminBlogGetCategoriesQuery.Request = GetCategoriesQueryAdminSchema;
-    AdminBlogGetCategoriesQuery.Response = zod_1.z.union([CategoriesListAdminResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    // Path/URL/Method
+    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;

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

@@ -2,7 +2,7 @@ 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<{
+    const Response: z.ZodObject<{
         uuid: z.ZodString;
         alias: z.ZodString;
         title: z.ZodString;
@@ -10,10 +10,7 @@ export declare namespace AdminBlogGetCategoryQuery {
         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>]>;
+    }, z.core.$strip>;
     const PATH: ":uuid";
     const URL: (uuid: string) => string;
     const METHOD = HttpMethod.GET;

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

@@ -6,13 +6,10 @@ 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.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;

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

@@ -2,7 +2,7 @@ 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<{
+    const Response: z.ZodObject<{
         uuid: z.ZodString;
         alias: z.ZodString;
         title: z.ZodString;
@@ -24,10 +24,7 @@ export declare namespace AdminBlogGetPostQuery {
         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>]>;
+    }, z.core.$strip>;
     const PATH: ":uuid";
     const URL: (uuid: string) => string;
     const METHOD = HttpMethod.GET;

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

@@ -6,13 +6,10 @@ 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.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;

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

@@ -1,38 +1,5 @@
 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>>;
@@ -40,7 +7,7 @@ export declare namespace AdminBlogGetPostsQuery {
         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<{
+    const Response: z.ZodObject<{
         data: z.ZodArray<z.ZodObject<{
             uuid: z.ZodString;
             alias: z.ZodString;
@@ -72,10 +39,7 @@ export declare namespace AdminBlogGetPostsQuery {
             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>]>;
+    }, z.core.$strip>;
     const PATH: "";
     const URL: "/api/v1/admin/blog/posts/";
     const METHOD = HttpMethod.GET;

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

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdminBlogGetPostsQuery = exports.PostsListAdminResponseSchema = void 0;
+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 common_schemas_1 = require("../../../../shared/common-schemas");
-exports.PostsListAdminResponseSchema = zod_1.z.object({
+const 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.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;

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

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

package/build/v1/blog/index.js

@@ -17,6 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./blog.types"), exports);
 __exportStar(require("./blog.paths"), exports);
+__exportStar(require("./controllers"), exports);
+__exportStar(require("./routes"), 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

@@ -2,7 +2,7 @@ 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<{
+    const Response: z.ZodObject<{
         categories: z.ZodArray<z.ZodObject<{
             uuid: z.ZodString;
             alias: z.ZodString;
@@ -12,10 +12,7 @@ export declare namespace BlogGetCategoriesQuery {
             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>]>;
+    }, z.core.$strip>;
     const PATH: "";
     const URL: "/api/v1/blog/categories/";
     const METHOD = HttpMethod.GET;

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

@@ -6,16 +6,13 @@ 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.Response = CategoriesListPublicResponseSchema;
     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;

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

@@ -2,7 +2,7 @@ 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<{
+    const Response: z.ZodObject<{
         uuid: z.ZodString;
         alias: z.ZodString;
         title: z.ZodString;
@@ -24,10 +24,7 @@ export declare namespace BlogGetPostByAliasQuery {
         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>]>;
+    }, z.core.$strip>;
     const PATH: ":alias";
     const URL: (alias: string) => string;
     const METHOD = HttpMethod.GET;

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

@@ -6,13 +6,10 @@ 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.Response = schemas_1.PostResponseSchema;
     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;

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

@@ -1,45 +1,12 @@
 import { z } from 'zod';
 import { HttpMethod } from '../../../../shared/http-method';
-export declare const PostsListResponseSchema: 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 BlogGetPostsQuery {
     const Request: z.ZodObject<{
         page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
         limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
         categoryAliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
-    const Response: z.ZodUnion<readonly [z.ZodObject<{
+    const Response: z.ZodObject<{
         data: z.ZodArray<z.ZodObject<{
             uuid: z.ZodString;
             alias: z.ZodString;
@@ -71,10 +38,7 @@ export declare namespace BlogGetPostsQuery {
             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>]>;
+    }, z.core.$strip>;
     const PATH: "";
     const URL: "/api/v1/blog/posts/";
     const METHOD = HttpMethod.GET;

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

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlogGetPostsQuery = exports.PostsListResponseSchema = void 0;
+exports.BlogGetPostsQuery = void 0;
 const zod_1 = require("zod");
 const schemas_1 = require("../../schemas");
 const pagination_schema_1 = require("../../../../shared/pagination.schema");
 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");
-exports.PostsListResponseSchema = zod_1.z.object({
+const PostsListResponseSchema = zod_1.z.object({
     data: zod_1.z.array(schemas_1.PostResponseSchema),
     meta: pagination_schema_1.PaginationMetaSchema,
 });
 var BlogGetPostsQuery;
 (function (BlogGetPostsQuery) {
-    // Request/Response
     BlogGetPostsQuery.Request = schemas_1.GetPostsQueryPublicSchema;
-    BlogGetPostsQuery.Response = zod_1.z.union([exports.PostsListResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    // Path/URL/Method
+    BlogGetPostsQuery.Response = PostsListResponseSchema;
     BlogGetPostsQuery.PATH = blog_public_routes_1.BLOG_PUBLIC_POSTS_ROUTES.GET_ALL;
     BlogGetPostsQuery.URL = rest_api_1.REST_API.V1.BLOG.PUBLIC.POSTS.GET_ALL;
     BlogGetPostsQuery.METHOD = http_method_1.HttpMethod.GET;

package/build/v1/unregistered-users/commands/authenticate.command.d.ts

@@ -4,16 +4,14 @@ export declare namespace UnregAuthenticateCommand {
     const Request: z.ZodObject<{
         token: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
-    const Response: z.ZodUnion<readonly [z.ZodObject<{
+    const Response: z.ZodObject<{
         token: z.ZodString;
         requests: z.ZodNumber;
         nextResetAt: z.ZodString;
         status: z.ZodEnum<typeof import("../schemas").UnregUserStatus>;
-    }, z.core.$strip>, z.ZodObject<{
-        code: z.ZodString;
-        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, z.core.$strip>]>;
-    const URL: "/api/v1/unreg";
+    }, z.core.$strip>;
+    const PATH: "";
+    const URL: "/api/v1/unreg/";
     const METHOD = HttpMethod.PUT;
     type RequestType = z.infer<typeof Request>;
     type ResponseType = z.infer<typeof Response>;

package/build/v1/unregistered-users/commands/authenticate.command.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnregAuthenticateCommand = void 0;
-const zod_1 = require("zod");
 const schemas_1 = require("../schemas");
-const unregistered_users_paths_1 = require("../unregistered-users.paths");
+const unreg_users_routes_1 = require("../routes/unreg-users.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 UnregAuthenticateCommand;
 (function (UnregAuthenticateCommand) {
     UnregAuthenticateCommand.Request = schemas_1.AuthenticateUnregUserRequestSchema;
-    UnregAuthenticateCommand.Response = zod_1.z.union([schemas_1.AuthenticateUnregUserResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    UnregAuthenticateCommand.URL = unregistered_users_paths_1.UNREG_USERS_API_PATHS.AUTHENTICATE;
+    UnregAuthenticateCommand.Response = schemas_1.AuthenticateUnregUserResponseSchema;
+    UnregAuthenticateCommand.PATH = unreg_users_routes_1.UNREG_USERS_ROUTES.AUTHENTICATE;
+    UnregAuthenticateCommand.URL = rest_api_1.REST_API.V1.UNREG.AUTHENTICATE;
     UnregAuthenticateCommand.METHOD = http_method_1.HttpMethod.PUT;
 })(UnregAuthenticateCommand || (exports.UnregAuthenticateCommand = UnregAuthenticateCommand = {}));

package/build/v1/unregistered-users/controllers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unregistered Users Controller path
+ */
+export declare const UNREG_USERS_CONTROLLER: "v1/unreg";

package/build/v1/unregistered-users/controllers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNREG_USERS_CONTROLLER = void 0;
+/**
+ * Unregistered Users Controller path
+ */
+exports.UNREG_USERS_CONTROLLER = 'v1/unreg';

package/build/v1/unregistered-users/routes/unreg-users.routes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unregistered Users Routes
+ */
+export declare const UNREG_USERS_ROUTES: {
+    readonly AUTHENTICATE: "";
+};

package/build/v1/unregistered-users/routes/unreg-users.routes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNREG_USERS_ROUTES = void 0;
+/**
+ * Unregistered Users Routes
+ */
+exports.UNREG_USERS_ROUTES = {
+    AUTHENTICATE: '', // PUT to controller base
+};

package/build/v1/users/commands/change-password.command.d.ts

@@ -6,10 +6,8 @@ export declare namespace UserChangePasswordCommand {
         newPassword: z.ZodString;
         logoutFromAllDevices: z.ZodDefault<z.ZodBoolean>;
     }, 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 Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: "me/password";
     const URL: "/api/v1/users/me/password";
     const METHOD = HttpMethod.PUT;
     type RequestType = z.infer<typeof Request>;

package/build/v1/users/commands/change-password.command.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserChangePasswordCommand = void 0;
-const schemas_1 = require("../schemas");
-const users_paths_1 = require("../users.paths");
+const change_password_request_schema_1 = require("../schemas/change-password-request.schema");
+const users_routes_1 = require("../routes/users.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 UserChangePasswordCommand;
 (function (UserChangePasswordCommand) {
-    UserChangePasswordCommand.Request = schemas_1.ChangePasswordRequestSchema;
-    UserChangePasswordCommand.Response = schemas_1.ChangePasswordResponseSchema;
-    UserChangePasswordCommand.URL = users_paths_1.USERS_API_PATHS.ME_PASSWORD;
+    UserChangePasswordCommand.Request = change_password_request_schema_1.ChangePasswordRequestSchema;
+    UserChangePasswordCommand.Response = common_schemas_1.EmptyResponseSchema;
+    UserChangePasswordCommand.PATH = users_routes_1.USERS_ROUTES.ME_PASSWORD;
+    UserChangePasswordCommand.URL = rest_api_1.REST_API.V1.USERS.ME_PASSWORD;
     UserChangePasswordCommand.METHOD = http_method_1.HttpMethod.PUT;
 })(UserChangePasswordCommand || (exports.UserChangePasswordCommand = UserChangePasswordCommand = {}));

package/build/v1/users/commands/delete-account.command.d.ts

@@ -2,10 +2,8 @@ import { z } from 'zod';
 import { HttpMethod } from '../../../shared/http-method';
 export declare namespace UserDeleteAccountCommand {
     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 Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: "me";
     const URL: "/api/v1/users/me";
     const METHOD = HttpMethod.DELETE;
     type RequestType = z.infer<typeof Request>;

package/build/v1/users/commands/delete-account.command.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserDeleteAccountCommand = void 0;
-const schemas_1 = require("../schemas");
-const users_paths_1 = require("../users.paths");
+const zod_1 = require("zod");
+const users_routes_1 = require("../routes/users.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 UserDeleteAccountCommand;
 (function (UserDeleteAccountCommand) {
-    UserDeleteAccountCommand.Request = schemas_1.DeleteAccountRequestSchema;
-    UserDeleteAccountCommand.Response = schemas_1.DeleteAccountResponseSchema;
-    UserDeleteAccountCommand.URL = users_paths_1.USERS_API_PATHS.ME;
+    UserDeleteAccountCommand.Request = zod_1.z.object({});
+    UserDeleteAccountCommand.Response = common_schemas_1.EmptyResponseSchema;
+    UserDeleteAccountCommand.PATH = users_routes_1.USERS_ROUTES.ME;
+    UserDeleteAccountCommand.URL = rest_api_1.REST_API.V1.USERS.ME;
     UserDeleteAccountCommand.METHOD = http_method_1.HttpMethod.DELETE;
 })(UserDeleteAccountCommand || (exports.UserDeleteAccountCommand = UserDeleteAccountCommand = {}));