ngx-color-picker

constructor(c: number, m: number, y: number, k: number, a?: number);

a: number;

c: number;

k: number;

m: number;

y: number;

constructor();

alphaSlider: ElementRef;

alphaSliderColor: string;

arrowTop: number;

cmykText: Cmyk;

cpAddColorButton: boolean;

cpAddColorButtonClass: string;

cpAddColorButtonText: string;

cpAlphaChannel: AlphaChannel;

cpArrowPosition: number;

cpCancelButton: boolean;

cpCancelButtonClass: string;

cpCancelButtonText: string;

cpCloseClickOutside: boolean;

cpCmykEnabled: boolean;

cpColorMode: number;

cpDialogDisplay: string;

cpDisableInput: boolean;

cpExtraTemplate: TemplateRef<any>;

cpEyeDropper: boolean;

cpHeight: number;

cpIgnoredElements: any;

cpMaxPresetColorsLength: number;

cpOKButton: boolean;

cpOKButtonClass: string;

cpOKButtonText: string;

cpOutputFormat: OutputFormat;

cpPosition: string;

cpPositionOffset: number;

cpPresetColors: string[];

cpPresetColorsClass: string;

cpPresetEmptyMessage: string;

cpPresetEmptyMessageClass: string;

cpPresetLabel: string;

cpRemoveColorButtonClass: string;

cpSaveClickOutside: boolean;

cpTriggerElement: ElementRef;

cpUsePosition: string;

cpWidth: number;

dialogElement: ElementRef;

eyeDropperSupported: boolean;

format: ColorFormats;

hexAlpha: number;

hexText: string;

hidden: boolean;

hslaText: Hsla;

hueSlider: ElementRef;

hueSliderColor: string;

left: number;

static ɵcmp: i0.ɵɵComponentDeclaration<
    ColorPickerComponent,
    'color-picker',
    never,
    {},
    {},
    never,
    never,
    true,
    never
>;

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

position: string;

rgbaText: Rgba;

selectedColor: string;

show: boolean;

slider: SliderPosition;

top: number;

closeDialog: () => void;

handleEnter: (event: any) => void;

handleEsc: (event: any) => void;

ngAfterViewInit: () => void;

ngOnDestroy: () => void;

ngOnInit: () => void;

onAcceptColor: (event: Event) => void;

onAddPresetColor: (event: any, value: string) => void;

onAlphaChange: (value: { v: number; rgX: number }) => void;

onAlphaInput: (value: { v: number; rg: number }) => void;

onBlackInput: (value: { v: number; rg: number }) => void;

onBlueInput: (value: { v: number; rg: number }) => void;

onCancelColor: (event: Event) => void;

onColorChange: (value: {
    s: number;
    v: number;
    rgX: number;
    rgY: number;
}) => void;

onCyanInput: (value: { v: number; rg: number }) => void;

onDragEnd: (slider: string) => void;

onDragStart: (slider: string) => void;

onEyeDropper: () => void;

onFormatToggle: (change: number) => void;

onGreenInput: (value: { v: number; rg: number }) => void;

onHexInput: (value: string | null) => void;

onHueChange: (value: { v: number; rgX: number }) => void;

onHueInput: (value: { v: number; rg: number }) => void;

onLightnessInput: (value: { v: number; rg: number }) => void;

onMagentaInput: (value: { v: number; rg: number }) => void;

onMouseDown: (event: MouseEvent) => void;

onRedInput: (value: { v: number; rg: number }) => void;

onRemovePresetColor: (event: any, value: string) => void;

onResize: () => void;

onSaturationInput: (value: { v: number; rg: number }) => void;

onValueChange: (value: { v: number; rgX: number }) => void;

onValueInput: (value: { v: number; rg: number }) => void;

onYellowInput: (value: { v: number; rg: number }) => void;

openDialog: (color: any, emit?: boolean) => void;

setColorFromString: (value: string, emit?: boolean, update?: boolean) => void;

setColorMode: (mode: string) => void;

setInitialColor: (color: any) => void;

setPresetConfig: (cpPresetLabel: string, cpPresetColors: string[]) => void;

setupDialog: (
    instance: any,
    elementRef: ElementRef,
    color: any,
    cpWidth: string,
    cpHeight: string,
    cpDialogDisplay: string,
    cpFallbackColor: string,
    cpColorMode: string,
    cpCmykEnabled: boolean,
    cpAlphaChannel: AlphaChannel,
    cpOutputFormat: OutputFormat,
    cpDisableInput: boolean,
    cpIgnoredElements: any,
    cpSaveClickOutside: boolean,
    cpCloseClickOutside: boolean,
    cpUseRootViewContainer: boolean,
    cpPosition: string,
    cpPositionOffset: string,
    cpPositionRelativeToArrow: boolean,
    cpPresetLabel: string,
    cpPresetColors: string[],
    cpPresetColorsClass: string,
    cpMaxPresetColorsLength: number,
    cpPresetEmptyMessage: string,
    cpPresetEmptyMessageClass: string,
    cpOKButton: boolean,
    cpOKButtonClass: string,
    cpOKButtonText: string,
    cpCancelButton: boolean,
    cpCancelButtonClass: string,
    cpCancelButtonText: string,
    cpAddColorButton: boolean,
    cpAddColorButtonClass: string,
    cpAddColorButtonText: string,
    cpRemoveColorButtonClass: string,
    cpEyeDropper: boolean,
    cpTriggerElement: ElementRef,
    cpExtraTemplate: TemplateRef<any>
) => void;

colorPicker: string;

colorPickerCancel: EventEmitter<string>;

colorPickerChange: EventEmitter<string>;

colorPickerClose: EventEmitter<string>;

colorPickerOpen: EventEmitter<string>;

colorPickerSelect: EventEmitter<string>;

cpAddColorButton: boolean;

cpAddColorButtonClass: string;

cpAddColorButtonText: string;

cpAlphaChannel: AlphaChannel;

cpArrowPosition: number;

cpCancelButton: boolean;

cpCancelButtonClass: string;

cpCancelButtonText: string;

cpCloseClickOutside: boolean;

cpCmykColorChange: EventEmitter<string>;

cpCmykEnabled: boolean;

cpColorMode: ColorMode;

cpDialogDisplay: string;

cpDisabled: boolean;

cpDisableInput: boolean;

cpExtraTemplate: TemplateRef<any>;

cpEyeDropper: boolean;

cpFallbackColor: string;

cpHeight: string;

cpIgnoredElements: any;

cpInputChange: EventEmitter<{
    input: string;
    value: number | string;
    color: string;
}>;

cpMaxPresetColorsLength: number;

cpOKButton: boolean;

cpOKButtonClass: string;

cpOKButtonText: string;

cpOutputFormat: OutputFormat;

cpPosition: string;

cpPositionOffset: string;

cpPositionRelativeToArrow: boolean;

cpPresetColors: string[];

cpPresetColorsChange: EventEmitter<any>;

cpPresetColorsClass: string;

cpPresetEmptyMessage: string;

cpPresetEmptyMessageClass: string;

cpPresetLabel: string;

cpRemoveColorButtonClass: string;

cpSaveClickOutside: boolean;

cpSliderChange: EventEmitter<{
    slider: string;
    value: string | number;
    color: string;
}>;

cpSliderDragEnd: EventEmitter<{ slider: string; color: string }>;

cpSliderDragStart: EventEmitter<{ slider: string; color: string }>;

cpToggle: boolean;

cpToggleChange: EventEmitter<boolean>;

cpUseRootViewContainer: boolean;

cpWidth: string;

static ɵdir: i0.ɵɵDirectiveDeclaration<
    ColorPickerDirective,
    '[colorPicker]',
    ['ngxColorPicker'],
    {
        colorPicker: { alias: 'colorPicker'; required: false };
        cpWidth: { alias: 'cpWidth'; required: false };
        cpHeight: { alias: 'cpHeight'; required: false };
        cpToggle: { alias: 'cpToggle'; required: false };
        cpDisabled: { alias: 'cpDisabled'; required: false };
        cpIgnoredElements: { alias: 'cpIgnoredElements'; required: false };
        cpFallbackColor: { alias: 'cpFallbackColor'; required: false };
        cpColorMode: { alias: 'cpColorMode'; required: false };
        cpCmykEnabled: { alias: 'cpCmykEnabled'; required: false };
        cpOutputFormat: { alias: 'cpOutputFormat'; required: false };
        cpAlphaChannel: { alias: 'cpAlphaChannel'; required: false };
        cpDisableInput: { alias: 'cpDisableInput'; required: false };
        cpDialogDisplay: { alias: 'cpDialogDisplay'; required: false };
        cpSaveClickOutside: { alias: 'cpSaveClickOutside'; required: false };
        cpCloseClickOutside: { alias: 'cpCloseClickOutside'; required: false };
        cpUseRootViewContainer: {
            alias: 'cpUseRootViewContainer';
            required: false;
        };
        cpPosition: { alias: 'cpPosition'; required: false };
        cpPositionOffset: { alias: 'cpPositionOffset'; required: false };
        cpPositionRelativeToArrow: {
            alias: 'cpPositionRelativeToArrow';
            required: false;
        };
        cpOKButton: { alias: 'cpOKButton'; required: false };
        cpOKButtonText: { alias: 'cpOKButtonText'; required: false };
        cpOKButtonClass: { alias: 'cpOKButtonClass'; required: false };
        cpCancelButton: { alias: 'cpCancelButton'; required: false };
        cpCancelButtonText: { alias: 'cpCancelButtonText'; required: false };
        cpCancelButtonClass: { alias: 'cpCancelButtonClass'; required: false };
        cpEyeDropper: { alias: 'cpEyeDropper'; required: false };
        cpPresetLabel: { alias: 'cpPresetLabel'; required: false };
        cpPresetColors: { alias: 'cpPresetColors'; required: false };
        cpPresetColorsClass: { alias: 'cpPresetColorsClass'; required: false };
        cpMaxPresetColorsLength: {
            alias: 'cpMaxPresetColorsLength';
            required: false;
        };
        cpPresetEmptyMessage: { alias: 'cpPresetEmptyMessage'; required: false };
        cpPresetEmptyMessageClass: {
            alias: 'cpPresetEmptyMessageClass';
            required: false;
        };
        cpAddColorButton: { alias: 'cpAddColorButton'; required: false };
        cpAddColorButtonText: { alias: 'cpAddColorButtonText'; required: false };
        cpAddColorButtonClass: {
            alias: 'cpAddColorButtonClass';
            required: false;
        };
        cpRemoveColorButtonClass: {
            alias: 'cpRemoveColorButtonClass';
            required: false;
        };
        cpArrowPosition: { alias: 'cpArrowPosition'; required: false };
        cpExtraTemplate: { alias: 'cpExtraTemplate'; required: false };
    },
    {
        cpInputChange: 'cpInputChange';
        cpToggleChange: 'cpToggleChange';
        cpSliderChange: 'cpSliderChange';
        cpSliderDragEnd: 'cpSliderDragEnd';
        cpSliderDragStart: 'cpSliderDragStart';
        colorPickerOpen: 'colorPickerOpen';
        colorPickerClose: 'colorPickerClose';
        colorPickerCancel: 'colorPickerCancel';
        colorPickerSelect: 'colorPickerSelect';
        colorPickerChange: 'colorPickerChange';
        cpCmykColorChange: 'cpCmykColorChange';
        cpPresetColorsChange: 'cpPresetColorsChange';
    },
    never,
    never,
    true,
    never
>;

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

closeDialog: () => void;

cmykChanged: (value: string) => void;

colorCanceled: () => void;

colorChanged: (value: string, ignore?: boolean) => void;

colorSelected: (value: string) => void;

handleClick: () => void;

handleFocus: () => void;

handleInput: (event: any) => void;

inputChange: (event: any) => void;

inputChanged: (event: any) => void;

inputFocus: () => void;

ngOnChanges: (changes: any) => void;

ngOnDestroy: () => void;

openDialog: () => void;

presetColorsChanged: (value: any[]) => void;

sliderChanged: (event: any) => void;

sliderDragEnd: (event: { slider: string; color: string }) => void;

sliderDragStart: (event: { slider: string; color: string }) => void;

stateChanged: (state: boolean) => void;

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

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

cmykToRgb: (cmyk: Cmyk) => Rgba;

denormalizeCMYK: (cmyk: Cmyk) => Cmyk;

denormalizeRGBA: (rgba: Rgba) => Rgba;

hsla2hsva: (hsla: Hsla) => Hsva;

hsva2hsla: (hsva: Hsva) => Hsla;

hsvaToRgba: (hsva: Hsva) => Rgba;

normalizeCMYK: (cmyk: Cmyk) => Cmyk;

outputFormat: (
    hsva: Hsva,
    outputFormat: string,
    alphaChannel: string | null
) => string;

rgbaToCmyk: (rgba: Rgba) => Cmyk;

rgbaToHex: (rgba: Rgba, allowHex8?: boolean) => string;

rgbaToHsva: (rgba: Rgba) => Hsva;

setActive: (active: ColorPickerComponent | null) => void;

stringToHsva: (colorString?: string, allowHex8?: boolean) => Hsva | null;

constructor(h: number, s: number, l: number, a: number);

a: number;

h: number;

l: number;

s: number;

constructor(h: number, s: number, v: number, a: number);

a: number;

h: number;

s: number;

v: number;

constructor(r: number, g: number, b: number, a: number);

a: number;

b: number;

g: number;

r: number;

constructor();

dragEnd: EventEmitter<any>;

dragStart: EventEmitter<any>;

newValue: EventEmitter<any>;

static ɵdir: i0.ɵɵDirectiveDeclaration<
    SliderDirective,
    '[slider]',
    never,
    {
        rgX: { alias: 'rgX'; required: false };
        rgY: { alias: 'rgY'; required: false };
    },
    { dragEnd: 'dragEnd'; dragStart: 'dragStart'; newValue: 'newValue' },
    never,
    never,
    true,
    never
>;

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

rgX: number;

rgY: number;

mouseDown: (event: any) => void;

touchStart: (event: any) => void;

newValue: EventEmitter<any>;

static ɵdir: i0.ɵɵDirectiveDeclaration<
    TextDirective,
    '[text]',
    never,
    {
        rg: { alias: 'rg'; required: false };
        text: { alias: 'text'; required: false };
    },
    { newValue: 'newValue' },
    never,
    never,
    true,
    never
>;

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

rg: number;

text: any;

inputChange: (event: any) => void;