@truelab/truelogic 3.2.3 → 3.3.0

package/dist/types/src/shared/lib/tests/utils/getPreloadedState.d.ts

@@ -6,6 +6,7 @@ export declare const getPreloadedState: (storePartial?: DeepPartial<TRootState>)
         gameLoadingProgress: number;
         imagesLoadingProgress: number;
         areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
         isFinishedAnimation: boolean;
         isPreloadSuccess: boolean;
         isWaitingSuccess: boolean;
@@ -79,7 +80,7 @@ export declare const getPreloadedState: (storePartial?: DeepPartial<TRootState>)
         isModalReady: boolean;
         serviceErrorName: string;
         serviceErrorMessage: string;
-        serviceAutoplayType: import("../../../model/modals/modalsSlice").TAutoplayServiceModalType;
+        serviceAutoplayType: import("../../../../entities/autoplay").TAutoplayServiceModalType;
     };
     app: {
         screen: import("../../../model/app/appSlice").TScreen;
@@ -255,13 +256,13 @@ export declare const getPreloadedState: (storePartial?: DeepPartial<TRootState>)
         fake: import("../../../api/roundsHistory").TApiRoundsHistoryFake;
     };
     gameInfo: {
-        containers: import("../../../../entities/gameInfo").TGameInfoContainer[];
+        deferredConfig: import("../../../../truelogic").TGameInfoConfig;
+        containers: import("../../../ui/InfoConstructor").TInfoContainer[];
         background?: {
             portrait?: string;
             landscape?: string;
         };
-        version?: string;
-        lastUpdate?: string;
+        preset?: import("../../../../entities/gameInfo").TGameInfoPreset;
     };
     apiRoundPlay: {
         data: import("../../../api/round/play").TApiRoundPlayResponse;
@@ -314,9 +315,38 @@ export declare const getPreloadedState: (storePartial?: DeepPartial<TRootState>)
         showed?: boolean;
     };
     prizeDrop: {
-        config?: {
-            isActive: boolean;
-            version: "default" | "dynamic";
+        rulesContainers: import("../../../ui/InfoConstructor").TInfoContainer[];
+        campaign?: import("../../../model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../../../model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListFake;
+        };
+        apiJoinCampaign: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+        };
+        apiSocketCredentials: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
         };
+        socketConnection?: import("../../../sockets").TPrizeDropSocketConnection;
+        restData?: import("../../../api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
     };
 } & import("redux-persist/es/persistReducer").PersistPartial;

package/dist/types/src/shared/lib/tests/utils/setupTestStore.d.ts

@@ -6,6 +6,7 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
         gameLoadingProgress: number;
         imagesLoadingProgress: number;
         areFontsLoaded: boolean;
+        areTranslationsLoaded: boolean;
         isFinishedAnimation: boolean;
         isPreloadSuccess: boolean;
         isWaitingSuccess: boolean;
@@ -79,7 +80,7 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
         isModalReady: boolean;
         serviceErrorName: string;
         serviceErrorMessage: string;
-        serviceAutoplayType: import("../../../model/modals/modalsSlice").TAutoplayServiceModalType;
+        serviceAutoplayType: import("../../../../entities/autoplay").TAutoplayServiceModalType;
     };
     app: {
         screen: import("../../../model/app/appSlice").TScreen;
@@ -255,13 +256,13 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
         fake: import("../../../api/roundsHistory").TApiRoundsHistoryFake;
     };
     gameInfo: {
-        containers: import("../../../../entities/gameInfo").TGameInfoContainer[];
+        deferredConfig: import("../../../../truelogic").TGameInfoConfig;
+        containers: import("../../../ui/InfoConstructor").TInfoContainer[];
         background?: {
             portrait?: string;
             landscape?: string;
         };
-        version?: string;
-        lastUpdate?: string;
+        preset?: import("../../../../entities/gameInfo").TGameInfoPreset;
     };
     apiRoundPlay: {
         data: import("../../../api/round/play").TApiRoundPlayResponse;
@@ -314,10 +315,39 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
         showed?: boolean;
     };
     prizeDrop: {
-        config?: {
-            isActive: boolean;
-            version: "default" | "dynamic";
+        rulesContainers: import("../../../ui/InfoConstructor").TInfoContainer[];
+        campaign?: import("../../../model/prizeDrop").TPrizeDropCampaign;
+        winDropItem?: import("../../../model/prizeDrop").TPrizeDropWinItem;
+        apiCampaignsList: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListFake;
+        };
+        apiJoinCampaign: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignFake;
         };
+        apiSocketCredentials: {
+            data: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+            isPending: boolean;
+            error: {
+                name: string;
+                message: string;
+            };
+            fake: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
+        };
+        socketConnection?: import("../../../sockets").TPrizeDropSocketConnection;
+        restData?: import("../../../api/prizeDrop").TPrizeDropApiData;
+        hasDefferedModal?: boolean;
     };
 }, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
     dispatch: import("redux-thunk").ThunkDispatch<{
@@ -328,6 +358,7 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
             gameLoadingProgress: number;
             imagesLoadingProgress: number;
             areFontsLoaded: boolean;
+            areTranslationsLoaded: boolean;
             isFinishedAnimation: boolean;
             isPreloadSuccess: boolean;
             isWaitingSuccess: boolean;
@@ -401,7 +432,7 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
             isModalReady: boolean;
             serviceErrorName: string;
             serviceErrorMessage: string;
-            serviceAutoplayType: import("../../../model/modals/modalsSlice").TAutoplayServiceModalType;
+            serviceAutoplayType: import("../../../../entities/autoplay").TAutoplayServiceModalType;
         };
         app: {
             screen: import("../../../model/app/appSlice").TScreen;
@@ -577,13 +608,13 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
             fake: import("../../../api/roundsHistory").TApiRoundsHistoryFake;
         };
         gameInfo: {
-            containers: import("../../../../entities/gameInfo").TGameInfoContainer[];
+            deferredConfig: import("../../../../truelogic").TGameInfoConfig;
+            containers: import("../../../ui/InfoConstructor").TInfoContainer[];
             background?: {
                 portrait?: string;
                 landscape?: string;
             };
-            version?: string;
-            lastUpdate?: string;
+            preset?: import("../../../../entities/gameInfo").TGameInfoPreset;
         };
         apiRoundPlay: {
             data: import("../../../api/round/play").TApiRoundPlayResponse;
@@ -636,10 +667,39 @@ export declare const setupTestStore: (storePartial?: DeepPartial<TRootState>) =>
             showed?: boolean;
         };
         prizeDrop: {
-            config?: {
-                isActive: boolean;
-                version: "default" | "dynamic";
+            rulesContainers: import("../../../ui/InfoConstructor").TInfoContainer[];
+            campaign?: import("../../../model/prizeDrop").TPrizeDropCampaign;
+            winDropItem?: import("../../../model/prizeDrop").TPrizeDropWinItem;
+            apiCampaignsList: {
+                data: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../api/prizeDrop").TApiPrizeDropCampaignsListFake;
+            };
+            apiJoinCampaign: {
+                data: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../api/prizeDrop").TApiPrizeDropJoinCampaignFake;
+            };
+            apiSocketCredentials: {
+                data: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsResponse;
+                isPending: boolean;
+                error: {
+                    name: string;
+                    message: string;
+                };
+                fake: import("../../../api/prizeDrop").TApiPrizeDropSocketCredentialsFake;
             };
+            socketConnection?: import("../../../sockets").TPrizeDropSocketConnection;
+            restData?: import("../../../api/prizeDrop").TPrizeDropApiData;
+            hasDefferedModal?: boolean;
         };
     }, undefined, import("redux").UnknownAction>;
 }>, import("redux").StoreEnhancer]>>;

package/dist/types/src/shared/lib/types/complianceOptions.d.ts

@@ -1,9 +1,16 @@
+/** @deprecated */
 export type TComplianceOptions = {
+    /** @deprecated */
     compliance?: {
+        /** @deprecated */
         isHidden?: boolean;
+        /** @deprecated */
         isBuyBonusInfo?: boolean;
+        /** @deprecated */
         isDesktopInfo?: boolean;
+        /** @deprecated */
         isAutoPlayInfo?: boolean;
+        /** @deprecated */
         isFastPlayInfo?: boolean;
     };
 };

package/dist/types/src/shared/localization/index.d.ts

@@ -1,3 +1,4 @@
+export { langsImportFactory } from './lib/langsImportFactory';
 export type { TLangText, TLocalizationSettings, TTranslations } from './lib/types';
 export { useTranslation } from './lib/useTranslation';
 export { localizationReducer, setLocalizationConfig } from './model/localizationSlice';

package/dist/types/src/shared/localization/lib/langsImportFactory.d.ts

@@ -0,0 +1,2 @@
+import { TTranslations } from './types';
+export declare const langsImportFactory: Record<string, () => Promise<TTranslations>>;

package/dist/types/src/shared/model/modals/modalsSlice.d.ts

@@ -1,7 +1,7 @@
+import { TAutoplayServiceModalType } from "../../../entities/autoplay";
 import { TAppThunkAction } from "../../lib/store";
 import { TMenuConfig } from '../menu';
-export type TAutoplayServiceModalType = 'numSpins' | 'lossLimit' | 'singleWinLimit' | 'bonusReached';
-export type TModalName = 'menu' | 'bonusFeature' | 'autoplay' | 'bonusConfirm' | 'realityCheck' | 'realityCheckReminder' | 'settings' | 'payTable' | 'roundsHistory' | 'roundDetails' | 'replay' | 'serviceMaxBet' | 'serviceInsufficientFunds' | 'serviceRestore' | 'serviceMaxWin' | 'serviceQuitTheGame' | 'serviceConnectionLost' | 'serviceError' | 'serviceFatalError' | 'serviceAutoplay' | 'gameInfo' | 'freeRounds' | 'freeRoundsResult' | 'prizeDropCongratulation' | 'prizeDropUnclaimed' | 'prizeDrop';
+export type TModalName = 'menu' | 'bonusFeature' | 'autoplay' | 'bonusConfirm' | 'realityCheck' | 'realityCheckReminder' | 'settings' | 'payTable' | 'roundsHistory' | 'roundDetails' | 'replay' | 'serviceMaxBet' | 'serviceInsufficientFunds' | 'serviceRestore' | 'serviceMaxWin' | 'serviceQuitTheGame' | 'serviceConnectionLost' | 'serviceError' | 'serviceFatalError' | 'serviceAutoplay' | 'gameInfo' | 'freeRounds' | 'freeRoundsResult' | 'prizeDropCongratulation' | 'prizeDropUnclaimed' | 'prizeDrop' | 'prizeDropSuccess' | 'prizeDropResult' | 'prizeDropLive';
 type TModalConfigs = {
     menu: TMenuConfig;
 };

package/dist/types/src/shared/model/prizeDrop/index.d.ts

@@ -0,0 +1 @@
+export { TPrizeDropCampaign, TPrizeDropCampaignPrize, TPrizeDropCampaignStatus, TPrizeDropWinItem } from './types';

package/dist/types/src/shared/model/prizeDrop/types.d.ts

@@ -0,0 +1,54 @@
+export type TPrizeDropWinItem = {
+    direct: boolean;
+    campaignId: string;
+    dropId: string;
+    prize: {
+        prizeId: string;
+        type: string;
+        configCash?: {
+            cash: {
+                value: number;
+                currency?: string;
+                decimals: number;
+            };
+        };
+    };
+};
+export type TPrizeDropCampaignPrize = {
+    prizeId: string;
+    type: 'cash';
+    topPrize: boolean;
+    totalCount: number;
+    leftCount: number;
+    configCash?: {
+        cash?: {
+            value: number;
+            currency: string;
+            decimals: number;
+        };
+    };
+};
+export type TPrizeDropCampaignStatus = 'scheduled' | 'running' | 'finished' | 'cancelled';
+export type TPrizeDropCampaign = {
+    campaignId: string;
+    joined: boolean;
+    status: TPrizeDropCampaignStatus;
+    dateStart: string;
+    dateEnd: string;
+    betAmount: number;
+    betTypes: string[];
+    prizesTotalCount: number;
+    prizesLeftCount: number;
+    winnersCount: number;
+    texts: {
+        title: string;
+        description: string;
+        rules: string;
+    };
+    prizes: TPrizeDropCampaignPrize[];
+    cashPrizePool?: {
+        value: number;
+        currency: string;
+        decimals: number;
+    };
+};

package/dist/types/src/shared/model/welcome/types.d.ts

@@ -4,6 +4,7 @@ export type TWelcomeDefaultSlide = {
     image: string;
     title: string;
     description: string;
+    isHidden?: boolean;
 } & TComplianceOptions;
 export type TWelcomeDefaultConfig = {
     version: 'default';

package/dist/types/src/shared/sockets/index.d.ts

@@ -0,0 +1,2 @@
+export { prizeDropSocketService } from './prizeDropSocketService';
+export { EPrizeDropSocketEvents, TPrizeDropSocketConnection, TPrizeDropSocketEventPayloadCampaignUpdated, TPrizeDropSocketEventPayloadDrop, } from './types';

package/dist/types/src/shared/sockets/prizeDropSocketService.d.ts

@@ -0,0 +1,46 @@
+import { EPrizeDropSocketEvents, TPrizeDropSocketEventPayloadCampaignUpdated, TPrizeDropSocketEventPayloadDrop } from './types';
+type TEventMap = {
+    [EPrizeDropSocketEvents.CAMPAIGN_UPDATED]: TPrizeDropSocketEventPayloadCampaignUpdated;
+    [EPrizeDropSocketEvents.DROP]: TPrizeDropSocketEventPayloadDrop;
+};
+type TTypedEvent<K extends keyof TEventMap> = {
+    type: K;
+    payload: TEventMap[K];
+    timestamp?: number;
+};
+type TEventCallback<K extends keyof TEventMap> = (event: TTypedEvent<K>) => void;
+type TConnectParams = {
+    url: string;
+    token: string;
+    campaignId: string;
+};
+declare class PrizeDropSocketService {
+    private socket;
+    private callbacks;
+    /**
+     * Opens Socket.io connection
+     */
+    connect({ url, token, campaignId }: TConnectParams): Promise<void>;
+    /**
+     * Disconnects the Socket.io connection
+     */
+    disconnect(): void;
+    /**
+     * Sends an event via Socket.io
+     */
+    send<K extends keyof TEventMap>(event: TTypedEvent<K>): void;
+    /**
+     * Register a callback for a specific event type
+     */
+    on<K extends keyof TEventMap>(eventType: K, cb: TEventCallback<K>): void;
+    /**
+     * Remove a previously registered callback
+     */
+    off<K extends keyof TEventMap>(eventType: K, cb: TEventCallback<K>): void;
+    /**
+     * Emits an event to all registered callbacks
+     */
+    private emit;
+}
+export declare const prizeDropSocketService: PrizeDropSocketService;
+export {};

package/dist/types/src/shared/sockets/types.d.ts

@@ -0,0 +1,48 @@
+import { TPrizeDropCampaignStatus } from '../model/prizeDrop';
+export declare enum EPrizeDropSocketEvents {
+    CAMPAIGN_UPDATED = "campaignUpdated",
+    DROP = "drop"
+}
+export type TPrizeDropSocketConnection = {
+    url: string;
+    token: string;
+    isPending: boolean;
+    isSuccess: boolean;
+    error: {
+        name: string;
+        message: string;
+    };
+};
+export type TPrizeDropSocketEventPayloadCampaignUpdated = {
+    campaignId: string;
+    status: TPrizeDropCampaignStatus;
+    prizesLeftCount: number;
+    winnersCount: number;
+    prizes: [
+        {
+            prizeId: string;
+            totalCount: number;
+            leftCount: number;
+        }
+    ];
+};
+export type TPrizeDropSocketEventPayloadDrop = {
+    drops: [
+        {
+            direct: boolean;
+            campaignId: string;
+            dropId: string;
+            prize: {
+                prizeId: string;
+                type: string;
+                configCash?: {
+                    cash: {
+                        value: number;
+                        currency?: string;
+                        decimals: number;
+                    };
+                };
+            };
+        }
+    ];
+};

package/dist/types/src/shared/ui/InfoConstructor/InfoConstructor.d.ts

@@ -0,0 +1,6 @@
+import { TInfoContainer } from "./";
+type TProps = {
+    containers: TInfoContainer[];
+};
+export declare const InfoConstructor: ({ containers }: TProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/index.d.ts

@@ -0,0 +1,5 @@
+export { EFeatureAlignmentV1Type, TInfoFeatureV1 } from './items/InfoFeatureV1';
+export { EFeatureWidthV2Type, TInfoFeatureV2 } from './items/InfoFeatureV2';
+export { TInfoListItem } from './items/InfoListItem';
+export { InfoText } from './items/InfoText';
+export { TInfoContainer, TInfoItem, TInfoSeparator } from './model/types';

package/dist/types/src/{entities/gameInfo/ui/GameInfoConstructor/items/GameInfoFeatureV1.d.ts → shared/ui/InfoConstructor/items/InfoFeatureV1.d.ts}

@@ -1,19 +1,20 @@
 import { FC } from 'react';
-import { TComplianceOptions } from "../../../../../shared/lib/types/complianceOptions";
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
 export declare enum EFeatureAlignmentV1Type {
     left = "left",
     right = "right"
 }
-export type TGameInfoFeatureV1 = {
+export type TInfoFeatureV1 = {
     type: 'feature-v1';
     alignment: `${EFeatureAlignmentV1Type}`;
     img: string;
     title?: string;
     description?: string;
     lineBreak?: boolean;
+    isHidden?: boolean;
 } & TComplianceOptions;
-type TGameInfoFeatureV1Props = {
-    item: TGameInfoFeatureV1;
+type TInfoFeatureV1Props = {
+    item: TInfoFeatureV1;
 };
-export declare const GameInfoFeatureV1: FC<TGameInfoFeatureV1Props>;
+export declare const InfoFeatureV1: FC<TInfoFeatureV1Props>;
 export {};

package/dist/types/src/{entities/gameInfo/ui/GameInfoConstructor/items/GameInfoFeatureV2.d.ts → shared/ui/InfoConstructor/items/InfoFeatureV2.d.ts}

@@ -1,19 +1,20 @@
 import { FC } from 'react';
-import { TComplianceOptions } from "../../../../../shared/lib/types/complianceOptions";
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
 export declare enum EFeatureWidthV2Type {
     half = "half",
     full = "full"
 }
-export type TGameInfoFeatureV2 = {
+export type TInfoFeatureV2 = {
     type: 'feature-v2';
     img: string;
     width?: `${EFeatureWidthV2Type}`;
     title?: string;
     description?: string;
     lineBreak?: boolean;
+    isHidden?: boolean;
 } & TComplianceOptions;
-type TGameInfoFeatureV2Props = {
-    item: TGameInfoFeatureV2;
+type TInfoFeatureV2Props = {
+    item: TInfoFeatureV2;
 };
-export declare const GameInfoFeatureV2: FC<TGameInfoFeatureV2Props>;
+export declare const InfoFeatureV2: FC<TInfoFeatureV2Props>;
 export {};

package/dist/types/src/shared/ui/InfoConstructor/items/InfoListItem.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+export type TInfoListItem = {
+    type: 'list-item';
+    text: string;
+    isHidden?: boolean;
+} & TComplianceOptions;
+type TInfoListItemProps = {
+    item: TInfoListItem;
+};
+export declare const InfoListItem: FC<TInfoListItemProps>;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/items/InfoSubTitle.d.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+export type TInfoSubTitle = {
+    type: 'subtitle';
+    text: string;
+    noMargin?: boolean;
+    isHidden?: boolean;
+} & TComplianceOptions;
+type TInfoSubTitleProps = {
+    item: TInfoSubTitle;
+    isFirstElement: boolean;
+    noMargin?: boolean;
+};
+export declare const InfoSubTitle: FC<TInfoSubTitleProps>;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/items/InfoTableCell.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+export type TInfoTableCell = {
+    type: 'table-cell';
+    values: [string, string];
+    equalWidthColumns?: boolean;
+    isHidden?: boolean;
+} & TComplianceOptions;
+type TInfoTableCellProps = {
+    item: TInfoTableCell;
+};
+export declare const InfoTableCell: FC<TInfoTableCellProps>;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/items/InfoTableHead.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+export type TInfoTableHead = {
+    type: 'table-head';
+    values: [string, string];
+    equalWidthColumns?: boolean;
+    isHidden?: boolean;
+} & TComplianceOptions;
+type TInfoTableHeadProps = {
+    item: TInfoTableHead;
+};
+export declare const InfoTableHead: FC<TInfoTableHeadProps>;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/items/InfoText.d.ts

@@ -0,0 +1,13 @@
+import { FC } from 'react';
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+export type TInfoText = {
+    type: 'text';
+    text: string;
+    dangerouslySetInnerHTML?: boolean;
+    isHidden?: boolean;
+} & TComplianceOptions;
+type TInfoTextProps = {
+    item: TInfoText;
+};
+export declare const InfoText: FC<TInfoTextProps>;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/items/InfoTitle.d.ts

@@ -0,0 +1,12 @@
+import { FC } from 'react';
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+export type TInfoTitle = {
+    type: 'title';
+    text: string;
+    isHidden?: boolean;
+} & TComplianceOptions;
+type TInfoTitleProps = {
+    item: TInfoTitle;
+};
+export declare const InfoTitle: FC<TInfoTitleProps>;
+export {};

package/dist/types/src/shared/ui/InfoConstructor/model/types.d.ts

@@ -0,0 +1,43 @@
+import { TComplianceOptions } from "../../../lib/types/complianceOptions";
+import { TInfoFeatureV1 } from '../items/InfoFeatureV1';
+import { TInfoFeatureV2 } from '../items/InfoFeatureV2';
+import { TInfoListItem } from '../items/InfoListItem';
+import { TInfoSubTitle } from '../items/InfoSubTitle';
+import { TInfoTableCell } from '../items/InfoTableCell';
+import { TInfoTableHead } from '../items/InfoTableHead';
+import { TInfoText } from '../items/InfoText';
+import { TInfoTitle } from '../items/InfoTitle';
+export type TInfoSeparator = {
+    type: 'separator';
+    size?: 'default' | 'small';
+    isHidden?: boolean;
+} & TComplianceOptions;
+export type TInfoItem = TInfoTitle | TInfoFeatureV1 | TInfoFeatureV2 | TInfoSeparator | TInfoSubTitle | TInfoText | TInfoListItem | TInfoTableHead | TInfoTableCell;
+export type TInfoContainer = {
+    type: TInfoTitle['type'];
+    items: TInfoTitle[];
+} | {
+    type: TInfoFeatureV1['type'];
+    items: TInfoFeatureV1[];
+} | {
+    type: TInfoFeatureV2['type'];
+    items: TInfoFeatureV2[];
+} | {
+    type: TInfoSeparator['type'];
+    items: TInfoSeparator[];
+} | {
+    type: TInfoSubTitle['type'];
+    items: TInfoSubTitle[];
+} | {
+    type: TInfoText['type'];
+    items: TInfoText[];
+} | {
+    type: TInfoListItem['type'];
+    items: TInfoListItem[];
+} | {
+    type: TInfoTableHead['type'];
+    items: TInfoTableHead[];
+} | {
+    type: TInfoTableCell['type'];
+    items: TInfoTableCell[];
+};