@scbt-ecom/ui 0.57.0 → 0.59.0

package/dist/widgets/advantages/Advantages.d.ts

@@ -6,10 +6,11 @@ export interface AdvantageClasses {
     description?: string;
 }
 export interface AdvantagesProps {
-    config: {
+    details: {
         variant: 'threeCards' | 'fourCards';
-        details: AdvantageItem[];
+        items: AdvantageItem[];
     };
+    enabled?: boolean;
     classes?: AdvantageClasses;
 }
-export declare const Advantages: ({ config, classes }: AdvantagesProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Advantages: ({ details, classes }: AdvantagesProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/banner/Banner.d.ts

@@ -1,18 +1,32 @@
 import { ReactElement } from 'react';
+import { ButtonProps } from '../../shared/ui';
 import { AdvantageClasses, AdvantagesProps } from '../advantages/Advantages';
+import { ButtonHandlerOptions } from '../buttonWithHandlers';
 import { BackgroundBannerColorsValues } from './model/constants';
-import { BannerClasses, ButtonsConfig, ImgBanner } from './model/types';
+import { BannerClasses, ImgBanner } from './model/types';
 export interface BannerProps {
     headTitle: string | ReactElement;
     subtitle: string | ReactElement;
     imgDesktop: ImgBanner;
     imgMobile: ImgBanner;
-    buttonsConfig: ButtonsConfig;
+    buttonsConfig: {
+        primary: {
+            buttonContent: ButtonProps & {
+                handlerOptions: ButtonHandlerOptions;
+            };
+            enabled: boolean;
+        };
+        secondary?: {
+            buttonContent: ButtonProps & {
+                handlerOptions: ButtonHandlerOptions;
+            };
+            enabled: boolean;
+        };
+    };
     advantages?: AdvantagesProps;
     classes?: BannerClasses & {
         advantages?: AdvantageClasses;
     };
-    withAdvantages?: boolean;
     variant?: 'separateImg' | 'fullImg';
     color?: BackgroundBannerColorsValues;
 }

package/dist/widgets/banner/ui/banners/BannerWithSeparateImg.d.ts

@@ -1,2 +1,2 @@
 import { BannerProps } from '../../..';
-export declare const BannerWithSeparateImg: ({ headTitle, subtitle, buttonsConfig, advantages, classes, imgMobile, withAdvantages, imgDesktop, color }: Omit<BannerProps, "bannerVariant">) => import("react/jsx-runtime").JSX.Element;
+export declare const BannerWithSeparateImg: ({ headTitle, subtitle, buttonsConfig, advantages, classes, imgMobile, imgDesktop, color }: Omit<BannerProps, "bannerVariant">) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/benefit/model/types.d.ts

@@ -1,4 +1,6 @@
 import { ReactElement } from 'react';
+import { ButtonProps } from '../../../shared/ui';
+import { ButtonHandlerOptions } from '../../buttonWithHandlers';
 import { allowedBannersBackgroundColors } from '../../../shared/constants';
 import { backgroundBenefitColors, BackgroundBenefitColorsValues } from './constants';
 export type Colors = keyof typeof allowedBannersBackgroundColors;
@@ -7,7 +9,9 @@ export type Img = {
     url: string;
 };
 export type Details = {
-    buttonText?: string;
+    button?: ButtonProps & {
+        handlerOptions: ButtonHandlerOptions;
+    };
     img?: ReactElement | Img;
     title: string;
     subtitle: string;

package/dist/widgets/benefit/ui/BenefitItem.d.ts

@@ -1,6 +1,8 @@
 import { ReactElement } from 'react';
 import { BackgroundBenefitColorsValues } from '../model/constants';
+import { ButtonProps } from '../../../shared/ui';
 import { Img } from '../model/types';
+import { ButtonHandlerOptions } from '../../buttonWithHandlers';
 export type BenefitItemClasses = {
     root?: string;
     button?: string;
@@ -18,8 +20,10 @@ export interface BenefitItemProps {
     mobileImg?: boolean;
     classes?: BenefitItemClasses;
     withButton?: boolean;
-    buttonText?: string;
+    button?: ButtonProps & {
+        handlerOptions: ButtonHandlerOptions;
+    };
     variant?: 'twoCards' | 'threeCards' | 'fourCards';
     color?: BackgroundBenefitColorsValues;
 }
-export declare const BenefitItem: ({ subtitle, title, img, mobileImg, classes, withButton, buttonText, variant, color }: BenefitItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BenefitItem: ({ subtitle, title, img, mobileImg, classes, withButton, button, variant, color }: BenefitItemProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/footer/Footer.d.ts

@@ -1,11 +1,12 @@
-import { Config, FooterClasses, FooterPhones, FooterRenderBlocks, FooterSocialLinks } from './model/types';
-export interface FooterProps {
+import { CopyrightType, Details, FooterClasses, LigalType, PhonesType, SocialsLinksType } from './model/types';
+export interface FooterProps<Enabled extends boolean> {
+    variant: 'fourCols';
+    socialsLinks: SocialsLinksType<Enabled>;
+    phones: PhonesType<Enabled>;
+    ligal: LigalType<Enabled>;
+    copyright: CopyrightType<Enabled>;
+    siteMap?: boolean;
+    details: Details[];
     classes?: FooterClasses;
-    renderBlocks?: FooterRenderBlocks;
-    socialsLinks?: FooterSocialLinks[];
-    phones?: FooterPhones[];
-    ligal?: string;
-    copyright?: string;
-    config: Config;
 }
-export declare const Footer: ({ renderBlocks: { withSocialsLinks, withPhones, withNavLinks, withCopyright, withSiteMap, withLigal }, socialsLinks, phones, ligal, copyright, classes, config }: FooterProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Footer: <Enabled extends boolean>({ socialsLinks, phones, ligal, copyright, classes, details, siteMap }: FooterProps<Enabled>) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/footer/model/types.d.ts

@@ -4,11 +4,7 @@ export interface FooterSocialLinks {
     iconName: `social/${SpritesMap['social']}`;
     href: string;
 }
-export interface Config {
-    variant?: string;
-    details: Detail[];
-}
-export interface Detail {
+export interface Details {
     column: Column[];
 }
 export interface Column {
@@ -23,14 +19,39 @@ export interface FooterPhones {
     phone: string;
     text: string;
 }
-export type FooterRenderBlocks = {
-    withSocialsLinks?: boolean;
-    withPhones?: boolean;
-    withNavLinks?: boolean;
-    withCopyright?: boolean;
-    withSiteMap?: boolean;
-    withLigal?: boolean;
+type SocialsLinksEnabled = {
+    enabled: true;
+    links: FooterSocialLinks[];
+};
+type SocialsLinksDisabled = {
+    enabled: false;
+};
+export type SocialsLinksType<Enabled extends boolean> = Enabled extends true ? SocialsLinksEnabled : SocialsLinksDisabled;
+type PhonesEnabled = {
+    enabled: true;
+    items: FooterPhones[];
+};
+type PhonesDisabled = {
+    enabled: false;
+};
+export type PhonesType<Enabled extends boolean> = Enabled extends true ? PhonesEnabled : PhonesDisabled;
+type LigalEnabled = {
+    enabled: true;
+    text: string;
+};
+type LigalDisabled = {
+    enabled: false;
+};
+export type LigalType<Enabled extends boolean> = Enabled extends true ? LigalEnabled : LigalDisabled;
+type CopyrightEnabled = {
+    enabled: true;
+    text: string;
+};
+type CopyrightDisabled = {
+    enabled: true;
+    text: string;
 };
+export type CopyrightType<Enabled extends boolean> = Enabled extends true ? CopyrightEnabled : CopyrightDisabled;
 export type FooterClasses = {
     root?: string;
     footerContainer?: string;
@@ -45,3 +66,4 @@ export type FooterClasses = {
     siteMap?: SiteMapClasses;
     copyright?: CopyrightClasses;
 };
+export {};

package/dist/widgets/footer/ui/NavLinks.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '../model/types';
+import { Details } from '../model/types';
 export type NavigationLinksClasses = {
     navRoot?: string;
     navGroup?: string;
@@ -9,7 +9,7 @@ export type NavigationLinksClasses = {
 };
 interface NavLinksProps {
     classes?: NavigationLinksClasses;
-    config: Config;
+    details: Details[];
 }
-export declare const NavLinks: ({ classes, config }: NavLinksProps) => import("react/jsx-runtime").JSX.Element;
+export declare const NavLinks: ({ classes, details }: NavLinksProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/widgets/header/Header.d.ts

@@ -1,2 +1,2 @@
-import { HeaderProps } from './model/types';
-export declare const Header: ({ logoPath, logoType, config, classes }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+import { HeaderProps, HeaderVariantType } from './model/types';
+export declare const Header: <Type extends HeaderVariantType>(props: HeaderProps<Type>) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/header/model/helpers.d.ts

@@ -1,2 +1,2 @@
-import { HeaderProps } from './types';
-export declare const renderContentVariant: (config: HeaderProps["config"]) => import("react/jsx-runtime").JSX.Element | null;
+import { HeaderProps, HeaderVariantType } from './types';
+export declare const renderContentVariant: <Type extends HeaderVariantType>({ variant, details }: HeaderProps<Type>) => import("react/jsx-runtime").JSX.Element | null;

package/dist/widgets/header/model/types.d.ts

@@ -11,9 +11,10 @@ interface CommonHeaderProps {
     logoType?: BrandLogoVariant;
     classes?: HeaderClasses;
 }
+export type HeaderVariantType = 'empty' | 'withPhone' | 'withButton';
 export interface HeaderEmptyProps {
     variant: 'empty';
-    details: {};
+    details?: {};
 }
 export interface HeaderWithPhone {
     variant: 'withPhone';
@@ -25,8 +26,6 @@ export interface HeaderWithButton {
         handlerOptions: ButtonHandlerOptions;
     };
 }
-export type HeaderVariant = HeaderWithButton | HeaderWithPhone | HeaderEmptyProps;
-export type HeaderProps = CommonHeaderProps & {
-    config: HeaderVariant;
-};
+export type HeaderVariant<Type extends HeaderVariantType> = Type extends 'withButton' ? HeaderWithButton : Type extends 'withPhone' ? HeaderWithPhone : HeaderEmptyProps;
+export type HeaderProps<Type extends HeaderVariantType> = CommonHeaderProps & HeaderVariant<Type>;
 export {};

package/dist/widgets/interLinking/InterLinking.d.ts

@@ -12,4 +12,4 @@ export interface InterLinkingProps extends InterLinkingRoot {
     rootAccordionProps?: Partial<AccordionProps>;
     classes?: InterLinkingClasses;
 }
-export declare const InterLinking: ({ config, headline, mobileAccordionProps, rootAccordionProps, classes }: InterLinkingProps) => import("react/jsx-runtime").JSX.Element;
+export declare const InterLinking: ({ variant, details, headline, mobileAccordionProps, rootAccordionProps, classes }: InterLinkingProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/interLinking/model/types.d.ts

@@ -12,8 +12,6 @@ export interface Column {
 export type InterLinkingVariant = 'twoCols' | 'threeCols' | 'fourCols';
 export interface InterLinkingRoot {
     headline: string;
-    config: {
-        variant: InterLinkingVariant;
-        details: Column[];
-    };
+    variant: InterLinkingVariant;
+    details: Column[];
 }

package/dist/widgets/longBanner/LongBanner.d.ts

@@ -1,13 +1,20 @@
 import { ReactElement } from 'react';
-import { ButtonConfig, Config, LongBannerClasses, LongBannerConfig } from './model/types';
-export interface LongBannerProps extends LongBannerConfig {
+import { ButtonHandlerOptions } from '../buttonWithHandlers';
+import { Details, LongBannerClasses, LongBannerConfig } from './model/types';
+import { ButtonProps } from '../../shared/ui';
+export interface LongBannerProps<Enabled extends boolean> extends LongBannerConfig {
     headline: string | ReactElement;
-    buttonConfig?: ButtonConfig;
-    config: Config;
+    details: Details<Enabled>[];
+    intent?: 'twoItems' | 'fourItems';
+    buttonConfig?: {
+        buttonContent: ButtonProps & {
+            handlerOptions: ButtonHandlerOptions;
+        };
+        enabled: boolean;
+    };
     image: ReactElement | {
         url: string;
     };
-    withButton?: boolean;
     classes?: LongBannerClasses;
 }
-export declare const LongBanner: ({ headline, buttonConfig, withButton, config, image, classes }: LongBannerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LongBanner: <Enabled extends boolean>({ headline, buttonConfig, intent, details, image, classes }: LongBannerProps<Enabled>) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/longBanner/model/types.d.ts

@@ -2,23 +2,19 @@ import { ReactElement } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { itemConfig } from './cva';
 export type LongBannerConfig = VariantProps<typeof itemConfig>;
-export type Config = {
-    intent?: 'twoItems' | 'fourItems';
-    details: Details[];
-};
-export type Details = {
+export type Details<Enabled extends boolean> = {
     title: string;
     description: string;
-    popover?: Popover;
+    popover?: Popover<Enabled>;
 };
-export interface ButtonConfig {
-    text: string | ReactElement;
-    onClick?: () => void;
-}
-export type Popover = {
-    enabled: boolean;
-    text?: string;
+type PopoverEnabled = {
+    enabled: true;
+    text: string;
+};
+type PopoverDisabled = {
+    enabled: false;
 };
+export type Popover<Enabled extends boolean> = Enabled extends true ? PopoverEnabled : PopoverDisabled;
 export interface LongBannerClasses {
     root?: string;
     container?: string;
@@ -29,10 +25,11 @@ export interface LongBannerClasses {
     image?: string;
     button?: string;
 }
-export interface TextItemProps extends LongBannerConfig {
+export interface TextItemProps<Enabled extends boolean> extends LongBannerConfig {
     data: {
         title: string | ReactElement;
         description: string | ReactElement;
-        popover?: Popover;
+        popover?: Popover<Enabled>;
     };
 }
+export {};

package/dist/widgets/longBanner/ui/TextItem.d.ts

@@ -1,2 +1,2 @@
 import { TextItemProps } from '../model/types';
-export declare const TextItem: ({ data, intent }: TextItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TextItem: <Enabled extends boolean>({ data, intent }: TextItemProps<Enabled>) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/longBanner/ui/TextList.d.ts

@@ -1,8 +1,8 @@
 import { Details, LongBannerConfig } from '../model/types';
-interface ListItemsProps {
-    details: Details[];
+interface ListItemsProps<Enabled extends boolean> {
+    details: Details<Enabled>[];
     intent: LongBannerConfig['intent'];
     withButton: boolean;
 }
-export declare const TextList: ({ details, intent, withButton }: ListItemsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TextList: <Enabled extends boolean>({ details, intent, withButton }: ListItemsProps<Enabled>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/widgets/model/helpers.d.ts

@@ -1 +1,2 @@
-export declare const WIDGET_LIST: readonly ["header", "footer", "interLinking", "stepper", "usefulInfo", "longBanner", "banner", "benefit"];
+export declare const WIDGET_LIST: readonly ["header", "footer", "interLinking", "stepper", "usefulInfo", "longBanner", "banner", "benefit", "form", "seoHeader"];
+export declare const widgetIds: Record<"header" | "footer" | "interLinking" | "stepper" | "usefulInfo" | "longBanner" | "banner" | "benefit" | "form" | "seoHeader", "header" | "footer" | "interLinking" | "stepper" | "usefulInfo" | "longBanner" | "banner" | "benefit" | "form" | "seoHeader">;

package/dist/widgets/stepper/Stepper.d.ts

@@ -11,10 +11,8 @@ export type StepperClasses = {
 };
 export interface StepperProps extends HTMLAttributes<HTMLDivElement> {
     headline: string;
-    config: {
-        variant: StepperVariant;
-        details: SingleStepItem[];
-    };
+    variant: StepperVariant;
+    details: SingleStepItem[];
     classes?: StepperClasses;
 }
-export declare const Stepper: ({ headline, config, classes }: StepperProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Stepper: ({ headline, details, variant, classes }: StepperProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/UsefulInfo.d.ts

@@ -1,6 +1,18 @@
-import { Tab } from './model';
+import { EntitiesAccordionsConfig, Tab } from './model';
+import { EntityClasses, TabsClasses } from './ui';
+export type UsefulInfoClasses = {
+    root?: string;
+    container?: string;
+    tabsWrapper?: string;
+    tabs?: TabsClasses;
+    headline?: string;
+    contentWrapper?: string;
+    entityClasses?: EntityClasses;
+};
 export type UsefulInfoProps = {
     headline: string;
     tabs: Tab[];
+    classes?: UsefulInfoClasses;
+    accordionsConfig?: EntitiesAccordionsConfig;
 };
-export declare const UsefulInfo: ({ headline, tabs }: UsefulInfoProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const UsefulInfo: ({ headline, tabs, classes, accordionsConfig }: UsefulInfoProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/widgets/usefulInfo/model/types.d.ts

@@ -1,50 +1,25 @@
+import { EntityDocumentsProps, EntityHtmlProps, EntityTableProps } from '../ui/subEntities';
+import { AccordionProps } from '../../../shared/ui';
 export type SubEntityDetailsConfig = {
     isAccordion: boolean;
     accordionTitle: string;
 };
-export type TableCell = {
-    cell: string;
-};
-export type TableRow = {
-    row: TableCell[];
-};
-export type TableHeading = {
-    heading: string;
-};
-export type EntityTable = {
-    title?: string;
-    description?: string;
-    columnsVariant: 'twoCols' | 'threeCols';
-    tableVariant: 'separator' | 'filled';
-    headings?: TableHeading[];
-    rows: TableRow[];
-    config?: SubEntityDetailsConfig;
-};
-export type EntityDocuments = {
-    iconType: 'documentOutline' | 'documentFilled';
-    title?: string;
-    description?: string;
-    docs: {
-        url: string;
-        size: string;
-        label: string;
-    }[];
-    config?: SubEntityDetailsConfig;
-};
-export type EntityHtml = {
-    html: string;
-    config?: SubEntityDetailsConfig;
+export type EntitiesAccordionsConfig = {
+    htmlAccordion?: Partial<AccordionProps>;
+    documentAccordion?: Partial<AccordionProps>;
+    tableAccordion?: Partial<AccordionProps>;
 };
 export type EntityVariant = 'HTML' | 'TABLE' | 'DOCUMENTS';
-export type EntityDetailsVariant = EntityHtml | EntityDocuments | EntityTable;
 export type Entity<Variant extends EntityVariant = EntityVariant> = {
     variant: Variant;
-    details: Variant extends 'HTML' ? EntityHtml[] : Variant extends 'TABLE' ? EntityTable[] : EntityDocuments[];
+    details: Variant extends 'HTML' ? EntityHtmlProps[] : Variant extends 'TABLE' ? EntityTableProps[] : EntityDocumentsProps[];
 };
 export type Contents = {
     entity: Entity;
+    entityId: string;
 };
 export type Tab = {
     tabName: string;
     contents: Contents[];
+    tabId: string;
 };

package/dist/widgets/usefulInfo/ui/RenderEntity.d.ts

@@ -1,5 +1,16 @@
-import { Entity } from '../model';
+import { EntitiesAccordionsConfig, Entity } from '../model';
+import { EntityDocumentsClasses, EntityHtmlClasses, EntityTableClasses } from './subEntities';
+export type EntityClasses = {
+    entityWrapper?: string;
+    entities?: {
+        html?: EntityHtmlClasses;
+        documents?: EntityDocumentsClasses;
+        table?: EntityTableClasses;
+    };
+};
 export interface RenderEntityProps {
     entity: Entity;
+    classes?: EntityClasses;
+    accordionsConfig?: EntitiesAccordionsConfig;
 }
-export declare const RenderEntity: ({ entity }: RenderEntityProps) => import("react/jsx-runtime").JSX.Element;
+export declare const RenderEntity: ({ entity, classes, accordionsConfig }: RenderEntityProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/ui/Tabs.d.ts

@@ -1,7 +1,12 @@
 import { Dispatch, SetStateAction } from 'react';
+export type TabsClasses = {
+    tabs?: string;
+    button?: string;
+};
 export interface TabsProps {
     tabsNames?: string[];
     activeTab?: number;
     setActiveTab: Dispatch<SetStateAction<number>>;
+    classes?: TabsClasses;
 }
-export declare const Tabs: ({ tabsNames, activeTab, setActiveTab }: TabsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Tabs: ({ tabsNames, activeTab, setActiveTab, classes }: TabsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/ui/subEntities/documents/Documents.d.ts

@@ -1,2 +1,23 @@
-import { EntityDocuments } from '../../../model';
-export declare const Documents: ({ docs, config, title, iconType, description }: EntityDocuments) => import("react/jsx-runtime").JSX.Element;
+import { EntitiesAccordionsConfig, SubEntityDetailsConfig } from '../../../model';
+import { DocumentClasses } from './ui/document';
+export type EntityDocumentsClasses = {
+    wrapper?: string;
+    headline?: string;
+    documentsWrapper?: string;
+    description?: string;
+    singleDocument?: DocumentClasses;
+};
+export type EntityDocumentsProps = {
+    iconType: 'documentOutline' | 'documentFilled';
+    title?: string;
+    description?: string;
+    docs: {
+        url: string;
+        size: string;
+        label: string;
+    }[];
+    config?: SubEntityDetailsConfig;
+    classes?: EntityDocumentsClasses;
+    accordionConfig?: EntitiesAccordionsConfig['documentAccordion'];
+};
+export declare const Documents: ({ docs, config, title, iconType, description, classes, accordionConfig }: EntityDocumentsProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/ui/subEntities/documents/ui/document/Document.d.ts

@@ -1,8 +1,16 @@
 import { IconNames } from './model/utils';
+export type DocumentClasses = {
+    link?: string;
+    icon?: string;
+    wrapper?: string;
+    label?: string;
+    size?: string;
+};
 export interface DocumentProps {
     label: string;
     size: string;
     url: string;
     iconType: IconNames;
+    classes?: DocumentClasses;
 }
-export declare const Document: ({ label, size, url, iconType }: DocumentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Document: ({ label, size, url, iconType, classes }: DocumentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/ui/subEntities/html/Html.d.ts

@@ -1,2 +1,11 @@
-import { EntityHtml } from '../../../model';
-export declare const Html: ({ html, config }: EntityHtml) => import("react/jsx-runtime").JSX.Element;
+import { EntitiesAccordionsConfig, SubEntityDetailsConfig } from '../../../model';
+export type EntityHtmlClasses = {
+    html?: string;
+};
+export type EntityHtmlProps = {
+    html: string;
+    config?: SubEntityDetailsConfig;
+    classes?: EntityHtmlClasses;
+    accordionConfig?: EntitiesAccordionsConfig['htmlAccordion'];
+};
+export declare const Html: ({ html, config, classes, accordionConfig }: EntityHtmlProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/ui/subEntities/table/Table.d.ts

@@ -1,2 +1,32 @@
-import { EntityTable } from '../../../model';
-export declare const Table: ({ tableVariant, description, columnsVariant, config, rows, title, headings }: EntityTable) => import("react/jsx-runtime").JSX.Element;
+import { EntitiesAccordionsConfig, SubEntityDetailsConfig } from '../../../model';
+import { TableBodyClasses } from './ui/TableBody';
+export type EntityTableClasses = {
+    wrapper?: string;
+    headline?: string;
+    description?: string;
+    tableBody?: TableBodyClasses;
+};
+export type TableCell = {
+    cell: string;
+    cellId: string;
+};
+export type TableRow = {
+    row: TableCell[];
+    rowId: string;
+};
+export type TableHeading = {
+    heading: string;
+    headingId: string;
+};
+export type EntityTableProps = {
+    title?: string;
+    description?: string;
+    columnsVariant: 'twoCols' | 'threeCols';
+    tableVariant: 'separator' | 'filled';
+    headings?: TableHeading[];
+    rows: TableRow[];
+    config?: SubEntityDetailsConfig;
+    classes?: EntityTableClasses;
+    accordionConfig?: EntitiesAccordionsConfig['documentAccordion'];
+};
+export declare const Table: ({ tableVariant, description, columnsVariant, config, rows, title, headings, accordionConfig, classes }: EntityTableProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/usefulInfo/ui/subEntities/table/model/utils.d.ts

@@ -1,9 +1,10 @@
-import { TableHeading, TableRow } from '../../../../model';
+import { TableHeading, TableRow } from '../Table';
 export declare const transformMobileRows: (rows: TableRow[], headings?: TableHeading[]) => {
     rows: {
         row: {
             heading: string | undefined;
             cell: string;
+            cellId: string;
         }[];
     }[];
 };

package/dist/widgets/usefulInfo/ui/subEntities/table/ui/DesktopHeadings.d.ts

@@ -1,7 +1,12 @@
-import { EntityTable } from '../../../../model';
+import { EntityTableProps } from '../Table';
+export type DesktopHeadingClasses = {
+    row?: string;
+    cell?: string;
+};
 interface DesktopHeadingsProps {
-    headings: EntityTable['headings'];
-    columnsVariant: EntityTable['columnsVariant'];
+    headings: EntityTableProps['headings'];
+    columnsVariant: EntityTableProps['columnsVariant'];
+    classes?: DesktopHeadingClasses;
 }
-export declare const DesktopHeadings: ({ headings, columnsVariant }: DesktopHeadingsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DesktopHeadings: ({ headings, columnsVariant, classes }: DesktopHeadingsProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/widgets/usefulInfo/ui/subEntities/table/ui/DesktopRow.d.ts

@@ -1,9 +1,14 @@
-import { EntityTable, TableRow } from '../../../../model';
+import { EntityTableProps, TableRow } from '../Table';
+export type DesktopRowClasses = {
+    row?: string;
+    cell?: string;
+};
 type DesktopRowProps = {
     row: TableRow['row'];
-    tableVariant: EntityTable['tableVariant'];
-    columnsVariant: EntityTable['columnsVariant'];
+    tableVariant: EntityTableProps['tableVariant'];
+    columnsVariant: EntityTableProps['columnsVariant'];
     rowIndex: number;
+    classes?: DesktopRowClasses;
 };
-export declare const DesktopRow: ({ row, tableVariant, columnsVariant, rowIndex }: DesktopRowProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DesktopRow: ({ row, tableVariant, columnsVariant, rowIndex, classes }: DesktopRowProps) => import("react/jsx-runtime").JSX.Element;
 export {};