oneentry 1.0.136 → 1.0.137

package/dist/base/syncModules.js

@@ -136,44 +136,29 @@ class SyncModules {
         return result;
     }
     /**
-     * Generates intervals for a specific date based on a schedule.
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} schedule - The schedule defining the intervals.
-     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
-     * @param {any[]} schedule.times - The times for each interval.
-     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
+     * Common logic for processing schedule dates (weekly, monthly, or both).
+     * @param {Date} date - The date for which to process intervals.
+     * @param {object} config - Configuration for schedule repetition.
+     * @param {boolean} config.inEveryWeek - Whether to repeat weekly.
+     * @param {boolean} config.inEveryMonth - Whether to repeat monthly.
+     * @param {Function} processDate - Callback function to process each date.
      */
-    _generateIntervalsForDate(date, schedule, utcIntervals) {
+    _processScheduleDates(date, config, processDate) {
         // Handle weekly schedules
-        if (schedule.inEveryWeek && !schedule.inEveryMonth) {
+        if (config.inEveryWeek && !config.inEveryMonth) {
             let currentDate = new Date(date);
             // Calculate the last day of the current month
             const endOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
             while (currentDate <= endOfMonth) {
-                schedule.times.forEach((timeRange) => {
-                    const [startTime, endTime] = timeRange;
-                    const intervalStart = new Date(currentDate);
-                    intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                    const intervalEnd = new Date(currentDate);
-                    intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                    // Add JSON string to Set for uniqueness
-                    utcIntervals.add([
-                        intervalStart.toISOString(),
-                        intervalEnd.toISOString(),
-                    ]);
-                });
+                processDate(currentDate);
                 // Move to the next week
                 currentDate = this._addDays(currentDate, 7);
             }
         }
         // Handle monthly schedules
-        if (schedule.inEveryMonth && !schedule.inEveryWeek) {
-            // Начальная дата
+        if (config.inEveryMonth && !config.inEveryWeek) {
             const startDate = new Date(date);
-            // Определяем день месяца начальной даты
             const targetDayOfMonth = startDate.getUTCDate();
-            // Количество месяцев, на которые нужно повторить
             const numberOfMonths = 12;
             for (let i = 0; i < numberOfMonths; i++) {
                 const currentDate = new Date(startDate);
@@ -184,26 +169,13 @@ class SyncModules {
                 if (currentDate.getUTCMonth() !== (startDate.getUTCMonth() + i) % 12) {
                     continue; // Skip this month if exceeded
                 }
-                schedule.times.forEach((timeRange) => {
-                    const [startTime, endTime] = timeRange;
-                    const intervalStart = new Date(currentDate);
-                    intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                    const intervalEnd = new Date(currentDate);
-                    intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                    utcIntervals.add([
-                        intervalStart.toISOString(),
-                        intervalEnd.toISOString(),
-                    ]);
-                });
+                processDate(currentDate);
             }
         }
         // Handle both weekly and monthly schedules
-        if (schedule.inEveryMonth && schedule.inEveryWeek) {
-            // Initial date
+        if (config.inEveryMonth && config.inEveryWeek) {
             const startDate = new Date(date);
-            // Determine the day of the week
             const targetDayOfWeek = startDate.getUTCDay();
-            // Number of months to repeat
             const numberOfMonths = 12;
             for (let i = 0; i < numberOfMonths; i++) {
                 const currentDate = new Date(startDate);
@@ -216,30 +188,50 @@ class SyncModules {
                 // Iterate over all target days of the week in the current month
                 while (currentDate.getUTCMonth() ===
                     (startDate.getUTCMonth() + i) % 12) {
-                    schedule.times.forEach((timeRange) => {
-                        const [startTime, endTime] = timeRange;
-                        const intervalStart = new Date(currentDate);
-                        intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                        const intervalEnd = new Date(currentDate);
-                        intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                        utcIntervals.add([
-                            intervalStart.toISOString(),
-                            intervalEnd.toISOString(),
-                        ]);
-                    });
+                    processDate(currentDate);
                     // Move to the next week (same day of the week)
                     currentDate.setUTCDate(currentDate.getUTCDate() + 7);
                 }
             }
         }
     }
+    /**
+     * Generates intervals for a specific date based on a schedule.
+     * @param {Date} date - The date for which to generate intervals.
+     * @param {object} schedule - The schedule defining the intervals.
+     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
+     * @param {any[]} schedule.times - The times for each interval.
+     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
+     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
+     */
+    _generateIntervalsForDate(date, schedule, utcIntervals) {
+        this._processScheduleDates(date, schedule, (currentDate) => {
+            schedule.times.forEach((timeRange) => {
+                const [startTime, endTime] = timeRange;
+                const intervalStart = new Date(currentDate);
+                intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
+                const intervalEnd = new Date(currentDate);
+                intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
+                utcIntervals.add([
+                    intervalStart.toISOString(),
+                    intervalEnd.toISOString(),
+                ]);
+            });
+        });
+    }
     /**
      * Adds time intervals to schedules.
      * @param {any[]} schedules - The schedules to process.
      * @returns {any} Schedules with added time intervals.
      */
     _addTimeIntervalsToSchedules(schedules) {
-        schedules.forEach((scheduleGroup) => {
+        schedules === null || schedules === void 0 ? void 0 : schedules.forEach((scheduleGroup) => {
+            // Skip if scheduleGroup.values is not an array
+            if (!scheduleGroup ||
+                !scheduleGroup.values ||
+                !Array.isArray(scheduleGroup.values)) {
+                return;
+            }
             scheduleGroup.values.forEach((schedule) => {
                 const utcIntervals = new Set();
                 const startDate = new Date(schedule.dates[0]);
@@ -294,48 +286,7 @@ class SyncModules {
                 }
             });
         };
-        // Handle weekly schedules
-        if (interval.inEveryWeek && !interval.inEveryMonth) {
-            let currentDate = new Date(date);
-            const endOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
-            while (currentDate <= endOfMonth) {
-                generateTimeSlotsForDate(currentDate);
-                currentDate = this._addDays(currentDate, 7);
-            }
-        }
-        // Handle monthly schedules
-        if (interval.inEveryMonth && !interval.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfMonth = startDate.getUTCDate();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                currentDate.setUTCDate(targetDayOfMonth);
-                if (currentDate.getUTCMonth() !== (startDate.getUTCMonth() + i) % 12) {
-                    continue;
-                }
-                generateTimeSlotsForDate(currentDate);
-            }
-        }
-        // Handle both weekly and monthly schedules
-        if (interval.inEveryMonth && interval.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfWeek = startDate.getUTCDay();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                currentDate.setUTCDate(1);
-                const daysUntilTargetDay = (targetDayOfWeek - currentDate.getUTCDay() + 7) % 7;
-                currentDate.setUTCDate(currentDate.getUTCDate() + daysUntilTargetDay);
-                while (currentDate.getUTCMonth() ===
-                    (startDate.getUTCMonth() + i) % 12) {
-                    generateTimeSlotsForDate(currentDate);
-                    currentDate.setUTCDate(currentDate.getUTCDate() + 7);
-                }
-            }
-        }
+        this._processScheduleDates(date, interval, generateTimeSlotsForDate);
     }
     /**
      * Adds time intervals to form schedules (different structure).

package/dist/base/utils.d.ts

@@ -27,8 +27,11 @@ type Types = 'product' | 'error_page' | 'catalog_page' | 'product_preview' | 'si
  *     errors: {
  *         isShell: true,
  *         customErrors: {
+ *             '400': badRequestFunction,
  *             '404': notFoundFunction,
- *             '400': errorFunction
+ *             '429': rateLimitFunction,
+ *             '500': serverErrorFunction,
+ *             '503': serviceUnavailableFunction
  *         }
  *     }
  * }
@@ -38,6 +41,11 @@ interface IConfig {
     token?: string;
     langCode?: string;
     traficLimit?: boolean;
+    validation?: {
+        enabled?: boolean;
+        strictMode?: boolean;
+        logErrors?: boolean;
+    };
     auth?: {
         customAuth?: boolean;
         refreshToken?: string;
@@ -51,7 +59,11 @@ interface IConfig {
             401?: (data?: IError) => any;
             403?: (data?: IError) => any;
             404?: (data?: IError) => any;
+            429?: (data?: IError) => any;
             500?: (data?: IError) => any;
+            502?: (data?: IError) => any;
+            503?: (data?: IError) => any;
+            504?: (data?: IError) => any;
         };
     };
 }
@@ -136,6 +148,33 @@ interface IError {
     timestamp: string;
     [key: string]: any;
 }
+/**
+ * @interface IHttpHeaders
+ * @property {string} [Content-Type] - Content type header
+ * @property {string} [x-app-token] - App token header
+ * @property {string} [x-device-metadata] - Device metadata header
+ * @property {string} [Authorization] - Authorization header
+ * @description Interface for HTTP headers
+ */
+interface IHttpHeaders {
+    'Content-Type'?: string;
+    'x-app-token'?: string;
+    'x-device-metadata'?: string;
+    Authorization?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * @interface IHttpOptions
+ * @property {string} method - HTTP method
+ * @property {IHttpHeaders} headers - HTTP headers
+ * @property {string | FormData | Blob} [body] - Request body
+ * @description Interface for HTTP request options
+ */
+interface IHttpOptions {
+    method: string;
+    headers: IHttpHeaders;
+    body?: string | FormData | Blob;
+}
 /**
  * AttributeType
  */
@@ -148,4 +187,4 @@ type LangType = string | Array<string>;
  * LocalizeType
  */
 type LocalizeType = ILocalizeInfos | ILocalizeInfo;
-export type { AttributeType, IAttributes, IAttributeValues, IConfig, IError, ILocalizeInfo, ILocalizeInfos, LangType, LocalizeType, Types, };
+export type { AttributeType, IAttributes, IAttributeValues, IConfig, IError, IHttpHeaders, IHttpOptions, ILocalizeInfo, ILocalizeInfos, LangType, LocalizeType, Types, };

package/dist/base/validation.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+/**
+ * Common validation schemas for API responses
+ * @description Base schemas that can be reused across different modules
+ */
+/**
+ * Error response schema
+ */
+export declare const ErrorSchema: z.ZodObject<{
+    statusCode: z.ZodNumber;
+    message: z.ZodString;
+    localizeMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Localize info schema
+ */
+export declare const LocalizeInfoSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    menuTitle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Attribute schema
+ */
+export declare const AttributeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    marker: z.ZodString;
+    type: z.ZodString;
+    isVisible: z.ZodOptional<z.ZodBoolean>;
+    isRequired: z.ZodOptional<z.ZodBoolean>;
+    position: z.ZodOptional<z.ZodNumber>;
+    localizeInfos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        menuTitle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    value: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * User entity schema
+ */
+export declare const UserEntitySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    identifier: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    phoneMask: z.ZodOptional<z.ZodString>;
+    phoneCode: z.ZodOptional<z.ZodString>;
+    phoneNumber: z.ZodOptional<z.ZodString>;
+    statusMarker: z.ZodOptional<z.ZodString>;
+    formData: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodAny>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    total: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    authProviderIdentifier: z.ZodOptional<z.ZodString>;
+    formIdentifier: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    moduleFormConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+}, z.core.$strip>;
+/**
+ * Auth entity schema
+ * API returns only accessToken and refreshToken
+ * userIdentifier and authProviderIdentifier are optional legacy fields
+ */
+export declare const AuthEntitySchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    userIdentifier: z.ZodOptional<z.ZodString>;
+    authProviderIdentifier: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        identifier: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        phoneMask: z.ZodOptional<z.ZodString>;
+        phoneCode: z.ZodOptional<z.ZodString>;
+        phoneNumber: z.ZodOptional<z.ZodString>;
+        statusMarker: z.ZodOptional<z.ZodString>;
+        formData: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodAny>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+        total: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        authProviderIdentifier: z.ZodOptional<z.ZodString>;
+        formIdentifier: z.ZodOptional<z.ZodString>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        moduleFormConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Paginated response schema factory
+ * @param {T} itemSchema - The schema for each item in the paginated response
+ * @returns {any} Paginated response schema
+ */
+export declare function createPaginatedSchema<T extends z.ZodTypeAny>(itemSchema: T): any;
+/**
+ * Validation helper function
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {object} options - Validation options
+ * @param {boolean} options.strict - Whether to use strict mode
+ * @param {boolean} options.logErrors - Whether to log errors
+ * @returns {object} Validated data or error
+ */
+export declare function validateResponse<T>(schema: z.ZodSchema<T>, data: unknown, options?: {
+    strict?: boolean;
+    logErrors?: boolean;
+}): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Safe validation helper - returns data even if validation fails
+ * Used when strict mode is disabled
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {boolean} logErrors - Whether to log errors
+ * @returns {T} Validated data or original data if validation fails in non-strict mode
+ */
+export declare function validateResponseSafe<T>(schema: z.ZodSchema<T>, data: unknown, logErrors?: boolean): T;

package/dist/base/validation.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthEntitySchema = exports.UserEntitySchema = exports.AttributeSchema = exports.LocalizeInfoSchema = exports.ErrorSchema = void 0;
+exports.createPaginatedSchema = createPaginatedSchema;
+exports.validateResponse = validateResponse;
+exports.validateResponseSafe = validateResponseSafe;
+/* eslint-disable jsdoc/reject-any-type */
+/* eslint-disable jsdoc/no-undefined-types */
+const zod_1 = require("zod");
+/**
+ * Common validation schemas for API responses
+ * @description Base schemas that can be reused across different modules
+ */
+/**
+ * Error response schema
+ */
+exports.ErrorSchema = zod_1.z.object({
+    statusCode: zod_1.z.number(),
+    message: zod_1.z.string(),
+    localizeMessage: zod_1.z.string().optional(),
+});
+/**
+ * Localize info schema
+ */
+exports.LocalizeInfoSchema = zod_1.z.object({
+    title: zod_1.z.string(),
+    content: zod_1.z.string().optional(),
+    menuTitle: zod_1.z.string().optional(),
+});
+/**
+ * Attribute schema
+ */
+exports.AttributeSchema = zod_1.z.object({
+    id: zod_1.z.number().optional(),
+    marker: zod_1.z.string(),
+    type: zod_1.z.string(),
+    isVisible: zod_1.z.boolean().optional(),
+    isRequired: zod_1.z.boolean().optional(),
+    position: zod_1.z.number().optional(),
+    localizeInfos: zod_1.z.record(zod_1.z.string(), exports.LocalizeInfoSchema).optional(),
+    value: zod_1.z.any().optional(),
+});
+/**
+ * User entity schema
+ */
+exports.UserEntitySchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    identifier: zod_1.z.string().optional(),
+    email: zod_1.z.string().email().optional(),
+    phoneMask: zod_1.z.string().optional(),
+    phoneCode: zod_1.z.string().optional(),
+    phoneNumber: zod_1.z.string().optional(),
+    statusMarker: zod_1.z.string().optional(),
+    formData: zod_1.z
+        .union([zod_1.z.array(zod_1.z.any()), zod_1.z.record(zod_1.z.string(), zod_1.z.any())])
+        .optional(),
+    total: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional(),
+    authProviderIdentifier: zod_1.z.string().optional(),
+    formIdentifier: zod_1.z.string().optional(),
+    groups: zod_1.z.array(zod_1.z.number()).optional(),
+    state: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    moduleFormConfigs: zod_1.z.array(zod_1.z.any()).optional(),
+});
+/**
+ * Auth entity schema
+ * API returns only accessToken and refreshToken
+ * userIdentifier and authProviderIdentifier are optional legacy fields
+ */
+exports.AuthEntitySchema = zod_1.z.object({
+    accessToken: zod_1.z.string(),
+    refreshToken: zod_1.z.string(),
+    userIdentifier: zod_1.z.string().optional(),
+    authProviderIdentifier: zod_1.z.string().optional(),
+    user: exports.UserEntitySchema.optional(),
+});
+/**
+ * Paginated response schema factory
+ * @param {T} itemSchema - The schema for each item in the paginated response
+ * @returns {any} Paginated response schema
+ */
+function createPaginatedSchema(itemSchema) {
+    return zod_1.z.object({
+        items: zod_1.z.array(itemSchema),
+        total: zod_1.z.number(),
+        page: zod_1.z.number().optional(),
+        limit: zod_1.z.number().optional(),
+    });
+}
+/**
+ * Validation helper function
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {object} options - Validation options
+ * @param {boolean} options.strict - Whether to use strict mode
+ * @param {boolean} options.logErrors - Whether to log errors
+ * @returns {object} Validated data or error
+ */
+function validateResponse(schema, data, options) {
+    try {
+        const validated = schema.parse(data);
+        return { success: true, data: validated };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            if (options === null || options === void 0 ? void 0 : options.logErrors) {
+                // eslint-disable-next-line no-undef, no-console
+                console.error('Validation error:', {
+                    errors: error.issues,
+                    data,
+                });
+            }
+            return { success: false, error };
+        }
+        throw error;
+    }
+}
+/**
+ * Safe validation helper - returns data even if validation fails
+ * Used when strict mode is disabled
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {boolean} logErrors - Whether to log errors
+ * @returns {T} Validated data or original data if validation fails in non-strict mode
+ */
+function validateResponseSafe(schema, data, logErrors = false) {
+    const result = validateResponse(schema, data, { logErrors });
+    if (result.success) {
+        return result.data;
+    }
+    // Return original data if validation fails in non-strict mode
+    return data;
+}

package/dist/blocks/blocksApi.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const asyncModules_1 = __importDefault(require("../base/asyncModules"));
+const blocksSchemas_1 = require("./blocksSchemas");
 /**
  * Controllers for working with blocks.
  * @handle /api/content/blocks
@@ -32,15 +34,14 @@ class BlocksApi extends asyncModules_1.default {
      */
     async getBlocks(type = '', langCode = this.state.lang, offset = 0, limit = 30) {
         const response = await this._fetchPost(`?langCode=${langCode}&type=${type}&offset=${offset}&limit=${limit}`);
+        // Validate response if validation is enabled
+        const validated = this._validateResponse(response, blocksSchemas_1.BlocksResponseSchema);
         if (!this.state.traficLimit) {
-            const normalizeResponse = this._normalizeData(response);
-            await Promise.all(
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            normalizeResponse.items.map(async (block) => {
+            const normalizeResponse = this._normalizeData(validated);
+            await Promise.all(normalizeResponse.items.map(async (block) => {
                 const customSettings = block.customSettings;
                 if (customSettings &&
-                    // eslint-disable-next-line no-prototype-builtins
-                    customSettings.hasOwnProperty('productConfig')) {
+                    Object.prototype.hasOwnProperty.call(customSettings, 'productConfig')) {
                     if (customSettings.productConfig.countElementsPerRow)
                         block.countElementsPerRow =
                             +customSettings.productConfig.countElementsPerRow;
@@ -73,7 +74,7 @@ class BlocksApi extends asyncModules_1.default {
             }));
             return this._normalizeData(normalizeResponse);
         }
-        return this._normalizeData(response);
+        return this._normalizeData(validated);
     }
     /**
      * Get block by marker.
@@ -88,10 +89,12 @@ class BlocksApi extends asyncModules_1.default {
      */
     async getBlockByMarker(marker, langCode = this.state.lang, offset = 0, limit = 30) {
         const response = await this._fetchGet(`/marker/${marker}?langCode=${langCode}`);
-        const normalizeResponse = this._normalizeData(response);
+        // Validate response if validation is enabled
+        const validated = this._validateResponse(response, blocksSchemas_1.BlockEntitySchema);
+        const normalizeResponse = this._normalizeData(validated);
         const customSettings = normalizeResponse.customSettings;
-        // eslint-disable-next-line no-prototype-builtins
-        if (customSettings && customSettings.hasOwnProperty('productConfig')) {
+        if (customSettings &&
+            Object.prototype.hasOwnProperty.call(customSettings, 'productConfig')) {
             if (customSettings.productConfig.countElementsPerRow)
                 normalizeResponse.countElementsPerRow =
                     +customSettings.productConfig.countElementsPerRow;
@@ -173,7 +176,9 @@ class BlocksApi extends asyncModules_1.default {
      */
     async searchBlock(name, langCode = this.state.lang) {
         const result = await this._fetchGet(`/quick/search?langCode=${langCode}&name=${name}`);
-        return result;
+        // Validate response if validation is enabled
+        const validated = this._validateResponse(result, blocksSchemas_1.SearchBlocksResponseSchema);
+        return validated;
     }
 }
 exports.default = BlocksApi;

package/dist/blocks/blocksInterfaces.d.ts

@@ -168,5 +168,5 @@ interface ISearchBlock {
  * @type {BlockType}
  * @description This type defines the possible values for block types used in the system.
  */
-type BlockType = 'product' | 'error_page' | 'catalog_page' | 'product_preview' | 'similar_products_block' | 'product_block' | 'form' | 'common_page' | 'common_block' | 'order' | 'service' | 'none';
+type BlockType = 'product' | 'error_page' | 'catalog_page' | 'product_preview' | 'similar_products_block' | 'product_block' | 'form' | 'common_page' | 'common_block' | 'order' | 'service' | 'external_page' | 'discount' | 'none';
 export type { BlockType, IBlockEntity, IBlocks, IBlocksResponse, ISearchBlock };