oneentry 1.0.156 → 1.0.158

package/changelog.md

@@ -1,5 +1,148 @@
 # SDK Change Log
 
+## v.1.0.158
+
+### What's New
+
+- Orders > `IOrderStatus` — four fields the API already returns on every status are now declared (all optional, like the rest of the interface): `axis` (status pipeline, e.g. `"payment"`), `isCancelFinal`, `isFinalSuccess`, `isMapped`.
+
+- Base > `ILocalizeInfo` — `plainContent?: string | null` is now declared: pages and menus return it as the plain-text counterpart of `htmlContent`.
+
+- Events > `IFormSubscriptionsResponse` — new exported type describing the container returned by `getFormSubscriptions`: `{ items: IListFormSubscription[]; total: number }`.
+
+- Products > `IProductsResponse` — `totalFound?: number` is now declared (and validated by `ProductsResponseSchema`): block product endpoints (`similarProducts` inside blocks, cart/wishlist recommendations, frequently ordered) return it alongside `items`/`total`; the `Products.getProducts*` endpoints do not, hence optional.
+
+- Products > `IProductBlockSimilarRule` — rewritten to match the real shape of `customSettings.similarProductRules[]` returned by `getProductBlockById`: `{ id, title, attributeMarker, conditionMarker, conditionValue, statusMarker, pageUrls }`. The previously declared fields (`property`, `includes`, `keywords`, `strict`) never occurred in real data.
+
+- AttributeSets > `IAttributeSchemaItem` — six fields the API already returns on schema items are now declared (all optional):
+  - `position` — sort position of the field inside the set;
+  - `listTitles` (`IListTitle[]`) — options for `list`/`radioButton`/`entity` fields, with extended data or linked-entity values;
+  - `listType` — for `entity` fields, how the option list is organized (e.g. `"nested"`);
+  - `moduleIdentifier` — for `entity` fields, the module the linked entities are taken from (e.g. `"catalog"`);
+  - `parentId` — parent field id, `null` for top-level;
+  - `splitParts` (`number[] | boolean`) — for split-price fields, ids of the schema fields the price is split into, `false` when the field does not split.
+
+### What's Changed
+
+- **Breaking** — Blocks > the ten recommendation methods (`getCartComplement`, `getCartComplementByProductIds`, `getCartSimilar`, `getCartSimilarByProductIds`, `getWishlistSimilar`, `getWishlistSimilarByProductIds`, `getTrending`, `getPersonalRecommendations`, `getRecentlyViewed`, `getRepeatPurchase`) — the declared return type is corrected from `IProductsEntity[]` to `IProductsResponse`: the endpoints actually return a container `{ items, total, totalFound? }`, and the SDK does not unwrap it. Type-level fix only; the response itself is unchanged — code that (incorrectly) called `res.map(...)` never worked on real data.
+
+- **Breaking** — Products > `getProductsByVectorSearch` — the declared return type is corrected from `IProductsEntity[]` to `IProductsResponse`: the endpoint returns `{ items, total }`. Type-level fix only.
+
+- **Breaking** — Events > `getFormSubscriptions` — the declared return type is corrected from `IListFormSubscription[]` to the new `IFormSubscriptionsResponse`: the endpoint returns `{ items, total }`. Type-level fix only.
+
+- Orders > `IBaseOrdersEntity.totalSum` — type corrected from `string` to `number`: `createOrder` and `updateOrderByMarkerAndId` return a number (e.g. `285`), which the Zod schemas (`CreateOrderResponseSchema` / `UpdateOrderResponseSchema`) already declared. `IOrderByMarkerEntity.totalSum` stays `string` — the by-marker endpoints really return `"300.00"`.
+
+- Forms > `IFormAttribute` — the seven auth/notification flags (`isLogin`, `isSignUp`, `isPassword`, `isSignUpRequired`, `isNotificationEmail`, `isNotificationPhonePush`, `isNotificationPhoneSMS`) are now optional: the API returns them only on attributes of sign-in/sign-up forms.
+
+- Forms > `IFormLocalizeInfo` — `title` is now optional: the API returns an empty `localizeInfos` object when the form has no localization for the requested language (all list responses on the test project). Same for attribute localization: Base > `IAttributeLocalizeInfo.title` is now optional too.
+
+- Forms > `IFormAttributeAdditionalField.marker` — now optional: entries of `additionalFields` arrive as `{ type, value }`, the marker is the map key.
+
+- Forms > a form with no attributes now returns `attributes: []`: the API sends an empty **object** (`{}`) in that case, and the SDK normalizes it to an empty array in `_normalizeAttr`, so `attributes` is always `IFormAttribute[]` and `form.attributes.map(...)` is safe on every form.
+
+- Events > `IContentApiEvent.module` — now optional: system events not bound to a module (e.g. `send_code`, `registration_event`) come without it.
+
+- Discounts > `IDiscountsEntity.attributeSetId` and `IDiscountValue.maxAmount` — type widened to `number | null`: both arrive as `null` when not configured.
+
+- Products > `IProductBlockProductConfig` — `quantity` and `countElementsPerRow` are now optional: `customSettings.productConfig` arrives as an empty object when the block is not configured.
+
+- Base > `ITimeIntervalRange.period` — type corrected to `number | null`: ranges that are not sliced into slots carry `period: null`. The runtime (`expandTimeIntervals`) already guarded against it; only the type (and the internal narrowing in `_addSlotsFromRanges`) changed.
+
+- AttributeSets > `getAttributesByMarker` — the declared return type is corrected from `IAttributeSetsEntity[]` (the attribute **set** entity: `id`, `schema`, `createdDate`, …) to `IAttributesSetsEntity[]` — the attribute entities the endpoint actually returns (`marker`, `type`, `value`, `listTitles`, `validators`, `localizeInfos`, `additionalFields`, …). Type-level fix only; runtime behavior and the response itself are unchanged.
+
+- AttributeSets > `IAttributeSchemaItem` — `initialValue` and `isPrice` are now optional: the API omits them on some fields (`isPrice` is returned only on product attribute sets).
+
+- Base > `ITimeIntervalSchedule` — `fullMonth` and `selectedYear` are now optional: the API returns them only when the schedule is pinned to a month/year rather than an explicit date `range`.
+
+## v.1.0.157
+
+### What's New
+
+- Subscriptions > `ISubscriptionEntity` — new exported type describing an available subscription: `id`, `identifier`, `localizeInfos` (`ILocalizeInfo`), `productIds`, `periodInDays`, `paymentAccountId`, `isUsed`. It backs the corrected return type of `getAllSubscriptions` (see below) and has a matching Zod schema (`SubscriptionEntitySchema` / `SubscriptionsListSchema`).
+
+- Orders > `IOrderByMarkerEntity` — four fields the API already returns are now declared: `fulfillmentStatusIdentifier`, `fulfillmentStatusLocalizeInfos`, `paymentStatusIdentifier`, `paymentStatusLocalizeInfos` (each `null` until the corresponding status is assigned). Response validation drops every key its schema does not describe, so with `validation.enabled` these four were silently stripped from `getOrderByMarkerAndId` and `getAllOrdersByMarker` before reaching the consumer:
+
+  ```ts
+  const order = await Orders.getOrderByMarkerAndId('my_order', 179);
+  order.paymentStatusIdentifier; // "inProgress-payment"
+  order.paymentStatusLocalizeInfos; // { title: "In progress" }
+  ```
+
+- Orders > `IBaseOrdersEntity` — `statusLocalizeInfos` (localized name of the status assigned to the order) is now declared on the `createOrder` / `updateOrderByMarkerAndId` response, which returned it but had it stripped by validation.
+
+- IntegrationCollections > `ICollectionRow` — `langCode` and `formIdentifier` are now declared. Both are returned by the create/update row endpoints (`formIdentifier` on update) and were stripped by validation.
+
+- AuthProvider > `ISignUpEntity` — `attributeSetId` and `attributesSets` are now declared on the `signUp` response, which returned them but had them stripped by validation.
+
+- Products > `IProductSearchResult` and Pages > `IPageSearchResult` — new exported types describing the short card the quick search endpoints return: `{ id, title, pageId }` for products and `{ id, title }` for pages. Both have matching Zod schemas (`ProductSearchResultSchema` / `ProductSearchResponseSchema`, `PageSearchResultSchema` / `PageSearchResponseSchema`), so the quick search response is validated like every other response.
+
+### What's Changed
+
+- **Breaking** — single-file `image` attributes are now unwrapped in **every** module, not only in the few that ran the extra post-processing step. When an `image` attribute holds exactly one file, its `value` is the file object itself (`[img]` → `img`); values with two or more files stay an array, as before.
+
+  Previously the unwrapping lived in `_clearArray`, which ran only after `_dataPostProcess` (products, menus, forms, forms-data, attribute-sets, integration-collections and `Pages.searchPage`) and only looked at the `attributeValues` key. Everywhere else — blocks, all other pages methods, `Products.getProductsEmptyPage`, `Products.getProductBlockById`, admins, discounts, templates, orders, users — the same attribute arrived as a one-element array, so consumers had to branch on the shape. Form `attributes`, form-data fields and nested `additionalFields` were never unwrapped at all.
+
+  The logic now lives in `_normalizeAttr`, which runs on every attribute of every response:
+
+  ```ts
+  const block = await Blocks.getBlockByMarker('promo');
+  // before: block.attributeValues.img.value[0].downloadLink
+  // now:    block.attributeValues.img.value.downloadLink
+  ```
+
+  Code that reads `value[0]` from products or menus is unaffected — those modules already returned the object. Code that reads `value[0]` from blocks, pages, users or orders must drop the index.
+
+- **Breaking** — a single-file `file` attribute is unwrapped like `image`: `value` is the file object itself, and an array only when several files are attached. `groupOfImages` is a collection by definition and always stays an array. `IBodyTypeFile.value` is widened to `IFileValue | IFileValue[]` accordingly.
+
+- **Breaking** — `real` attributes are cast to a number. `integer` and `float` were already normalized, `real` was not, so the same numeric field reached the consumer as `10` or as `"10"` depending on which of the three types it was declared with:
+
+  ```ts
+  const page = await Pages.getPageByUrl('catalog');
+  // before: page.attributeValues.amount.value // "5"
+  // now:    page.attributeValues.amount.value // 5
+  ```
+
+- **Breaking** — numeric normalization now also runs on form attributes and on form-data fields, which were skipped entirely. A `rating` field of an `integer` form attribute is a `number`, not a string. `IBodyTypeStringNumberFloat.value` is widened to `string | number | null` (send a string; responses come back normalized).
+
+- **Breaking** — an attribute with no value is always `null`. The API returns an empty localization map (`{}`) for an unset value, and the SDK passed it through for text-like types while numeric types became `null` — the same "no value" state had three representations. As a side effect, an unset `integer`/`float` no longer becomes `0`: `Number(null)` is `0`, so an explicit `null` from the API used to be reported as a real zero.
+
+- **Breaking** — form `attributes` are sorted by `position`, the way `attributeValues` always were. The API returns form fields unordered (a field with `position: 10` could arrive after `position: 14`), so rendering a form in CMS order required sorting on the consumer side.
+
+- **Breaking** — Subscriptions > `getAllSubscriptions` returns `ISubscriptionEntity[]` instead of `string[]`. The signature was taken from swagger, which declares `GET /api/content/subscriptions` as an array of markers; the endpoint actually returns full subscription objects, so response validation reported `expected string, received object` on every call and the declared type never matched the data. Callers that read markers should switch from the array element to its `identifier` field:
+
+  ```ts
+  const subscriptions = await Subscriptions.getAllSubscriptions();
+  // before: subscriptions // string[]
+  // now:    subscriptions.map((s) => s.identifier)
+  ```
+
+  `getActiveSubscriptions` is unchanged (`string[]`).
+
+- **Breaking (types only)** — `Products.searchProduct` returns `IProductsEntity[] | IProductSearchResult[] | IError` and `Pages.searchPage` returns `IPagesEntity[] | IPageSearchResult[] | IError`. With `traficLimit: true` both methods return the raw quick search response — a short card without `attributeValues`, `localizeInfos`, `blocks` and the rest of the entity — while the signature promised a full entity in both modes, so a consumer reading `attributeValues` in traficLimit mode got `undefined` with no type error. Runtime behaviour is unchanged; narrow by config or by field:
+
+  ```ts
+  const found = await Products.searchProduct('cos');
+  if (Array.isArray(found) && found.length && 'attributeValues' in found[0]) {
+    // IProductsEntity[] — traficLimit is off
+  }
+  ```
+
+- `Pages.searchPage` no longer runs the template lookup over the traficLimit response. Short cards carry no `templateIdentifier`, so the step could never attach anything; the result is identical, minus the pointless pass.
+
+### Bug Fixes
+
+- Methods whose result is just success-or-failure no longer report `true` when the API rejected the request: `Subscriptions.cancelSubscription`, `Subscriptions.recoverSubscriptions`, `Events.subscribeByMarker`, `Events.unsubscribeByMarker`, `Events.subscribeToForm`, `Events.unsubscribeFromForm`.
+
+  With `errors.isShell` enabled — the default — the SDK **returns** the API error instead of throwing it. The shared helper behind these six methods only had a `try/catch`, so nothing ever reached its `catch` and every failure was reported as a success: `cancelSubscription` answered `true` while the API replied `404 "Subscription already inactive"`, and the `IError` half of the declared `Promise<boolean | IError>` was unreachable. The helper now also inspects the returned value and passes the error through:
+
+  ```ts
+  const cancelled = await Subscriptions.cancelSubscription({ marker: 'premium' });
+  // before: true — on 404 and 403 alike
+  // now:    { statusCode: 404, message: 'Subscription already inactive', ... }
+  ```
+
+  The success path is unchanged (`true`), and `isShell: false` still throws. Code that checks these results with `if (result)` must switch to `if (result === true)` — an error object is truthy.
+
 ## v.1.0.156
 
 ### What's New

package/dist/attribute-sets/attributeSetsApi.d.ts

@@ -38,11 +38,11 @@ export default class AttributesSetsApi extends AsyncModules implements IAttribut
      * @handleName getAttributesByMarker
      * @param {string} marker - Attribute marker. Example: "productAttributes".
      * @param {string} [langCode] - Language code. Default: "en_US".
-     * @returns {Promise<IAttributeSetsEntity[] | IError>} Returns an array of Attributes objects.
+     * @returns {Promise<IAttributesSetsEntity[] | IError>} Returns an array of Attributes objects.
      * @throws {IError} When isShell=false and an error occurs during the fetch
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getAttributesByMarker getAttributesByMarker} documentation.
      */
-    getAttributesByMarker(marker: string, langCode?: string): Promise<IAttributeSetsEntity[] | IError>;
+    getAttributesByMarker(marker: string, langCode?: string): Promise<IAttributesSetsEntity[] | IError>;
     /**
      * Get a single attribute with data from the attribute sets.
      * @handleName getSingleAttributeByMarkerSet

package/dist/attribute-sets/attributeSetsApi.js

@@ -50,14 +50,14 @@ class AttributesSetsApi extends asyncModules_1.default {
         const result = await this._fetchGet(`?` + this._queryParamsToString(query));
         // Validate response if validation is enabled
         const validated = this._validateResponse(result, attributeSetsSchemas_1.AttributeSetsResponseSchema);
-        return this._dataPostProcess(validated, langCode);
+        return this._normalizeData(validated, langCode);
     }
     /**
      * Getting all attributes with data from the attribute set.
      * @handleName getAttributesByMarker
      * @param {string} marker - Attribute marker. Example: "productAttributes".
      * @param {string} [langCode] - Language code. Default: "en_US".
-     * @returns {Promise<IAttributeSetsEntity[] | IError>} Returns an array of Attributes objects.
+     * @returns {Promise<IAttributesSetsEntity[] | IError>} Returns an array of Attributes objects.
      * @throws {IError} When isShell=false and an error occurs during the fetch
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getAttributesByMarker getAttributesByMarker} documentation.
      */
@@ -65,7 +65,7 @@ class AttributesSetsApi extends asyncModules_1.default {
         const result = await this._fetchGet(`/${marker}/attributes?langCode=${langCode}`);
         // Validate response if validation is enabled
         const validated = this._validateResponse(result, attributeSetsSchemas_1.AttributesArrayResponseSchema);
-        return this._dataPostProcess(validated, langCode);
+        return this._normalizeData(validated, langCode);
     }
     /**
      * Get a single attribute with data from the attribute sets.
@@ -81,7 +81,7 @@ class AttributesSetsApi extends asyncModules_1.default {
         const result = await this._fetchGet(`/${setMarker}/attributes/${attributeMarker}?langCode=${langCode}`);
         // Validate response if validation is enabled
         const validated = this._validateResponse(result, attributeSetsSchemas_1.AttributeEntitySchema);
-        return this._dataPostProcess(validated, langCode);
+        return this._normalizeData(validated, langCode);
     }
     /**
      * Getting a single object from a set of attributes by marker.
@@ -96,7 +96,7 @@ class AttributesSetsApi extends asyncModules_1.default {
         const result = await this._fetchGet(`/marker/${marker}?langCode=${langCode}`);
         // Validate response if validation is enabled
         const validated = this._validateResponse(result, attributeSetsSchemas_1.AttributeSetEntitySchema);
-        return this._dataPostProcess(validated, langCode);
+        return this._normalizeData(validated, langCode);
     }
 }
 exports.default = AttributesSetsApi;

package/dist/attribute-sets/attributeSetsInterfaces.d.ts

@@ -10,11 +10,11 @@ interface IAttributesSets {
      * @handleName getAttributesByMarker
      * @param {string} marker - The marker used to identify the attribute set. Example: "productAttributes".
      * @param {string} [langCode] - The language code for localization purposes. Default: 'en_US'.
-     * @returns {IAttributeSetsEntity[]} A promise that resolves to an array of attribute set entities or an error.
+     * @returns {IAttributesSetsEntity[]} A promise that resolves to an array of attribute entities or an error.
      * @throws {IError} - If there is an error during the fetch operation, it will return an error object.
      * @description This method fetches attributes by a specific marker.
      */
-    getAttributesByMarker(marker: string, langCode: string): Promise<IAttributeSetsEntity[] | IError>;
+    getAttributesByMarker(marker: string, langCode: string): Promise<IAttributesSetsEntity[] | IError>;
     /**
      * Fetches a single attribute by its marker and the set marker.
      * @handleName getSingleAttributeByMarkerSet
@@ -82,7 +82,7 @@ type AttributeType = 'string' | 'text' | 'textWithHeader' | 'integer' | 'real' |
  * Represents an attribute set entity.
  * @interface IAttributesSetsEntity
  * @property {AttributeType} type - Attribute type. Example: "string", "text", "integer", "etc".
- * @property {unknown} [value] - Value of the attribute, which can be of any type.
+ * @property {unknown} [value] - Value of the attribute, normalized the same way as an entity attribute value: `number | null` for numeric types, the file object itself for a single-file `image`/`file`, `null` when the attribute carries no value.
  * @property {unknown} initialValue - Initial value of the attribute.
  * @property {string} marker - Textual identifier of the attribute (marker). Example: "color", "size", "etc".
  * @property {number} position - Position number for sorting. Example: 1.
@@ -137,35 +137,47 @@ interface IAttributesSetsEntity {
  * @interface IAttributeSchemaItem
  * @property {number} id - Unique identifier of the schema item. Example: 1.
  * @property {string} identifier - Field marker (machine name) within the schema. Example: "name".
- * @property {unknown} initialValue - Default value applied when the field is not filled.
- * @property {boolean} isPrice - Whether the field's numeric value is treated as the price for product entities. Example: false.
+ * @property {unknown} [initialValue] - Default value applied when the field is not filled. Optional — absent on some fields.
+ * @property {boolean} [isPrice] - Whether the field's numeric value is treated as the price for product entities. Optional — present on product (`forProducts`) attribute sets. Example: false.
  * @property {boolean} isVisible - Whether the field is exposed in the public API/UI. Example: true.
  * @property {IAttributeLocalizeInfo} localizeInfos - Localized labels for the field.
  * @property {boolean} original - Whether the field is part of the original (system) schema, not a user extension. Example: true.
  * @property {AttributeType} type - Attribute data type (e.g. "string", "file").
+ * @property {number} [position] - Sort position of the field inside the set. Optional. Example: 1.
+ * @property {IListTitle[]} [listTitles] - Options for `list`/`radioButton`/`entity` fields (with extended data or linked-entity values). Optional.
+ * @property {string} [listType] - For `entity` fields — how the option list is organized. Optional. Example: "nested".
+ * @property {string} [moduleIdentifier] - For `entity` fields — identifier of the module the linked entities are taken from. Optional. Example: "catalog".
+ * @property {number | null} [parentId] - Identifier of the parent field, `null` for top-level. Optional, seen on `groupOfImages` fields.
  * @property {Record<string, IAttributeSchemaItem>} [additionalFields] - Nested sub-fields keyed by marker. Optional.
  * @property {IAttributeValidators} [validators] - Validation rules for the field. Optional.
  * @property {boolean | string} [splitUnit] - Splitting unit configuration; `false` when disabled, otherwise the unit name (e.g. "percent"). Optional, used by numeric fields.
+ * @property {number[] | boolean} [splitParts] - For split-price fields — ids of the schema fields the price is split into (e.g. [2, 3]); `false` when the field does not split. Optional.
  * @property {boolean} [isCurrency] - Whether the field stores currency values. Optional.
  * @property {boolean} [splitPrice] - Whether the price is split between several fields. Optional.
  * @property {boolean} [isCompress] - Whether uploaded images are compressed. Optional, used by `image`/`groupOfImages` fields.
  * @property {boolean} [receiveValues] - For `timeInterval` fields — whether the field receives precomputed values. Optional.
  * @property {ITimeIntervalSchedule[]} [intervals] - For `timeInterval` fields — top-level schedule definition (separate from `localizeInfos.intervals`). Optional.
- * @property {unknown} [value] - For `timeInterval` fields — current value/state of the schedule. Optional.
+ * @property {unknown} [value] - Current value of the field: `null` on numeric fields without a value, an array of schedule groups on `timeInterval` fields. Optional.
  * @description Definition of a single field inside an attribute set's schema.
  */
 interface IAttributeSchemaItem {
     id: number;
     identifier: string;
-    initialValue: unknown;
-    isPrice: boolean;
+    initialValue?: unknown;
+    isPrice?: boolean;
     isVisible: boolean;
     localizeInfos: IAttributeLocalizeInfo;
     original: boolean;
     type: AttributeType;
+    position?: number;
+    listTitles?: IListTitle[];
+    listType?: string;
+    moduleIdentifier?: string;
+    parentId?: number | null;
     additionalFields?: Record<string, IAttributeSchemaItem>;
     validators?: IAttributeValidators;
     splitUnit?: boolean | string;
+    splitParts?: number[] | boolean;
     isCurrency?: boolean;
     splitPrice?: boolean;
     isCompress?: boolean;

package/dist/auth-provider/authProviderSchemas.d.ts

@@ -26,6 +26,8 @@ export declare const SignUpResponseSchema: z.ZodObject<{
     isDeleted: z.ZodOptional<z.ZodBoolean>;
     state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     rating: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    attributeSetId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    attributesSets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 /**
  * Auth response schema (login/refresh)

package/dist/auth-provider/authProviderSchemas.js

@@ -30,6 +30,8 @@ exports.SignUpResponseSchema = zod_1.z.object({
     isDeleted: zod_1.z.boolean().optional(),
     state: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
     rating: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    attributeSetId: zod_1.z.number().nullable().optional(),
+    attributesSets: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
 });
 /**
  * Auth response schema (login/refresh)

package/dist/auth-provider/authProvidersInterfaces.d.ts

@@ -268,6 +268,8 @@ interface IOauthData {
  * @property {boolean} [isDeleted] - Whether the entity is deleted. Example: false.
  * @property {Record<string, unknown>} [state] - Additional state information. Example: {}.
  * @property {IRating} [rating] - Rating data.
+ * @property {number | null} [attributeSetId] - Identifier of the attribute set attached to the user, or null when none is attached. Example: null.
+ * @property {Record<string, unknown>} [attributesSets] - Attribute sets attached to the user, keyed by marker; empty object when none. Example: {}.
  * @description This interface defines the structure of a sign-up entity.
  */
 interface ISignUpEntity {
@@ -285,6 +287,8 @@ interface ISignUpEntity {
     isDeleted?: boolean;
     state?: Record<string, unknown>;
     rating?: IRating;
+    attributeSetId?: number | null;
+    attributesSets?: Record<string, unknown>;
 }
 /**
  * Interface representing a code entity used for user registration or verification processes.

package/dist/base/asyncModules.d.ts

@@ -15,6 +15,17 @@ export default abstract class AsyncModules extends SyncModules {
      * @description Constructor initializes the AsyncModules with a given state.
      */
     protected constructor(state: StateModule);
+    /**
+     * Detects an API error returned as a value instead of being thrown.
+     *
+     * With `isShell` enabled (the default) `browserResponse` returns the error
+     * body — and a caught exception — instead of throwing, so a failed request
+     * is indistinguishable from a successful one by control flow alone.
+     * @param {unknown} value - Value returned by a request.
+     * @returns {boolean} True when the value is an API error (statusCode >= 400) or a thrown error object.
+     * @description Recognizes both the OneEntry error body and errors caught by browserResponse (e.g. a network failure).
+     */
+    protected _isErrorResponse(value: unknown): value is IError;
     /**
      * Validates API response against a Zod schema (optional)
      * @param {unknown} data - The data to validate
@@ -59,8 +70,13 @@ export default abstract class AsyncModules extends SyncModules {
      *
      * Several endpoints (cancel/recover subscription, subscribe/unsubscribe to
      * events) return no useful body — callers only care whether the request
-     * succeeded. This helper resolves to `true` on success and to the caught
-     * error (as IError) on failure, centralizing the repeated try/catch.
+     * succeeded. This helper resolves to `true` on success and to the error
+     * (as IError) on failure, centralizing the repeated try/catch.
+     *
+     * The returned value has to be inspected as well: with `isShell` enabled
+     * (the default) browserResponse returns the API error instead of throwing
+     * it, so relying on the catch alone would report every failed call — a 404
+     * from cancelSubscription, a 403 from recoverSubscriptions — as a success.
      * @param {() => Promise<unknown>} request - Thunk performing the fetch call.
      * @returns {Promise<boolean | IError>} `true` on success, IError on failure.
      */

package/dist/base/asyncModules.js

@@ -20,6 +20,26 @@ class AsyncModules extends syncModules_1.default {
         this.state = state;
         this._url = this.state.url;
     }
+    /**
+     * Detects an API error returned as a value instead of being thrown.
+     *
+     * With `isShell` enabled (the default) `browserResponse` returns the error
+     * body — and a caught exception — instead of throwing, so a failed request
+     * is indistinguishable from a successful one by control flow alone.
+     * @param {unknown} value - Value returned by a request.
+     * @returns {boolean} True when the value is an API error (statusCode >= 400) or a thrown error object.
+     * @description Recognizes both the OneEntry error body and errors caught by browserResponse (e.g. a network failure).
+     */
+    _isErrorResponse(value) {
+        if (value instanceof Error) {
+            return true;
+        }
+        return (value !== null &&
+            typeof value === 'object' &&
+            'statusCode' in value &&
+            typeof value.statusCode === 'number' &&
+            value.statusCode >= 400);
+    }
     /**
      * Validates API response against a Zod schema (optional)
      * @param {unknown} data - The data to validate
@@ -33,11 +53,7 @@ class AsyncModules extends syncModules_1.default {
             return data;
         }
         // Skip validation for error responses (statusCode indicates API error)
-        if (data !== null &&
-            typeof data === 'object' &&
-            'statusCode' in data &&
-            typeof data.statusCode === 'number' &&
-            data.statusCode >= 400) {
+        if (this._isErrorResponse(data)) {
             return data;
         }
         // Use strict or safe validation based on config
@@ -109,14 +125,22 @@ class AsyncModules extends syncModules_1.default {
      *
      * Several endpoints (cancel/recover subscription, subscribe/unsubscribe to
      * events) return no useful body — callers only care whether the request
-     * succeeded. This helper resolves to `true` on success and to the caught
-     * error (as IError) on failure, centralizing the repeated try/catch.
+     * succeeded. This helper resolves to `true` on success and to the error
+     * (as IError) on failure, centralizing the repeated try/catch.
+     *
+     * The returned value has to be inspected as well: with `isShell` enabled
+     * (the default) browserResponse returns the API error instead of throwing
+     * it, so relying on the catch alone would report every failed call — a 404
+     * from cancelSubscription, a 403 from recoverSubscriptions — as a success.
      * @param {() => Promise<unknown>} request - Thunk performing the fetch call.
      * @returns {Promise<boolean | IError>} `true` on success, IError on failure.
      */
     async _fetchBoolean(request) {
         try {
-            await request();
+            const result = await request();
+            if (this._isErrorResponse(result)) {
+                return result;
+            }
             return true;
         }
         catch (e) {

package/dist/base/syncModules.d.ts

@@ -88,27 +88,33 @@ export default abstract class SyncModules {
      */
     protected _normalizePostBody(body: any, langCode?: string): any;
     /**
-     * Clears arrays within the data structure.
+     * Normalizes the value of a single attribute in place.
      *
-     * Traverses the data and fixes a specific edge case with image attributes:
-     * when an `image` attribute has a single-element array in `value`,
-     * the API returns an array but consumers expect a plain object.
-     * In that case `value` is unwrapped: `[img]` → `img`.
+     * Applies the three type-driven fixes the API response needs, so that an
+     * attribute of a given type always reaches the consumer in the same shape,
+     * no matter which collection it arrived in:
      *
-     * For all other keys the method recursively copies the structure unchanged.
-     * @param {Record<string, any>} data - The data to clear.
-     * @returns {any} Cleared data.
+     * 1. **Single-file values** (`image`, `file`) — the API always sends an array,
+     * even for one file: `[img]` → `img`. Multi-file values and `groupOfImages`
+     * (a collection by definition) stay an array.
+     * 2. **Empty values** — an attribute with no value comes back as an empty
+     * localization map `{}`; it is replaced with `null`, the same marker the
+     * numeric branch already produced.
+     * 3. **Numbers** (`integer`, `float`, `real`) — cast to a JS number; anything
+     * that is not a number (including an empty value) becomes `null`.
+     * @param {any} attr - The attribute object to normalize in place.
      */
-    protected _clearArray(data: Record<string, any>): any;
+    private _normalizeAttrValue;
     /**
      * Sorts attributes by their positions.
      *
-     * The API returns attributes as an object `{ marker: AttrObject }`.
-     * Each attribute has a `position` field. The method rebuilds the object
-     * with keys sorted by ascending `position` so that the display order
-     * matches the order defined in the CMS.
-     * @param {any} data - The data containing attributes.
-     * @returns {any} Sorted attributes.
+     * Each attribute has a `position` field, and the API returns them in no
+     * particular order. The method rebuilds the collection sorted by ascending
+     * `position`, so the display order matches the order defined in the CMS.
+     * Both container shapes the API uses are handled: an object keyed by marker
+     * (`attributeValues`) and an array (form `attributes`).
+     * @param {any} data - The attributes collection to sort.
+     * @returns {any} Sorted attributes, in the same container shape.
      */
     protected _sortAttributes: (data: any) => any;
     /**
@@ -127,18 +133,24 @@ export default abstract class SyncModules {
      *
      * Handles three different attribute formats returned by the API:
      *
-     * **1. `attributeValues`** — attributes of pages, products and other entities.
-     * Contains an object `{ marker: AttrObject }`. For each attribute:
-     * - `_normalizeAdditionalFields` is called;
-     * - numeric types (`integer`, `float`) are cast to a JS number (or `null`);
-     * - the whole object is re-sorted by `position`.
+     * All three go through the same steps, so an attribute of a given type looks
+     * the same whichever collection it arrived in:
+     * - `_normalizeAdditionalFields` turns nested fields into a marker map;
+     * - `_normalizeAttrValue` unwraps single-file values, empties to `null` and
+     * casts numbers;
+     * - the collection is re-sorted by `position`.
      *
-     * **2. `attributes`** — form attributes (different API structure).
-     * Same `additionalFields` processing,
-     * but numbers are not normalized here (commented out — logic differs).
+     * **1. `attributeValues`** — attributes of pages, products and other entities,
+     * an object `{ marker: AttrObject }`.
      *
-     * **3. `type`** — a single attribute from an attribute set.
-     * Same transformations as in case 1, but without sorting.
+     * **2. `attributes`** — form attributes, an array (or a marker map on some
+     * endpoints); form-only boolean flags (`isLogin`, `isSignUp`, notifications)
+     * are additionally coerced from `null` to `false`. A form with no attributes
+     * arrives as an empty object `{}` — it is normalized to an empty array.
+     *
+     * **3. `type`** — a standalone attribute: an attribute-set entry, a form-data
+     * field or a nested `additionalFields` entry. Same transformations, but there
+     * is no collection to sort.
      *
      * `timeInterval` attributes are left exactly as the API returned them — a
      * compact recurrence rule. Resolving one into concrete slots is the caller's
@@ -150,17 +162,6 @@ export default abstract class SyncModules {
      * @returns {any} Normalized attributes.
      */
     protected _normalizeAttr(data: any): any;
-    /**
-     * Processes data after fetching or receiving it.
-     *
-     * Final post-processing of the API response: first unwraps localized fields
-     * (`_normalizeData`), then fixes single-element image attributes
-     * (`_clearArray`). Called at the end of every fetch method.
-     * @param {any} data - The data to process.
-     * @param {any} [langCode] - The language code for processing.
-     * @returns {any} Processed data.
-     */
-    protected _dataPostProcess(data: any, langCode?: string): any;
     /**
      * Sets the access token in the state.
      * @param {string} accessToken - The access token to set.