intelicoreact 1.8.68 → 2.0.0

package/dist/Atomic/UI/Chart/partial/optionsConstructor.d.ts

@@ -0,0 +1,145 @@
+export namespace reactChartJsOptionsLayouts {
+    namespace lineIconLayout {
+        namespace options {
+            let responsive: boolean;
+            let maintainAspectRatio: boolean;
+            namespace scales {
+                namespace x {
+                    let display: boolean;
+                }
+                namespace y {
+                    let display_1: boolean;
+                    export { display_1 as display };
+                }
+            }
+            namespace elements {
+                namespace point {
+                    let radius: number;
+                }
+                namespace line {
+                    let tension: number;
+                    let borderJoinStyle: string;
+                    let borderWidth: number;
+                    let capBezierPoints: boolean;
+                }
+            }
+        }
+        let redraw: boolean;
+        namespace notLibraryOptions {
+            let chartTypeKey: string;
+            namespace setCanvasDimensions {
+                let width: string;
+                let height: string;
+            }
+        }
+    }
+    namespace lineLayout {
+        export namespace options_1 {
+            let responsive_1: boolean;
+            export { responsive_1 as responsive };
+            export namespace elements_1 {
+                export namespace point_1 {
+                    let radius_1: number;
+                    export { radius_1 as radius };
+                    export let pointStyle: string;
+                    export let backgroundColor: string;
+                    export let color: string;
+                }
+                export { point_1 as point };
+                export namespace line_1 {
+                    let tension_1: number;
+                    export { tension_1 as tension };
+                    let borderJoinStyle_1: string;
+                    export { borderJoinStyle_1 as borderJoinStyle };
+                    let borderWidth_1: number;
+                    export { borderWidth_1 as borderWidth };
+                    let capBezierPoints_1: boolean;
+                    export { capBezierPoints_1 as capBezierPoints };
+                }
+                export { line_1 as line };
+            }
+            export { elements_1 as elements };
+        }
+        export { options_1 as options };
+        let redraw_1: boolean;
+        export { redraw_1 as redraw };
+        export namespace notLibraryOptions_1 {
+            let chartTypeKey_1: string;
+            export { chartTypeKey_1 as chartTypeKey };
+        }
+        export { notLibraryOptions_1 as notLibraryOptions };
+    }
+    namespace barLayout {
+        export namespace options_2 {
+            let responsive_2: boolean;
+            export { responsive_2 as responsive };
+            export namespace elements_2 {
+                namespace bar {
+                    let borderRadius: number;
+                }
+            }
+            export { elements_2 as elements };
+        }
+        export { options_2 as options };
+        let redraw_2: boolean;
+        export { redraw_2 as redraw };
+        export namespace notLibraryOptions_2 {
+            let chartTypeKey_2: string;
+            export { chartTypeKey_2 as chartTypeKey };
+        }
+        export { notLibraryOptions_2 as notLibraryOptions };
+    }
+    namespace emptyLayout {
+        export namespace options_3 {
+            let responsive_3: boolean;
+            export { responsive_3 as responsive };
+            let maintainAspectRatio_1: boolean;
+            export { maintainAspectRatio_1 as maintainAspectRatio };
+            export namespace scales_1 {
+                export namespace x_1 {
+                    let display_2: boolean;
+                    export { display_2 as display };
+                }
+                export { x_1 as x };
+                export namespace y_1 {
+                    let display_3: boolean;
+                    export { display_3 as display };
+                }
+                export { y_1 as y };
+            }
+            export { scales_1 as scales };
+            export namespace elements_3 {
+                export namespace point_2 {
+                    let radius_2: number;
+                    export { radius_2 as radius };
+                }
+                export { point_2 as point };
+                export namespace line_2 {
+                    let borderWidth_2: number;
+                    export { borderWidth_2 as borderWidth };
+                }
+                export { line_2 as line };
+            }
+            export { elements_3 as elements };
+        }
+        export { options_3 as options };
+        export namespace notLibraryOptions_3 {
+            let chartTypeKey_3: string;
+            export { chartTypeKey_3 as chartTypeKey };
+        }
+        export { notLibraryOptions_3 as notLibraryOptions };
+    }
+}
+export namespace finturfReactChartJsOptions {
+    let finturfChartBar: any;
+    let finturfLoadingModeBar: any;
+    let finturfChartLine: any;
+    let finturfLoadingModeLine: any;
+    let finturfPositiveLineIcon: any;
+    let finturfNegativeLineIcon: any;
+}
+declare namespace _default {
+    import emptyLayout_1 = reactChartJsOptionsLayouts.emptyLayout;
+    export { emptyLayout_1 as emptyLayout };
+}
+export default _default;

package/dist/Atomic/UI/Chart/partial/optionsSetters.d.ts

@@ -0,0 +1,4 @@
+export function addGradientsSettings(currentOptions: any, gradientsSettings: any): any;
+export function addTooltipOptions(currentOptions: any, tooltipOptions: any): any;
+export default addAdditionalOptions;
+declare function addAdditionalOptions(currentOptions: any, optionsToAdd: any): any;

package/dist/Atomic/UI/Chart/partial/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function getChartTypeKey(model: string): string | undefined;
+export declare function correctModelKey(model?: string): string;
+export declare function getOptions(model: string): any;
+export declare function getNotLibraryOptionsOptions(model: string): any;
+export declare function prepareData(model: string, data: any, chartInstance: any, addToDatasets?: any): any;

package/dist/Atomic/UI/CircleProgressBar/CircleProgressBar.d.ts

@@ -0,0 +1,14 @@
+export default CircleProgressBar;
+declare function CircleProgressBar({ amount, totalAmount, isReverseType, children, className, colors, isInnerLine, radius, strokeWidth, innerLineStrokeWidth, testId, }: {
+    amount: any;
+    totalAmount: any;
+    isReverseType: any;
+    children: any;
+    className: any;
+    colors: any;
+    isInnerLine: any;
+    radius?: number | undefined;
+    strokeWidth?: number | undefined;
+    innerLineStrokeWidth?: number | undefined;
+    testId?: string | undefined;
+}): JSX.Element;

package/dist/Atomic/UI/DateTime/DateTime.d.ts

@@ -0,0 +1,5 @@
+import type { IDateTimeProps } from './DateTime.interface';
+import React from 'react';
+import './DateTime.scss';
+declare const DateTime: React.FC<IDateTimeProps>;
+export default DateTime;

package/dist/Atomic/UI/DateTime/DateTime.interface.d.ts

@@ -0,0 +1,11 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface IDateTimeProps extends IUniProps {
+    value: string | number | Date;
+    valueFormat?: string;
+    dateFormat?: string;
+    timeFormat?: string;
+    isNoDate?: boolean;
+    isNoTime?: boolean;
+    testId?: string;
+    isIncludeOuterStyles?: boolean;
+}

package/dist/Atomic/UI/DebugContainer/DebugContainer.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+import './DebugContainer.scss';
+export interface DebugContainerProps {
+    data?: Record<string, any>;
+    children?: ReactNode;
+    className?: string;
+}
+declare const DebugContainer: React.FC<DebugContainerProps>;
+export default DebugContainer;

package/dist/Atomic/UI/DebugContainer/useDebugContainer.d.ts

@@ -0,0 +1,7 @@
+export interface UseDebugContainer {
+    debugData: Record<string, any>;
+    setDebugData: React.Dispatch<React.SetStateAction<Record<string, any>>>;
+    renderDebugContainer: JSX.Element;
+}
+declare function useDebugContainer(): UseDebugContainer;
+export default useDebugContainer;

package/dist/Atomic/UI/DoubleString/DoubleString.d.ts

@@ -0,0 +1,5 @@
+import type { IDoubleStringProps } from './DoubleString.interface';
+import React from 'react';
+import './DoubleString.scss';
+declare const DoubleString: React.FC<IDoubleStringProps>;
+export default DoubleString;

package/dist/Atomic/UI/DoubleString/DoubleString.interface.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+interface DateFormatSettings {
+    parseFormat?: string;
+    displayFormat?: string;
+}
+export interface IDoubleStringProps extends IUniProps {
+    value: string;
+    description?: ReactNode;
+    subDescription?: ReactNode;
+    valuePostfix?: ReactNode;
+    className?: string;
+    testId?: string;
+    isFormatValueToDate?: boolean;
+    isUseOnClick?: boolean;
+    dateFormatSettings?: DateFormatSettings;
+    revert?: boolean;
+    noTitle?: boolean;
+    isUseHideMode?: boolean;
+    isShowHiddenValueAvailable?: boolean;
+}
+export {};

package/dist/Atomic/UI/DoubleString/index.d.ts

@@ -0,0 +1,4 @@
+import type { IDoubleStringProps } from './DoubleString.interface';
+import DoubleString from './DoubleString';
+export type { IDoubleStringProps };
+export default DoubleString;

package/dist/Atomic/UI/DynamicIcon/DynamicIcon.d.ts

@@ -0,0 +1,4 @@
+import type { IDynamicIconProps } from './DynamicIcon.interface';
+import React from 'react';
+declare const DynamicIcon: React.FC<IDynamicIconProps>;
+export default DynamicIcon;

package/dist/Atomic/UI/DynamicIcon/DynamicIcon.interface.d.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+import type * as FeatherIcons from 'react-feather';
+import type { IUniProps } from '../../../types/base.interface';
+export interface IDynamicIconProps extends React.SVGProps<SVGSVGElement>, IUniProps {
+    iconKey: keyof typeof FeatherIcons | string;
+}

package/dist/Atomic/UI/DynamicIcon/index.d.ts

@@ -0,0 +1,3 @@
+import DynamicIcon from './DynamicIcon';
+export default DynamicIcon;
+export type { IDynamicIconProps } from './DynamicIcon.interface';

package/dist/Atomic/UI/ExampleChartIntegration/ExampleChartIntegration.d.ts

@@ -0,0 +1,2 @@
+export default ExampleChartIntegration;
+declare function ExampleChartIntegration(props: any): JSX.Element;

package/dist/Atomic/UI/ExampleChartIntegration/partial/utils.d.ts

@@ -0,0 +1,4 @@
+export function getSafelyDateRange(dateRange: any): import("../../../FormElements/InputDateRange/InputDateRange.interface").IInputDateRange;
+export function getLabels(range: any): never[];
+export function getMockValue(): number;
+export function getTab(tabId: any, range: any, callback: any): Promise<any>;

package/dist/Atomic/UI/Hint/Hint.d.ts

@@ -0,0 +1,5 @@
+import type { IHintProps } from './Hint.interface';
+import React from 'react';
+import './Hint.scss';
+declare const Hint: React.FC<IHintProps>;
+export default Hint;

package/dist/Atomic/UI/Hint/Hint.interface.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export type THintPosition = string | 'top' | 'centeredTop' | 'bottom' | 'centeredBottom' | 'left' | 'right';
+export interface IHintProps extends IUniProps {
+    key?: string;
+    id?: string;
+    hint?: string | ReactNode;
+    side?: string | 'top' | 'centeredTop' | 'bottom' | 'centeredBottom' | 'left' | 'right';
+    hintContainer?: {
+        className?: string;
+        addWidth?: string | number;
+        addLeft?: string | number;
+        addTop?: string | number;
+    };
+    label?: string | ReactNode;
+    variant?: 'outlined' | 'filled' | 'warning';
+    handleOpenType?: 'click' | 'hover';
+    children?: ReactNode;
+    icon?: ReactNode;
+    isAccessability?: boolean;
+    isHoverableContent?: boolean;
+    isLoading?: boolean;
+    isCloseOnChildrenClick?: boolean;
+    onClickCallback?: () => void;
+    onOpenChange?: (isOpen: boolean) => void;
+}

package/dist/Atomic/UI/Hint/index.d.ts

@@ -0,0 +1,4 @@
+import type { IHintProps } from './Hint.interface';
+import Hint from './Hint';
+export default Hint;
+export type { IHintProps };

package/dist/Atomic/UI/Hint/partials/_constants.d.ts

@@ -0,0 +1,6 @@
+export declare const I_AM_OPENED_EVENT_NAME = "hint:i-am-open";
+export declare const I_AM_OPENED_EVENT_OPTIONS: {
+    bubbles: boolean;
+    cancelable: boolean;
+    composed: boolean;
+};

package/dist/Atomic/UI/Hint/partials/_utils.d.ts

@@ -0,0 +1,6 @@
+export declare const getHintContainerId: (hintId: string | number) => string;
+export declare function getHintContainer(hintId: string | number): HTMLElement | null;
+export declare function getParentNode(): HTMLElement | null;
+export declare function initHintContainer(hintId: string | number, hintContainerSettings: any): void;
+export declare function HandleScrollObj(this: any, setIsOpen: (isOpen: boolean) => void): void;
+export declare function HandleClickOutsideObj(this: any, id: string | number, setIsOpen: (isOpen: boolean) => void): void;

package/dist/Atomic/UI/Modal/Modal.d.ts

@@ -0,0 +1,20 @@
+import type { ReactElement } from 'react';
+import type { IModalProps } from './Modal.interface';
+import './Modal.scss';
+import './ModalMobile.scss';
+export declare const KEY_CODE: Readonly<{
+    readonly ENTER: 13;
+    readonly ESC: 27;
+}>;
+export declare function renderModalTitle({ mode, title, onlyTitle, }: {
+    mode?: string;
+    title: string;
+    onlyTitle?: boolean;
+}): string;
+declare function Modal({ ref, id, testId, zIndex, isOpen, onConfirm, onDecline, closeModal, className, variant, size, mode, title, onlyTitle, atributesForModalBody, confirmBtnClassName, confirmBtnLabel, confirmBtnVariant, confirmBtnDisable, confirmBtnIcon, isConfirmBtnIconPositionRight, noConfirmBtn, forced, closeBtnClassName, closeBtnText, closeBtnVariant, closeBtnDisable, closeBtnIcon, btnClassNames, isCloseBtnIconPositionRight, noCloseBtn, noHeader, noHeaderCloseBtn, customHeader, declineBtnDisable, noFooter, customFooter, withFixedFooter, leftContentOfFooter, isSubmittingByEnter: isSubmittingByEnterOuter, isClosingByEsc: isClosingByEscOuter, withEventManagement, submitOnEnter, closeOnEsc, withMobileLogic, children, }: IModalProps & {
+    ref?: React.RefObject<HTMLDivElement | null>;
+}): ReactElement | null;
+declare namespace Modal {
+    var displayName: string;
+}
+export default Modal;

package/dist/Atomic/UI/Modal/Modal.interface.d.ts

@@ -0,0 +1,70 @@
+import type { ReactNode, RefObject } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+import type TWithEventManagementAsObj from '../../../types/declaration/TWithEventManagementAsObj';
+export type TModalVariant = 'default' | 'primary' | 'title';
+export type TModalMode = 'default' | 'create' | 'edit' | 'add';
+export type TModalSize = 'default' | 290 | 420 | 870 | 770 | 950;
+export interface IModalTitleProps extends IUniProps {
+    variant?: TModalVariant;
+    children: ReactNode;
+    isForced?: boolean;
+    onClose?: () => void;
+    closeBtnDisable?: boolean;
+    noHeaderCloseBtn?: boolean;
+    wrapperRef?: RefObject<HTMLDivElement>;
+}
+export interface IModalFooterProps extends IUniProps {
+    children: ReactNode;
+    wrapperRef?: RefObject<HTMLDivElement>;
+}
+export interface IModalProps extends IUniProps {
+    /** ID for correct identification */
+    id?: number | string;
+    isOpen: boolean;
+    title: string;
+    children: ReactNode;
+    variant?: TModalVariant;
+    mode?: TModalMode;
+    size?: TModalSize | string | number;
+    zIndex?: number;
+    onConfirm?: () => void;
+    onDecline?: () => void;
+    closeModal?: () => void;
+    onlyTitle?: boolean;
+    noHeader?: boolean;
+    noHeaderCloseBtn?: boolean;
+    customHeader?: ReactNode;
+    atributesForModalBody?: Record<string, unknown>;
+    noFooter?: boolean;
+    withFixedFooter?: boolean;
+    leftContentOfFooter?: ReactNode;
+    customFooter?: ReactNode;
+    confirmBtnClassName?: string;
+    confirmBtnLabel?: string;
+    confirmBtnVariant?: string;
+    confirmBtnDisable?: boolean;
+    confirmBtnIcon?: ReactNode;
+    isConfirmBtnIconPositionRight?: boolean;
+    noConfirmBtn?: boolean;
+    closeBtnClassName?: string;
+    closeBtnText?: string;
+    closeBtnVariant?: string;
+    closeBtnDisable?: boolean;
+    closeBtnIcon?: ReactNode;
+    isCloseBtnIconPositionRight?: boolean;
+    noCloseBtn?: boolean;
+    declineBtnDisable?: boolean;
+    forced?: boolean;
+    withMobileLogic?: boolean;
+    btnClassNames?: string;
+    withEventManagement?: TWithEventManagementAsObj<'Modal'> | boolean | null;
+    isSubmittingByEnter?: boolean;
+    isClosingByEsc?: boolean;
+    submitOnEnter?: boolean;
+    closeOnEsc?: boolean;
+}
+export interface IModalHOCProps extends Pick<IModalProps, 'id' | 'zIndex' | 'isOpen' | 'children' | 'className' | 'size' | 'testId' | 'isClosingByEsc' | 'closeOnEsc'> {
+    closeModal?: () => void;
+    closeBtnDisable?: boolean;
+    withEventManagement?: TWithEventManagementAsObj<'Modal'> | boolean | null;
+}

package/dist/Atomic/UI/Modal/ModalHOC.d.ts

@@ -0,0 +1,5 @@
+import type { IModalHOCProps } from './Modal.interface';
+import React from 'react';
+import './Modal.scss';
+declare const ModalHOC: React.FC<IModalHOCProps>;
+export default ModalHOC;

package/dist/Atomic/UI/Modal/index.d.ts

@@ -0,0 +1,9 @@
+import Modal from './Modal';
+import ModalHOC from './ModalHOC';
+import { EVENTS } from './partials/_constants';
+import { dispatchEventForModalManagement } from './partials/_utils';
+export type { IModalFooterProps, IModalHOCProps, IModalProps, IModalTitleProps } from './Modal.interface';
+export { Modal, ModalHOC };
+export { EVENTS };
+export { dispatchEventForModalManagement };
+export default Modal;

package/dist/Atomic/UI/Modal/partials/ModalFooter.d.ts

@@ -0,0 +1,4 @@
+import type { IModalFooterProps } from '../Modal.interface';
+import React from 'react';
+declare const ModalFooter: React.FC<IModalFooterProps>;
+export default ModalFooter;

package/dist/Atomic/UI/Modal/partials/ModalTitle.d.ts

@@ -0,0 +1,4 @@
+import type { IModalTitleProps } from '../Modal.interface';
+import React from 'react';
+declare const ModalTitle: React.FC<IModalTitleProps>;
+export default ModalTitle;

package/dist/Atomic/UI/Modal/partials/_constants.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_EVENT_OPTIONS: Readonly<{
+    bubbles: true;
+    cancelable: true;
+    composed: false;
+}>;
+export declare enum ModalEventsInnerKeys {
+    iGotAnEnterKeyPress = "iGotAnEnterKeyPress",
+    iGotAnEscKeyPress = "iGotAnEscKeyPress"
+}
+/** Тип значения ev.key (KeyboardEvent.key) — привязка к глобальному типу, без своего union */
+export type KeyboardEventKey = globalThis.KeyboardEvent['key'];
+export interface ICustomEvent<Key extends ModalEventsInnerKeys> {
+    innerKey: Key;
+    name: string;
+    shortName: string;
+    middlewareKey: string | KeyboardEventKey;
+    options: EventInit;
+}
+/** Объект, у которого каждый ключ K из енама задаёт тип значения ICustomEvent<K> */
+export type IConstantInfoAboutModalEvents<Keys extends ModalEventsInnerKeys> = {
+    [K in Keys]: ICustomEvent<K>;
+};
+export declare const EVENTS: IConstantInfoAboutModalEvents<ModalEventsInnerKeys>;

package/dist/Atomic/UI/Modal/partials/_utils.d.ts

@@ -0,0 +1,11 @@
+import type { ISuspendProcessing } from '../../../../Functions/useKeyPress/useKeyPress';
+import type TWithEventManagementAsObj from '../../../../types/declaration/TWithEventManagementAsObj';
+import type { IModalProps } from '../Modal.interface';
+export declare function getWithEventManagementStructure(modalId: number | string | null | undefined, withEventManagement?: IModalProps['withEventManagement']): TWithEventManagementAsObj<'Modal', true>;
+export declare function getOnKeyPress({ id: modalId, onSubmit, onClose, suspendProcessing, }: {
+    id: number | string | null | undefined;
+    onSubmit?: () => unknown;
+    onClose?: () => unknown;
+    suspendProcessing?: ISuspendProcessing | null;
+}): ((ev: Event) => void) | null;
+export declare function dispatchEventForModalManagement(realEvent: globalThis.KeyboardEvent, nameOfCustomEvent: string, uniqueIdOfRecipient: number | string, target?: HTMLElement | Document): void;

package/dist/Atomic/UI/Modal/partials/useMobileModal.d.ts

@@ -0,0 +1,31 @@
+import type { MutableRefObject, ReactNode } from 'react';
+type ScrollDirection = 'up' | 'down';
+interface ModalsLogic {
+    IS_HEADER_HIDDEN: boolean;
+    IS_HEADER_STICKY: boolean;
+    IS_FOOTER_HIDDEN: boolean;
+    IS_FOOTER_STICKY: boolean;
+}
+interface UseMobileModalProps {
+    modalRef?: React.RefObject<HTMLDivElement>;
+    withMobileLogic?: boolean;
+    withFixedFooter?: boolean;
+    isOpen?: boolean;
+}
+interface UseMobileModalReturn {
+    modalMobileContainerRef: MutableRefObject<HTMLDivElement | null>;
+    modalMobileHeaderRef: MutableRefObject<HTMLDivElement | null>;
+    modalMobileBodyRef: MutableRefObject<HTMLDivElement | null>;
+    modalMobileFooterRef: MutableRefObject<HTMLDivElement | null>;
+    MODALS_LOGIC: ModalsLogic;
+    SCROLL_DIRECTION: {
+        UP: ScrollDirection;
+        DOWN: ScrollDirection;
+    };
+    scrollTop: number;
+    scrollHeight: number;
+    renderModal: (modal: ReactNode) => ReactNode;
+    isMobile: boolean;
+}
+export default function useMobileModal({ modalRef, withMobileLogic, withFixedFooter, isOpen, }: UseMobileModalProps): UseMobileModalReturn;
+export {};

package/dist/Atomic/UI/MonoAccordion/MonoAccordion._test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Atomic/UI/MonoAccordion/MonoAccordion.d.ts

@@ -0,0 +1,12 @@
+export default MonoAccordion;
+declare function MonoAccordion({ titleJSX, icon, children, isOpen, onClick, className, disabled, testId, datasetProp, }: {
+    titleJSX: any;
+    icon: any;
+    children: any;
+    isOpen: any;
+    onClick: any;
+    className: any;
+    disabled: any;
+    testId?: string | undefined;
+    datasetProp?: {} | undefined;
+}): JSX.Element;

package/dist/Atomic/UI/MonoAccordion/MonoAccordion.interface.d.ts

@@ -0,0 +1,17 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface IMonoAccordionProps extends IUniProps {
+    /** JSX content for the accordion title */
+    titleJSX: React.ReactNode;
+    /** Icon component to display */
+    icon?: React.ReactNode;
+    /** Accordion content */
+    children: React.ReactNode;
+    /** Controls if accordion is expanded */
+    isOpen: boolean;
+    /** Click handler for the accordion header */
+    onClick: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    /** Disables accordion interaction */
+    disabled?: boolean;
+    /** Additional data attributes */
+    datasetProp?: Record<string, string>;
+}

package/dist/Atomic/UI/MonoAccordion/index.d.ts

@@ -0,0 +1,3 @@
+import MonoAccordion from './MonoAccordion';
+export default MonoAccordion;
+export type { IMonoAccordionProps } from './MonoAccordion.interface';

package/dist/Atomic/UI/NavLine/NavLine.d.ts

@@ -0,0 +1,5 @@
+import type { INavLineProps } from './NavLine.interface';
+import React from 'react';
+import './NavLine.scss';
+declare const NavLine: React.FC<INavLineProps>;
+export default NavLine;

package/dist/Atomic/UI/NavLine/NavLine.interface.d.ts

@@ -0,0 +1,31 @@
+import type { RefObject } from 'react';
+export interface INavLineItem {
+    tabId: string;
+    label: string;
+    icon?: string;
+    count?: number;
+    disabled?: boolean;
+    isHidden?: boolean;
+    ref?: RefObject<HTMLElement>;
+    title?: string;
+    linkChapter?: string;
+}
+export interface INavLineProps {
+    root?: string;
+    activeTab: string;
+    variant?: 'simple';
+    onChange: (tabId: string) => void;
+    className?: string;
+    items: INavLineItem[];
+    children?: React.ReactNode;
+    isLocal?: boolean;
+    mode?: string;
+    isNavigateByKeys?: boolean;
+    isTabLoading?: boolean;
+    scrollMode?: boolean;
+    testId?: string;
+    initialTab?: string;
+}
+export interface IScrollTask {
+    type: 'next' | 'prev';
+}

package/dist/Atomic/UI/NavLine/index.d.ts

@@ -0,0 +1,3 @@
+import NavLine from './NavLine';
+export default NavLine;
+export type { INavLineItem, INavLineProps } from './NavLine.interface';

package/dist/Atomic/UI/PageTitle/PageTitle.d.ts

@@ -0,0 +1,5 @@
+import type { IPageTitleProps } from './PageTitle.interface';
+import React from 'react';
+import './PageTitle.scss';
+declare const PageTitle: React.FC<IPageTitleProps>;
+export default PageTitle;

package/dist/Atomic/UI/PageTitle/PageTitle.interface.d.ts

@@ -0,0 +1,15 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface PageItem {
+    name: string;
+    path: string;
+}
+export interface IPageTitleProps extends IUniProps {
+    /** Main title of the page */
+    title: string;
+    /** Array of breadcrumb items */
+    pages: PageItem[];
+    /** Optional children elements */
+    children?: React.ReactNode;
+    /** Test ID for testing purposes */
+    testId?: string;
+}

package/dist/Atomic/UI/PageTitle/index.d.ts

@@ -0,0 +1,3 @@
+import PageTitle from './PageTitle';
+export default PageTitle;
+export type { IPageTitleProps, PageItem } from './PageTitle.interface';

package/dist/Atomic/UI/PieChart/PieChart.d.ts

@@ -0,0 +1,8 @@
+export default PieChart;
+declare function PieChart({ data, cutout, resultLabel, resultValue, withLegend, }: {
+    data: any;
+    cutout?: string | undefined;
+    resultLabel: any;
+    resultValue?: number | undefined;
+    withLegend?: boolean | undefined;
+}): JSX.Element;