ngx-image-cropper

alignImage: 'left' | 'center';

aspectRatio: number;

autoCrop: boolean;

backgroundColor: string;

canvasRotation: number;

containWithinAspectRatio: boolean;

cropperFrameAriaLabel: string;

cropperMaxHeight: number;

cropperMaxWidth: number;

cropperMinHeight: number;

cropperMinWidth: number;

cropperScaledMaxHeight: number;

cropperScaledMaxWidth: number;

cropperScaledMinHeight: number;

cropperScaledMinWidth: number;

cropperStaticHeight: number;

cropperStaticWidth: number;

format: OutputFormat;

hideResizeSquares: boolean;

imageQuality: number;

initialStepSize: number;

maintainAspectRatio: boolean;

onlyScaleDown: boolean;

output: OutputType;

resetCropOnAspectRatioChange: boolean;

resizeToHeight: number;

resizeToWidth: number;

roundCropper: boolean;

stepSize: number;

transform: ImageTransform;

setOptions: (options: Partial<CropperOptions>) => void;

setOptionsFromChanges: (changes: SimpleChanges) => void;

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

static ɵprov: i0.ɵɵInjectableDeclaration<CropService>;

crop: {
    (
        loadedImage: LoadedImage,
        cropper: CropperPosition,
        settings: CropperSettings,
        output: 'blob',
        maxSize: Dimensions
    ): Promise<ImageCroppedEvent> | null;
    (
        loadedImage: LoadedImage,
        cropper: CropperPosition,
        settings: CropperSettings,
        output: 'base64',
        maxSize: Dimensions
    ): ImageCroppedEvent;
};

getQuality: (settings: CropperSettings) => number;

getResizeRatio: (
    width: number,
    height: number,
    settings: CropperSettings
) => number;

constructor(
    cropService: CropService,
    cropperPositionService: CropperPositionService,
    loadImageService: LoadImageService,
    sanitizer: DomSanitizer,
    cd: ChangeDetectorRef,
    zone: NgZone,
    hammerLoader: any
);

alignImage: 'left' | 'center';

allowMoveImage: boolean;

aspectRatio: number;

autoCrop: boolean;

backgroundColor: string;

canvasRotation: number;

containWithinAspectRatio: boolean;

cropper: CropperPosition;

cropperFrameAriaLabel: string;

cropperMaxHeight: number;

cropperMaxWidth: number;

cropperMinHeight: number;

cropperMinWidth: number;

cropperReady: EventEmitter<Dimensions>;

cropperStaticHeight: number;

cropperStaticWidth: number;

disabled: boolean;

format: OutputFormat;

hidden: boolean;

hideResizeSquares: boolean;

imageAltText?: string;

imageBase64?: string;

imageChangedEvent?: Event;

imageCropped: EventEmitter<ImageCroppedEvent>;

imageFile?: File;

imageLoaded: EventEmitter<LoadedImage>;

imageQuality: number;

imageURL?: string;

imageVisible: boolean;

initialStepSize: number;

loadImageFailed: EventEmitter<void>;

maintainAspectRatio: boolean;

marginLeft: any;

maxSize: Dimensions;

moveTypes: typeof MoveTypes;

onlyScaleDown: boolean;

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 };
        cropperFrameAriaLabel: {
            alias: 'cropperFrameAriaLabel';
            required: false;
        };
        output: { alias: 'output'; required: false };
        format: { alias: 'format'; 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 };
        autoCrop: { alias: 'autoCrop'; required: false };
        backgroundColor: { alias: 'backgroundColor'; required: false };
        containWithinAspectRatio: {
            alias: 'containWithinAspectRatio';
            required: false;
        };
        hideResizeSquares: { alias: 'hideResizeSquares'; required: false };
        allowMoveImage: { alias: 'allowMoveImage'; required: false };
        cropper: { alias: 'cropper'; 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';
    },
    never,
    never,
    true,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<
    ImageCropperComponent,
    [null, null, null, null, null, null, { optional: true }]
>;

resetCropOnAspectRatioChange: boolean;

resizeToHeight: number;

resizeToWidth: number;

roundCropper: boolean;

safeImgDataUrl?: any;

safeTransformStyle?: any;

sourceImage: ElementRef<HTMLDivElement>;

startCropImage: EventEmitter<void>;

transform: ImageTransform;

transformChange: EventEmitter<ImageTransform>;

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;

ngOnInit: () => void;

onPinch: (event: any) => void;

onResize: () => void;

pinchStop: () => void;

resetCropperPosition: () => void;

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

startPinch: (event: any) => void;

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

static ɵprov: i0.ɵɵInjectableDeclaration<LoadImageService>;

loadBase64Image: (
    imageBase64: string,
    cropperSettings: CropperSettings
) => Promise<LoadedImage>;

loadImageFile: (
    file: File,
    cropperSettings: CropperSettings
) => Promise<LoadedImage>;

loadImageFromURL: (
    url: string,
    cropperSettings: CropperSettings
) => Promise<LoadedImage>;

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

alignImage: 'left' | 'center';

aspectRatio: number;

autoCrop: boolean;

backgroundColor: string;

canvasRotation: number;

containWithinAspectRatio: boolean;

cropperMaxHeight: number;

cropperMaxWidth: number;

cropperMinHeight: number;

cropperMinWidth: number;

cropperStaticHeight: number;

cropperStaticWidth: number;

format: OutputFormat;

hideResizeSquares: boolean;

imageQuality: number;

initialStepSize: number;

maintainAspectRatio: boolean;

onlyScaleDown: boolean;

resetCropOnAspectRatioChange: boolean;

resizeToHeight: number;

resizeToWidth: number;

roundCropper: boolean;

transform: ImageTransform;

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;
};

active: boolean;

clientX: number;

clientY: number;

position: string | null;

transform?: ImageTransform;

type: MoveTypes | null;

x1: number;

x2: number;

y1: number;

y2: number;