import { BaseFabricObject } from 'fabric';
import { default as default_2 } from 'react';
import { FabricImage } from 'fabric';
import { FabricObjectProps } from 'fabric';
import { FabricText } from 'fabric';
import { ImageFormat } from 'fabric';
import { ImageProps } from 'fabric';
import { ImageSource } from 'fabric';
import { JSX } from 'react';
import { JSXElementConstructor } from 'react';
import { ObjectEvents } from 'fabric';
import { Pattern } from 'fabric';
import { PropsWithChildren } from 'react';
import { ReactElement } from 'react';
import { ReactNode } from 'react';
import { ReactPortal } from 'react';
import { Rect } from 'fabric';
import { RectProps } from 'fabric';
import { Required as Required_2 } from 'utility-types';
import { SerializedImageProps } from 'fabric';
import { SerializedRectProps } from 'fabric';
import { Shadow } from 'fabric';
import { StaticCanvas } from 'fabric';
import { StaticCanvasEvents } from 'fabric';
import { TClassProperties } from 'fabric';
import { TDegree } from 'fabric';
import { TextProps } from 'fabric';
import { TFiller } from 'fabric';
import { TOptions } from 'fabric';
import { TOriginX } from 'fabric';
import { TOriginY } from 'fabric';
import { UploadProps } from 'antd';

export declare type Block = BlockViewport | BlockBackground | BlockImage | BlockWaterMark;

export declare type Block4Content = BlockBackground | BlockImage;

/**
 * 画布根块
 * @description 实现背景替换等接口
 */
export declare class BlockBackground<Props extends TOptions<BlockBackgroundProps> = Partial<BlockBackgroundProps>, SProps extends SerializedBlockBackgroundProps = SerializedBlockBackgroundProps, EventSpec extends ObjectEvents = ObjectEvents> extends Rect<Props, SProps, EventSpec> implements IBlock {
    static patternFromURL(url: string, size: Pick<FabricObjectProps, 'width' | 'height'>): Promise<Pattern>;
    static fromColour(hex: string, size: Pick<FabricObjectProps, 'width' | 'height'>): Promise<BlockBackground<{
        fill: string;
        width: number;
        height: number;
    }, SerializedBlockBackgroundProps, ObjectEvents>>;
    static fromURL(url: string, size: Pick<FabricObjectProps, 'width' | 'height'>): Promise<BlockBackground<{
        fill: Pattern;
        width: number;
        height: number;
    }, SerializedBlockBackgroundProps, ObjectEvents>>;
    blockType: BlockTypes;
    _fill: string | TFiller | null;
    get fill(): string | TFiller | null;
    set fill(v: string | TFiller | null);
    constructor(props?: Props);
    toggleSelectable(): void;
    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
}

declare interface BlockBackgroundProps extends RectProps, IBlock {
}

declare interface BlockBackgroundProps_2 extends ImageProps, IBlock {
}

/**
 * 图片块
 * @description 实现滤镜、风格话等各种图片操作接口
 */
export declare class BlockImage<Props extends TOptions<BlockBackgroundProps_2> = Partial<BlockBackgroundProps_2>, SProps extends SerializedBlockImageProps = SerializedBlockImageProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricImage<Props, SProps, EventSpec> implements IBlock {
    blockType: BlockTypes;
    constructor(elementId: string, options?: Props);
    constructor(element: ImageSource, options?: Props);
    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
}

export declare enum BlockTypes {
    Viewport = "viewport",
    Background = "background",
    Image = "image",
    WaterMark = "waterMark"
}

/**
 * 画布根块
 * @description 实现背景替换等接口
 */
export declare class BlockViewport<Props extends TOptions<BlockViewportProps> = Partial<BlockViewportProps>, SProps extends SerializedBlockViewportProps = SerializedBlockViewportProps, EventSpec extends ObjectEvents = ObjectEvents> extends Rect<Props, SProps, EventSpec> implements IBlock {
    blockType: BlockTypes;
    constructor(props?: Props);
    fill: TFiller | string | null;
    cloneWithoutFill(): Promise<this>;
    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
}

declare interface BlockViewportProps extends RectProps, IBlock {
}

/**
 * 水印块
 * @description 实现水印等接口
 */
export declare class BlockWaterMark<Props extends Required_2<TOptions<BlockWaterMarkProps>, 'width' | 'height'> = Required_2<BlockWaterMarkProps, 'width' | 'height'>, SProps extends SerializedBlockWaterMarkProps = SerializedBlockWaterMarkProps, EventSpec extends ObjectEvents = ObjectEvents> extends Rect<Props, SProps, EventSpec> implements IBlock {
    blockType: BlockTypes;
    objectCaching: boolean;
    selectable: boolean;
    evented: boolean;
    hasControls: boolean;
    static fromURL({ value, props }: WaterMark, rectOpts: Required_2<Partial<RectProps>, 'width' | 'height'>): Promise<BlockWaterMark<{
        id?: string | undefined;
        left?: number | undefined;
        top?: number | undefined;
        noScaleCache?: boolean | undefined;
        hoverCursor?: string | null | undefined;
        moveCursor?: string | null | undefined;
        selectionBackgroundColor?: string | undefined;
        perPixelTargetFind?: boolean | undefined;
        selectable?: boolean | undefined;
        evented?: boolean | undefined;
        activeOn?: "down" | "up" | undefined;
        clipPath?: BaseFabricObject | undefined;
        fill?: string | TFiller | null | undefined;
        stroke?: string | TFiller | null | undefined;
        shadow?: Shadow | null | undefined;
        canvas: StaticCanvas<StaticCanvasEvents>;
        minScaleLimit?: number | undefined;
        objectCaching?: boolean | undefined;
        includeDefaultValues?: boolean | undefined;
        excludeFromExport?: boolean | undefined;
        opacity?: number | undefined;
        globalCompositeOperation?: GlobalCompositeOperation | undefined;
        backgroundColor?: string | undefined;
        visible?: boolean | undefined;
        originX?: TOriginX | undefined;
        originY?: TOriginY | undefined;
        angle?: TDegree | undefined;
        flipX?: boolean | undefined;
        flipY?: boolean | undefined;
        scaleX?: number | undefined;
        scaleY?: number | undefined;
        skewX?: TDegree | undefined;
        skewY?: TDegree | undefined;
        paintFirst?: "fill" | "stroke" | undefined;
        fillRule?: CanvasFillRule | undefined;
        strokeWidth?: number | undefined;
        strokeDashArray?: number[] | null | undefined;
        strokeDashOffset?: number | undefined;
        strokeLineCap?: CanvasLineCap | undefined;
        strokeLineJoin?: CanvasLineJoin | undefined;
        strokeMiterLimit?: number | undefined;
        strokeUniform?: boolean | undefined;
        inverted?: boolean | undefined;
        absolutePositioned?: boolean | undefined;
        snapAngle?: TDegree | undefined;
        snapThreshold?: TDegree | undefined;
        centeredRotation?: boolean | undefined;
        centeredScaling?: boolean | undefined;
        cornerSize?: number | undefined;
        touchCornerSize?: number | undefined;
        transparentCorners?: boolean | undefined;
        cornerColor?: string | undefined;
        cornerStrokeColor?: string | undefined;
        cornerStyle?: "rect" | "circle" | undefined;
        cornerDashArray?: number[] | null | undefined;
        padding?: number | undefined;
        hasControls?: boolean | undefined;
        borderColor?: string | undefined;
        borderDashArray?: number[] | null | undefined;
        hasBorders?: boolean | undefined;
        borderOpacityWhenMoving?: number | undefined;
        borderScaleFactor?: number | undefined;
        lockMovementX?: boolean | undefined;
        lockMovementY?: boolean | undefined;
        lockRotation?: boolean | undefined;
        lockScalingX?: boolean | undefined;
        lockScalingY?: boolean | undefined;
        lockSkewingX?: boolean | undefined;
        lockSkewingY?: boolean | undefined;
        lockScalingFlip?: boolean | undefined;
        rx?: number | undefined;
        ry?: number | undefined;
        width: number;
        height: number;
    }, SerializedBlockWaterMarkProps, ObjectEvents>>;
    static fromText({ value, props }: WaterMark, rectOpts: Required_2<Partial<RectProps>, 'width' | 'height'>): Promise<BlockWaterMark<{
        id?: string | undefined;
        left?: number | undefined;
        top?: number | undefined;
        noScaleCache?: boolean | undefined;
        hoverCursor?: string | null | undefined;
        moveCursor?: string | null | undefined;
        selectionBackgroundColor?: string | undefined;
        perPixelTargetFind?: boolean | undefined;
        selectable?: boolean | undefined;
        evented?: boolean | undefined;
        activeOn?: "down" | "up" | undefined;
        clipPath?: BaseFabricObject | undefined;
        fill?: string | TFiller | null | undefined;
        stroke?: string | TFiller | null | undefined;
        shadow?: Shadow | null | undefined;
        canvas: StaticCanvas<StaticCanvasEvents>;
        minScaleLimit?: number | undefined;
        objectCaching?: boolean | undefined;
        includeDefaultValues?: boolean | undefined;
        excludeFromExport?: boolean | undefined;
        opacity?: number | undefined;
        globalCompositeOperation?: GlobalCompositeOperation | undefined;
        backgroundColor?: string | undefined;
        visible?: boolean | undefined;
        originX?: TOriginX | undefined;
        originY?: TOriginY | undefined;
        angle?: TDegree | undefined;
        flipX?: boolean | undefined;
        flipY?: boolean | undefined;
        scaleX?: number | undefined;
        scaleY?: number | undefined;
        skewX?: TDegree | undefined;
        skewY?: TDegree | undefined;
        paintFirst?: "fill" | "stroke" | undefined;
        fillRule?: CanvasFillRule | undefined;
        strokeWidth?: number | undefined;
        strokeDashArray?: number[] | null | undefined;
        strokeDashOffset?: number | undefined;
        strokeLineCap?: CanvasLineCap | undefined;
        strokeLineJoin?: CanvasLineJoin | undefined;
        strokeMiterLimit?: number | undefined;
        strokeUniform?: boolean | undefined;
        inverted?: boolean | undefined;
        absolutePositioned?: boolean | undefined;
        snapAngle?: TDegree | undefined;
        snapThreshold?: TDegree | undefined;
        centeredRotation?: boolean | undefined;
        centeredScaling?: boolean | undefined;
        cornerSize?: number | undefined;
        touchCornerSize?: number | undefined;
        transparentCorners?: boolean | undefined;
        cornerColor?: string | undefined;
        cornerStrokeColor?: string | undefined;
        cornerStyle?: "rect" | "circle" | undefined;
        cornerDashArray?: number[] | null | undefined;
        padding?: number | undefined;
        hasControls?: boolean | undefined;
        borderColor?: string | undefined;
        borderDashArray?: number[] | null | undefined;
        hasBorders?: boolean | undefined;
        borderOpacityWhenMoving?: number | undefined;
        borderScaleFactor?: number | undefined;
        lockMovementX?: boolean | undefined;
        lockMovementY?: boolean | undefined;
        lockRotation?: boolean | undefined;
        lockScalingX?: boolean | undefined;
        lockScalingY?: boolean | undefined;
        lockSkewingX?: boolean | undefined;
        lockSkewingY?: boolean | undefined;
        lockScalingFlip?: boolean | undefined;
        rx?: number | undefined;
        ry?: number | undefined;
        width: number;
        height: number;
    }, SerializedBlockWaterMarkProps, ObjectEvents>>;
    static fromWatermark(object: FabricImage | FabricText, rectOpts: Required_2<Partial<RectProps>, 'width' | 'height'>, offsetX?: number, offsetY?: number): Promise<BlockWaterMark<{
        id?: string | undefined;
        left?: number | undefined;
        top?: number | undefined;
        noScaleCache?: boolean | undefined;
        hoverCursor?: string | null | undefined;
        moveCursor?: string | null | undefined;
        selectionBackgroundColor?: string | undefined;
        perPixelTargetFind?: boolean | undefined;
        selectable?: boolean | undefined;
        evented?: boolean | undefined;
        activeOn?: "down" | "up" | undefined;
        clipPath?: BaseFabricObject | undefined;
        fill?: string | TFiller | null | undefined;
        stroke?: string | TFiller | null | undefined;
        shadow?: Shadow | null | undefined;
        canvas: StaticCanvas<StaticCanvasEvents>;
        minScaleLimit?: number | undefined;
        objectCaching?: boolean | undefined;
        includeDefaultValues?: boolean | undefined;
        excludeFromExport?: boolean | undefined;
        opacity?: number | undefined;
        globalCompositeOperation?: GlobalCompositeOperation | undefined;
        backgroundColor?: string | undefined;
        visible?: boolean | undefined;
        originX?: TOriginX | undefined;
        originY?: TOriginY | undefined;
        angle?: TDegree | undefined;
        flipX?: boolean | undefined;
        flipY?: boolean | undefined;
        scaleX?: number | undefined;
        scaleY?: number | undefined;
        skewX?: TDegree | undefined;
        skewY?: TDegree | undefined;
        paintFirst?: "fill" | "stroke" | undefined;
        fillRule?: CanvasFillRule | undefined;
        strokeWidth?: number | undefined;
        strokeDashArray?: number[] | null | undefined;
        strokeDashOffset?: number | undefined;
        strokeLineCap?: CanvasLineCap | undefined;
        strokeLineJoin?: CanvasLineJoin | undefined;
        strokeMiterLimit?: number | undefined;
        strokeUniform?: boolean | undefined;
        inverted?: boolean | undefined;
        absolutePositioned?: boolean | undefined;
        snapAngle?: TDegree | undefined;
        snapThreshold?: TDegree | undefined;
        centeredRotation?: boolean | undefined;
        centeredScaling?: boolean | undefined;
        cornerSize?: number | undefined;
        touchCornerSize?: number | undefined;
        transparentCorners?: boolean | undefined;
        cornerColor?: string | undefined;
        cornerStrokeColor?: string | undefined;
        cornerStyle?: "rect" | "circle" | undefined;
        cornerDashArray?: number[] | null | undefined;
        padding?: number | undefined;
        hasControls?: boolean | undefined;
        borderColor?: string | undefined;
        borderDashArray?: number[] | null | undefined;
        hasBorders?: boolean | undefined;
        borderOpacityWhenMoving?: number | undefined;
        borderScaleFactor?: number | undefined;
        lockMovementX?: boolean | undefined;
        lockMovementY?: boolean | undefined;
        lockRotation?: boolean | undefined;
        lockScalingX?: boolean | undefined;
        lockScalingY?: boolean | undefined;
        lockSkewingX?: boolean | undefined;
        lockSkewingY?: boolean | undefined;
        lockScalingFlip?: boolean | undefined;
        rx?: number | undefined;
        ry?: number | undefined;
        width: number;
        height: number;
    }, SerializedBlockWaterMarkProps, ObjectEvents>>;
    constructor(props: Props);
    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
}

declare interface BlockWaterMarkProps extends RectProps, IBlock {
}

export declare const defaultMaxPort: {
    width: number;
    height: number;
};

export declare const DefaultPicexContext: IPicexContext;

declare interface DesignProps {
    viewport?: Size;
    maxport?: Size;
    images?: PicexContentActionInit['images'];
    watermark?: WaterMark;
    historable?: boolean;
    uploadProps?: UploadBoxProps;
    downloadProps?: DownloadProps;
    enableOperators?: boolean;
    childrenZeroBlock?: default_2.ReactNode;
    onlyChildren?: boolean;
    lang?: string;
    childNode?: {
        [key: string]: default_2.ReactNode;
    };
    activeToolKey?: string;
}

declare type DownloadProps = {
    format?: ImageFormat;
    filename?: string;
};

export declare type IBlock = Pick<FabricObjectProps, 'left' | 'top' | 'width' | 'height'> & {
    blockType: BlockTypes;
};

export declare const IBlockPropKeys: readonly ["blockType"];

export declare type IPicexToolRenderParams = {
    ctx: IPicexContext;
    dispatch: IPicexDispatch;
    tool?: PicexTool;
};

export declare const PicexContext: default_2.Context<IPicexContext>;

export declare const PicexDispatchContext: default_2.Context<IPicexDispatch>;

export declare function PicexEditor({ tools, initialSelectedTool, activeToolKey, multiple, historable, images, watermark, viewport, children, childrenZeroBlock, left, right, layout, uploadProps, downloadProps, onlyChildren, onToolChange, lang, childNode, }: DesignProps & PropsWithChildren<{
    lang?: string;
    tools?: PicexTool[];
    multiple?: boolean;
    initialSelectedTool?: string;
    activeToolKey?: string;
    onToolChange?: (key: string) => void;
    left?: PropsWithChildren<{
        style?: default_2.CSSProperties;
        className?: string;
    }>;
    right?: PropsWithChildren<{
        style?: default_2.CSSProperties;
        className?: string;
    }>;
    layout?: {
        leftStyle?: default_2.CSSProperties;
        rightStyle?: default_2.CSSProperties;
        contentStyle?: default_2.CSSProperties;
        leftClassName?: string;
        rightClassName?: string;
        contentClassName?: string;
    };
    childNode?: {
        [key: string]: default_2.ReactNode;
    };
}>): default_2.JSX.Element;

export declare abstract class PicexTool {
    abstract key: string;
    abstract name: string;
    abstract visible: boolean;
    abstract disabled: boolean;
    toggle(v?: boolean): void;
    toggleDisabled(v?: boolean): void;
    abstract renderIcon(params: IPicexToolRenderParams): ReactNode;
    abstract renderPanel(params: IPicexToolRenderParams): ReactNode;
    renderOutput?(params: IPicexToolRenderParams): ReactNode;
}

export declare class PicexToolBackground extends PicexTool {
    protected props?: PicexToolBackgroundProps | undefined;
    key: string;
    name: any;
    visible: boolean;
    disabled: boolean;
    constructor(props?: PicexToolBackgroundProps | undefined);
    renderIcon(): JSX.Element;
    /**
     * 实现更改BlockCanvas纯色背景、图片背景的功能
     */
    renderPanel({ ctx, dispatch }: IPicexToolRenderParams): JSX.Element;
}

declare type PicexToolBackgroundProps = DesignProps & UploadBoxProps & {
    name?: string;
    maxColours?: number;
    maxImages?: number;
};

export declare class PicexToolCustom extends PicexTool {
    protected props?: PicexToolCustomProps | undefined;
    key: string;
    name: string;
    visible: boolean;
    disabled: boolean;
    constructor(props?: PicexToolCustomProps | undefined);
    renderIcon(): string | number | bigint | true | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element;
    renderPanel({ ctx, dispatch }: IPicexToolRenderParams): JSX.Element;
}

declare type PicexToolCustomProps = {
    key?: string;
    name?: string;
    disabled?: boolean;
    visible?: boolean;
    panelChildren?: React.ReactNode;
    icon?: React.ReactNode;
};

export declare class PicexToolResize extends PicexTool {
    key: string;
    icon: string;
    name: string;
    visible: boolean;
    disabled: boolean;
    renderIcon(): null;
    /**
     * 实现更改BlockCanvas大小的功能
     */
    renderPanel(): null;
}

declare interface SerializedBlockBackgroundProps extends SerializedRectProps, IBlock {
}

declare interface SerializedBlockImageProps extends SerializedImageProps, IBlock {
}

declare interface SerializedBlockViewportProps extends SerializedRectProps, IBlock {
}

declare interface SerializedBlockWaterMarkProps extends SerializedRectProps, IBlock {
    canvas: StaticCanvas;
}

declare type UploadBoxProps = Omit<Partial<UploadProps<UploadFileAttrs>>, 'children'> & {
    err?: default_2.ReactNode;
    visible?: boolean;
    hidden?: boolean;
    icon?: default_2.ReactNode;
    iconClassName?: string;
    wordings?: default_2.ReactNode;
    wordingsClassName?: string;
    className?: string;
    children?: (x: {
        loading: boolean;
        error: Error | null;
    }) => default_2.ReactNode;
};

declare type UploadFileAttrs = {
    url: string;
    width: number;
    height: number;
};

export declare const usePicexCtx: () => IPicexContext;

export declare const usePicexDispatch: () => IPicexDispatch;

declare interface WaterMark {
    value: string;
    props?: Partial<ImageProps> | Partial<TextProps>;
}

export { }


declare global {
    interface Size {
        width: number;
        height: number;
    }
    interface IPicexContext {
        naturalSize?: Size;
        displaySize?: Size;
        watermark: string;
        blocks: Block[];
        tools: PicexTool[];
        currentBlock: Block | null;
        fcanvas: Canvas | null;
        error?: null | Error;
        elMenuWrapper: React.RefObject<null | HTMLElement>;
        elCanvasWrapper: React.RefObject<null | HTMLDivElement>;
        elBlockTreeWrapper: React.RefObject<null | HTMLElement>;
        elPropertiesWrapper: React.RefObject<null | HTMLElement>;
    }
    type PicexContentActionInit = {
        type: 'init';
        images: Array<Size & {
            url: string;
            loadedImage?: HTMLImageElement;
        }>;
        naturalSize?: Size;
        displaySize?: Size;
    };
    type PicexContentActionCover = {
        type: 'cover';
        blocks: Block[];
    };
    type PicexContentActionMount = {
        type: 'mount';
        fcanvas: Canvas;
    };
    type PicexContentActionAddWatermark = {
        type: 'addWatermark';
        block: BlockWaterMark;
    };
    type PicexContentActionAddBlock = {
        type: 'addBlock';
        block: Block4Content;
    };
    type PicexContentActionUpdateBlock = {
        type: 'updateBlock';
        block: Block;
        payload?: Record<string, any>;
    };
    type PicexContentActionRemoveBlock = {
        type: 'removeBlock';
        block: Block;
    };
    type PicexContextAction = PicexContentActionInit | PicexContentActionCover | PicexContentActionMount | PicexContentActionAddWatermark | PicexContentActionAddBlock | PicexContentActionUpdateBlock | PicexContentActionRemoveBlock;
    type IPicexDispatch = React.Dispatch<PicexContextAction>;
}


declare module 'fabric' {
    interface FabricObject {
        id?: string;
    }
    interface SerializedObjectProps {
        id?: string;
    }
}


declare module 'fabric' {
    interface Canvas {
        history?: FabricHistory;
    }
    interface CanvasEvents {
        'history:append': () => void;
        'history:clear': () => void;
        'history:undo': () => void;
        'history:redo': () => void;
    }
}