import { ContentItem } from "./ContentItem";
import { ImagePermissions } from "./ImagePermissions";
import { PointF } from "../../Math/PointF";
import { INotifyPropertyChanged } from "../../INotifyPropertyChanged";
import { EventWithSenderArg } from "../../EventObject";
import { RotatedRectangleF, ISize } from "../../Math";
import { ImageEffect } from "./ImageEffect";
import { OverlayEffect } from "./OverlayEffect";
import { IEqualsReady } from "../../Utils/Utils";
import { Size } from "./Size";
import { ImageViolationSettings } from "./ImageViolationSettings";
import { NDEffects } from "../Effects/NDEffects";
export declare class ImageItem extends ContentItem {
    ndEffects: NDEffects;
    originalImageSource: ImageItem.ImageSource;
    private _imagePermissions;
    private _effect;
    private _overlayEffect;
    private _source;
    constructor(sourceStorageId?: string, location?: PointF, width?: number, height?: number, ratioWidthToHeight?: number);
    protected _copy(source: ImageItem, destination: ImageItem, generateNewIds: boolean, appropriateParentContainer: boolean): void;
    equals(other: ImageItem): boolean;
    clone(generateNewIds?: boolean, appropriateParentContainer?: boolean): ImageItem;
    static type: string;
    type: string;
    get imagePermissions(): ImagePermissions;
    set imagePermissions(value: ImagePermissions);
    get violationSettings(): ImageViolationSettings;
    set violationSettings(value: ImageViolationSettings);
    protected _setViolationSettings(value: ImageViolationSettings, skipTypeCheck?: boolean): void;
    applyPermissionsConstrain(): void;
    mviKeepTemplateTransform: boolean;
    values: ImageItem.ImageItemValue[];
    allowedSubfolder: string;
    allowedTabs: string[];
    private _displayName;
    get displayName(): string;
    set displayName(value: string);
    ratioWidthToHeight: number;
    isUserImage: boolean;
    unconvertedSource: ImageItem.ImageSource;
    get source(): ImageItem.ImageSource;
    set source(value: ImageItem.ImageSource);
    private _onSourcePropertyChanged;
    get effect(): ImageEffect;
    set effect(value: ImageEffect);
    get overlayEffect(): OverlayEffect;
    set overlayEffect(value: OverlayEffect);
    private _subscribeOverlayEffectPropertyChanged;
    private _unsubscribeOverlayEffectPropertyChanged;
    private _onOverlayEffectPropertyChanged;
    SetWidth(value: number, calculateHeight?: boolean): void;
    SetHeight(value: number, calculateWidth?: boolean): void;
    getSource(): string;
    private _calculateHeight;
    private _calculateWidth;
    getSimplifiedObject(omitProperties?: string[] | string): Object;
    getOriginalImageSize(): ISize;
}
export declare module ImageItem {
    class ImageMetaData implements IEqualsReady {
        id: string;
        width: number;
        height: number;
        isVector: boolean;
        constructor(rawData: Object);
        clone(): ImageMetaData;
        equals(other: ImageMetaData): boolean;
    }
    class ImageItemValue implements IEqualsReady {
        name: string;
        value: ImageMetaData;
        transformedRectangle?: RotatedRectangleF;
        constructor(name: string, value: ImageMetaData, transformedRectangle?: RotatedRectangleF);
        clone(): ImageItemValue;
        equals(other: ImageItemValue): boolean;
    }
    enum ImageSourceType {
        None = 0,
        File = 1,
        StorageId = 3,
        Url = 4,
        PublicImage = 5,
        UserImage = 6
    }
    class ImageSource implements INotifyPropertyChanged<ImageSource, string>, IEqualsReady {
        private _storageId;
        private _url;
        private _type;
        private _width;
        private _height;
        private _isVector;
        private _containsOnlyVectorElements;
        private _pageIndex;
        private _origin;
        private _actualSize;
        private _saveAspectRatio;
        private _dpiX;
        private _dpiY;
        constructor(storageId?: string, url?: string, sourcePageIndex?: number, actualSize?: boolean, saveAspectRatio?: boolean, origin?: ImageSource.Origin);
        clone(): ImageSource;
        equals(other: ImageSource): boolean;
        get id(): string;
        set id(value: string);
        setIdWithOrigin(id: string, origin: ImageSource.Origin): void;
        get url(): string;
        set url(value: string);
        get width(): number;
        set width(value: number);
        get height(): number;
        set height(value: number);
        get isVector(): boolean;
        set isVector(value: boolean);
        get containsOnlyVectorElements(): boolean;
        set containsOnlyVectorElements(value: boolean);
        get pageIndex(): number;
        set pageIndex(value: number);
        get origin(): ImageSource.Origin;
        private _setOrigin;
        get type(): ImageSourceType;
        get actualSize(): boolean;
        set actualSize(value: boolean);
        get saveAspectRatio(): boolean;
        set saveAspectRatio(value: boolean);
        get dpiX(): number;
        set dpiX(dpi: number);
        get dpiY(): number;
        set dpiY(dpi: number);
        protected _propertyChanged: EventWithSenderArg<ImageSource, string>;
        addPropertyChanged(listener: (sender: ImageSource, eventArgs: string) => void): void;
        removePropertyChanged(listener: (sender: ImageSource, eventArgs: string) => void): void;
        toJSON(): {
            id: string;
            width: number;
            height: number;
            isVector: boolean;
            containsOnlyVectorElements: boolean;
            pageIndex: number;
            url: string;
            actualSize: boolean;
            saveAspectRatio: boolean;
            origin: ImageSource.Origin;
        };
    }
    namespace ImageSource {
        class Origin implements IEqualsReady {
            constructor(rawData?: Object);
            type: string;
            data?: any;
            originalSize?: Size;
            equals(other: Origin): boolean;
            clone(): Origin;
        }
    }
}