react-bricks 4.7.0-beta.0 → 4.7.0-beta.1

package/astro/react-bricks-astro.d.ts

@@ -0,0 +1,1216 @@
+import * as React from 'react';
+import React__default from 'react';
+import { Descendant, Editor, BaseEditor, Element, Node } from 'slate';
+import { RenderElementProps, RenderLeafProps, ReactEditor } from 'slate-react';
+import { HistoryEditor } from 'slate-history';
+
+declare namespace types {
+    export const EmbedProp = "RB_PAGE_EMBED";
+    export const EmbedContent = "RB_PAGE_EMBED_CONTENT";
+    /**
+     * Type of Sidebar control
+     */
+    export enum SideEditPropType {
+        Text = "TEXT",
+        Textarea = "TEXTAREA",
+        Number = "NUMBER",
+        Date = "DATE",
+        Range = "RANGE",
+        Boolean = "BOOLEAN",
+        Select = "SELECT",
+        Autocomplete = "AUTOCOMPLETE",
+        Image = "IMAGE",
+        Custom = "CUSTOM",
+        Relationship = "RELATIONSHIP",
+        IconSelector = "ICON-SELECTOR"
+    }
+    /**
+     * How to display the options
+     */
+    export enum OptionsDisplay {
+        Select = "SELECT",
+        Radio = "RADIO",
+        Color = "COLOR"
+    }
+    /**
+     * Features for RichText: see also the new RichTextExt
+     */
+    export enum RichTextFeatures {
+        Bold = "BOLD",
+        Italic = "ITALIC",
+        Code = "CODE",
+        Highlight = "HIGHLIGHT",
+        Subscript = "SUB",
+        Superscript = "SUP",
+        Link = "LINK",
+        UnorderedList = "UL",
+        OrderedList = "OL",
+        Heading1 = "H1",
+        Heading2 = "H2",
+        Heading3 = "H3",
+        Heading4 = "H4",
+        Heading5 = "H5",
+        Heading6 = "H6",
+        Quote = "QUOTE"
+    }
+    /**
+     * Supported Icon Sets
+     */
+    export enum IconSets {
+        HeroIconSolid = "hi-solid",
+        HeroIconOutline = "hi-outline",
+        FontAwesome = "fa6",
+        Feather = "fi"
+    }
+    /**
+     * Page status
+     */
+    export enum PageStatus {
+        Draft = "DRAFT",
+        Published = "PUBLISHED"
+    }
+    /**
+     * Approval status
+     */
+    export enum EditStatus {
+        Merged = "MERGED",
+        Working = "WORKING",
+        MergeRequested = "MERGE_REQUESTED"
+    }
+    /**
+     * Device type for responsive preview (for the icon)
+     */
+    export enum DeviceType {
+        Desktop = "DESKTOP",
+        Tablet = "TABLET",
+        Phone = "PHONE"
+    }
+    /**
+     * Corner for the click-to-edit button
+     */
+    export enum ClickToEditSide {
+        BottomRight = "BOTTOM-RIGHT",
+        BottomLeft = "BOTTOM-LEFT",
+        TopRight = "TOP-RIGHT",
+        TopLeft = "TOP-LEFT",
+        None = "NONE"
+    }
+    export enum BlockIconsPosition {
+        InsideBlock = "INSIDE-BLOCK",
+        OutsideBlock = "OUTSIDE-BLOCK"
+    }
+    /**
+     * A Brick is a type of content block
+     */
+    export type Brick<T = {}> = React__default.FC<T> & {
+        schema: IBlockType<T>;
+    };
+    /**
+     * Bricks are types of content block
+     */
+    export type Bricks = {
+        [key: string]: Brick<any>;
+    };
+    /**
+     * A Category contains bricks
+     */
+    export type Category = {
+        categoryName: string;
+        bricks: Brick<any>[];
+    };
+    /**
+     * A Theme contains categories and bricks
+     */
+    export type Theme = {
+        themeName: string;
+        categories: Category[];
+    };
+    /**
+     * Custom role type
+     */
+    export type CustomRole = {
+        id: string;
+        name: string;
+    };
+    /**
+     * The type of the user passed to permission functions
+     */
+    export type PermissionUser = {
+        firstName: string;
+        lastName: string;
+        email: string;
+        isAdmin: boolean;
+        role: string;
+        customRole?: CustomRole;
+    };
+    /**
+     * The type of the page passed to permission functions
+     */
+    export type PermissionPage = {
+        slug: string;
+        pageType: string;
+        language: string;
+    };
+    /**
+     * The type of the brick passed to permission functions
+     */
+    export type PermissionBrick = {
+        name: string;
+        category: string;
+        theme: string;
+        tags: string[];
+    };
+    /**
+     * The permission functions
+     */
+    export type Permissions = {
+        canAddPage?: (user: PermissionUser, pageType: string) => boolean;
+        canAddTranslation?: (user: PermissionUser, pageType: string, language: string) => boolean;
+        canSeePageType?: (user: PermissionUser, pageType: string) => boolean;
+        canSeePage?: (user: PermissionUser, page: Omit<PermissionPage, 'language'>) => boolean;
+        canEditPage?: (user: PermissionUser, page: PermissionPage) => boolean;
+        canDeletePage?: (user: PermissionUser, page: Omit<PermissionPage, 'language'>) => boolean;
+        canDeleteTranslation?: (user: PermissionUser, page: PermissionPage) => boolean;
+        canUseBrick?: (user: PermissionUser, brick: PermissionBrick) => boolean;
+    };
+    /**
+     * The logged-in User
+     */
+    export type User = {
+        id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        company: string;
+        avatarUrl?: string;
+        isAdmin: boolean;
+        token: string;
+        appName: string;
+        appId: string;
+        appEnv: string;
+        deployHookUrl?: string;
+        deployHookMethod?: string;
+        deployHookTriggerOnScheduledPublishing: boolean;
+        deployHookStagingUrl?: string;
+        deployHookStagingMethod?: string;
+        deployHookStagingTriggerOnScheduledPublishing: boolean;
+        deployHookDevUrl?: string;
+        deployHookDevMethod?: string;
+        deployHookDevTriggerOnScheduledPublishing: boolean;
+        eventsHookUrl?: string;
+        eventsHookAuthToken?: string;
+        canCreatePage: boolean;
+        canDeletePage: boolean;
+        canDeploy: boolean;
+        canDeployStaging: boolean;
+        canDeployDev: boolean;
+        canEditPageAttributes: boolean;
+        canEditSeo: boolean;
+        canApprove: boolean;
+        role: string;
+        customRole?: CustomRole;
+        plan: string;
+        isVerified: boolean;
+        languages: Language[];
+        defaultLanguage: string;
+        hostname: string;
+        useWorkingCopy: boolean;
+        useApprovalWorkflow: boolean;
+        subscription: {
+            maxStories: number;
+            collaboration: boolean;
+            deployHookStaging: boolean;
+            deployHookDev: boolean;
+            scheduledPublishing: boolean;
+            embedPages: boolean;
+            lockBlocks: boolean;
+            flexibleRoles: boolean;
+            advancedSeo: boolean;
+            eventsLog: boolean;
+            maxFileSize: number;
+            maxImageSize: number;
+            maxFilesBatch: number;
+            maxFilesConcurrency: number;
+            diskSpace: number;
+            advancedDam: boolean;
+            workingCopy: boolean;
+            approvalWorkflow: boolean;
+            template: boolean;
+        };
+    } | null;
+    /**
+     * Translation for a Page
+     */
+    export type Translation = {
+        language: string;
+        slug: string;
+        name: string;
+        status: PageStatus;
+        editStatus: EditStatus;
+        isLocked: boolean;
+        scheduledForPublishingOn: string;
+    };
+    /**
+     * The page editing User
+     */
+    export type EditingUser = {
+        id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        company: string;
+        avatarUrl?: string;
+    };
+    /**
+     * Date and User of last edit
+     */
+    export type LastEditedBy = {
+        date: string;
+        user: EditingUser;
+    };
+    /**
+     * A React Bricks Page
+     */
+    export type Page = {
+        id: string;
+        type: string;
+        name: string;
+        slug: string;
+        meta: IMeta;
+        customValues?: Props;
+        externalData?: Props;
+        content: IContentBlock[];
+        workingContent?: IContentBlock[];
+        committedContent?: IContentBlock[];
+        authorId?: string;
+        author: Author;
+        invalidBlocksTypes?: string[];
+        status: PageStatus;
+        editStatus: EditStatus;
+        isLocked: boolean;
+        tags: string[];
+        category?: string;
+        createdAt: string;
+        publishedAt?: string;
+        scheduledForPublishingOn?: string;
+        language: string;
+        translations: Translation[];
+        lastEditedBy: LastEditedBy;
+    };
+    /**
+     * Page fields (without content)
+     */
+    export type PageValues = Omit<Page, 'content'>;
+    /**
+     * A Page with all optional fields, used for the patch
+     */
+    export type PartialPage = Partial<Page>;
+    /**
+     * Page from a list (no content)
+     */
+    export type PageFromList = Omit<Page, 'content'>;
+    /**
+     * Page from a list with pagination
+     */
+    export type PagesFromListWithPagination = {
+        items: PageFromList[];
+        pagination: {
+            page: number;
+            pageSize: number;
+            totalItems: number;
+            totalPages: number;
+        };
+    };
+    /**
+     * The Author of a Page
+     */
+    export type Author = {
+        id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        avatarUrl?: string;
+        company?: string;
+    };
+    export type BrickStory<T = Props> = {
+        id: string;
+        name: string;
+        showAsBrick?: boolean;
+        previewImageUrl?: string;
+        props: T;
+    };
+    type RepeaterItemDefault = IContentBlock | Omit<IContentBlock, 'id'> | Props;
+    export type RepeaterItems<T = RepeaterItemDefault> = Array<T>;
+    /**
+     * A Language for i18n
+     */
+    export type Language = {
+        code: string;
+        name: string;
+    };
+    /**
+     * Render function for local links (should use the app's Router)
+     */
+    interface LocalLinkProps {
+        href: string;
+        target?: string;
+        className?: string;
+        activeClassName?: string;
+        isAdmin?: boolean;
+        tabIndex?: number;
+    }
+    type LocalLinkPropsReal = React__default.PropsWithChildren<Omit<React__default.AnchorHTMLAttributes<HTMLAnchorElement>, keyof LocalLinkProps> & LocalLinkProps>;
+    export type RenderLocalLink = ({ href, target, className, activeClassName, isAdmin, tabIndex, children, }: LocalLinkPropsReal) => React__default.ReactElement;
+    /**-
+     * The type of Text and RichText value
+     */
+    export type TextValue = Descendant[] | string;
+    /**
+     * Props of a content block
+     */
+    export type Props = {
+        [key: string]: any;
+    };
+    /**
+     * Options passed to the fetch function
+     */
+    export type FetchOptions = {
+        cache?: string;
+        next?: {
+            [key: string]: any;
+        };
+    };
+    /**
+     * Interface for the Schema of a Brick
+     */
+    export interface IBlockType<T = Props> {
+        name: string;
+        label: string;
+        getDefaultProps?: () => Partial<T>;
+        hideFromAddMenu?: boolean;
+        sideEditProps?: Array<ISideEditProp<T> | ISideGroup<T>>;
+        repeaterItems?: IRepeaterItem[];
+        newItemMenuOpen?: boolean;
+        groupByRepeater?: boolean;
+        mapExternalDataToProps?: (externalData: Props, brickProps?: T) => Partial<T>;
+        getData?: (page: Page, brickProps?: T, args?: any) => Promise<Partial<T>>;
+        getExternalData?: (page: Page, brickProps?: T, args?: any) => Promise<Partial<T>>;
+        playgroundLinkUrl?: string;
+        playgroundLinkLabel?: string;
+        theme?: string;
+        category?: string;
+        tags?: string[];
+        previewImageUrl?: string;
+        previewIcon?: React__default.ReactElement;
+        stories?: BrickStory<Partial<T>>[];
+        astroInteractivity?: 'load' | {
+            load: true;
+        } | 'idle' | {
+            idle: true;
+        } | {
+            idle: {
+                timeout: number;
+            };
+        } | 'visible' | {
+            visible: true;
+        } | {
+            visible: {
+                rootMargin: string;
+            };
+        } | {
+            media: string;
+        } | {
+            only: string;
+        };
+    }
+    /**
+     * Item of a Repeater
+     */
+    export interface IRepeaterItem {
+        name: string;
+        label?: string;
+        itemType?: string;
+        itemLabel?: string;
+        defaultOpen?: boolean;
+        min?: number;
+        max?: number;
+        positionLabel?: string;
+        getDefaultProps?: () => Props;
+        items?: {
+            type: string;
+            label?: string;
+            min?: number;
+            max?: number;
+            getDefaultProps?: () => Props;
+        }[];
+    }
+    /**
+     * The content of a block (instance of a Brick)
+     */
+    export interface IContentBlock {
+        id: string;
+        type: string;
+        props: Props;
+        locked?: boolean;
+        canAddAfter?: boolean;
+        canAddBefore?: boolean;
+        canEditContent?: boolean;
+    }
+    /**
+     * Option of a select sidebar prop
+     */
+    export interface IOption {
+        value: any;
+        label: string;
+    }
+    /**
+     * Interface for Props of a Custom sidebar component
+     */
+    export interface ICustomKnobProps {
+        id: string;
+        value: any;
+        onChange: any;
+        isValid: boolean;
+        errorMessage?: string;
+    }
+    /**
+     * Sidebar edit Props for a Page
+     */
+    export interface ISideEditPropPage<T = Props> {
+        name: string;
+        label: string;
+        type: SideEditPropType;
+        component?: React__default.FC<ICustomKnobProps>;
+        validate?: (value: any, props?: T) => boolean | string;
+        show?: (props: T, page?: Page, user?: User) => boolean;
+        helperText?: string;
+        textareaOptions?: {
+            height?: number;
+        };
+        imageOptions?: {
+            maxWidth?: number;
+            quality?: number;
+            aspectRatio?: number;
+        };
+        rangeOptions?: {
+            min?: number;
+            max?: number;
+            step?: number;
+        };
+        selectOptions?: {
+            options?: IOption[];
+            getOptions?: (props: Props) => IOption[] | Promise<IOption[]>;
+            display: OptionsDisplay;
+        };
+        autocompleteOptions?: {
+            placeholder?: string;
+            getOptions: (input: string, props: Props) => any[] | Promise<any[]>;
+            getKey: (option: any) => string | number;
+            getLabel: (option: any) => string;
+            renderOption?: ({ option, selected, focus, }: {
+                option: any;
+                selected: boolean;
+                focus: boolean;
+            }) => React__default.ReactElement;
+            debounceTime?: number;
+            getNoOptionsMessage?: (input?: string) => string;
+        };
+        iconSelectorOptions?: {
+            iconSets?: IconSets[];
+        };
+        relationshipOptions?: {
+            label?: string;
+            references: string;
+            multiple: boolean;
+            embedValues?: boolean;
+        };
+    }
+    /**
+     * Sidebar Edit Props
+     */
+    export interface ISideEditProp<T = Props> extends ISideEditPropPage<T> {
+        shouldRefreshText?: boolean;
+        shouldRefreshStyles?: boolean;
+    }
+    /**
+     * A collapsible Group of sidebar Props
+     */
+    export interface ISideGroup<T = Props> {
+        groupName: string;
+        defaultOpen?: boolean;
+        show?: (props: T, page?: Page, user?: User) => boolean;
+        props: ISideEditProp<T>[] | ISideEditPropPage<T>[];
+    }
+    /**
+     * Image Crop interface
+     */
+    export interface ICrop {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }
+    /**
+     * Image Transform interface
+     */
+    export interface ITransform {
+        rotate?: number;
+        flip?: {
+            horizontal: boolean;
+            vertical: boolean;
+        };
+    }
+    /**
+     * Image value interface
+     */
+    export interface IImageSource {
+        src: string;
+        srcSet?: string;
+        type?: string;
+        fallbackSrc?: string;
+        fallbackSrcSet?: string;
+        fallbackType?: string;
+        placeholderSrc?: string;
+        alt?: string;
+        seoName?: string;
+        width?: number;
+        height?: number;
+        highPriority?: boolean;
+        hashId?: string;
+        crop?: ICrop;
+        transform?: ITransform;
+    }
+    /**
+     * File value interface
+     */
+    export interface IFileSource {
+        name: string;
+        url: string;
+        size: number;
+        extension: string;
+        pagesNum: number;
+        title?: string | undefined;
+        alt?: string | undefined;
+        copyright?: string | undefined;
+        source?: string | undefined;
+    }
+    /**
+     * A Color for a Select sidebar prop
+     */
+    export interface IColor {
+        color: string;
+        [propName: string]: any;
+    }
+    export interface IBrickStory {
+        brickName: string;
+        storyName: string;
+        locked?: boolean;
+        canAddAfter?: boolean;
+        canAddBefore?: boolean;
+    }
+    /**
+     * TemplateSlot type
+     */
+    export type TemplateSlot = {
+        slotName: string;
+        label: string;
+        min?: number;
+        max?: number;
+        allowedBlockTypes?: string[];
+        excludedBlockTypes?: string[];
+        editable?: boolean;
+        getDefaultContent?: () => (string | IBrickStory | IContentBlock)[];
+    };
+    /**
+     * Page type
+     */
+    export interface IPageType {
+        name: string;
+        pluralName: string;
+        isEntity?: boolean;
+        allowedBlockTypes?: string[];
+        excludedBlockTypes?: string[];
+        defaultLocked?: boolean;
+        defaultStatus?: PageStatus;
+        defaultFeaturedImage?: string;
+        getDefaultContent?: () => (string | IBrickStory | IContentBlock)[];
+        customFields?: Array<ISideEditPropPage | ISideGroup>;
+        getExternalData?: (page: Page, args?: any) => Promise<Props>;
+        getDefaultMeta?: (page: PageFromList, externalData: Props) => Partial<IMeta>;
+        metaImageAspectRatio?: number;
+        categories?: ICategory[];
+        slugPrefix?: ISlugPrefix;
+        template?: Array<TemplateSlot>;
+        headlessView?: boolean;
+    }
+    /**
+     * Structure returned by the cleanBlocks function
+     */
+    export interface ICleanBlocks {
+        blocks: IContentBlock[];
+        invalidBlocksTypes: string[];
+    }
+    /**
+     * Responsive breakpoint for preview
+     */
+    export interface ResponsiveBreakpoint {
+        type: DeviceType;
+        width: number | string;
+        label: string;
+    }
+    /**
+     * Login UI customization
+     */
+    export interface LoginUI {
+        sideImage?: string;
+        logo?: string;
+        logoWidth?: number;
+        logoHeight?: number;
+        welcomeText?: string;
+        welcomeTextStyle?: React__default.CSSProperties;
+    }
+    /**
+     * MenuItem interface
+     */
+    export interface IMenuItem {
+        label: string;
+        path?: string;
+    }
+    /**
+     * The ReactBricks configuration
+     */
+    export interface ReactBricksConfig {
+        appId: string;
+        apiKey: string;
+        environment?: string;
+        bricks?: types.Brick<any>[] | types.Theme[];
+        pageTypes?: types.IPageType[];
+        logo?: string;
+        loginUI?: LoginUI;
+        contentClassName?: string;
+        defaultTheme?: string;
+        renderLocalLink: types.RenderLocalLink;
+        navigate: (path: string) => void;
+        loginPath?: string;
+        editorPath?: string;
+        mediaLibraryPath?: string;
+        playgroundPath?: string;
+        appSettingsPath?: string;
+        previewPath?: string;
+        getAdminMenu?: (args: {
+            isAdmin: boolean;
+        }) => IMenuItem[];
+        isDarkColorMode?: boolean;
+        toggleColorMode?: () => void;
+        useCssInJs?: boolean;
+        appRootElement: string | HTMLElement;
+        clickToEditSide?: ClickToEditSide;
+        customFields?: Array<ISideEditPropPage | ISideGroup>;
+        responsiveBreakpoints?: ResponsiveBreakpoint[];
+        enableAutoSave?: boolean;
+        disableSaveIfInvalidProps?: boolean;
+        enablePreview?: boolean;
+        blockIconsPosition?: BlockIconsPosition;
+        enablePreviewImage?: boolean;
+        enablePreviewIcon?: boolean;
+        enableUnsplash?: boolean;
+        unsplashApiKey?: string;
+        enableDefaultEmbedBrick?: boolean;
+        permissions?: Permissions;
+        allowAccentsInSlugs?: boolean;
+        warningIfLowBattery?: boolean;
+        rtlLanguages?: Array<string>;
+    }
+    /**
+     * The ReactBricks context
+     */
+    export interface IReactBricksContext {
+        version: string;
+        appId: string;
+        apiKey: string;
+        environment?: string;
+        bricks: Bricks;
+        themes: types.Theme[];
+        pageTypes: IPageType[];
+        logo: string;
+        loginUI: LoginUI;
+        contentClassName: string;
+        defaultTheme: string;
+        renderLocalLink: RenderLocalLink;
+        navigate: (path: string) => void;
+        loginPath: string;
+        editorPath: string;
+        mediaLibraryPath: string;
+        playgroundPath: string;
+        appSettingsPath: string;
+        previewPath: string;
+        getAdminMenu?: (args: {
+            isAdmin: boolean;
+        }) => IMenuItem[];
+        isDarkColorMode?: boolean;
+        toggleColorMode?: () => void;
+        useCssInJs?: boolean;
+        appRootElement: string | HTMLElement;
+        clickToEditSide?: ClickToEditSide;
+        customFields?: Array<ISideEditPropPage | ISideGroup>;
+        responsiveBreakpoints: ResponsiveBreakpoint[];
+        enableAutoSave: boolean;
+        disableSaveIfInvalidProps: boolean;
+        enablePreview: boolean;
+        browserSupport: {
+            webP: boolean;
+            lazyLoading: boolean;
+        };
+        blockIconsPosition: BlockIconsPosition;
+        enablePreviewImage: boolean;
+        enablePreviewIcon: boolean;
+        enableUnsplash: boolean;
+        unsplashApiKey?: string;
+        enableDefaultEmbedBrick: boolean;
+        permissions?: Permissions;
+        allowAccentsInSlugs: boolean;
+        warningIfLowBattery: boolean;
+        isRtlLanguage: ({ language }: {
+            language: string;
+        }) => boolean;
+        rtlLanguages: string[];
+    }
+    /**
+     * The current page in Admin
+     */
+    export interface ICurrentPage {
+        pageId: string;
+        language?: string;
+    }
+    /**
+     * The Admin context returned from useAdminContext
+     */
+    export interface IReadAdminContext {
+        isAdmin: boolean;
+        previewMode: boolean;
+        currentPage: ICurrentPage;
+        showRichTextModal: ShowRichTextModal;
+    }
+    /**
+     * Opengraph type
+     */
+    export type OpenGraphType = 'article' | 'website' | 'profile' | 'book' | 'video' | 'music';
+    /**
+     * OpenGraph data
+     */
+    export type OpenGraphData = {
+        url?: string;
+        type?: OpenGraphType;
+        title?: string;
+        description?: string;
+        image?: types.IImageSource;
+    };
+    /**
+     * Twitter card type
+     */
+    export type TwitterCardType = 'summary' | 'summary_large_image' | 'app' | 'player';
+    /**
+     * Data for Twitter card
+     */
+    export type TwitterCardData = {
+        card?: TwitterCardType;
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        image?: types.IImageSource;
+    };
+    /**
+     * Meta Fields type
+     * */
+    export type MetaData = {
+        title?: string;
+        description?: string;
+        keywords?: string;
+        featuredImage?: string;
+        image?: IImageSource;
+    };
+    /**
+     * Meta fields on Page
+     */
+    export interface IMeta extends MetaData {
+        language?: string;
+        openGraph?: OpenGraphData;
+        twitterCard?: TwitterCardData;
+        schemaOrg?: SchemaOrgData;
+    }
+    /**
+     * Category on categories (pageTypes)
+     */
+    export interface ICategory {
+        category?: string;
+    }
+    /**
+     * A RichTextExt Plugin
+     */
+    export interface RichTextPlugin {
+        type: 'Mark' | 'Block' | 'List';
+        name: string;
+        isInline?: boolean;
+        itemName?: string;
+        label: string;
+        hotKey?: string;
+        renderElement?: (props: RenderElementProps) => React__default.ReactElement;
+        renderItemElement?: (props: RenderElementProps) => React__default.ReactElement;
+        renderLeaf?: (props: RenderLeafProps) => React__default.ReactElement;
+        toggle: (editor: Editor, plugins: RichTextPlugin[], showRichTextModal: types.ShowRichTextModal) => void;
+        button?: {
+            icon: React__default.ReactElement;
+            isActive: (editor: Editor) => boolean;
+        };
+        enhanceEditor?: (editor: Editor) => Editor;
+    }
+    /**
+     * Definition for a Mark plugin
+     */
+    export interface MarkPlugin {
+        name: string;
+        label?: string;
+        hotKey?: string;
+        render: (props: RenderLeafProps) => React__default.ReactElement;
+        icon?: React__default.ReactElement;
+    }
+    /**
+     * Constructor for a Mark plugin
+     */
+    export type MarkPluginConstructor = (markPlugin: MarkPlugin) => RichTextPlugin;
+    /**
+     * Definition for a Block plugin
+     */
+    export interface BlockPlugin {
+        name: string;
+        isInline?: boolean;
+        itemName?: string;
+        label?: string;
+        hotKey?: string;
+        render: (props: RenderElementProps) => React__default.ReactElement;
+        renderItem?: (props: RenderElementProps) => React__default.ReactElement;
+        icon?: React__default.ReactElement;
+    }
+    export type BlockWithModalPlugin = BlockPlugin & {
+        getDefaultProps?: () => Props;
+        renderAdmin?: (props: RenderElementProps) => React__default.ReactElement;
+        renderItemAdmin?: (props: RenderElementProps) => React__default.ReactElement;
+        pluginCustomFields: Array<types.ISideEditPropPage | types.ISideGroup>;
+    };
+    /**
+     * Constructor for a Block plugin
+     */
+    export type BlockPluginConstructor = (blockPlugin: BlockPlugin) => RichTextPlugin;
+    /**
+     * Constructor for a Block with Modal plugin
+     */
+    export type BlockWithModalPluginConstructor = (blockPlugin: BlockWithModalPlugin) => RichTextPlugin;
+    /**
+     * Icon
+     */
+    export type Icon = {
+        name: string;
+        svg: string;
+        url: string;
+        set: string;
+    };
+    export {  };
+}
+
+interface AstroBrickProps {
+    index?: number;
+    itemsCount?: number;
+    blockProps: {
+        [x: string]: any;
+    };
+    page?: types.Page;
+    block: types.IContentBlock;
+    pathname?: string;
+}
+declare const AstroBrick: React__default.FC<AstroBrickProps>;
+
+declare const ClickToEdit: React__default.FC<ClickToEditProps>;
+
+/**
+ * Props for Link component
+ */
+interface LinkProps {
+    href: string;
+    target?: string;
+    className?: string;
+    activeClassName?: string;
+    simpleAnchor?: boolean;
+}
+type LinkPropsReal = React.PropsWithChildren<Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, keyof LinkProps> & LinkProps>;
+declare const Link: React.FC<LinkPropsReal>;
+
+/**
+ * Props for Text
+ */
+interface FileProps {
+    propName: string;
+    renderBlock: (props: types.IFileSource | null) => React__default.ReactElement;
+    allowedExtensions?: string[];
+    source: types.IFileSource;
+}
+declare const File: React__default.FC<FileProps>;
+
+/**
+ * Arguments for the renderWrapper function
+ */
+interface IRenderWrapperArgs {
+    children: React.ReactNode;
+    width?: number;
+    height?: number;
+}
+/**
+ * renderWrapper function type
+ */
+type RenderWrapper = (args: IRenderWrapperArgs) => React.ReactElement;
+interface PlaceholderProps {
+    aspectRatio?: number;
+    maxWidth?: number;
+    isDarkColorMode?: boolean;
+    isAdmin: boolean;
+}
+interface SharedImageProps {
+    readonly?: boolean;
+    alt: string;
+    noLazyLoad?: boolean;
+    containerClassName?: string;
+    containerStyle?: React.CSSProperties;
+    imageClassName?: string;
+    imageStyle?: React.CSSProperties;
+    noWrapper?: boolean;
+    quality?: number;
+    sizes?: string;
+    loading?: 'lazy' | 'eager';
+    renderWrapper?: RenderWrapper;
+    useNativeLazyLoading?: boolean;
+    useWebP?: boolean;
+    placeholder?: (props: PlaceholderProps) => string;
+    source: types.IImageSource;
+}
+interface EditableImage extends SharedImageProps {
+    readonly?: false;
+    propName?: string;
+    metaFieldName?: 'image';
+    customFieldName?: string;
+    aspectRatio?: number;
+    maxWidth?: number;
+}
+interface ReadOnlyImage extends SharedImageProps {
+    readonly: true;
+}
+/**
+ * Props for Image
+ */
+type ImageProps = EditableImage | ReadOnlyImage;
+declare const Image: React.FC<ImageProps>;
+
+/**
+ * Props for Repeater
+ */
+interface RepeaterProps {
+    propName: string;
+    itemProps?: types.Props;
+    renderWrapper?: (items: React.ReactElement) => React.ReactElement;
+    renderItemWrapper?: (item: React.ReactElement, index: number, itemsCount: number) => React.ReactElement;
+    items: types.RepeaterItems;
+}
+declare const Repeater: React.FC<RepeaterProps>;
+
+/**
+ * Props for renderLink render function
+ */
+interface RenderLinkElementProps extends RenderElementProps {
+    href: string;
+    target?: string;
+    rel?: string;
+}
+interface BaseRichTextProps {
+    renderBlock?: (props: RenderElementProps) => React__default.ReactElement;
+    placeholder?: string;
+    renderPlaceholder?: (props: {
+        children: any;
+    }) => React__default.ReactElement;
+    multiline?: boolean;
+    softLineBreak?: boolean;
+    allowedFeatures?: types.RichTextFeatures[];
+    renderBold?: (props: RenderLeafProps) => React__default.ReactElement;
+    renderItalic?: (props: RenderLeafProps) => React__default.ReactElement;
+    renderHighlight?: (props: RenderLeafProps) => React__default.ReactElement;
+    renderCode?: (props: RenderLeafProps) => React__default.ReactElement;
+    renderSub?: (props: RenderLeafProps) => React__default.ReactElement;
+    renderSup?: (props: RenderLeafProps) => React__default.ReactElement;
+    renderLink?: (props: RenderLinkElementProps) => React__default.ReactElement;
+    renderUL?: (props: RenderElementProps) => React__default.ReactElement;
+    renderOL?: (props: RenderElementProps) => React__default.ReactElement;
+    renderLI?: (props: RenderElementProps) => React__default.ReactElement;
+    renderH1?: (props: RenderElementProps) => React__default.ReactElement;
+    renderH2?: (props: RenderElementProps) => React__default.ReactElement;
+    renderH3?: (props: RenderElementProps) => React__default.ReactElement;
+    renderH4?: (props: RenderElementProps) => React__default.ReactElement;
+    renderH5?: (props: RenderElementProps) => React__default.ReactElement;
+    renderH6?: (props: RenderElementProps) => React__default.ReactElement;
+    renderQuote?: (props: RenderElementProps) => React__default.ReactElement;
+}
+interface RichTextPropsWithPropName extends BaseRichTextProps {
+    propName: string;
+    value: Descendant[] | string;
+    metaFieldName?: never;
+    customFieldName?: never;
+    customFieldPlainText?: never;
+}
+interface RichTextPropsWithMetaFieldName extends BaseRichTextProps {
+    propName?: never;
+    value?: never;
+    metaFieldName: 'title' | 'description' | 'language';
+    customFieldName?: never;
+    customFieldPlainText?: never;
+}
+interface RichTextPropsWithCustomFieldName extends BaseRichTextProps {
+    propName?: never;
+    value?: never;
+    metaFieldName?: never;
+    customFieldName: string;
+    customFieldPlainText?: boolean;
+}
+/**
+ * Props for RichText component
+ */
+type RichTextProps$1 = RichTextPropsWithPropName | RichTextPropsWithMetaFieldName | RichTextPropsWithCustomFieldName;
+declare const CompatibleRichText: React__default.FC<RichTextProps$1>;
+
+/**
+ * Props for RichTextExt (v3)
+ */
+interface RichTextProps {
+    renderBlock?: (props: RenderElementProps) => React.ReactElement;
+    placeholder?: string;
+    renderPlaceholder?: (props: {
+        children: any;
+    }) => React.ReactElement;
+    plugins?: types.RichTextPlugin[];
+    multiline?: boolean;
+    softLineBreak?: boolean;
+    propName?: string;
+    value?: Descendant[] | string;
+    metaFieldName?: 'title' | 'description' | 'language';
+    customFieldName?: string;
+    customFieldPlainText?: boolean;
+}
+declare const RichText: React.FC<RichTextProps>;
+
+/**
+ * CustomElement for Slate
+ */
+type CustomElement = {
+    type: string;
+    element?: Element;
+    children: CustomText[];
+    [key: string]: any;
+};
+/**
+ * CustomText for Slate
+ */
+type CustomText = {
+    text?: string;
+    [key: string]: any;
+};
+declare module 'slate' {
+    interface CustomTypes {
+        Editor: BaseEditor & ReactEditor & HistoryEditor;
+        Element: CustomElement;
+        Text: CustomText;
+    }
+}
+interface BaseTextProps {
+    renderBlock?: (props: RenderElementProps) => React.ReactElement;
+    placeholder?: string;
+    renderPlaceholder?: (props: {
+        children: any;
+    }) => React.ReactElement;
+    multiline?: boolean;
+    softLineBreak?: boolean;
+}
+interface TextPropsWithPropName extends BaseTextProps {
+    propName: string;
+    value: Descendant[] | string;
+    metaFieldName?: never;
+    customFieldName?: never;
+}
+interface TextPropsWithMetaFieldName extends BaseTextProps {
+    propName?: never;
+    value?: never;
+    metaFieldName: 'title' | 'description' | 'language';
+    customFieldName?: never;
+}
+interface TextPropsWithCustomFieldName extends BaseTextProps {
+    propName?: never;
+    value?: never;
+    metaFieldName?: never;
+    customFieldName: string;
+}
+/**
+ * Props for Text component
+ */
+type TextProps = TextPropsWithPropName | TextPropsWithMetaFieldName | TextPropsWithCustomFieldName;
+declare const Text: React.FC<TextProps>;
+
+declare class ReactBricksAstroStore {
+    static instance: any;
+    private configListeners;
+    private pageListeners;
+    constructor();
+    register(config: types.ReactBricksConfig): void;
+    setPage(page: types.Page): void;
+    setBlock(block: types.IContentBlock): void;
+    setIsAdmin(isAdmin: boolean): void;
+    setPathname(pathname: string): void;
+    getConfig(): types.ReactBricksConfig;
+    getBrick(block: types.IContentBlock): types.Brick<any> | null;
+    getBricks(): types.Bricks;
+    getThemes(): types.Theme[];
+    getPage(): types.Page | undefined;
+    getPageValues(): types.PageValues | null;
+    getBlock(): types.IContentBlock | null;
+    getBlockValue(propName: string): any | null;
+    getPageType(page: types.Page): types.IPageType | undefined;
+    getPathname(): string | undefined;
+    isAdmin(): boolean;
+    isRegistered(): boolean;
+    mapConfig(config: types.ReactBricksConfig): {
+        bricks: any;
+        themes: types.Theme[];
+    };
+    __subscribeConfig(listener: () => void): () => void;
+    __subscribePage(listener: () => void): () => void;
+    private notifyConfigListeners;
+    private notifyPageListeners;
+}
+declare const reactBricksAstroStore: ReactBricksAstroStore;
+
+declare const useAdminContext: () => types.IReadAdminContext;
+
+declare const usePageValues: () => [types.PageValues | null, (pageData: types.PartialPage) => void];
+
+declare function useReactBricksContext(): any;
+
+declare const useVisualEdit: (propName: string) => [(value: any) => void, boolean];
+
+declare const _default: {
+    serialize: (nodes: Node[]) => string;
+    serializeLight: (nodes: any[]) => string | any[];
+    deserialize: (input: string) => Descendant[];
+    isText: (value: any) => boolean;
+    isSlateContent: (value: any) => boolean;
+};
+
+declare const getBricks: () => types.Bricks;
+declare const getPageValues: () => types.PageValues | null;
+declare const getBlockValue: (propName: string) => any | null;
+declare const isAdmin: () => boolean;
+
+export { AstroBrick, ClickToEdit, File, Image, Link, _default as Plain, Repeater, CompatibleRichText as RichText, RichText as RichTextExt, Text, getBlockValue, getBricks, getPageValues, isAdmin, reactBricksAstroStore, types, useAdminContext, usePageValues, useReactBricksContext, useVisualEdit };