@gravity-ui/page-constructor 1.2.3-alpha.3 → 1.2.4

package/build/esm/blocks/HeaderSlider/schema.d.ts

@@ -151,139 +151,163 @@ export declare const HeaderSliderBlock: {
                         };
                         background: {
                             oneOf: ({
-                                fullWidth: {
-                                    type: string;
-                                };
-                                fullWidthMedia: {
-                                    type: string;
-                                };
-                                color: {
+                                oneOf: ({
                                     type: string;
-                                };
-                                image: {
-                                    anyOf: ({
-                                        oneOf: ({
+                                    additionalProperties: boolean;
+                                    required: never[];
+                                    properties: {
+                                        fullWidth: {
                                             type: string;
-                                            properties: {
-                                                when: {
-                                                    type: string;
-                                                };
-                                            };
-                                        } | {
+                                        };
+                                        color: {
                                             type: string;
-                                            pattern: string;
-                                        })[];
-                                    } | {
-                                        type: string;
-                                        items: {
-                                            oneOf: ({
-                                                type: string;
-                                                properties: {
-                                                    when: {
-                                                        type: string;
+                                        };
+                                        image: {
+                                            anyOf: ({
+                                                oneOf: ({
+                                                    type: string;
+                                                    properties: {
+                                                        when: {
+                                                            type: string;
+                                                        };
                                                     };
-                                                };
+                                                } | {
+                                                    type: string;
+                                                    pattern: string;
+                                                })[];
                                             } | {
                                                 type: string;
-                                                pattern: string;
+                                                items: {
+                                                    oneOf: ({
+                                                        type: string;
+                                                        properties: {
+                                                            when: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    } | {
+                                                        type: string;
+                                                        pattern: string;
+                                                    })[];
+                                                };
                                             })[];
                                         };
-                                    })[];
-                                };
-                                video: {
-                                    type: string;
-                                    additionalProperties: boolean;
-                                    required: string[];
-                                    properties: {
-                                        src: {
+                                        video: {
                                             type: string;
-                                            items: {
-                                                type: string;
+                                            additionalProperties: boolean;
+                                            required: string[];
+                                            properties: {
+                                                src: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                };
+                                                loop: {
+                                                    anyOf: ({
+                                                        type: string;
+                                                        additionalProperties: boolean;
+                                                        required: string[];
+                                                        properties: {
+                                                            start: {
+                                                                type: string;
+                                                            };
+                                                            end: {
+                                                                type: string;
+                                                            };
+                                                        };
+                                                    } | {
+                                                        type: string;
+                                                    })[];
+                                                };
+                                                type: {
+                                                    type: string;
+                                                    enum: string[];
+                                                };
+                                                muted: {
+                                                    type: string;
+                                                };
+                                                playing: {
+                                                    type: string;
+                                                };
+                                                elapsedTime: {
+                                                    type: string;
+                                                };
+                                                playIcon: {
+                                                    type: string;
+                                                    additionalProperties: boolean;
+                                                    properties: {
+                                                        type: {
+                                                            type: string;
+                                                            enum: string[];
+                                                        };
+                                                        theme: {
+                                                            type: string;
+                                                            enum: string[];
+                                                        };
+                                                        text: {
+                                                            type: string;
+                                                        };
+                                                    };
+                                                };
+                                                controls: {
+                                                    type: string;
+                                                    enum: string[];
+                                                };
                                             };
                                         };
-                                        loop: {
-                                            anyOf: ({
+                                        youtube: {
+                                            type: string;
+                                        };
+                                        parallax: {
+                                            type: string;
+                                        };
+                                        height: {
+                                            type: string;
+                                        };
+                                        previewImg: {
+                                            type: string;
+                                        };
+                                        dataLens: {
+                                            oneOf: ({
                                                 type: string;
                                                 additionalProperties: boolean;
                                                 required: string[];
                                                 properties: {
-                                                    start: {
+                                                    id: {
                                                         type: string;
                                                     };
-                                                    end: {
+                                                    theme: {
                                                         type: string;
+                                                        enum: string[];
                                                     };
                                                 };
                                             } | {
                                                 type: string;
                                             })[];
                                         };
-                                        type: {
-                                            type: string;
-                                            enum: string[];
-                                        };
-                                        muted: {
+                                    };
+                                } | {
+                                    type: string;
+                                    additionalProperties: boolean;
+                                    properties: {
+                                        color: {
                                             type: string;
                                         };
-                                        playing: {
+                                        url: {
                                             type: string;
                                         };
-                                        elapsedTime: {
+                                        disableCompress: {
                                             type: string;
                                         };
-                                        playIcon: {
+                                        fullWidth: {
                                             type: string;
-                                            additionalProperties: boolean;
-                                            properties: {
-                                                type: {
-                                                    type: string;
-                                                    enum: string[];
-                                                };
-                                                theme: {
-                                                    type: string;
-                                                    enum: string[];
-                                                };
-                                                text: {
-                                                    type: string;
-                                                };
-                                            };
                                         };
-                                        controls: {
+                                        fullWidthMedia: {
                                             type: string;
-                                            enum: string[];
                                         };
                                     };
-                                };
-                                youtube: {
-                                    type: string;
-                                };
-                                parallax: {
-                                    type: string;
-                                };
-                                height: {
-                                    type: string;
-                                };
-                                previewImg: {
-                                    type: string;
-                                };
-                                dataLens: {
-                                    oneOf: ({
-                                        type: string;
-                                        additionalProperties: boolean;
-                                        required: string[];
-                                        properties: {
-                                            id: {
-                                                type: string;
-                                            };
-                                            theme: {
-                                                type: string;
-                                                enum: string[];
-                                            };
-                                        };
-                                    } | {
-                                        type: string;
-                                    })[];
-                                };
+                                })[];
                             } | {
                                 type: string;
                                 additionalProperties: boolean;

package/build/esm/blocks/Tabs/Tabs.js

@@ -9,7 +9,6 @@ import FullScreenImage from '../../components/FullscreenImage/FullscreenImage';
 import Media from '../../components/Media/Media';
 import Links from '../../components/Link/Links';
 import { ThemeValueContext } from '../../context/theme/ThemeValueContext';
-import { getMediaImage } from '../../components/Media/Image/utils';
 import './Tabs.css';
 const b = block('TabsBlock');
 export const TabsBlock = ({ items, title, description, animated }) => {
@@ -21,7 +20,7 @@ export const TabsBlock = ({ items, title, description, animated }) => {
     let imageProps;
     if (activeTabData) {
         const themedImage = getThemedValue(activeTabData.image, theme);
-        imageProps = themedImage && getMediaImage(themedImage);
+        imageProps = typeof themedImage === 'string' ? { src: themedImage } : themedImage;
     }
     const showMedia = Boolean((activeTabData === null || activeTabData === void 0 ? void 0 : activeTabData.media) || imageProps);
     return (React.createElement(AnimateBlock, { className: b(), onScroll: () => setPlay(true), animate: animated },
@@ -34,7 +33,7 @@ export const TabsBlock = ({ items, title, description, animated }) => {
                 } },
                 (activeTabData === null || activeTabData === void 0 ? void 0 : activeTabData.media) && (React.createElement(Media, Object.assign({}, getThemedValue(activeTabData.media, theme), { key: activeTab, className: b('media'), playVideo: play }))),
                 imageProps && (React.createElement(Fragment, null,
-                    React.createElement(FullScreenImage, Object.assign({}, imageProps, { imageClassName: b('image') })),
+                    React.createElement(FullScreenImage, { imageClassName: b('image'), src: (imageProps && imageProps.src) || 'default_image', alt: imageProps && imageProps.alt, disableCompress: imageProps === null || imageProps === void 0 ? void 0 : imageProps.disableCompress }),
                     activeTabData && (React.createElement("p", { className: b('caption') }, activeTabData.caption)))))),
             React.createElement(Col, { sizes: { all: 12, md: showMedia ? 4 : 8 }, className: b('content') },
                 React.createElement("div", { className: b('content-wrapper', {

package/build/esm/blocks/Tabs/schema.js

@@ -1,6 +1,5 @@
 import { filteredArray } from '../../schema/validators/utils';
-import { LinkProps, withTheme, BlockBaseProps, TitleProps, MediaProps, } from '../../schema/validators/common';
-import { ImageProps } from '../../components/Image/schema';
+import { ImageProps, LinkProps, withTheme, BlockBaseProps, TitleProps, MediaProps, } from '../../schema/validators/common';
 export const tabsItem = {
     type: 'object',
     additionalProperties: false,

package/build/esm/components/BackgroundImage/BackgroundImage.js

@@ -4,9 +4,9 @@ import Image from '../Image/Image';
 import './BackgroundImage.css';
 const b = block('storage-background-image');
 const BackgroundImage = (props) => {
-    const { children, src, desktop, className, imageClassName, style, hide } = props;
+    const { children, src, alt, disableCompress, className, imageClassName, style, hide } = props;
     return (React.createElement("div", { className: b(null, className), style: style },
-        (src || desktop) && !hide && React.createElement(Image, Object.assign({}, props, { className: b('img', imageClassName) })),
+        src && !hide && (React.createElement(Image, { className: b('img', imageClassName), src: src, alt: alt, disableCompress: disableCompress })),
         children && React.createElement("div", { className: b('container') }, children)));
 };
 export default BackgroundImage;

package/build/esm/components/FullscreenImage/FullscreenImage.d.ts

@@ -1,7 +1,7 @@
 import { CSSProperties } from 'react';
-import { ImageOwnProps } from '../Image/Image';
+import { ImageProps } from '../Image/Image';
 import './FullScreenImage.css';
-export interface FullScreenImageProps extends ImageOwnProps {
+export interface FullScreenImageProps extends ImageProps {
     imageClassName?: string;
     modalImageClass?: string;
     imageStyle?: CSSProperties;

package/build/esm/components/Image/Image.d.ts

@@ -1,9 +1,11 @@
 import { CSSProperties, MouseEventHandler } from 'react';
-import { ImageDeviceProps, ImageObjectProps } from '../../models';
-export interface ImageOwnProps extends Partial<ImageObjectProps>, Partial<ImageDeviceProps> {
+export interface ImageProps {
+    src: string;
+    alt?: string;
+    disableCompress?: boolean;
     style?: CSSProperties;
     className?: string;
     onClick?: MouseEventHandler;
 }
-declare const Image: (props: ImageOwnProps) => JSX.Element | null;
+declare const Image: (props: ImageProps) => JSX.Element | null;
 export default Image;

package/build/esm/components/Image/Image.js

@@ -1,24 +1,20 @@
 import React, { useContext, useState } from 'react';
 import { ProjectSettingsContext } from '../../context/projectSettingsContext';
-import { BREAKPOINTS } from '../../constants';
 const Image = (props) => {
     const projectSettings = useContext(ProjectSettingsContext);
-    const { src, alt, disableCompress, tablet, desktop, mobile, style, className, onClick } = props;
+    const { src, alt, disableCompress, style, className, onClick } = props;
     const [imgLoadingError, setImgLoadingError] = useState(false);
-    const imageSrc = src || desktop;
-    if (!imageSrc) {
+    if (!src) {
         return null;
     }
     // TODO: Temporary solution for .svg images
     const disableWebp = projectSettings.disableCompress ||
         disableCompress ||
-        imageSrc.endsWith('.svg') ||
+        src.endsWith('.svg') ||
         imgLoadingError;
-    const webp = imageSrc.endsWith('.webp') ? src : src + '.webp';
+    const webp = src.endsWith('.webp') ? src : src + '.webp';
     return (React.createElement("picture", null,
         disableWebp ? null : React.createElement("source", { srcSet: webp, type: "image/webp" }),
-        mobile && React.createElement("source", { srcSet: mobile, media: `(max-width: ${BREAKPOINTS.sm}px)` }),
-        tablet && React.createElement("source", { srcSet: tablet, media: `(max-width: ${BREAKPOINTS.md}px)` }),
-        React.createElement("img", { className: className, src: imageSrc, alt: alt, style: style, onClick: onClick, onError: () => setImgLoadingError(true) })));
+        React.createElement("img", { className: className, src: src, alt: alt, style: style, onClick: onClick, onError: () => setImgLoadingError(true) })));
 };
 export default Image;

package/build/esm/components/Media/Image/Image.js

@@ -34,16 +34,16 @@ const Image = (props) => {
     const imageClass = b('item', { withVideo: Boolean(video) && !hasVideoFallback }, imageClassName);
     const imageSlider = (imageArray) => (React.createElement(SliderBlock, { slidesToShow: 1, type: SliderType.MediaCard }, imageArray.map((item) => {
         const itemData = getMediaImage(item);
-        return (React.createElement(FullScreenImage, Object.assign({ key: itemData.alt }, itemData, { imageClassName: imageClass, imageStyle: { height } })));
+        return (React.createElement(FullScreenImage, { key: itemData.src, src: itemData.src, alt: itemData.alt, imageClassName: imageClass, imageStyle: { height } }));
     })));
     const imageBackground = (oneImage) => {
         const imageData = getMediaImage(oneImage);
         return (React.createElement(animated.div, { style: { transform: parallaxInterpolate } },
-            React.createElement(BackgroundImage, Object.assign({}, imageData, { className: imageClass, style: { height } }))));
+            React.createElement(BackgroundImage, { className: imageClass, src: imageData.src, style: { height }, disableCompress: imageData.disableCompress })));
     };
     const imageOnly = (oneImage) => {
         const imageData = getMediaImage(oneImage);
-        return React.createElement(ImageView, Object.assign({}, imageData, { className: imageClass, style: { height } }));
+        return (React.createElement(ImageView, { className: imageClass, src: imageData.src, alt: imageData.alt, style: { height }, disableCompress: imageData.disableCompress }));
     };
     if (Array.isArray(image)) {
         return imageSlider(image);

package/build/esm/components/Media/Image/utils.d.ts

@@ -1,2 +1,2 @@
-import { ImageProps } from '../../../models';
-export declare function getMediaImage(image: ImageProps): import("../../../models").ImageObjectProps | import("../../../models").ImageDeviceProps;
+import { ImageObjectProps, ImageProps } from '../../../models';
+export declare function getMediaImage(image: ImageProps): ImageObjectProps;

package/build/esm/models/constructor-items/blocks.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { BackgroundImageProps, ButtonProps, ContentSize, ContentTextSize, ContentTheme, FileLinkProps, HeaderBreadCrumbsProps, HeaderImageSize, HeaderOffset, HeaderWidth, Justify, LinkProps, LinkTheme, MediaDirection, MediaProps, PreviewItemProps, PreviewRatioMediaContent, TextSize, TextTheme, ThemedImage, ThemedMediaProps, ThemedMediaVideoProps, TitleProps, LegendTableMarkerType, AnchorProps, TitleBaseProps, Animatable, BlockHeaderProps, ImageDeviceProps, ImageProps } from './common';
+import { BackgroundImageProps, ButtonProps, ContentSize, ContentTextSize, ContentTheme, FileLinkProps, HeaderBreadCrumbsProps, HeaderImageSize, HeaderOffset, HeaderWidth, Justify, LinkProps, LinkTheme, MediaDirection, MediaProps, PreviewItemProps, PreviewRatioMediaContent, TextSize, TextTheme, ThemedImage, ThemedMediaProps, ThemedMediaVideoProps, TitleProps, LegendTableMarkerType, AnchorProps, TitleBaseProps, Animatable, BlockHeaderProps } from './common';
 import { ThemeSupporting } from '../../utils';
 import { GridColumnSize, GridColumnSizesType } from '../../grid/types';
 import { BannerCardProps, SubBlock } from './sub-blocks';
@@ -78,9 +78,8 @@ export interface HeaderSliderBlockProps extends Omit<SliderProps, 'title' | 'des
     items: HeaderBlockProps[];
 }
 interface HeaderBackgroundProps {
-    /** @deprecated replaced by Media Props image */
-    url?: ImageProps;
-    /** @deprecated replaced by Media Props image */
+    color?: string;
+    url?: string;
     disableCompress?: boolean;
 }
 export interface HeaderBlockBackground extends Partial<HeaderBackgroundProps>, Partial<MediaProps> {
@@ -152,7 +151,12 @@ export interface BannerBlockProps extends BannerCardProps, Animatable {
 }
 export interface CompaniesBlockProps extends Animatable {
     title: string;
-    images: ThemeSupporting<ImageDeviceProps>;
+    images: ThemeSupporting<{
+        desktop: string;
+        tablet: string;
+        mobile: string;
+        alt?: string;
+    }>;
 }
 export interface MediaContentProps {
     title: string;

package/build/esm/models/constructor-items/common.d.ts

@@ -81,21 +81,17 @@ interface LoopProps {
     start: number;
     end?: number;
 }
-export interface ImageInfoProps {
+export interface ImageObjectProps {
+    src: string;
     alt?: string;
     disableCompress?: boolean;
 }
-export interface ImageObjectProps extends ImageInfoProps {
-    src: string;
-}
-export interface ImageDeviceProps extends ImageInfoProps {
-    desktop: string;
-    mobile: string;
-    tablet?: string;
-}
-export declare type ImageProps = string | ImageObjectProps | ImageDeviceProps;
+export declare type ImageProps = string | ImageObjectProps;
 export declare type ThemedImage = ThemeSupporting<ImageProps>;
-export interface BackgroundImageProps extends React.HTMLProps<HTMLDivElement>, Partial<ImageDeviceProps>, Partial<ImageObjectProps> {
+export interface BackgroundImageProps extends React.HTMLProps<HTMLDivElement> {
+    src?: string;
+    alt?: string;
+    disableCompress?: boolean;
     style?: CSSProperties;
     imageClassName?: string;
     hide?: boolean;

package/build/esm/models/guards.d.ts

@@ -1,4 +1,5 @@
-import { Block, ConstructorItem } from './';
-import { MetrikaGoal, NewMetrikaGoal } from './index';
+import { Block, ConstructorItem, HeaderBlockBackground } from './';
+import { MediaProps, MetrikaGoal, NewMetrikaGoal } from './index';
 export declare function isBlock(block: ConstructorItem): block is Block;
 export declare function isNewMetrikaFormat(metrika: MetrikaGoal): metrika is NewMetrikaGoal[];
+export declare function headerHasMediaBackground(background: HeaderBlockBackground): background is MediaProps;

package/build/esm/models/guards.js

@@ -5,3 +5,6 @@ export function isBlock(block) {
 export function isNewMetrikaFormat(metrika) {
     return Boolean(Array.isArray(metrika) && metrika.length && typeof metrika[0] === 'object');
 }
+export function headerHasMediaBackground(background) {
+    return 'image' in background || 'video' in background || 'youtube' in background;
+}

package/build/esm/schema/validators/common.d.ts

@@ -19,6 +19,7 @@ export declare const sizeNumber: {
     minimum: number;
 };
 export declare const contentThemes: string[];
+export declare const urlPattern = "^((http[s]?|ftp):\\/)?\\/?([^:\\/\\s]+)((\\/\\w+)*\\/)([\\w\\-\\.]+[^#?\\s]+)(.*)?(#[\\w\\-]+)?$";
 export declare const BaseProps: {
     type: {};
     when: {};
@@ -158,6 +159,36 @@ export declare const JustifyProps: {
     type: string;
     enum: string[];
 };
+export declare const ImageObjectProps: {
+    type: string;
+    additionalProperties: boolean;
+    required: string[];
+    properties: {
+        src: {
+            type: string;
+            pattern: string;
+        };
+        alt: {
+            type: string;
+        };
+        disableCompress: {
+            type: string;
+        };
+    };
+};
+export declare const ImageProps: {
+    oneOf: ({
+        type: string;
+        properties: {
+            when: {
+                type: string;
+            };
+        };
+    } | {
+        type: string;
+        pattern: string;
+    })[];
+};
 export declare const DataLensObjectProps: {
     type: string;
     additionalProperties: boolean;

package/build/esm/schema/validators/common.js

@@ -1,6 +1,6 @@
+import { filteredItem } from './utils';
 import { pixelEvents } from './pixel';
 import { Theme } from '../../models';
-import { ImageProps, urlPattern } from '../../components/Image/schema';
 export const mediaDirection = ['media-content', 'content-media'];
 export const textSize = ['s', 'm', 'l'];
 export const containerSizesArray = ['sm', 'md', 'lg', 'xl', 'all'];
@@ -15,6 +15,7 @@ export const fileLinkTypes = ['vertical', 'horizontal'];
 export const dividerEnum = { enum: [0, 'xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl', 'xxxl'] };
 export const sizeNumber = { type: 'number', maximum: 12, minimum: 1 };
 export const contentThemes = ['default', 'dark', 'light'];
+export const urlPattern = '^((http[s]?|ftp):\\/)?\\/?([^:\\/\\s]+)((\\/\\w+)*\\/)([\\w\\-\\.]+[^#?\\s]+)(.*)?(#[\\w\\-]+)?$';
 export const BaseProps = {
     type: {},
     when: {},
@@ -126,6 +127,32 @@ export const JustifyProps = {
     type: 'string',
     enum: ['start', 'center', 'end'],
 };
+export const ImageObjectProps = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['src'],
+    properties: {
+        src: {
+            type: 'string',
+            pattern: urlPattern,
+        },
+        alt: {
+            type: 'string',
+        },
+        disableCompress: {
+            type: 'boolean',
+        },
+    },
+};
+export const ImageProps = {
+    oneOf: [
+        {
+            type: 'string',
+            pattern: urlPattern,
+        },
+        filteredItem(Object.assign({}, ImageObjectProps)),
+    ],
+};
 export const DataLensObjectProps = {
     type: 'object',
     additionalProperties: false,

package/build/esm/sub-blocks/BackgroundCard/schema.js

@@ -1,7 +1,6 @@
-import { BaseProps, withTheme } from '../../schema/validators/common';
+import { BaseProps, ImageObjectProps, withTheme } from '../../schema/validators/common';
 import { CardBase } from '../../components/CardBase/schema';
 import { ContentBase } from '../Content/schema';
-import { ImageObjectProps } from '../../components/Image/schema';
 import _ from 'lodash';
 const BackgroundCardContentProps = _.omit(ContentBase, ['size']);
 export const BackgroundCard = {

package/build/esm/sub-blocks/BasicCard/BasicCard.js

@@ -11,7 +11,7 @@ const BasicCard = (props) => {
     const iconProps = icon && getMediaImage(icon);
     return (React.createElement(CardBase, { className: b(), url: url, border: border },
         React.createElement(CardBase.Content, null,
-            iconProps && React.createElement(Image, Object.assign({}, iconProps, { className: b('icon') })),
+            iconProps && (React.createElement(Image, { src: iconProps.src, alt: iconProps.alt, className: b('icon'), disableCompress: iconProps.disableCompress })),
             React.createElement(Content, { title: title, text: text, additionalInfo: additionalInfo, links: links, buttons: buttons, colSizes: { all: 12, md: 12 }, size: "s" }))));
 };
 export default BasicCard;

package/build/esm/sub-blocks/BasicCard/schema.js

@@ -1,8 +1,7 @@
 import _ from 'lodash';
-import { BaseProps } from '../../schema/validators/common';
+import { BaseProps, ImageProps } from '../../schema/validators/common';
 import { CardBase } from '../../components/CardBase/schema';
 import { ContentBase } from '../Content/schema';
-import { ImageProps } from '../../components/Image/schema';
 const BasicCardContentProps = _.omit(ContentBase, ['size', 'theme']);
 export const BasicCard = {
     'basic-card': {

package/build/esm/sub-blocks/Content/Content.css

@@ -22,10 +22,11 @@ unpredictable css rules order in build */
   color: var(--yc-color-text-primary);
 }
 
-.pc-content__button {
+.pc-content__button.pc-content__button {
   margin-top: 0;
   margin-right: 12px;
 }
+
 .pc-content__links {
   display: flex;
   flex-direction: column;

package/build/esm/sub-blocks/Partner/Partner.js

@@ -7,7 +7,7 @@ const Partner = ({ text, logo, url, border }) => {
     const logoData = typeof logo === 'string' ? { src: logo } : logo;
     return (React.createElement(CardBase, { url: url, target: "_blank", className: b(), border: border },
         React.createElement(CardBase.Content, null,
-            React.createElement(Image, Object.assign({ className: b('logo') }, logoData)),
+            React.createElement(Image, { className: b('logo'), src: logoData.src, alt: logoData.alt }),
             React.createElement(HTML, null, text))));
 };
 export default Partner;

package/build/esm/sub-blocks/Partner/schema.js

@@ -1,5 +1,4 @@
-import { BaseProps } from '../../schema/validators/common';
-import { ImageProps } from '../../components/Image/schema';
+import { BaseProps, ImageProps } from '../../schema/validators/common';
 export const PartnerBlock = {
     partner: {
         additionalProperties: false,