ngx-image-cropper

crop: {
    (input: CropInput, output: 'blob'): Promise<ImageCroppedEvent> | null;
    (input: CropInput, output: 'base64'): ImageCroppedEvent;
};

getQuality: (options?: { imageQuality?: number }) => number;

getResizeRatio: (
    width: number,
    height: number,
    options?: {
        resizeToWidth?: number;
        resizeToHeight?: number;
        onlyScaleDown?: boolean;
    }
) => number;

constructor(sanitizer: DomSanitizer);

alignImage?: 'left' | 'center';

readonly alignImageStyle: 'left' | 'center';

allowMoveImage: boolean;

aspectRatio?: number;

autoCrop?: boolean;

backgroundColor?: string;

canvasRotation?: number;

checkImageType: boolean;

containWithinAspectRatio?: boolean;

cropper?: CropperPosition;

readonly cropperChange: any;

cropperFrameAriaLabel?: string;

cropperMaxHeight?: number;

cropperMaxWidth?: number;

cropperMinHeight?: number;

cropperMinWidth?: number;

readonly cropperReady: any;

cropperStaticHeight?: number;

cropperStaticWidth?: number;

disabled: boolean;

format?: OutputFormat;

hidden: boolean;

hideResizeSquares?: boolean;

imageAltText?: string;

imageBase64?: string;

imageChangedEvent?: Event;

readonly imageCropped: any;

imageFile?: File;

readonly imageLoaded: any;

imageQuality?: number;

imageURL?: string;

imageVisible: boolean;

initialStepSize?: number;

readonly loadImageFailed: any;

maintainAspectRatio?: boolean;

marginLeft: any;

protected readonly moveTypes: typeof MoveTypes;

onlyScaleDown?: boolean;

options?: Partial<CropperOptions>;

output?: 'blob' | 'base64';

static ɵcmp: i0.ɵɵComponentDeclaration<
    ImageCropperComponent,
    'image-cropper',
    never,
    {
        imageChangedEvent: { alias: 'imageChangedEvent'; required: false };
        imageURL: { alias: 'imageURL'; required: false };
        imageBase64: { alias: 'imageBase64'; required: false };
        imageFile: { alias: 'imageFile'; required: false };
        imageAltText: { alias: 'imageAltText'; required: false };
        options: { alias: 'options'; required: false };
        cropperFrameAriaLabel: {
            alias: 'cropperFrameAriaLabel';
            required: false;
        };
        output: { alias: 'output'; required: false };
        format: { alias: 'format'; required: false };
        autoCrop: { alias: 'autoCrop'; required: false };
        cropper: { alias: 'cropper'; required: false };
        transform: { alias: 'transform'; required: false };
        maintainAspectRatio: { alias: 'maintainAspectRatio'; required: false };
        aspectRatio: { alias: 'aspectRatio'; required: false };
        resetCropOnAspectRatioChange: {
            alias: 'resetCropOnAspectRatioChange';
            required: false;
        };
        resizeToWidth: { alias: 'resizeToWidth'; required: false };
        resizeToHeight: { alias: 'resizeToHeight'; required: false };
        cropperMinWidth: { alias: 'cropperMinWidth'; required: false };
        cropperMinHeight: { alias: 'cropperMinHeight'; required: false };
        cropperMaxHeight: { alias: 'cropperMaxHeight'; required: false };
        cropperMaxWidth: { alias: 'cropperMaxWidth'; required: false };
        cropperStaticWidth: { alias: 'cropperStaticWidth'; required: false };
        cropperStaticHeight: { alias: 'cropperStaticHeight'; required: false };
        canvasRotation: { alias: 'canvasRotation'; required: false };
        initialStepSize: { alias: 'initialStepSize'; required: false };
        roundCropper: { alias: 'roundCropper'; required: false };
        onlyScaleDown: { alias: 'onlyScaleDown'; required: false };
        imageQuality: { alias: 'imageQuality'; required: false };
        backgroundColor: { alias: 'backgroundColor'; required: false };
        containWithinAspectRatio: {
            alias: 'containWithinAspectRatio';
            required: false;
        };
        hideResizeSquares: { alias: 'hideResizeSquares'; required: false };
        allowMoveImage: { alias: 'allowMoveImage'; required: false };
        checkImageType: { alias: 'checkImageType'; required: false };
        alignImage: { alias: 'alignImage'; required: false };
        disabled: { alias: 'disabled'; required: false };
        hidden: { alias: 'hidden'; required: false };
    },
    {
        imageCropped: 'imageCropped';
        startCropImage: 'startCropImage';
        imageLoaded: 'imageLoaded';
        cropperReady: 'cropperReady';
        loadImageFailed: 'loadImageFailed';
        transformChange: 'transformChange';
        cropperChange: 'cropperChange';
    },
    never,
    never,
    true,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<ImageCropperComponent, never>;

resetCropOnAspectRatioChange?: boolean;

resizeToHeight?: number;

resizeToWidth?: number;

roundCropper?: boolean;

readonly safeImgDataUrl: any;

readonly safeTransformStyle: any;

sourceImage: ElementRef<HTMLDivElement>;

readonly startCropImage: any;

protected readonly state: CropperState;

transform?: ImageTransform;

readonly transformChange: any;

wrapper: ElementRef<HTMLDivElement>;

crop: {
    (): ImageCroppedEvent | null;
    (output: 'base64'): ImageCroppedEvent;
    (output: 'blob'): Promise<ImageCroppedEvent>;
};

imageLoadedInView: () => void;

keyboardAccess: (event: KeyboardEvent) => void;

loadImageError: (error: unknown) => void;

ngOnChanges: (changes: SimpleChanges) => void;

ngOnDestroy: () => void;

ngOnInit: () => void;

onResize: () => void;

resetCropperPosition: () => void;

startMove: (
    event: Event | BasicEvent,
    moveType: MoveTypes,
    position?: Position | null
) => void;

startPinch: (event: TouchEvent) => void;

loadBase64Image: (
    imageBase64: string,
    options: LoadImageOptions
) => Promise<LoadedImage>;

loadImageFile: (file: File, options: LoadImageOptions) => Promise<LoadedImage>;

loadImageFromURL: (
    url: string,
    options: LoadImageOptions
) => Promise<LoadedImage>;

transformLoadedImage: (
    loadedImage: Partial<LoadedImage>,
    options: LoadImageOptions,
    forceTransform?: boolean
) => Promise<LoadedImage>;

cropper: CropperPosition;

loadedImage: LoadedImage;

maxSize: Dimensions;

options?: {
    backgroundColor?: string;
    containWithinAspectRatio?: boolean;
    maintainAspectRatio?: boolean;
    aspectRatio?: number;
    format?: OutputFormat;
    canvasRotation?: number;
    imageQuality?: number;
    resizeToWidth?: number;
    resizeToHeight?: number;
    onlyScaleDown?: boolean;
};

transform?: ImageTransform;

alignImage: 'left' | 'center';

aspectRatio: number;

autoCrop: boolean;

backgroundColor: string | undefined;

canvasRotation: number;

checkImageType: boolean;

containWithinAspectRatio: boolean;

cropperFrameAriaLabel: string | undefined;

cropperMaxHeight: number;

cropperMaxWidth: number;

cropperMinHeight: number;

cropperMinWidth: number;

cropperStaticHeight: number;

cropperStaticWidth: number;

format: OutputFormat;

hideResizeSquares: boolean;

imageQuality: number;

maintainAspectRatio: boolean;

onlyScaleDown: boolean;

output: OutputType;

resetCropOnAspectRatioChange: boolean;

resizeToHeight: number;

resizeToWidth: number;

roundCropper: boolean;

x1: number;

x2: number;

y1: number;

y2: number;

height: number;

width: number;

base64?: string | null;

blob?: Blob | null;

cropperPosition: CropperPosition;

height: number;

imagePosition: CropperPosition;

objectUrl?: string | null;

offsetImagePosition?: CropperPosition;

width: number;

flipH?: boolean;

flipV?: boolean;

rotate?: number;

scale?: number;

translateH?: number;

translateUnit?: '%' | 'px';

translateV?: number;

exifTransform: ExifTransform;

original: {
    objectUrl: string;
    image: HTMLImageElement;
    size: Dimensions;
};

transformed: {
    objectUrl: string;
    image: HTMLImageElement;
    size: Dimensions;
};

aspectRatio?: number;

canvasRotation?: number;

checkImageType?: boolean;

containWithinAspectRatio?: boolean;

format?: OutputFormat;

clientX: number;

clientY: number;

cropper: CropperPosition;

position: Position | null;

transform?: ImageTransform;

type: MoveTypes | null;