@veruna/api-contracts 1.0.4 → 1.0.7

package/build/index.d.ts

@@ -1,6 +1,4 @@
-export * from './shared/http-method';
-export * from './shared/regex';
-export * from './v1/auth';
-export * from './v1/users';
-export * from './v1/unregistered-users';
+export * from './shared';
+export * from './v1';
 export * from './locales';
+export * from './utils';

package/build/index.js

@@ -15,9 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // Export all contracts
-__exportStar(require("./shared/http-method"), exports);
-__exportStar(require("./shared/regex"), exports);
-__exportStar(require("./v1/auth"), exports);
-__exportStar(require("./v1/users"), exports);
-__exportStar(require("./v1/unregistered-users"), exports);
+__exportStar(require("./shared"), exports);
+__exportStar(require("./v1"), exports);
 __exportStar(require("./locales"), exports);
+__exportStar(require("./utils"), exports);

package/build/rest-api.d.ts

@@ -18,6 +18,9 @@ export declare const REST_API: {
             readonly ME_MARKETING_CONSENT: "/api/v1/users/me/marketing-consent";
             readonly ME_PASSWORD: "/api/v1/users/me/password";
         };
+        readonly UNREG: {
+            readonly AUTHENTICATE: "/api/v1/unreg/";
+        };
         readonly BLOG: {
             readonly ADMIN: {
                 readonly CATEGORIES: {

package/build/rest-api.js

@@ -11,6 +11,8 @@ const controllers_2 = require("./v1/auth/controllers");
 const auth_routes_1 = require("./v1/auth/routes/auth.routes");
 const controllers_3 = require("./v1/users/controllers");
 const users_routes_1 = require("./v1/users/routes/users.routes");
+const controllers_4 = require("./v1/unregistered-users/controllers");
+const unreg_users_routes_1 = require("./v1/unregistered-users/routes/unreg-users.routes");
 exports.ROOT = '/api';
 exports.REST_API = {
     V1: {
@@ -29,6 +31,10 @@ exports.REST_API = {
             ME_MARKETING_CONSENT: `${exports.ROOT}/${controllers_3.USERS_CONTROLLER}/${users_routes_1.USERS_ROUTES.ME_MARKETING_CONSENT}`,
             ME_PASSWORD: `${exports.ROOT}/${controllers_3.USERS_CONTROLLER}/${users_routes_1.USERS_ROUTES.ME_PASSWORD}`,
         },
+        // Unregistered Users
+        UNREG: {
+            AUTHENTICATE: `${exports.ROOT}/${controllers_4.UNREG_USERS_CONTROLLER}/${unreg_users_routes_1.UNREG_USERS_ROUTES.AUTHENTICATE}`,
+        },
         // Blog module
         BLOG: {
             ADMIN: {

package/build/shared/error-response.schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/**
+ * Base error response schema
+ */
+export declare const ErrorResponseSchema: z.ZodObject<{
+    statusCode: z.ZodNumber;
+    message: z.ZodString;
+    error: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+/**
+ * Validation error response schema
+ */
+export declare const ValidationErrorResponseSchema: z.ZodObject<{
+    statusCode: z.ZodNumber;
+    message: z.ZodString;
+    error: z.ZodString;
+    timestamp: z.ZodString;
+    code: z.ZodLiteral<"VALIDATION_ERROR">;
+    details: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ValidationErrorResponse = z.infer<typeof ValidationErrorResponseSchema>;

package/build/shared/error-response.schema.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationErrorResponseSchema = exports.ErrorResponseSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Base error response schema
+ */
+exports.ErrorResponseSchema = zod_1.z.object({
+    statusCode: zod_1.z.number(),
+    message: zod_1.z.string(),
+    error: zod_1.z.string(),
+    code: zod_1.z.string().optional(),
+    details: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    timestamp: zod_1.z.string(),
+});
+/**
+ * Validation error response schema
+ */
+exports.ValidationErrorResponseSchema = exports.ErrorResponseSchema.extend({
+    code: zod_1.z.literal('VALIDATION_ERROR'),
+    details: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())),
+});

package/build/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './error-response.schema';
+export * from './pagination.schema';

package/build/shared/index.js

@@ -0,0 +1,18 @@
+"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("./error-response.schema"), exports);
+__exportStar(require("./pagination.schema"), exports);

package/build/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './path-builder';

package/build/utils/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("./path-builder"), exports);

package/build/utils/path-builder.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Build URL path with parameters
+ * @example
+ * buildPath('/users/:id', { id: '123' }) // '/users/123'
+ * buildPath('/users/:id/posts/:postId', { id: '1', postId: '2' }) // '/users/1/posts/2'
+ */
+export declare function buildPath(pattern: string, params?: Record<string, string | number>): string;
+/**
+ * Build URL with query parameters
+ * @example
+ * buildUrl('/users', { page: 1, limit: 10 }) // '/users?page=1&limit=10'
+ */
+export declare function buildUrl(path: string, queryParams?: Record<string, string | number | boolean | undefined>): string;
+/**
+ * Build full URL with path params and query params
+ * @example
+ * buildFullUrl('/users/:id', { id: '123' }, { include: 'posts' })
+ * // '/users/123?include=posts'
+ */
+export declare function buildFullUrl(pattern: string, pathParams?: Record<string, string | number>, queryParams?: Record<string, string | number | boolean | undefined>): string;

package/build/utils/path-builder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPath = buildPath;
+exports.buildUrl = buildUrl;
+exports.buildFullUrl = buildFullUrl;
+/**
+ * Build URL path with parameters
+ * @example
+ * buildPath('/users/:id', { id: '123' }) // '/users/123'
+ * buildPath('/users/:id/posts/:postId', { id: '1', postId: '2' }) // '/users/1/posts/2'
+ */
+function buildPath(pattern, params) {
+    if (!params) {
+        return pattern;
+    }
+    let path = pattern;
+    for (const [key, value] of Object.entries(params)) {
+        path = path.replace(`:${key}`, String(value));
+    }
+    return path;
+}
+/**
+ * Build URL with query parameters
+ * @example
+ * buildUrl('/users', { page: 1, limit: 10 }) // '/users?page=1&limit=10'
+ */
+function buildUrl(path, queryParams) {
+    if (!queryParams || Object.keys(queryParams).length === 0) {
+        return path;
+    }
+    const query = Object.entries(queryParams)
+        .filter(([_, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+        .join('&');
+    return query ? `${path}?${query}` : path;
+}
+/**
+ * Build full URL with path params and query params
+ * @example
+ * buildFullUrl('/users/:id', { id: '123' }, { include: 'posts' })
+ * // '/users/123?include=posts'
+ */
+function buildFullUrl(pattern, pathParams, queryParams) {
+    const path = buildPath(pattern, pathParams);
+    return buildUrl(path, queryParams);
+}

package/build/v1/auth/commands/delete-session.command.d.ts

@@ -2,11 +2,9 @@ import { z } from 'zod';
 import { HttpMethod } from '../../../shared/http-method';
 export declare namespace AuthDeleteSessionCommand {
     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: (sessionId: string) => string;
+    const Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: "sessions/:id";
+    const URL: (id: string) => string;
     const METHOD = HttpMethod.DELETE;
     type RequestType = z.infer<typeof Request>;
     type ResponseType = z.infer<typeof Response>;

package/build/v1/auth/commands/delete-session.command.js

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthDeleteSessionCommand = void 0;
 const zod_1 = require("zod");
-const auth_paths_1 = require("../auth.paths");
+const auth_routes_1 = require("../routes/auth.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 AuthDeleteSessionCommand;
 (function (AuthDeleteSessionCommand) {
-    AuthDeleteSessionCommand.Request = zod_1.z.object({}); // Session ID in URL params
-    AuthDeleteSessionCommand.Response = zod_1.z.union([common_schemas_1.EmptyResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    AuthDeleteSessionCommand.URL = (sessionId) => auth_paths_1.AUTH_API_PATHS.SESSION_BY_ID(sessionId);
+    // Request/Response
+    AuthDeleteSessionCommand.Request = zod_1.z.object({});
+    AuthDeleteSessionCommand.Response = common_schemas_1.EmptyResponseSchema;
+    // Path/URL/Method
+    AuthDeleteSessionCommand.PATH = auth_routes_1.AUTH_ROUTES.SESSION_BY_ID;
+    AuthDeleteSessionCommand.URL = (id) => rest_api_1.REST_API.V1.AUTH.SESSION_BY_ID(id);
     AuthDeleteSessionCommand.METHOD = http_method_1.HttpMethod.DELETE;
 })(AuthDeleteSessionCommand || (exports.AuthDeleteSessionCommand = AuthDeleteSessionCommand = {}));

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

@@ -5,7 +5,7 @@ export declare namespace AuthLoginCommand {
         email: z.ZodString;
         password: z.ZodString;
     }, z.core.$strip>;
-    const Response: z.ZodUnion<readonly [z.ZodObject<{
+    const Response: z.ZodObject<{
         user: z.ZodObject<{
             uuid: z.ZodString;
             email: z.ZodString;
@@ -23,10 +23,8 @@ export declare namespace AuthLoginCommand {
             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>]>;
+    }, z.core.$strip>;
+    const PATH: "login";
     const URL: "/api/v1/auth/login";
     const METHOD = HttpMethod.POST;
     type RequestType = z.infer<typeof Request>;

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

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthLoginCommand = void 0;
-const zod_1 = require("zod");
 const login_request_schema_1 = require("../schemas/login-request.schema");
 const auth_response_schema_1 = require("../schemas/auth-response.schema");
-const auth_paths_1 = require("../auth.paths");
+const auth_routes_1 = require("../routes/auth.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 AuthLoginCommand;
 (function (AuthLoginCommand) {
+    // Request/Response
     AuthLoginCommand.Request = login_request_schema_1.LoginRequestSchema;
-    AuthLoginCommand.Response = zod_1.z.union([auth_response_schema_1.AuthResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    AuthLoginCommand.URL = auth_paths_1.AUTH_API_PATHS.LOGIN;
+    AuthLoginCommand.Response = auth_response_schema_1.AuthResponseSchema;
+    // Path/URL/Method
+    AuthLoginCommand.PATH = auth_routes_1.AUTH_ROUTES.LOGIN;
+    AuthLoginCommand.URL = rest_api_1.REST_API.V1.AUTH.LOGIN;
     AuthLoginCommand.METHOD = http_method_1.HttpMethod.POST;
 })(AuthLoginCommand || (exports.AuthLoginCommand = AuthLoginCommand = {}));

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

@@ -2,10 +2,8 @@ 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 Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: "logout-all";
     const URL: "/api/v1/auth/logout-all";
     const METHOD = HttpMethod.POST;
     type RequestType = z.infer<typeof Request>;

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

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthLogoutAllCommand = void 0;
 const zod_1 = require("zod");
-const auth_paths_1 = require("../auth.paths");
+const auth_routes_1 = require("../routes/auth.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 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;
+    // Request/Response
+    AuthLogoutAllCommand.Request = zod_1.z.object({});
+    AuthLogoutAllCommand.Response = common_schemas_1.EmptyResponseSchema;
+    // Path/URL/Method
+    AuthLogoutAllCommand.PATH = auth_routes_1.AUTH_ROUTES.LOGOUT_ALL;
+    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

@@ -2,10 +2,8 @@ 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 Response: z.ZodObject<{}, z.core.$strip>;
+    const PATH: "logout";
     const URL: "/api/v1/auth/logout";
     const METHOD = HttpMethod.POST;
     type RequestType = z.infer<typeof Request>;

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

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthLogoutCommand = void 0;
 const zod_1 = require("zod");
-const auth_paths_1 = require("../auth.paths");
+const auth_routes_1 = require("../routes/auth.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 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;
+    // Request/Response
+    AuthLogoutCommand.Request = zod_1.z.object({});
+    AuthLogoutCommand.Response = common_schemas_1.EmptyResponseSchema;
+    // Path/URL/Method
+    AuthLogoutCommand.PATH = auth_routes_1.AUTH_ROUTES.LOGOUT;
+    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/signup.command.d.ts

@@ -14,7 +14,7 @@ export declare namespace AuthSignupCommand {
             utmTerm: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
-    const Response: z.ZodUnion<readonly [z.ZodObject<{
+    const Response: z.ZodObject<{
         user: z.ZodObject<{
             uuid: z.ZodString;
             email: z.ZodString;
@@ -32,10 +32,8 @@ export declare namespace AuthSignupCommand {
             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>]>;
+    }, z.core.$strip>;
+    const PATH: "signup";
     const URL: "/api/v1/auth/signup";
     const METHOD = HttpMethod.POST;
     type RequestType = z.infer<typeof Request>;

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

@@ -1,16 +1,18 @@
 "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 auth_routes_1 = require("../routes/auth.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 AuthSignupCommand;
 (function (AuthSignupCommand) {
+    // Request/Response
     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.Response = auth_response_schema_1.AuthResponseSchema;
+    // Path/URL/Method
+    AuthSignupCommand.PATH = auth_routes_1.AUTH_ROUTES.SIGNUP;
+    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

@@ -2,5 +2,7 @@ export * from './schemas';
 export * from './auth.types';
 export * from './auth.paths';
 export * from './auth.errors';
+export * from './controllers';
+export * from './routes/auth.routes';
 export * from './commands';
 export * from './queries';

package/build/v1/auth/index.js

@@ -18,5 +18,7 @@ __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);

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

@@ -2,7 +2,7 @@ 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<{
+    const Response: z.ZodObject<{
         sessions: z.ZodArray<z.ZodObject<{
             uuid: z.ZodString;
             deviceName: z.ZodString;
@@ -11,10 +11,8 @@ export declare namespace AuthGetSessionsQuery {
             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>]>;
+    }, z.core.$strip>;
+    const PATH: "sessions";
     const URL: "/api/v1/auth/sessions";
     const METHOD = HttpMethod.GET;
     type RequestType = z.infer<typeof Request>;

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

@@ -3,13 +3,16 @@ 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 auth_routes_1 = require("../routes/auth.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 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;
+    // 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;
+    AuthGetSessionsQuery.URL = rest_api_1.REST_API.V1.AUTH.SESSIONS;
     AuthGetSessionsQuery.METHOD = http_method_1.HttpMethod.GET;
 })(AuthGetSessionsQuery || (exports.AuthGetSessionsQuery = AuthGetSessionsQuery = {}));

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

@@ -7,7 +7,7 @@ export declare namespace AdminBlogCreateCategoryCommand {
         order: z.ZodDefault<z.ZodNumber>;
         status: z.ZodDefault<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 AdminBlogCreateCategoryCommand {
         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: "";
     const URL: "/api/v1/admin/blog/categories/";
     const METHOD = HttpMethod.POST;

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

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

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

@@ -12,7 +12,7 @@ export declare namespace AdminBlogCreatePostCommand {
         categoryIds: z.ZodArray<z.ZodString>;
         status: z.ZodDefault<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 AdminBlogCreatePostCommand {
         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: "";
     const URL: "/api/v1/admin/blog/posts/";
     const METHOD = HttpMethod.POST;

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

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

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

@@ -2,10 +2,7 @@ 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 Response: z.ZodObject<{}, z.core.$strip>;
     const PATH: ":uuid";
     const URL: (uuid: string) => string;
     const METHOD = HttpMethod.DELETE;

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

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

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

@@ -2,10 +2,7 @@ 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 Response: z.ZodObject<{}, z.core.$strip>;
     const PATH: ":uuid";
     const URL: (uuid: string) => string;
     const METHOD = HttpMethod.DELETE;

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

@@ -8,10 +8,8 @@ const http_method_1 = require("../../../../shared/http-method");
 const common_schemas_1 = require("../../../../shared/common-schemas");
 var AdminBlogDeletePostCommand;
 (function (AdminBlogDeletePostCommand) {
-    // Request/Response
     AdminBlogDeletePostCommand.Request = zod_1.z.object({});
-    AdminBlogDeletePostCommand.Response = zod_1.z.union([common_schemas_1.EmptyResponseSchema, common_schemas_1.ErrorResponseSchema]);
-    // Path/URL/Method
+    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;