@piopi/easy-email-core 4.16.4

package/lib/blocks/advanced/blocks/index.d.ts

@@ -0,0 +1,16 @@
+import { IButton, ICarousel, IDivider, IImage, INavbar, ISpacer, IText, IAccordion, ISocial, IWrapper, ISection, IGroup, IColumn, IHero } from '../../standard';
+export declare const AdvancedText: import("../../..").IBlock<IText>;
+export declare const AdvancedButton: import("../../..").IBlock<IButton>;
+export declare const AdvancedImage: import("../../..").IBlock<IImage>;
+export declare const AdvancedDivider: import("../../..").IBlock<IDivider>;
+export declare const AdvancedSpacer: import("../../..").IBlock<ISpacer>;
+export declare const AdvancedNavbar: import("../../..").IBlock<INavbar>;
+export declare const AdvancedAccordion: import("../../..").IBlock<IAccordion>;
+export declare const AdvancedCarousel: import("../../..").IBlock<ICarousel>;
+export declare const AdvancedSocial: import("../../..").IBlock<ISocial>;
+export declare const AdvancedTable: import("../../..").IBlock<import("../generateAdvancedTableBlock").AdvancedTableBlock>;
+export declare const AdvancedWrapper: import("../../..").IBlock<IWrapper>;
+export declare const AdvancedSection: import("../../..").IBlock<ISection>;
+export declare const AdvancedGroup: import("../../..").IBlock<IGroup>;
+export declare const AdvancedColumn: import("../../..").IBlock<IColumn>;
+export declare const AdvancedHero: import("../../..").IBlock<IHero>;

package/lib/blocks/advanced/generateAdvancedBlock.d.ts

@@ -0,0 +1,60 @@
+import { BasicType } from '../../constants';
+import { IBlock, IBlockData } from '../../typings';
+import { IPage } from '../standard';
+export declare function generateAdvancedBlock<T extends AdvancedBlock>(option: {
+    type: string;
+    baseType: BasicType;
+    getContent: (params: {
+        index: number;
+        data: T;
+        idx: string | null | undefined;
+        mode: 'testing' | 'production';
+        context?: IPage;
+        dataSource?: {
+            [key: string]: any;
+        };
+    }) => ReturnType<NonNullable<IBlock['render']>>;
+    validParentType: string[];
+}): IBlock<T>;
+export interface AdvancedBlock extends IBlockData {
+    data: {
+        value: {
+            condition?: ICondition;
+            iteration?: {
+                enabled: boolean;
+                dataSource: string;
+                itemName: string;
+                limit: number;
+                mockQuantity: number;
+            };
+        };
+    };
+}
+export interface ICondition {
+    groups: Array<IConditionGroup>;
+    symbol: OperatorSymbol;
+    enabled: boolean;
+}
+export interface IConditionGroup {
+    symbol: OperatorSymbol;
+    groups: Array<IConditionGroupItem>;
+}
+export interface IConditionGroupItem {
+    left: string;
+    operator: Operator;
+    right: string | number;
+}
+export declare enum Operator {
+    TRUTHY = "truthy",
+    FALSY = "falsy",
+    EQUAL = "==",
+    NOT_EQUAL = "!=",
+    GREATER = ">",
+    GREATER_OR_EQUAL = ">=",
+    LESS = "<",
+    LESS_OR_EQUAL = "<="
+}
+export declare enum OperatorSymbol {
+    AND = "and",
+    OR = "or"
+}

package/lib/blocks/advanced/generateAdvancedContentBlock.d.ts

@@ -0,0 +1,6 @@
+import { BasicType } from '../../constants';
+import { IBlockData } from '../..';
+export declare function generateAdvancedContentBlock<T extends IBlockData>(option: {
+    type: string;
+    baseType: BasicType;
+}): import("../..").IBlock<T>;

package/lib/blocks/advanced/generateAdvancedLayoutBlock.d.ts

@@ -0,0 +1,7 @@
+import { BasicType } from '../../constants';
+import { AdvancedBlock } from './generateAdvancedBlock';
+export declare function generateAdvancedLayoutBlock<T extends AdvancedBlock>(option: {
+    type: string;
+    baseType: BasicType;
+    validParentType: string[];
+}): import("../..").IBlock<T>;

package/lib/blocks/advanced/generateAdvancedTableBlock.d.ts

@@ -0,0 +1,21 @@
+import { BasicType } from '../../constants';
+import { IBlock, IBlockData } from '../../typings';
+export declare function generateAdvancedTableBlock(option: {
+    type: string;
+    baseType: BasicType;
+}): IBlock<AdvancedTableBlock>;
+export interface IAdvancedTableData {
+    content: string;
+    colSpan?: number;
+    rowSpan?: number;
+    backgroundColor?: string;
+}
+export type AdvancedTableBlock = IBlockData<{
+    cellPadding?: string;
+    cellBorderColor?: string;
+    'font-style'?: string;
+    'text-align'?: string;
+}, {
+    content?: string;
+    tableSource: IAdvancedTableData[][];
+}>;

package/lib/blocks/advanced/index.d.ts

@@ -0,0 +1,22 @@
+import { AdvancedBlock, ICondition, IConditionGroup, IConditionGroupItem, Operator, OperatorSymbol } from './generateAdvancedBlock';
+import { IAdvancedTableData, AdvancedTableBlock } from './generateAdvancedTableBlock';
+export declare const advancedBlocks: {
+    advanced_text: import("../..").IBlock<import("..").IText>;
+    advanced_button: import("../..").IBlock<import("..").IButton>;
+    advanced_image: import("../..").IBlock<import("..").IImage>;
+    advanced_divider: import("../..").IBlock<import("..").IDivider>;
+    advanced_spacer: import("../..").IBlock<import("..").ISpacer>;
+    advanced_navbar: import("../..").IBlock<import("..").INavbar>;
+    advanced_accordion: import("../..").IBlock<import("..").IAccordion>;
+    advanced_carousel: import("../..").IBlock<import("..").ICarousel>;
+    advanced_social: import("../..").IBlock<import("..").ISocial>;
+    advanced_table: import("../..").IBlock<AdvancedTableBlock>;
+    advanced_wrapper: import("../..").IBlock<import("..").IWrapper>;
+    advanced_section: import("../..").IBlock<import("..").ISection>;
+    advanced_group: import("../..").IBlock<import("..").IGroup>;
+    advanced_column: import("../..").IBlock<import("..").IColumn>;
+    advanced_hero: import("../..").IBlock<import("..").IHero>;
+};
+export { Operator, OperatorSymbol };
+export type { AdvancedBlock, ICondition, IConditionGroup, IConditionGroupItem };
+export type { IAdvancedTableData, AdvancedTableBlock };

package/lib/blocks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './standard';
+export * from './advanced';

package/lib/blocks/standard/Accordion/index.d.ts

@@ -0,0 +1,17 @@
+import { IBlockData } from '../../../typings';
+export type IAccordion = IBlockData<{
+    'icon-width': string;
+    'icon-height': string;
+    'container-background-color'?: string;
+    border?: string;
+    padding: string;
+    'inner-padding'?: string;
+    'font-family'?: string;
+    'icon-align'?: 'middle' | 'top' | 'bottom';
+    'icon-position': 'left' | 'right';
+    'icon-unwrapped-alt'?: string;
+    'icon-unwrapped-url'?: string;
+    'icon-wrapped-alt'?: string;
+    'icon-wrapped-url'?: string;
+}, {}>;
+export declare const Accordion: import("../../../typings").IBlock<IAccordion>;

package/lib/blocks/standard/AccordionElement/index.d.ts

@@ -0,0 +1,16 @@
+import { IBlockData } from '../../../typings';
+export type IAccordionElement = IBlockData<{
+    'icon-width': string;
+    'icon-height': string;
+    'container-background-color'?: string;
+    border?: string;
+    'inner-padding'?: string;
+    'font-family'?: string;
+    'icon-align'?: 'middle' | 'top' | 'bottom';
+    'icon-position': 'left' | 'right';
+    'icon-unwrapped-alt'?: string;
+    'icon-unwrapped-url'?: string;
+    'icon-wrapped-alt'?: string;
+    'icon-wrapped-url'?: string;
+}, {}>;
+export declare const AccordionElement: import("../../../typings").IBlock<IAccordionElement>;

package/lib/blocks/standard/AccordionText/index.d.ts

@@ -0,0 +1,12 @@
+import { IBlock, IBlockData } from '../../../typings';
+export type IAccordionText = IBlockData<{
+    color?: string;
+    'background-color'?: string;
+    'font-size'?: string;
+    'font-family'?: string;
+    padding?: string;
+    'font-weight'?: string;
+    'line-height'?: string;
+    'letter-spacing'?: string;
+}, {}>;
+export declare const AccordionText: IBlock;

package/lib/blocks/standard/AccordionTitle/index.d.ts

@@ -0,0 +1,9 @@
+import { IBlock, IBlockData } from '../../../typings';
+export type IAccordionTitle = IBlockData<{
+    color?: string;
+    'background-color'?: string;
+    'font-size'?: string;
+    'font-family'?: string;
+    padding?: string;
+}, {}>;
+export declare const AccordionTitle: IBlock;

package/lib/blocks/standard/Button/index.d.ts

@@ -0,0 +1,30 @@
+import { IBlockData } from '../../../typings';
+export type IButton = IBlockData<{
+    align?: string;
+    color?: string;
+    'background-color'?: string;
+    'container-background-color'?: string;
+    border?: string;
+    'border-radius'?: string;
+    href?: string;
+    rel?: string;
+    target?: string;
+    title?: string;
+    padding?: string;
+    'inner-padding'?: string;
+    'text-align'?: string;
+    'vertical-align'?: 'middle' | 'top' | 'bottom';
+    width?: string;
+    'font-family'?: string;
+    'font-size'?: string;
+    'font-style'?: string;
+    'font-weight'?: string;
+    'line-height'?: string;
+    'letter-spacing'?: string;
+    height?: string;
+    'text-decoration'?: string;
+    'text-transform'?: string;
+}, {
+    content: string;
+}>;
+export declare const Button: import("../../../typings").IBlock<IButton>;

package/lib/blocks/standard/Carousel/index.d.ts

@@ -0,0 +1,26 @@
+import { IBlockData } from '../../../typings';
+export type ICarousel = IBlockData<{
+    align?: string;
+    'background-color'?: string;
+    'border-radius'?: string;
+    'icon-width'?: string;
+    'left-icon'?: string;
+    'right-icon'?: string;
+    'tb-border'?: string;
+    'tb-border-radius'?: string;
+    'tb-hover-border-color'?: string;
+    'tb-selected-border-color'?: string;
+    'tb-width'?: string;
+    thumbnails?: string;
+}, {
+    images: Array<{
+        src: string;
+        target: string;
+        href?: string;
+        'thumbnails-src'?: string;
+        title?: string;
+        rel?: string;
+        alt?: string;
+    }>;
+}>;
+export declare const Carousel: import("../../../typings").IBlock<ICarousel>;

package/lib/blocks/standard/Column/index.d.ts

@@ -0,0 +1,13 @@
+import { IBlockData } from '../../../typings';
+export type IColumn = IBlockData<{
+    'background-color'?: string;
+    border?: string;
+    'border-radius'?: string;
+    'inner-border'?: string;
+    'inner-border-radius'?: string;
+    padding?: string;
+    'text-align'?: string;
+    'vertical-align'?: string;
+    width?: string;
+}, {}>;
+export declare const Column: import("../../../typings").IBlock<IColumn>;

package/lib/blocks/standard/Divider/index.d.ts

@@ -0,0 +1,11 @@
+import { IBlockData } from '../../../typings';
+export type IDivider = IBlockData<{
+    'border-color'?: string;
+    'border-style'?: string;
+    'border-width'?: string;
+    'container-background-color'?: string;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    padding?: string;
+}, {}>;
+export declare const Divider: import("../../../typings").IBlock<IDivider>;

package/lib/blocks/standard/Group/index.d.ts

@@ -0,0 +1,8 @@
+import { IBlock, IBlockData } from '../../../typings';
+export type IGroup = IBlockData<{
+    width?: string;
+    'vertical-align'?: 'middle' | 'top' | 'bottom';
+    'background-color'?: string;
+    direction?: 'ltr' | 'rtl';
+}>;
+export declare const Group: IBlock<IGroup>;

package/lib/blocks/standard/Hero/index.d.ts

@@ -0,0 +1,15 @@
+import { IBlockData } from '../../../typings';
+export type IHero = IBlockData<{
+    'background-color'?: string;
+    'background-height'?: string;
+    'background-position'?: string;
+    'background-url'?: string;
+    'background-width'?: string;
+    'vertical-align'?: string;
+    'border-radius'?: string;
+    width?: string;
+    height?: string;
+    mode: 'fluid-height' | 'fixed-height';
+    padding?: string;
+}, {}>;
+export declare const Hero: import("../../../typings").IBlock<IHero>;

package/lib/blocks/standard/Image/index.d.ts

@@ -0,0 +1,18 @@
+import { CSSProperties } from 'react';
+import { IBlock, IBlockData } from '../../../typings';
+export type IImage = IBlockData<{
+    alt?: string;
+    src?: string;
+    title?: string;
+    href?: string;
+    target?: string;
+    border?: string;
+    height?: string;
+    'text-decoration'?: string;
+    'text-transform'?: CSSProperties['textTransform'];
+    align?: CSSProperties['textAlign'];
+    'container-background-color'?: string;
+    width?: string;
+    padding?: string;
+}>;
+export declare const Image: IBlock<IImage>;

package/lib/blocks/standard/Navbar/index.d.ts

@@ -0,0 +1,27 @@
+import { IBlock, IBlockData } from '../../../typings';
+export type INavbar = IBlockData<{
+    align?: string;
+    hamburger?: string;
+    'ico-align'?: string;
+    'ico-color'?: string;
+    'ico-font-size'?: string;
+    'ico-line-height'?: string;
+    'ico-padding'?: string;
+    'ico-text-decoration'?: string;
+    'ico-text-transform'?: string;
+}, {
+    links: Array<{
+        content: string;
+        color?: string;
+        href?: string;
+        'font-family'?: string;
+        'font-size'?: string;
+        'font-style'?: string;
+        'font-weight'?: string;
+        'line-height'?: string;
+        'text-decoration'?: string;
+        target?: string;
+        padding?: string;
+    }>;
+}>;
+export declare const Navbar: IBlock<INavbar>;

package/lib/blocks/standard/Page/index.d.ts

@@ -0,0 +1,29 @@
+import { IBlockData } from '../../../typings';
+export type IPage = IBlockData<{
+    'background-color'?: string;
+    width: string;
+}, {
+    breakpoint?: string;
+    headAttributes: string;
+    fonts?: {
+        name: string;
+        href: string;
+    }[];
+    headStyles?: {
+        content?: string;
+        inline?: 'inline';
+    }[];
+    extraHeadContent?: string;
+    responsive?: boolean;
+    'font-family': string;
+    'font-size': string;
+    'font-weight': string;
+    'line-height': string;
+    'text-color': string;
+    'user-style'?: {
+        content?: string;
+        inline?: 'inline';
+    };
+    'content-background-color'?: string;
+}>;
+export declare const Page: import("../../../typings").IBlock<IPage>;

package/lib/blocks/standard/Raw/index.d.ts

@@ -0,0 +1,5 @@
+import { IBlockData } from '../../../typings';
+export type IRaw = IBlockData<{}, {
+    content: string;
+}>;
+export declare const Raw: import("../../../typings").IBlock<IRaw>;

package/lib/blocks/standard/Section/index.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties } from 'react';
+import { IBlockData } from '../../../typings';
+export type ISection = IBlockData<{
+    'background-color'?: string;
+    'background-position'?: string;
+    'background-position-x'?: string;
+    'background-position-y'?: string;
+    'background-repeat'?: 'repeat' | 'no-repeat';
+    'background-size'?: string;
+    'background-url'?: string;
+    border?: string;
+    'border-radius'?: string;
+    direction?: 'ltr' | 'rtl';
+    'full-width'?: string;
+    padding?: string;
+    'text-align'?: CSSProperties['textAlign'];
+    'max-width'?: string;
+}, {}>;
+export declare const Section: import("../../../typings").IBlock<ISection>;

package/lib/blocks/standard/Social/index.d.ts

@@ -0,0 +1,47 @@
+import { IBlock, IBlockData } from '../../../typings';
+export type ISocial = IBlockData<{
+    align?: string;
+    color?: string;
+    'container-background-color'?: string;
+    'border-radius'?: string;
+    'icon-height'?: string;
+    'icon-size'?: string;
+    mode?: 'vertical' | 'horizontal';
+    'icon-padding': string;
+    'text-padding': string;
+    'text-decoration'?: string;
+    padding?: string;
+    'inner-padding'?: string;
+    'font-family'?: string;
+    'font-size'?: string;
+    'font-style'?: string;
+    'font-weight'?: string;
+    'line-height'?: string;
+}, {
+    elements: Array<{
+        content: string;
+        src: string;
+        align?: string;
+        alt?: string;
+        'background-color'?: string;
+        'border-radius'?: string;
+        color?: string;
+        'font-family'?: string;
+        'font-size'?: string;
+        'font-style'?: string;
+        'font-weight'?: string;
+        href?: string;
+        'icon-height'?: string;
+        'icon-size'?: string;
+        'line-height'?: string;
+        name?: string;
+        padding?: string;
+        'icon-padding'?: string;
+        'text-padding'?: string;
+        target?: string;
+        title?: string;
+        'text-decoration'?: string;
+        'vertical-align'?: string;
+    }>;
+}>;
+export declare const Social: IBlock<ISocial>;

package/lib/blocks/standard/Spacer/index.d.ts

@@ -0,0 +1,7 @@
+import { IBlock, IBlockData } from '../../../typings';
+export type ISpacer = IBlockData<{
+    'container-background-color'?: string;
+    height?: string;
+    padding?: string;
+}>;
+export declare const Spacer: IBlock<ISpacer>;

package/lib/blocks/standard/Table/index.d.ts

@@ -0,0 +1,5 @@
+import { IBlockData } from '../../../typings';
+export type ITable = IBlockData<{}, {
+    content: string;
+}>;
+export declare const Table: import("../../../typings").IBlock<ITable>;

package/lib/blocks/standard/Template/index.d.ts

@@ -0,0 +1,5 @@
+import { IBlockData } from '../../../typings';
+export type ITemplate = IBlockData<{}, {
+    idx?: string | null;
+}>;
+export declare const Template: import("../../../typings").IBlock<ITemplate>;

package/lib/blocks/standard/Text/index.d.ts

@@ -0,0 +1,20 @@
+import { IBlockData } from '../../../typings';
+export type IText = IBlockData<{
+    color?: string;
+    'font-family'?: string;
+    'font-size'?: string;
+    'font-style'?: string;
+    'font-weight'?: string;
+    'line-height'?: string;
+    'letter-spacing'?: string;
+    height?: string;
+    'text-decoration'?: string;
+    'text-transform'?: string;
+    align?: string;
+    'container-background-color'?: string;
+    width?: string;
+    padding?: string;
+}, {
+    content: string;
+}>;
+export declare const Text: import("../../../typings").IBlock<IText>;

package/lib/blocks/standard/Wrapper/index.d.ts

@@ -0,0 +1,12 @@
+import { IBlockData } from '../../../typings';
+import { CSSProperties } from 'react';
+export type IWrapper = IBlockData<{
+    'background-color'?: string;
+    border?: string;
+    'border-radius'?: string;
+    'full-width'?: string;
+    direction?: 'ltr' | 'rtl';
+    padding?: string;
+    'text-align'?: CSSProperties['textAlign'];
+}, {}>;
+export declare const Wrapper: import("../../../typings").IBlock<IWrapper>;

package/lib/blocks/standard/index.d.ts

@@ -0,0 +1,45 @@
+import { IPage } from './Page';
+import { ISection } from './Section';
+import { IColumn } from './Column';
+import { IText } from './Text';
+import { IImage } from './Image';
+import { IGroup } from './Group';
+import { IButton } from './Button';
+import { IDivider } from './Divider';
+import { IWrapper } from './Wrapper';
+import { ISpacer } from './Spacer';
+import { ICarousel } from './Carousel';
+import { IHero } from './Hero';
+import { INavbar } from './Navbar';
+import { ISocial } from './Social';
+import { IRaw } from './Raw';
+import { ITemplate } from './Template';
+import { IAccordion } from './Accordion';
+import { IAccordionElement } from './AccordionElement';
+import { IAccordionTitle } from './AccordionTitle';
+import { IAccordionText } from './AccordionText';
+import { ITable } from './Table';
+export declare const standardBlocks: {
+    page: import("../..").IBlock<IPage>;
+    section: import("../..").IBlock<ISection>;
+    column: import("../..").IBlock<IColumn>;
+    text: import("../..").IBlock<IText>;
+    image: import("../..").IBlock<IImage>;
+    group: import("../..").IBlock<IGroup>;
+    button: import("../..").IBlock<IButton>;
+    divider: import("../..").IBlock<IDivider>;
+    wrapper: import("../..").IBlock<IWrapper>;
+    spacer: import("../..").IBlock<ISpacer>;
+    raw: import("../..").IBlock<IRaw>;
+    carousel: import("../..").IBlock<ICarousel>;
+    hero: import("../..").IBlock<IHero>;
+    navbar: import("../..").IBlock<INavbar>;
+    social: import("../..").IBlock<ISocial>;
+    template: import("../..").IBlock<ITemplate>;
+    accordion: import("../..").IBlock<IAccordion>;
+    "accordion-element": import("../..").IBlock<IAccordionElement>;
+    "accordion-title": import("../..").IBlock<import("../..").IBlockData<any, any>>;
+    "accordion-text": import("../..").IBlock<import("../..").IBlockData<any, any>>;
+    table: import("../..").IBlock<ITable>;
+};
+export type { IPage, ISection, IWrapper, IColumn, IGroup, IText, ITable, IImage, IButton, IDivider, ISpacer, ICarousel, IHero, ISocial, INavbar, IRaw, IAccordion, IAccordionElement, IAccordionTitle, IAccordionText, ITemplate, };

package/lib/components/Accordion.d.ts

@@ -0,0 +1,8 @@
+import { RecursivePartial } from '../typings';
+import React from 'react';
+import { IAccordion } from '../blocks';
+import { MjmlBlockProps } from '../components/MjmlBlock';
+export type AccordionProps = RecursivePartial<IAccordion['data']> & RecursivePartial<IAccordion['attributes']> & {
+    children?: MjmlBlockProps<IAccordion>['children'];
+};
+export declare function Accordion(props: AccordionProps): React.JSX.Element;

package/lib/components/AccordionElement.d.ts

@@ -0,0 +1,8 @@
+import { RecursivePartial } from '../typings';
+import React from 'react';
+import { IAccordionElement } from '../blocks';
+import { MjmlBlockProps } from '../components/MjmlBlock';
+export type AccordionElementProps = RecursivePartial<IAccordionElement['data']> & RecursivePartial<IAccordionElement['attributes']> & {
+    children?: MjmlBlockProps<IAccordionElement>['children'];
+};
+export declare function AccordionElement(props: AccordionElementProps): React.JSX.Element;

package/lib/components/AccordionText.d.ts

@@ -0,0 +1,8 @@
+import { RecursivePartial } from '../typings';
+import React from 'react';
+import { IAccordionText } from '../blocks';
+import { MjmlBlockProps } from '../components/MjmlBlock';
+export type AccordionTextProps = RecursivePartial<IAccordionText['data']> & RecursivePartial<IAccordionText['attributes']> & {
+    children?: MjmlBlockProps<IAccordionText>['children'];
+};
+export declare function AccordionText(props: AccordionTextProps): React.JSX.Element;

package/lib/components/AccordionTitle.d.ts

@@ -0,0 +1,8 @@
+import { RecursivePartial } from '../typings';
+import React from 'react';
+import { IAccordionTitle } from '../blocks';
+import { MjmlBlockProps } from '../components/MjmlBlock';
+export type AccordionTitleProps = RecursivePartial<IAccordionTitle['data']> & RecursivePartial<IAccordionTitle['attributes']> & {
+    children?: MjmlBlockProps<IAccordionTitle>['children'];
+};
+export declare function AccordionTitle(props: AccordionTitleProps): React.JSX.Element;

package/lib/components/BasicBlock.d.ts

@@ -0,0 +1,7 @@
+import { IBlock } from '../typings';
+import React from 'react';
+export declare function BasicBlock(props: {
+    params: Parameters<IBlock['render']>[0];
+    tag: string;
+    children?: React.ReactNode;
+}): React.JSX.Element;

package/lib/components/BlockRenderer.d.ts

@@ -0,0 +1,5 @@
+import { IBlock } from '../typings';
+import React from 'react';
+type BlockDataItem = Omit<Parameters<IBlock['render']>[0], 'mode' | 'context' | 'dataSource'>;
+export declare const BlockRenderer: (props: BlockDataItem) => React.JSX.Element | null;
+export {};

package/lib/components/Button.d.ts

@@ -0,0 +1,8 @@
+import { RecursivePartial } from '../typings';
+import React from 'react';
+import { IButton } from '../blocks';
+import { MjmlBlockProps } from '../components/MjmlBlock';
+export type ButtonProps = RecursivePartial<IButton['data']> & RecursivePartial<IButton['attributes']> & {
+    children?: MjmlBlockProps<IButton>['children'];
+};
+export declare function Button(props: ButtonProps): React.JSX.Element;