@scbt-ecom/ui 0.30.1 → 0.31.0

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

@@ -1,16 +1,12 @@
-import * as React from 'react';
-export interface IAdvantageClasses {
-    advantageWrapper: string;
-    advantageItem: string;
-    advantageTitle: string;
-    advantageDescription: string;
+import { AdvantageItem } from './model/types';
+export interface AdvantageClasses {
+    root?: string;
+    item?: string;
+    title?: string;
+    description?: string;
 }
-export interface IAdvantage {
-    title: string;
-    description: string | React.ReactElement;
+export interface AdvantagesProps {
+    advantagesList: AdvantageItem[];
+    classes?: AdvantageClasses;
 }
-export interface IAdvantagesProps {
-    advantagesList: IAdvantage[];
-    classes?: Partial<IAdvantageClasses>;
-}
-export declare const Advantages: ({ advantagesList, classes }: IAdvantagesProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Advantages: ({ advantagesList, classes }: AdvantagesProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1 +1 @@
-export { Advantages, type IAdvantagesProps } from './Advantages.tsx';
+export { Advantages, type AdvantagesProps } from './Advantages.tsx';

package/dist/widgets/advantages/model/index.d.ts

@@ -0,0 +1 @@
+export type { AdvantageItem } from './types';

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

@@ -0,0 +1,4 @@
+export interface AdvantageItem {
+    title: string;
+    description: string | React.ReactElement;
+}

package/dist/widgets/authProvider/AuthProvider.d.ts

@@ -1,3 +1,3 @@
-import { TAuthProviderProps } from './model/types';
+import { AuthProviderProps } from './model/types';
 import * as React from 'react';
-export declare const AuthProvider: (props: TAuthProviderProps) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare const AuthProvider: (props: AuthProviderProps) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;

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

@@ -1,15 +1,15 @@
-import { TAuthWrapperClasses, TLinksClasses } from '../ui/ui';
+import { AuthWrapperClasses, TLinksClasses } from '../ui/ui';
 import { AUTH_PROVIDER_MODE } from './helpers';
-import { ILoaderProps } from '../../../shared/ui';
-export type TCombineClasses = {
+import { LoaderProps } from '../../../shared/ui';
+export type CombineClasses = {
     root?: string;
     topContent?: string;
     badge?: string;
     subtitle?: string;
     authWrapper?: string;
 };
-type TMobileIdClasses = {
-    authWrapper?: TAuthWrapperClasses;
+type MobileIdClasses = {
+    authWrapper?: AuthWrapperClasses;
     innerWrapper?: string;
     textContent?: string;
     mtsLogo?: string;
@@ -19,8 +19,8 @@ type TMobileIdClasses = {
     badge?: string;
     links?: TLinksClasses;
 };
-type TEsiaClasses = {
-    authWrapper?: TAuthWrapperClasses;
+type EsiaClasses = {
+    authWrapper?: AuthWrapperClasses;
     innerWrapper?: string;
     textContent?: string;
     esiaLogo?: string;
@@ -28,7 +28,7 @@ type TEsiaClasses = {
     badge?: string;
     links?: TLinksClasses;
 };
-export type TSingleAuthSchema = {
+export type SingleAuthSchema = {
     mainLink: {
         title: string;
         mobileTitle: string;
@@ -38,33 +38,33 @@ export type TSingleAuthSchema = {
         text: string;
         href: string;
     };
-    classes?: TCombineClasses;
+    classes?: CombineClasses;
     badge?: string;
-    loaderProps?: ILoaderProps;
+    loaderProps?: LoaderProps;
     isLoading?: boolean;
 };
-type TCombineAuthSchema = {
-    esiaConfig: Omit<TSingleAuthSchema, 'badge'> & Pick<TEsiaMode, 'classes'>;
-    mobileIdConfig: Omit<TSingleAuthSchema, 'badge'> & Pick<TMobileIdMode, 'classes'>;
+type CombineAuthSchema = {
+    esiaConfig: Omit<SingleAuthSchema, 'badge'> & Pick<EsiaMode, 'classes'>;
+    mobileIdConfig: Omit<SingleAuthSchema, 'badge'> & Pick<MobileIdMode, 'classes'>;
     subtitle?: string;
     badge?: string;
-    classes?: TCombineClasses;
+    classes?: CombineClasses;
 };
-type TEsiaMode = TSingleAuthSchema & {
-    classes?: TEsiaClasses;
+type EsiaMode = SingleAuthSchema & {
+    classes?: EsiaClasses;
 } & {
     mode: typeof AUTH_PROVIDER_MODE.ESIA;
 };
-type TMobileIdMode = TSingleAuthSchema & {
-    classes?: TMobileIdClasses;
+type MobileIdMode = SingleAuthSchema & {
+    classes?: MobileIdClasses;
 } & {
     mode: typeof AUTH_PROVIDER_MODE.MOBILE_ID;
 };
-type TCombineMode = TCombineAuthSchema & {
+type CombineMode = CombineAuthSchema & {
     mode: typeof AUTH_PROVIDER_MODE.COMBINE;
 };
-export type TEsiaProps = Omit<TEsiaMode, 'mode'>;
-export type TMobileIdProps = Omit<TMobileIdMode, 'mode'>;
-export type TCombineProps = Omit<TCombineMode, 'mode'>;
-export type TAuthProviderProps = TCombineMode | TMobileIdMode | TEsiaMode;
+export type TEsiaProps = Omit<EsiaMode, 'mode'>;
+export type TMobileIdProps = Omit<MobileIdMode, 'mode'>;
+export type TCombineProps = Omit<CombineMode, 'mode'>;
+export type AuthProviderProps = CombineMode | MobileIdMode | EsiaMode;
 export {};

package/dist/widgets/authProvider/ui/ui/AuthWrapper.d.ts

@@ -1,12 +1,12 @@
-import { ILoaderProps } from '../../../../shared/ui';
-export type TAuthWrapperClasses = {
+import { LoaderProps } from '../../../../shared/ui';
+export type AuthWrapperClasses = {
     root?: string;
     wrapper?: string;
 };
-export interface IAuthWrapper {
+export interface AuthWrapperProps {
     children: React.ReactElement;
-    classes?: TAuthWrapperClasses;
+    classes?: AuthWrapperClasses;
     isLoading?: boolean;
-    loaderProps?: ILoaderProps;
+    loaderProps?: LoaderProps;
 }
-export declare const AuthWrapper: ({ children, isLoading, classes, loaderProps }: IAuthWrapper) => import("react/jsx-runtime").JSX.Element;
+export declare const AuthWrapper: ({ children, isLoading, classes, loaderProps }: AuthWrapperProps) => import("react/jsx-runtime").JSX.Element;

package/dist/widgets/authProvider/ui/ui/Links.d.ts

@@ -1,10 +1,10 @@
-import { TSingleAuthSchema } from '../../model/types';
+import { SingleAuthSchema } from '../../model/types';
 export type TLinksClasses = {
     linksWrapper?: string;
     linksMainLink?: string;
     linksSubLink?: string;
 };
-interface ILinksProps extends Pick<TSingleAuthSchema, 'subLink' | 'mainLink'> {
+interface ILinksProps extends Pick<SingleAuthSchema, 'subLink' | 'mainLink'> {
     isMobile: boolean;
     classes?: TLinksClasses;
 }

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

@@ -1,24 +1,8 @@
 import { ReactElement } from 'react';
-import { IAdvantage, IAdvantageClasses } from '../advantages/Advantages.tsx';
-import { IBannerButtonsGroupClasses } from './ui/BannerButtonsGroup';
-import { IButtonProps } from '../../shared/ui';
-interface IBannerClasses extends IBannerButtonsGroupClasses {
-    section: string;
-    container: string;
-    wrapper: string;
-    content: string;
-    textBlock: string;
-    title: string;
-    subtitle: string;
-    imageContainer: string;
-    image: string;
-    advantageContainer: string;
-}
-export type TButtonsConfig = {
-    primary: IButtonProps;
-    secondary?: IButtonProps;
-};
-export interface IBannerProps {
+import { AdvantageClasses } from '../advantages/Advantages.tsx';
+import { AdvantageItem } from '../advantages/model/types.ts';
+import { BannerClasses, ButtonsConfig } from './model/types.ts';
+export interface BannerProps {
     headTitle: string | ReactElement;
     subtitle: string | ReactElement;
     img?: string;
@@ -27,10 +11,11 @@ export interface IBannerProps {
         mob: string;
         type?: string;
     };
-    buttonsConfig: TButtonsConfig;
-    advantagesList?: IAdvantage[];
-    classes?: Partial<IBannerClasses> & Partial<IAdvantageClasses>;
+    buttonsConfig: ButtonsConfig;
+    advantagesList?: AdvantageItem[];
+    classes?: BannerClasses & {
+        advantages?: AdvantageClasses;
+    };
     bannerVariant?: 'separateImg' | 'fullImg';
 }
-export declare const Banner: ({ bannerVariant, ...props }: IBannerProps) => import("react/jsx-runtime").JSX.Element;
-export {};
+export declare const Banner: ({ bannerVariant, ...props }: BannerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +1,2 @@
 export { BannerWithSeparateImg } from './ui/banners';
-export { Banner, type IBannerProps } from './Banner';
+export { Banner, type BannerProps } from './Banner';

package/dist/widgets/banner/model/index.d.ts

@@ -0,0 +1 @@
+export type { ButtonsConfig, BannerClasses } from './types';

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

@@ -0,0 +1,18 @@
+import { ButtonProps } from '../../../shared/ui';
+import { BannerButtonsGroupClasses } from '../ui/BannerButtonsGroup';
+export interface BannerClasses extends BannerButtonsGroupClasses {
+    root?: string;
+    container?: string;
+    wrapper?: string;
+    content?: string;
+    textBlock?: string;
+    title?: string;
+    subtitle?: string;
+    imageContainer?: string;
+    image?: string;
+    advantageContainer?: string;
+}
+export type ButtonsConfig = {
+    primary: ButtonProps;
+    secondary?: ButtonProps;
+};

package/dist/widgets/banner/ui/BannerButtonsGroup.d.ts

@@ -1,13 +1,13 @@
-import { TButtonsConfig } from '../Banner';
-export interface IBannerButtonsGroupClasses {
-    group: string;
-    primary: string;
-    secondary: string;
+import { ButtonsConfig } from '../model';
+export interface BannerButtonsGroupClasses {
+    group?: string;
+    primary?: string;
+    secondary?: string;
 }
-interface IBannerButtonsGroupProps {
-    buttonsConfig: TButtonsConfig;
-    classes?: Partial<IBannerButtonsGroupClasses>;
+interface BannerButtonsGroupProps {
+    buttonsConfig: ButtonsConfig;
+    classes?: Partial<BannerButtonsGroupClasses>;
     className?: string;
 }
-export declare const BannerButtonsGroup: ({ buttonsConfig, classes, className }: IBannerButtonsGroupProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BannerButtonsGroup: ({ buttonsConfig, classes, className }: BannerButtonsGroupProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,2 +1,2 @@
-import { IBannerProps } from '../../..';
-export declare const BannerImageFull: ({ headTitle, subtitle, buttonsConfig, advantagesList, classes, img, imgSets }: Omit<IBannerProps, "bannerVariant">) => import("react/jsx-runtime").JSX.Element;
+import { BannerProps } from '../../..';
+export declare const BannerImageFull: ({ headTitle, subtitle, buttonsConfig, advantagesList, classes, img, imgSets }: Omit<BannerProps, "bannerVariant">) => import("react/jsx-runtime").JSX.Element;

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

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

package/dist/widgets/benefit/Benefit.d.ts

@@ -1,20 +1,20 @@
 import { ReactElement } from 'react';
 import { VariantProps } from 'class-variance-authority';
-import { IBenefitItemClasses, IBenefitItemProps } from './ui/BenefitItem';
-export type IBenefitClasses = IBenefitItemClasses & {
-    item?: string;
+import { BenefitItemClasses, BenefitItemProps } from './ui/BenefitItem';
+export type BenefitClasses = {
+    root?: string;
+    container?: string;
+    item?: BenefitItemClasses;
     heading?: string;
     grid?: string;
-    container?: string;
-    section?: string;
 };
 declare const gridConfig: (props?: ({
     intent?: "twoCards" | "threeCards" | "fourCards" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface IBenefitProps extends VariantProps<typeof gridConfig> {
+export interface BenefitProps extends VariantProps<typeof gridConfig> {
     heading: string | ReactElement;
-    cards: IBenefitItemProps[];
-    classes?: IBenefitClasses;
+    cards: BenefitItemProps[];
+    classes?: BenefitClasses;
 }
-export declare const Benefit: ({ heading, cards, classes, intent }: IBenefitProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Benefit: ({ heading, cards, classes, intent }: BenefitProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/widgets/benefit/index.d.ts

@@ -1 +1 @@
-export { Benefit, type IBenefitProps } from './Benefit.tsx';
+export { Benefit, type BenefitProps } from './Benefit.tsx';

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

@@ -1,3 +1,3 @@
 import { allowedBannersBackgroundColors } from '../../../shared/constants';
-export type TColors = keyof typeof allowedBannersBackgroundColors;
-export type AllowedBannerBackgroundColor = `bg-banner-${TColors}`;
+export type Colors = keyof typeof allowedBannersBackgroundColors;
+export type AllowedBannerBackgroundColor = `bg-banner-${Colors}`;

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

@@ -1,28 +1,28 @@
 import { ReactElement } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { AllowedBannerBackgroundColor } from '../model';
-export type IBenefitItemClasses = {
+export type BenefitItemClasses = {
+    root?: string;
     button?: string;
-    item?: string;
-    itemWrapper?: string;
-    itemTextContainer?: string;
-    itemDescription?: string;
+    wrapper?: string;
+    textContainer?: string;
+    description?: string;
     img?: string;
-    imgWrapper?: string;
-    headingBenefitItem?: string;
+    imgContainer?: string;
+    title?: string;
 };
 declare const itemConfig: (props?: ({
     intent?: "twoCards" | "threeCards" | "fourCards" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-export interface IBenefitItemProps extends VariantProps<typeof itemConfig> {
+export interface BenefitItemProps extends VariantProps<typeof itemConfig> {
     title: string;
     description: string | ReactElement;
     img?: string;
     mobileImg?: boolean;
-    classes?: IBenefitItemClasses;
+    classes?: BenefitItemClasses;
     withButton?: boolean;
     buttonText?: string;
     cardColor?: AllowedBannerBackgroundColor;
 }
-export declare const BenefitItem: ({ description, title, img, mobileImg, classes, withButton, buttonText, intent, cardColor }: IBenefitItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BenefitItem: ({ description, title, img, mobileImg, classes, withButton, buttonText, intent, cardColor }: BenefitItemProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,12 +1,12 @@
-import { IFooterNavLinks, IFooterPhones, IFooterSocialLinks, TFooterClasses, TFooterRenderBlocks } from './model/types';
+import { FooterClasses, FooterNavLinks, FooterPhones, FooterRenderBlocks, FooterSocialLinks } from './model/types';
 import * as React from 'react';
-export interface IFooterProps {
-    classes?: TFooterClasses;
-    renderBlocks?: TFooterRenderBlocks;
-    socialsLinks?: IFooterSocialLinks[];
-    phones?: IFooterPhones[];
-    navigationLinks?: IFooterNavLinks[];
+export interface FooterProps {
+    classes?: FooterClasses;
+    renderBlocks?: FooterRenderBlocks;
+    socialsLinks?: FooterSocialLinks[];
+    phones?: FooterPhones[];
+    navigationLinks?: FooterNavLinks[];
     ligal?: string | React.ReactElement;
     copyright?: string | React.ReactElement;
 }
-export declare const Footer: ({ renderBlocks: { withSocial, withPhones, withNavLinks, withCopyright, withSiteMap }, socialsLinks, phones, navigationLinks, ligal, copyright, classes }: IFooterProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Footer: ({ renderBlocks: { withSocial, withPhones, withNavLinks, withCopyright, withSiteMap }, socialsLinks, phones, navigationLinks, ligal, copyright, classes }: FooterProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1 +1 @@
-export { Footer, type IFooterProps } from './Footer';
+export { Footer, type FooterProps } from './Footer';

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

@@ -1,5 +1,5 @@
-import { IFooterNavLinks, IFooterPhones, IFooterSocialLinks } from './types';
+import { FooterNavLinks, FooterPhones, FooterSocialLinks } from './types';
 export declare const defaultCopyright: import("react/jsx-runtime").JSX.Element;
-export declare const defaultPhones: IFooterPhones[];
-export declare const defaultSocialsLinks: IFooterSocialLinks[];
-export declare const defaultNavigationLinks: IFooterNavLinks[];
+export declare const defaultPhones: FooterPhones[];
+export declare const defaultSocialsLinks: FooterSocialLinks[];
+export declare const defaultNavigationLinks: FooterNavLinks[];

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

@@ -1,38 +1,38 @@
-import { TCopyrightClasses, TFooterLogoClasses, TNavigationLinksClasses, TPhoneBlockClasses, TSiteMapClasses, TSocialLinksClasses } from '../ui';
+import { CopyrightClasses, FooterLogoClasses, NavigationLinksClasses, PhoneBlockClasses, SiteMapClasses, SocialLinksClasses } from '../ui';
 import { SpritesMap } from '../../../shared/ui';
-export interface IFooterSocialLinks {
+export interface FooterSocialLinks {
     iconName: `social/${SpritesMap['social']}`;
     href: string;
 }
-export interface IFooterNavLinks {
+export interface FooterNavLinks {
     groupLabel: string;
     links: {
         text: string;
         href: string;
     }[];
 }
-export interface IFooterPhones {
+export interface FooterPhones {
     phone: string;
     text: string;
 }
-export type TFooterRenderBlocks = {
+export type FooterRenderBlocks = {
     withSocial?: boolean;
     withPhones?: boolean;
     withNavLinks?: boolean;
     withCopyright?: boolean;
     withSiteMap?: boolean;
 };
-export type TFooterClasses = {
+export type FooterClasses = {
     root?: string;
     footerContainer?: string;
     footerWrapper?: string;
     footerHead?: string;
     footerSocialBlock?: string;
     footerBottom?: string;
-    footerLogo?: TFooterLogoClasses;
-    navLinks?: TNavigationLinksClasses;
-    phonesBlock?: TPhoneBlockClasses;
-    socialLinks?: TSocialLinksClasses;
-    siteMap?: TSiteMapClasses;
-    copyright?: TCopyrightClasses;
+    footerLogo?: FooterLogoClasses;
+    navLinks?: NavigationLinksClasses;
+    phonesBlock?: PhoneBlockClasses;
+    socialLinks?: SocialLinksClasses;
+    siteMap?: SiteMapClasses;
+    copyright?: CopyrightClasses;
 };

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

@@ -1,10 +1,10 @@
 import * as React from 'react';
-export type TCopyrightClasses = {
+export type CopyrightClasses = {
     copyRight?: string;
 };
-interface ICopyrightProps {
+interface CopyrightProps {
     text?: string | React.ReactElement;
-    classes?: TCopyrightClasses;
+    classes?: CopyrightClasses;
 }
-export declare const Copyright: ({ text, classes }: ICopyrightProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Copyright: ({ text, classes }: CopyrightProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,8 +1,8 @@
-export type TFooterLogoClasses = {
+export type FooterLogoClasses = {
     footerLogo?: string;
     footerLogoIcon?: string;
 };
-export interface IFooterLogoProps {
-    classes?: TFooterLogoClasses;
+export interface FooterLogoProps {
+    classes?: FooterLogoClasses;
 }
-export declare const FooterLogo: ({ classes }: IFooterLogoProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FooterLogo: ({ classes }: FooterLogoProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,5 +1,5 @@
-import { IFooterNavLinks } from '../model/types';
-export type TNavigationLinksClasses = {
+import { FooterNavLinks } from '../model/types';
+export type NavigationLinksClasses = {
     navRoot?: string;
     navGroup?: string;
     navLabel?: string;
@@ -7,9 +7,9 @@ export type TNavigationLinksClasses = {
     navLink?: string;
     navLinkIcon?: string;
 };
-interface INavLinksProps {
-    navigationLinks: IFooterNavLinks[];
-    classes?: TNavigationLinksClasses;
+interface NavLinksProps {
+    navigationLinks: FooterNavLinks[];
+    classes?: NavigationLinksClasses;
 }
-export declare const NavLinks: ({ navigationLinks, classes }: INavLinksProps) => import("react/jsx-runtime").JSX.Element;
+export declare const NavLinks: ({ navigationLinks, classes }: NavLinksProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,13 +1,13 @@
-import { IFooterPhones } from '../model/types';
-export type TPhoneBlockClasses = {
+import { FooterPhones } from '../model/types';
+export type PhoneBlockClasses = {
     phonesRoot?: string;
     phoneWrapper?: string;
     phoneText?: string;
     phoneLink?: string;
 };
-interface IPhonesBlockProps {
-    phones: IFooterPhones[];
-    classes?: TPhoneBlockClasses;
+interface PhonesBlockProps {
+    phones: FooterPhones[];
+    classes?: PhoneBlockClasses;
 }
-export declare const PhonesBlock: ({ phones, classes }: IPhonesBlockProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PhonesBlock: ({ phones, classes }: PhonesBlockProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,8 +1,8 @@
-export type TSiteMapClasses = {
+export type SiteMapClasses = {
     siteMapLink?: string;
     siteMapLinkIcon?: string;
 };
-export interface ISiteMapProps {
-    classes?: TSiteMapClasses;
+export interface SiteMapProps {
+    classes?: SiteMapClasses;
 }
-export declare const SiteMap: ({ classes }: ISiteMapProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SiteMap: ({ classes }: SiteMapProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,12 +1,12 @@
-import { IFooterSocialLinks } from '../model/types';
-export type TSocialLinksClasses = {
+import { FooterSocialLinks } from '../model/types';
+export type SocialLinksClasses = {
     socialRoot?: string;
     socialLink?: string;
     socialIcon?: string;
 };
 interface ISocialLinksProps {
-    socialsLinks: IFooterSocialLinks[];
-    classes?: TSocialLinksClasses;
+    socialsLinks: FooterSocialLinks[];
+    classes?: SocialLinksClasses;
 }
 export declare const SocialLinks: ({ socialsLinks, classes }: ISocialLinksProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,16 +1,16 @@
-import { TInterLinkingSchema } from './model/types';
-import { TColumnClasses } from './ui';
-import { IAccordionProps } from '../../shared/ui';
-export type TInterLinkingClasses = {
+import { InterLinkingSchema } from './model/types';
+import { ColumnClasses } from './ui';
+import { AccordionProps } from '../../shared/ui';
+export type InterLinkingClasses = {
     root?: string;
     heading?: string;
     columnsWrapper?: string;
-    column?: TColumnClasses;
+    column?: ColumnClasses;
 };
-export interface IInterLinkingProps {
-    data: TInterLinkingSchema;
-    mobileAccordionProps?: IAccordionProps;
-    rootAccordionProps?: IAccordionProps;
-    classes?: TInterLinkingClasses;
+export interface InterLinkingProps {
+    data: InterLinkingSchema;
+    mobileAccordionProps?: AccordionProps;
+    rootAccordionProps?: AccordionProps;
+    classes?: InterLinkingClasses;
 }
-export declare const InterLinking: ({ data, mobileAccordionProps, rootAccordionProps, classes }: IInterLinkingProps) => import("react/jsx-runtime").JSX.Element;
+export declare const InterLinking: ({ data, mobileAccordionProps, rootAccordionProps, classes }: InterLinkingProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { columnGroupSchema, interLinkingSchema } from './helpers';
 export type TColumnGroupSchema = z.infer<typeof columnGroupSchema>;
-export type TInterLinkingSchema = z.infer<typeof interLinkingSchema>;
-export type TColumnsLinks = TColumnGroupSchema[number]['links'];
-export type TColumnsGroupLabel = TColumnGroupSchema[number]['groupLabel'];
+export type InterLinkingSchema = z.infer<typeof interLinkingSchema>;
+export type ColumnsLinks = TColumnGroupSchema[number]['links'];
+export type ColumnsGroupLabel = TColumnGroupSchema[number]['groupLabel'];

package/dist/widgets/interLinking/ui/Column.d.ts

@@ -1,13 +1,13 @@
-import { IAccordionProps } from '../../../shared/ui';
+import { AccordionProps } from '../../../shared/ui';
 import { TColumnGroupSchema } from '../model/types';
-import { TColumnGroupClasses } from './ColumnGroup';
-export type TColumnClasses = {
+import { ColumnGroupClasses } from './ColumnGroup';
+export type ColumnClasses = {
     column?: string;
-    columnGroup?: TColumnGroupClasses;
+    columnGroup?: ColumnGroupClasses;
 };
-export interface IColumnProps {
+export interface ColumnProps {
     columnsGroup: TColumnGroupSchema;
-    mobileAccordionProps?: IAccordionProps;
-    classes?: TColumnClasses;
+    mobileAccordionProps?: AccordionProps;
+    classes?: ColumnClasses;
 }
-export declare const Column: ({ columnsGroup, mobileAccordionProps, classes }: IColumnProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Column: ({ columnsGroup, mobileAccordionProps, classes }: ColumnProps) => import("react/jsx-runtime").JSX.Element;