@veruna/api-contracts 1.0.13 → 1.0.15

package/build/v1/seo-pages/admin/commands/update-page.command.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminSeoPageUpdatePageCommand {
+    const Request: z.ZodObject<{
+        metaTitle: z.ZodOptional<z.ZodString>;
+        metaDescription: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        alias: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<typeof import("../../schemas").PageType>>;
+    }, z.core.$strip>;
+    const Response: z.ZodObject<{
+        uuid: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        content: z.ZodString;
+        alias: z.ZodString;
+        type: z.ZodEnum<typeof import("../../schemas").PageType>;
+        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/seo-pages/admin/commands/update-page.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminSeoPageUpdatePageCommand = void 0;
+const schemas_1 = require("../../schemas");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+var AdminSeoPageUpdatePageCommand;
+(function (AdminSeoPageUpdatePageCommand) {
+    AdminSeoPageUpdatePageCommand.Request = schemas_1.UpdatePageRequestSchema;
+    AdminSeoPageUpdatePageCommand.Response = schemas_1.PageResponseSchema;
+    AdminSeoPageUpdatePageCommand.URL = (uuid) => rest_api_1.REST_API.V1.SEO_PAGES.ADMIN.UPDATE(uuid);
+    AdminSeoPageUpdatePageCommand.METHOD = http_method_1.HttpMethod.PATCH;
+})(AdminSeoPageUpdatePageCommand || (exports.AdminSeoPageUpdatePageCommand = AdminSeoPageUpdatePageCommand = {}));

package/build/v1/seo-pages/admin/queries/get-page.query.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminSeoPageGetPageQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{
+        uuid: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        content: z.ZodString;
+        alias: z.ZodString;
+        type: z.ZodEnum<typeof import("../../schemas").PageType>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+    const URL: (uuid: string) => string;
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/seo-pages/admin/queries/get-page.query.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminSeoPageGetPageQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+var AdminSeoPageGetPageQuery;
+(function (AdminSeoPageGetPageQuery) {
+    AdminSeoPageGetPageQuery.Request = zod_1.z.object({});
+    AdminSeoPageGetPageQuery.Response = schemas_1.PageResponseSchema;
+    AdminSeoPageGetPageQuery.URL = (uuid) => rest_api_1.REST_API.V1.SEO_PAGES.ADMIN.GET_BY_UUID(uuid);
+    AdminSeoPageGetPageQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AdminSeoPageGetPageQuery || (exports.AdminSeoPageGetPageQuery = AdminSeoPageGetPageQuery = {}));

package/build/v1/seo-pages/admin/queries/get-pages.query.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace AdminSeoPageGetPagesQuery {
+    const Request: z.ZodObject<{
+        page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+        limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    }, z.core.$strip>;
+    const Response: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            metaTitle: z.ZodString;
+            metaDescription: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodString;
+            content: z.ZodString;
+            alias: z.ZodString;
+            type: z.ZodEnum<typeof import("../../schemas").PageType>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        meta: z.ZodObject<{
+            page: z.ZodNumber;
+            limit: z.ZodNumber;
+            total: z.ZodNumber;
+            totalPages: z.ZodNumber;
+            hasNext: z.ZodBoolean;
+            hasPrev: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    const URL: "/api/v1/admin/seo-pages/";
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/seo-pages/admin/queries/get-pages.query.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminSeoPageGetPagesQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const pagination_schema_1 = require("../../../../shared/pagination.schema");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+const PagesListAdminResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(schemas_1.PageResponseSchema),
+    meta: pagination_schema_1.PaginationMetaSchema,
+});
+var AdminSeoPageGetPagesQuery;
+(function (AdminSeoPageGetPagesQuery) {
+    AdminSeoPageGetPagesQuery.Request = pagination_schema_1.PaginationQuerySchema;
+    AdminSeoPageGetPagesQuery.Response = PagesListAdminResponseSchema;
+    AdminSeoPageGetPagesQuery.URL = rest_api_1.REST_API.V1.SEO_PAGES.ADMIN.GET_ALL;
+    AdminSeoPageGetPagesQuery.METHOD = http_method_1.HttpMethod.GET;
+})(AdminSeoPageGetPagesQuery || (exports.AdminSeoPageGetPagesQuery = AdminSeoPageGetPagesQuery = {}));

package/build/v1/seo-pages/admin/queries/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Centralized exports for SEO Pages admin queries
+ */
+export { AdminSeoPageGetPagesQuery } from './get-pages.query';
+export { AdminSeoPageGetPageQuery } from './get-page.query';

package/build/v1/seo-pages/admin/queries/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminSeoPageGetPageQuery = exports.AdminSeoPageGetPagesQuery = void 0;
+/**
+ * Centralized exports for SEO Pages admin queries
+ */
+var get_pages_query_1 = require("./get-pages.query");
+Object.defineProperty(exports, "AdminSeoPageGetPagesQuery", { enumerable: true, get: function () { return get_pages_query_1.AdminSeoPageGetPagesQuery; } });
+var get_page_query_1 = require("./get-page.query");
+Object.defineProperty(exports, "AdminSeoPageGetPageQuery", { enumerable: true, get: function () { return get_page_query_1.AdminSeoPageGetPageQuery; } });

package/build/v1/seo-pages/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Centralized exports for SEO Pages contracts
+ */
+export { SeoPageErrorCode, SEO_PAGE_ERRORS } from './seo-pages.errors';
+export * from './schemas';
+export * from './admin/commands';
+export * from './admin/queries';
+export * from './public/queries';

package/build/v1/seo-pages/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Centralized exports for SEO Pages contracts
+ */
+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 });
+exports.SEO_PAGE_ERRORS = exports.SeoPageErrorCode = void 0;
+// Errors
+var seo_pages_errors_1 = require("./seo-pages.errors");
+Object.defineProperty(exports, "SeoPageErrorCode", { enumerable: true, get: function () { return seo_pages_errors_1.SeoPageErrorCode; } });
+Object.defineProperty(exports, "SEO_PAGE_ERRORS", { enumerable: true, get: function () { return seo_pages_errors_1.SEO_PAGE_ERRORS; } });
+// Schemas
+__exportStar(require("./schemas"), exports);
+// Admin Commands
+__exportStar(require("./admin/commands"), exports);
+// Admin Queries
+__exportStar(require("./admin/queries"), exports);
+// Public Queries
+__exportStar(require("./public/queries"), exports);

package/build/v1/seo-pages/public/queries/get-page-by-alias.query.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { HttpMethod } from '../../../../shared/http-method';
+export declare namespace SeoPageGetPageByAliasQuery {
+    const Request: z.ZodObject<{}, z.core.$strip>;
+    const Response: z.ZodObject<{
+        uuid: z.ZodString;
+        metaTitle: z.ZodString;
+        metaDescription: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        content: z.ZodString;
+        alias: z.ZodString;
+        type: z.ZodEnum<typeof import("../../schemas").PageType>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+    const URL: (alias: string) => string;
+    const METHOD = HttpMethod.GET;
+    type RequestType = z.infer<typeof Request>;
+    type ResponseType = z.infer<typeof Response>;
+}

package/build/v1/seo-pages/public/queries/get-page-by-alias.query.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeoPageGetPageByAliasQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const rest_api_1 = require("../../../../rest-api");
+const http_method_1 = require("../../../../shared/http-method");
+var SeoPageGetPageByAliasQuery;
+(function (SeoPageGetPageByAliasQuery) {
+    SeoPageGetPageByAliasQuery.Request = zod_1.z.object({});
+    SeoPageGetPageByAliasQuery.Response = schemas_1.PageResponseSchema;
+    SeoPageGetPageByAliasQuery.URL = (alias) => rest_api_1.REST_API.V1.SEO_PAGES.PUBLIC.GET_BY_ALIAS(alias);
+    SeoPageGetPageByAliasQuery.METHOD = http_method_1.HttpMethod.GET;
+})(SeoPageGetPageByAliasQuery || (exports.SeoPageGetPageByAliasQuery = SeoPageGetPageByAliasQuery = {}));

package/build/v1/seo-pages/public/queries/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Centralized exports for SEO Pages public queries
+ */
+export { SeoPageGetPageByAliasQuery } from './get-page-by-alias.query';

package/build/v1/seo-pages/public/queries/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeoPageGetPageByAliasQuery = void 0;
+/**
+ * Centralized exports for SEO Pages public queries
+ */
+var get_page_by_alias_query_1 = require("./get-page-by-alias.query");
+Object.defineProperty(exports, "SeoPageGetPageByAliasQuery", { enumerable: true, get: function () { return get_page_by_alias_query_1.SeoPageGetPageByAliasQuery; } });

package/build/v1/seo-pages/schemas/create-page-request.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { PageType } from './page-type.enum';
+/**
+ * Create SEO Page Request Schema
+ */
+export declare const CreatePageRequestSchema: z.ZodObject<{
+    metaTitle: z.ZodString;
+    metaDescription: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    content: z.ZodString;
+    alias: z.ZodString;
+    type: z.ZodEnum<typeof PageType>;
+}, z.core.$strip>;

package/build/v1/seo-pages/schemas/create-page-request.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePageRequestSchema = void 0;
+const zod_1 = require("zod");
+const shared_1 = require("../../../shared");
+const page_type_enum_1 = require("./page-type.enum");
+/**
+ * Create SEO Page Request Schema
+ */
+exports.CreatePageRequestSchema = zod_1.z.object({
+    metaTitle: zod_1.z.string().min(1).max(100),
+    metaDescription: zod_1.z.string().min(1).max(200),
+    title: zod_1.z.string().min(1).max(300),
+    description: zod_1.z.string().min(1),
+    content: zod_1.z.string().min(1),
+    alias: zod_1.z.string().min(1).max(200).regex(shared_1.SLUG_REGEX),
+    type: zod_1.z.nativeEnum(page_type_enum_1.PageType),
+});

package/build/v1/seo-pages/schemas/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Centralized exports for SEO Pages schemas
+ */
+export { PageType } from './page-type.enum';
+export { PageResponseSchema } from './page-response.schema';
+export { CreatePageRequestSchema } from './create-page-request.schema';
+export { UpdatePageRequestSchema } from './update-page-request.schema';

package/build/v1/seo-pages/schemas/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePageRequestSchema = exports.CreatePageRequestSchema = exports.PageResponseSchema = exports.PageType = void 0;
+/**
+ * Centralized exports for SEO Pages schemas
+ */
+var page_type_enum_1 = require("./page-type.enum");
+Object.defineProperty(exports, "PageType", { enumerable: true, get: function () { return page_type_enum_1.PageType; } });
+var page_response_schema_1 = require("./page-response.schema");
+Object.defineProperty(exports, "PageResponseSchema", { enumerable: true, get: function () { return page_response_schema_1.PageResponseSchema; } });
+var create_page_request_schema_1 = require("./create-page-request.schema");
+Object.defineProperty(exports, "CreatePageRequestSchema", { enumerable: true, get: function () { return create_page_request_schema_1.CreatePageRequestSchema; } });
+var update_page_request_schema_1 = require("./update-page-request.schema");
+Object.defineProperty(exports, "UpdatePageRequestSchema", { enumerable: true, get: function () { return update_page_request_schema_1.UpdatePageRequestSchema; } });

package/build/v1/seo-pages/schemas/page-response.schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { PageType } from './page-type.enum';
+/**
+ * SEO Page Response Schema
+ */
+export declare const PageResponseSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    metaTitle: z.ZodString;
+    metaDescription: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    content: z.ZodString;
+    alias: z.ZodString;
+    type: z.ZodEnum<typeof PageType>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;

package/build/v1/seo-pages/schemas/page-response.schema.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageResponseSchema = void 0;
+const zod_1 = require("zod");
+const regex_1 = require("../../../shared/regex");
+const page_type_enum_1 = require("./page-type.enum");
+/**
+ * SEO Page Response Schema
+ */
+exports.PageResponseSchema = zod_1.z.object({
+    uuid: zod_1.z.string().regex(regex_1.UUID_REGEX),
+    metaTitle: zod_1.z.string(),
+    metaDescription: zod_1.z.string(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    content: zod_1.z.string(),
+    alias: zod_1.z.string(),
+    type: zod_1.z.nativeEnum(page_type_enum_1.PageType),
+    createdAt: zod_1.z.string().regex(regex_1.DATETIME_REGEX),
+    updatedAt: zod_1.z.string().regex(regex_1.DATETIME_REGEX),
+});

package/build/v1/seo-pages/schemas/page-type.enum.d.ts

@@ -0,0 +1,8 @@
+/**
+ * SEO Page Type
+ */
+export declare enum PageType {
+    CATEGORY = "category",
+    AI_MODEL = "ai_model",
+    META = "meta"
+}

package/build/v1/seo-pages/schemas/page-type.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageType = void 0;
+/**
+ * SEO Page Type
+ */
+var PageType;
+(function (PageType) {
+    PageType["CATEGORY"] = "category";
+    PageType["AI_MODEL"] = "ai_model";
+    PageType["META"] = "meta";
+})(PageType || (exports.PageType = PageType = {}));

package/build/v1/seo-pages/schemas/update-page-request.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { PageType } from './page-type.enum';
+/**
+ * Update SEO Page Request Schema
+ */
+export declare const UpdatePageRequestSchema: z.ZodObject<{
+    metaTitle: z.ZodOptional<z.ZodString>;
+    metaDescription: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    alias: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<typeof PageType>>;
+}, z.core.$strip>;

package/build/v1/seo-pages/schemas/update-page-request.schema.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePageRequestSchema = void 0;
+const zod_1 = require("zod");
+const shared_1 = require("../../../shared");
+const page_type_enum_1 = require("./page-type.enum");
+/**
+ * Update SEO Page Request Schema
+ */
+exports.UpdatePageRequestSchema = zod_1.z.object({
+    metaTitle: zod_1.z.string().min(1).max(100).optional(),
+    metaDescription: zod_1.z.string().min(1).max(200).optional(),
+    title: zod_1.z.string().min(1).max(300).optional(),
+    description: zod_1.z.string().min(1).optional(),
+    content: zod_1.z.string().min(1).optional(),
+    alias: zod_1.z.string().min(1).max(200).regex(shared_1.SLUG_REGEX).optional(),
+    type: zod_1.z.nativeEnum(page_type_enum_1.PageType).optional(),
+});

package/build/v1/seo-pages/seo-pages.errors.d.ts

@@ -0,0 +1,11 @@
+import { ErrorMetadata } from '../../shared';
+export declare enum SeoPageErrorCode {
+    PAGE_NOT_FOUND = "PAGE_NOT_FOUND",
+    PAGE_ALIAS_ALREADY_EXISTS = "PAGE_ALIAS_ALREADY_EXISTS",
+    INVALID_PAGE_TYPE = "INVALID_PAGE_TYPE",
+    PAGE_CREATION_FAILED = "PAGE_CREATION_FAILED",
+    PAGE_UPDATE_FAILED = "PAGE_UPDATE_FAILED",
+    PAGE_DELETE_FAILED = "PAGE_DELETE_FAILED",
+    INVALID_ALIAS_FORMAT = "INVALID_ALIAS_FORMAT"
+}
+export declare const SEO_PAGE_ERRORS: Record<SeoPageErrorCode, ErrorMetadata>;

package/build/v1/seo-pages/seo-pages.errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEO_PAGE_ERRORS = exports.SeoPageErrorCode = void 0;
+var SeoPageErrorCode;
+(function (SeoPageErrorCode) {
+    SeoPageErrorCode["PAGE_NOT_FOUND"] = "PAGE_NOT_FOUND";
+    SeoPageErrorCode["PAGE_ALIAS_ALREADY_EXISTS"] = "PAGE_ALIAS_ALREADY_EXISTS";
+    SeoPageErrorCode["INVALID_PAGE_TYPE"] = "INVALID_PAGE_TYPE";
+    SeoPageErrorCode["PAGE_CREATION_FAILED"] = "PAGE_CREATION_FAILED";
+    SeoPageErrorCode["PAGE_UPDATE_FAILED"] = "PAGE_UPDATE_FAILED";
+    SeoPageErrorCode["PAGE_DELETE_FAILED"] = "PAGE_DELETE_FAILED";
+    SeoPageErrorCode["INVALID_ALIAS_FORMAT"] = "INVALID_ALIAS_FORMAT";
+})(SeoPageErrorCode || (exports.SeoPageErrorCode = SeoPageErrorCode = {}));
+exports.SEO_PAGE_ERRORS = {
+    [SeoPageErrorCode.PAGE_NOT_FOUND]: {
+        code: SeoPageErrorCode.PAGE_NOT_FOUND,
+        statusCode: 404,
+    },
+    [SeoPageErrorCode.PAGE_ALIAS_ALREADY_EXISTS]: {
+        code: SeoPageErrorCode.PAGE_ALIAS_ALREADY_EXISTS,
+        statusCode: 409,
+    },
+    [SeoPageErrorCode.INVALID_PAGE_TYPE]: {
+        code: SeoPageErrorCode.INVALID_PAGE_TYPE,
+        statusCode: 400,
+    },
+    [SeoPageErrorCode.PAGE_CREATION_FAILED]: {
+        code: SeoPageErrorCode.PAGE_CREATION_FAILED,
+        statusCode: 500,
+    },
+    [SeoPageErrorCode.PAGE_UPDATE_FAILED]: {
+        code: SeoPageErrorCode.PAGE_UPDATE_FAILED,
+        statusCode: 500,
+    },
+    [SeoPageErrorCode.PAGE_DELETE_FAILED]: {
+        code: SeoPageErrorCode.PAGE_DELETE_FAILED,
+        statusCode: 500,
+    },
+    [SeoPageErrorCode.INVALID_ALIAS_FORMAT]: {
+        code: SeoPageErrorCode.INVALID_ALIAS_FORMAT,
+        statusCode: 400,
+    },
+};

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

@@ -1,7 +1,3 @@
+export * from './commands';
 export * from './schemas';
-export * from './unregistered-users.types';
-export * from './unregistered-users.paths';
 export * from './unregistered-users.errors';
-export * from './commands';
-export { UNREG_USERS_CONTROLLER } from '../../controllers';
-export { UNREG_USERS_ROUTES } from '../../routes';

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

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

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

@@ -1,15 +1,14 @@
-/**
- * Unregistered User error codes
- */
+import { ErrorMetadata } from '../../shared/error-metadata';
 export declare enum UnregUserErrorCode {
-    /** Invalid JWT token */
     INVALID_TOKEN = "INVALID_TOKEN",
-    /** Token expired or invalidated */
     TOKEN_EXPIRED = "TOKEN_EXPIRED",
-    /** IP mismatch - token bound to different IP */
     IP_MISMATCH = "IP_MISMATCH",
-    /** User marked as fraud */
     FRAUD_DETECTED = "FRAUD_DETECTED",
-    /** Token version mismatch */
-    TOKEN_VERSION_MISMATCH = "TOKEN_VERSION_MISMATCH"
+    TOKEN_VERSION_MISMATCH = "TOKEN_VERSION_MISMATCH",
+    CANNOT_RESET_FRAUD_USER = "CANNOT_RESET_FRAUD_USER",
+    USER_ALREADY_FRAUD = "USER_ALREADY_FRAUD",
+    USER_ALREADY_MIGRATED = "USER_ALREADY_MIGRATED",
+    CANNOT_MIGRATE_FRAUD_USER = "CANNOT_MIGRATE_FRAUD_USER",
+    INVALID_USER_DATA = "INVALID_USER_DATA"
 }
+export declare const UNREG_USER_ERRORS: Record<UnregUserErrorCode, ErrorMetadata>;

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

@@ -1,19 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnregUserErrorCode = void 0;
-/**
- * Unregistered User error codes
- */
+exports.UNREG_USER_ERRORS = exports.UnregUserErrorCode = void 0;
 var UnregUserErrorCode;
 (function (UnregUserErrorCode) {
-    /** Invalid JWT token */
     UnregUserErrorCode["INVALID_TOKEN"] = "INVALID_TOKEN";
-    /** Token expired or invalidated */
     UnregUserErrorCode["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
-    /** IP mismatch - token bound to different IP */
     UnregUserErrorCode["IP_MISMATCH"] = "IP_MISMATCH";
-    /** User marked as fraud */
     UnregUserErrorCode["FRAUD_DETECTED"] = "FRAUD_DETECTED";
-    /** Token version mismatch */
     UnregUserErrorCode["TOKEN_VERSION_MISMATCH"] = "TOKEN_VERSION_MISMATCH";
+    UnregUserErrorCode["CANNOT_RESET_FRAUD_USER"] = "CANNOT_RESET_FRAUD_USER";
+    UnregUserErrorCode["USER_ALREADY_FRAUD"] = "USER_ALREADY_FRAUD";
+    UnregUserErrorCode["USER_ALREADY_MIGRATED"] = "USER_ALREADY_MIGRATED";
+    UnregUserErrorCode["CANNOT_MIGRATE_FRAUD_USER"] = "CANNOT_MIGRATE_FRAUD_USER";
+    UnregUserErrorCode["INVALID_USER_DATA"] = "INVALID_USER_DATA";
 })(UnregUserErrorCode || (exports.UnregUserErrorCode = UnregUserErrorCode = {}));
+exports.UNREG_USER_ERRORS = {
+    [UnregUserErrorCode.INVALID_TOKEN]: { code: UnregUserErrorCode.INVALID_TOKEN, statusCode: 401 },
+    [UnregUserErrorCode.TOKEN_EXPIRED]: { code: UnregUserErrorCode.TOKEN_EXPIRED, statusCode: 401 },
+    [UnregUserErrorCode.IP_MISMATCH]: { code: UnregUserErrorCode.IP_MISMATCH, statusCode: 403 },
+    [UnregUserErrorCode.FRAUD_DETECTED]: { code: UnregUserErrorCode.FRAUD_DETECTED, statusCode: 403 },
+    [UnregUserErrorCode.TOKEN_VERSION_MISMATCH]: { code: UnregUserErrorCode.TOKEN_VERSION_MISMATCH, statusCode: 401 },
+    [UnregUserErrorCode.CANNOT_RESET_FRAUD_USER]: { code: UnregUserErrorCode.CANNOT_RESET_FRAUD_USER, statusCode: 400 },
+    [UnregUserErrorCode.USER_ALREADY_FRAUD]: { code: UnregUserErrorCode.USER_ALREADY_FRAUD, statusCode: 400 },
+    [UnregUserErrorCode.USER_ALREADY_MIGRATED]: { code: UnregUserErrorCode.USER_ALREADY_MIGRATED, statusCode: 400 },
+    [UnregUserErrorCode.CANNOT_MIGRATE_FRAUD_USER]: { code: UnregUserErrorCode.CANNOT_MIGRATE_FRAUD_USER, statusCode: 400 },
+    [UnregUserErrorCode.INVALID_USER_DATA]: { code: UnregUserErrorCode.INVALID_USER_DATA, statusCode: 400 },
+};

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

@@ -1,6 +1,5 @@
 export * from './schemas';
-export * from './users.types';
-export * from './users.paths';
+export * from './users.errors';
 export * from './commands';
 export * from './queries';
 export { USERS_CONTROLLER } from '../../controllers';

package/build/v1/users/index.js

@@ -16,8 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.USERS_ROUTES = exports.USERS_CONTROLLER = void 0;
 __exportStar(require("./schemas"), exports);
-__exportStar(require("./users.types"), exports);
-__exportStar(require("./users.paths"), exports);
+__exportStar(require("./users.errors"), exports);
 __exportStar(require("./commands"), exports);
 __exportStar(require("./queries"), exports);
 // Re-export from centralized locations

package/build/v1/users/users.errors.d.ts

@@ -0,0 +1,18 @@
+import { ErrorMetadata } from '../../shared';
+export declare enum UserErrorCode {
+    USER_NOT_FOUND = "USER_NOT_FOUND",
+    INCORRECT_PASSWORD = "INCORRECT_PASSWORD",
+    USER_DELETED = "USER_DELETED",
+    EMAIL_ALREADY_EXISTS = "EMAIL_ALREADY_EXISTS",
+    INVALID_EMAIL_FORMAT = "INVALID_EMAIL_FORMAT",
+    INVALID_PASSWORD_FORMAT = "INVALID_PASSWORD_FORMAT",
+    WEAK_PASSWORD = "WEAK_PASSWORD",
+    INVALID_USER_ROLE = "INVALID_USER_ROLE",
+    PASSWORD_MISMATCH = "PASSWORD_MISMATCH",
+    SAME_PASSWORD = "SAME_PASSWORD",
+    INVALID_USER_DATA = "INVALID_USER_DATA",
+    USER_CREATION_FAILED = "USER_CREATION_FAILED",
+    USER_UPDATE_FAILED = "USER_UPDATE_FAILED",
+    PASSWORD_CHANGE_FAILED = "PASSWORD_CHANGE_FAILED"
+}
+export declare const USER_ERRORS: Record<UserErrorCode, ErrorMetadata>;