yuyeon 0.0.14 → 0.0.16

package/types/composables/list-items.d.ts

@@ -0,0 +1,117 @@
+import type { ExtractPropTypes, Ref } from 'vue';
+export interface ListItem<T = any> {
+    value: any;
+    text: string;
+    props: {
+        [key: string]: any;
+        value: any;
+        text: string;
+    };
+    children?: ListItem<T>[];
+    raw: T;
+}
+declare const listItemsPropsOptions: {
+    returnItem: BooleanConstructor;
+    items: {
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    };
+    itemKey: Omit<{
+        type: import("vue").PropType<string>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    itemText: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    itemChildren: Omit<{
+        type: import("vue").PropType<string | boolean>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    };
+};
+type ListItemProps = ExtractPropTypes<typeof listItemsPropsOptions>;
+export declare const pressListItemsPropsOptions: <Defaults extends {
+    returnItem?: unknown;
+    items?: unknown;
+    itemKey?: unknown;
+    itemText?: unknown;
+    itemChildren?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    returnItem: unknown extends Defaults["returnItem"] ? BooleanConstructor : {
+        type: import("vue").PropType<unknown extends Defaults ? "returnItem" : "returnItem" | Defaults>;
+        default: unknown extends Defaults["returnItem"] ? boolean : boolean | Defaults["returnItem"];
+    };
+    items: unknown extends Defaults["items"] ? {
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    } : Omit<{
+        type: import("vue").PropType<any[]>;
+        default: () => never[];
+    }, "default" | "type"> & {
+        type: import("vue").PropType<unknown extends Defaults["items"] ? any[] : any[] | Defaults["items"]>;
+        default: unknown extends Defaults["items"] ? any[] : any[] | Defaults["items"];
+    };
+    itemKey: unknown extends Defaults["itemKey"] ? Omit<{
+        type: import("vue").PropType<string>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<string>;
+        default: string;
+    } : Omit<Omit<{
+        type: import("vue").PropType<string>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<string>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<unknown extends Defaults["itemKey"] ? string : string | Defaults["itemKey"]>;
+        default: unknown extends Defaults["itemKey"] ? string : string | Defaults["itemKey"];
+    };
+    itemText: unknown extends Defaults["itemText"] ? {
+        type: import("vue").PropType<string>;
+        default: string;
+    } : Omit<{
+        type: import("vue").PropType<string>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<unknown extends Defaults["itemText"] ? string : string | Defaults["itemText"]>;
+        default: unknown extends Defaults["itemText"] ? string : string | Defaults["itemText"];
+    };
+    itemChildren: unknown extends Defaults["itemChildren"] ? Omit<{
+        type: import("vue").PropType<string | boolean>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    } : Omit<Omit<{
+        type: import("vue").PropType<string | boolean>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<unknown extends Defaults["itemChildren"] ? NonNullable<string | boolean> : Defaults["itemChildren"] | NonNullable<NonNullable<string | boolean>>>;
+        default: unknown extends Defaults["itemChildren"] ? NonNullable<string | boolean> : Defaults["itemChildren"] | NonNullable<NonNullable<string | boolean>>;
+    };
+};
+export declare function refineListItems(props: Omit<ListItemProps, 'items'>, items: any[]): ListItem<any>[];
+export declare function refineListItem(props: Omit<ListItemProps, 'items'>, item: any): ListItem;
+export declare function useItems(props: ListItemProps): {
+    items: Ref<ListItem<any>[]>;
+    toEmitItems: (items: ListItem<any>[]) => unknown[];
+    toRefineItems: (values: any[]) => ListItem<any>[];
+};
+export declare function useRefineListItems<T extends {
+    value: unknown;
+}>(items: Ref<T[]>, refine: (value: unknown) => T): {
+    items: Ref<T[]>;
+    toEmitItems: (items: T[]) => unknown[];
+    toRefineItems: (values: any[]) => T[];
+};
+export {};

package/types/composables/theme/factory.d.ts

@@ -0,0 +1,3 @@
+import { ThemeDefinition } from './types';
+export declare function createThemes(options: Record<string, any>): Record<string, ThemeDefinition>;
+export declare function createPalette(options: Record<string, string | any>): Record<string, string>;

package/types/composables/theme/helper.d.ts

@@ -0,0 +1,3 @@
+export declare function cssClass(selector: string, content: string[]): string[];
+export declare function cssVariables(variables: Record<string, string>, prefix?: string): string[];
+export declare function cssVariable(property: string, value: string): string;

package/types/composables/theme/index.d.ts

@@ -1,15 +1,55 @@
-import type { App } from 'vue';
-import type { ThemeOptions } from "./setting";
+import type { App, ComputedRef, Ref } from 'vue';
+import { ThemeScheme } from './setting';
+import type { ThemeOptions } from './types';
+export type { ThemeOptions };
 export declare const Y_THEME_PREFIX = "y-theme";
+export interface ThemeModuleInstance {
+    scheme: keyof typeof ThemeScheme | 'auto';
+    theme: Ref<[string, string?]>;
+    readonly themes: any;
+    readonly global: {
+        scheme: keyof typeof ThemeScheme | 'auto';
+        theme: Ref<[string, string?]>;
+    };
+    readonly currentThemeKey: Readonly<ComputedRef<string>>;
+    readonly themeClasses: Readonly<ComputedRef<string | undefined>>;
+    readonly computedThemes: Readonly<ComputedRef<any>>;
+    readonly computedPalette: Readonly<ComputedRef<any>>;
+    readonly supportedAutoMode: Readonly<Ref<boolean>>;
+    readonly preferColorScheme: Readonly<Ref<'light' | 'dark'>>;
+}
 export declare const YUYEON_THEME_KEY: unique symbol;
+export declare const pressThemePropsOptions: <Defaults extends {
+    theme?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    theme: unknown extends Defaults["theme"] ? StringConstructor : {
+        type: import("vue").PropType<unknown extends Defaults ? "theme" : "theme" | Defaults>;
+        default: unknown extends Defaults["theme"] ? string : string | Defaults["theme"];
+    };
+};
+export declare function isDarkMode(): boolean;
+export declare function isSupportAutoScheme(): boolean;
 export declare function createThemeModule(options: ThemeOptions): {
     install: (app: App) => void;
     init: (yuyeon: any) => void;
     scope: import("vue").EffectScope;
     instance: {
-        scheme: any;
-        theme: [string, string];
+        global: {
+            scheme: Ref<string>;
+            theme: Ref<[string, string]>;
+        };
         themes: any;
-        mode: any;
+        scheme: Ref<string>;
+        theme: Ref<[string, string]>;
+        currentThemeKey: ComputedRef<string>;
+        themeClasses: ComputedRef<string>;
+        computedThemes: ComputedRef<Record<string, import("./types").ThemeDefinition>>;
+        computedPalette: ComputedRef<Record<string, string>>;
+        supportedAutoMode: Readonly<Ref<boolean>>;
+        preferColorScheme: Readonly<Ref<string>>;
     };
 };
+export declare function useLocalTheme(props: {
+    theme?: string;
+}): ThemeModuleInstance;
+export declare function useTheme(): ThemeModuleInstance;

package/types/composables/theme/setting.d.ts

@@ -1,12 +1,9 @@
+import { PaletteOption, ThemeOptions } from './types';
 export declare const ThemeScheme: {
     readonly light: "light";
     readonly dark: "dark";
 };
-export interface ThemeOptions {
-    mode: 'manual';
-    scheme: keyof typeof ThemeScheme | 'normal';
-    theme: string | [string, string];
-    themes: any;
-}
+export declare const defaultTonalLuminance: number[];
+export declare const defaultPalette: PaletteOption;
 export declare const defaultThemesValues: any;
 export declare function configureOptions(options?: ThemeOptions): any;

package/types/composables/theme/types.d.ts

@@ -0,0 +1,28 @@
+export interface ThemeOptions {
+    scheme: 'light' | 'dark' | 'auto';
+    theme: [string, string?];
+    themes: Record<string, ThemeDefinition>;
+    palette?: PaletteOption;
+    cspNonce?: string;
+}
+export interface PaletteOption {
+    scaleMethod: 'manual' | 'luma' | 'tonal';
+    colors: Record<string, string | PaletteLevelColorOption | PaletteLumaColorOption>;
+    defaultLamaScale?: {
+        darken?: 0 | 1 | 2 | 3 | 4;
+        lighten?: 0 | 1 | 2 | 3 | 4 | 5;
+    };
+}
+type ScaleLevel = number;
+export type PaletteLevelColorOption = Record<ScaleLevel, string>;
+export type PaletteLumaColorOption = {
+    value: string;
+    darken?: 0 | 1 | 2 | 3 | 4;
+    lighten?: 0 | 1 | 2 | 3 | 4 | 5;
+};
+export interface ThemeDefinition {
+    isDark: boolean;
+    colors: Record<string, string>;
+    variables: Record<string, string>;
+}
+export {};

package/types/directives/complement-click/index.d.ts

@@ -13,7 +13,7 @@ declare global {
 export interface ComplementClickBindingOptions {
     handler: (mouseEvent: MouseEvent) => void;
     determine?: (event: Event) => boolean;
-    include?: () => HTMLElement[];
+    include?: () => (HTMLElement | undefined)[];
 }
 export interface ComplementClickBinding extends DirectiveBinding {
     value: ((mouseEvent: MouseEvent) => void) | ComplementClickBindingOptions;

package/types/directives/theme-class.d.ts

@@ -1,3 +1,3 @@
-import { FunctionDirective } from "vue";
+import { FunctionDirective } from 'vue';
 declare const bindThemeClass: FunctionDirective;
 export default bindThemeClass;

package/types/index.d.ts

@@ -1,4 +1,5 @@
 import type { App } from 'vue';
+import { useTheme } from './composables/theme';
 declare module 'vue' {
     interface ComponentCustomProperties {
         $yuyeon: any;
@@ -7,3 +8,4 @@ declare module 'vue' {
 export declare function init(options?: any): {
     install: (app: App) => any;
 };
+export { useTheme };

package/types/shims.d.ts

@@ -12,6 +12,7 @@ import {
   YDataTableServer,
   YDialog,
   YDividePanel,
+  YDropdown,
   YExpandHTransition,
   YExpandVTransition,
   YFieldInput,
@@ -31,6 +32,7 @@ import {
   YTooltip,
   YTreeView,
   YTreeViewNode,
+  YSelect,
 } from 'yuyeon/types/components';
 
 declare module '@vue/runtime-core' {
@@ -67,5 +69,7 @@ declare module '@vue/runtime-core' {
     YInputCheckbox: typeof YInputCheckbox;
     YCheckbox: typeof YCheckbox;
     YSwitch: typeof YSwitch;
+    YDropdown: typeof YDropdown;
+    YSelect: typeof YSelect;
   }
 }

package/types/util/color/apca.d.ts

@@ -0,0 +1,29 @@
+/** @preserve
+ /////    SAPC APCA - Advanced Perceptual Contrast Algorithm
+ /////           Beta 0.1.9 W3 • contrast function only
+ /////           DIST: W3 • Revision date: July 3, 2022
+ /////    Function to parse color values and determine Lc contrast
+ /////    Copyright © 2019-2022 by Andrew Somers. All Rights Reserved.
+ /////    LICENSE: W3 LICENSE
+ /////    CONTACT: Please use the ISSUES or DISCUSSIONS tab at:
+ /////    https://github.com/Myndex/SAPC-APCA/
+ /////
+ ///////////////////////////////////////////////////////////////////////////////
+ /////
+ /////    MINIMAL IMPORTS:
+ /////      import { APCAcontrast, sRGBtoY, displayP3toY,
+/////               calcAPCA, fontLookupAPCA } from 'apca-w3';
+ /////      import { colorParsley } from 'colorparsley';
+ /////
+ /////    FORWARD CONTRAST USAGE:
+ /////      Lc = APCAcontrast( sRGBtoY( TEXTcolor ) , sRGBtoY( BACKGNDcolor ) );
+ /////    Where the colors are sent as an rgba array [255,255,255,1]
+ /////
+ /////    Retrieving an array of font sizes for the contrast:
+ /////      fontArray = fontLookupAPCA(Lc);
+ /////
+ /////    Live Demonstrator at https://www.myndex.com/APCA/
+ // */
+export declare function sRGBtoY(rgb?: number[]): number;
+export declare function APCAcontrast(txtY: number, bgY: number, places?: number): string | number;
+export declare function alphaBlend(rgbaFG?: number[], rgbBG?: number[], round?: boolean): (number | boolean)[];

package/types/util/color/const.d.ts

@@ -0,0 +1,5 @@
+export declare const RGBA_REGEX: RegExp;
+export declare const HEX_COLOR_REGEX: RegExp;
+export declare const SRGB_TO_XYZ: number[][];
+export declare const XYZ_TO_SRGB: number[][];
+export declare const WHITE_POINT_D65: number[];

package/types/util/color/conversion.d.ts

@@ -0,0 +1,130 @@
+import { Rgba } from './types';
+export declare function rgbFromHex(color: string): number[] | undefined;
+export declare function hexFromRgb(red: number, green: number, blue: number): string;
+export declare function hexFromArgb(argb: number): string;
+/**
+ * Converts a color from RGB components to ARGB format.
+ */
+export declare function argbFromRgb(red: number, green: number, blue: number): number;
+/**
+ * Converts a color from linear RGB components to ARGB format.
+ */
+export declare function argbFromLinrgb(linrgb: number[]): number;
+/**
+ * Returns the alpha component of a color in ARGB format.
+ */
+export declare function alphaFromArgb(argb: number): number;
+/**
+ * Returns the red component of a color in ARGB format.
+ */
+export declare function redFromArgb(argb: number): number;
+/**
+ * Returns the green component of a color in ARGB format.
+ */
+export declare function greenFromArgb(argb: number): number;
+/**
+ * Returns the blue component of a color in ARGB format.
+ */
+export declare function blueFromArgb(argb: number): number;
+/**
+ * Returns whether a color in ARGB format is opaque.
+ */
+export declare function isOpaque(argb: number): boolean;
+/**
+ * Converts a color from ARGB to XYZ.
+ */
+export declare function argbFromXyz(x: number, y: number, z: number): number;
+/**
+ * Converts a color from XYZ to ARGB.
+ */
+export declare function xyzFromArgb(argb: number): number[];
+/**
+ * Converts a color represented in Lab color space into an ARGB
+ * integer.
+ */
+export declare function argbFromLab(l: number, a: number, b: number): number;
+/**
+ * Converts a color from ARGB representation to L*a*b*
+ * representation.
+ *
+ * @param argb the ARGB representation of a color
+ * @return a Lab object representing the color
+ */
+export declare function labFromArgb(argb: number): number[];
+/**
+ * Converts an L* value to an ARGB representation.
+ *
+ * @param lstar L* in L*a*b*
+ * @return ARGB representation of grayscale color with lightness
+ * matching L*
+ */
+export declare function argbFromLstar(lstar: number): number;
+/**
+ * Computes the L* value of a color in ARGB representation.
+ *
+ * @param argb ARGB representation of a color
+ * @return L*, from L*a*b*, coordinate of the color
+ */
+export declare function lstarFromArgb(argb: number): number;
+/**
+ * Converts an L* value to a Y value.
+ *
+ * L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
+ *
+ * L* measures perceptual luminance, a linear scale. Y in XYZ
+ * measures relative luminance, a logarithmic scale.
+ *
+ * @param lstar L* in L*a*b*
+ * @return Y in XYZ
+ */
+export declare function yFromLstar(lstar: number): number;
+/**
+ * Converts a Y value to an L* value.
+ *
+ * L* in L*a*b* and Y in XYZ measure the same quantity, luminance.
+ *
+ * L* measures perceptual luminance, a linear scale. Y in XYZ
+ * measures relative luminance, a logarithmic scale.
+ *
+ * @param y Y in XYZ
+ * @return L* in L*a*b*
+ */
+export declare function lstarFromY(y: number): number;
+/**
+ * Linearizes an RGB component.
+ *
+ * @param rgbComponent 0 <= rgb_component <= 255, represents R/G/B
+ * channel
+ * @return 0.0 <= output <= 100.0, color channel converted to
+ * linear RGB space
+ */
+export declare function linearized(rgbComponent: number): number;
+/**
+ * Delinearizes an RGB component.
+ *
+ * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents
+ * linear R/G/B channel
+ * @return 0 <= output <= 255, color channel converted to regular
+ * RGB space
+ */
+export declare function delinearized(rgbComponent: number): number;
+/**
+ * Returns the standard white point; white on a sunny day.
+ *
+ * @return The white point
+ */
+export declare function whitePointD65(): number[];
+/**
+ * Return RGBA from a given int32 color
+ *
+ * @param argb ARGB representation of a int32 color.
+ * @return RGBA representation of a int32 color.
+ */
+export declare function rgbaFromArgb(argb: number): Rgba;
+/**
+ * Return int32 color from a given RGBA component
+ *
+ * @param rgba RGBA representation of a int32 color.
+ * @returns ARGB representation of a int32 color.
+ */
+export declare function argbFromRgba({ r, g, b, a }: Rgba): number;

package/types/util/color/hct/cam16.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ViewingConditions } from './viewing_conditions';
+/**
+ * CAM16, a color appearance model. Colors are not just defined by their hex
+ * code, but rather, a hex code and viewing conditions.
+ *
+ * CAM16 instances also have coordinates in the CAM16-UCS space, called J*, a*,
+ * b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+ * specification, and should be used when measuring distances between colors.
+ *
+ * In traditional color spaces, a color can be identified solely by the
+ * observer's measurement of the color. Color appearance models such as CAM16
+ * also use information about the environment where the color was
+ * observed, known as the viewing conditions.
+ *
+ * For example, white under the traditional assumption of a midday sun white
+ * point is accurately measured as a slightly chromatic blue by CAM16. (roughly,
+ * hue 203, chroma 3, lightness 100)
+ */
+export declare class Cam16 {
+    readonly hue: number;
+    readonly chroma: number;
+    readonly j: number;
+    readonly q: number;
+    readonly m: number;
+    readonly s: number;
+    readonly jstar: number;
+    readonly astar: number;
+    readonly bstar: number;
+    /**
+     * All of the CAM16 dimensions can be calculated from 3 of the dimensions, in
+     * the following combinations:
+     *      -  {j or q} and {c, m, or s} and hue
+     *      - jstar, astar, bstar
+     * Prefer using a static method that constructs from 3 of those dimensions.
+     * This constructor is intended for those methods to use to return all
+     * possible dimensions.
+     *
+     * @param hue
+     * @param chroma informally, colorfulness / color intensity. like saturation
+     *     in HSL, except perceptually accurate.
+     * @param j lightness
+     * @param q brightness; ratio of lightness to white point's lightness
+     * @param m colorfulness
+     * @param s saturation; ratio of chroma to white point's chroma
+     * @param jstar CAM16-UCS J coordinate
+     * @param astar CAM16-UCS a coordinate
+     * @param bstar CAM16-UCS b coordinate
+     */
+    constructor(hue: number, chroma: number, j: number, q: number, m: number, s: number, jstar: number, astar: number, bstar: number);
+    /**
+     * CAM16 instances also have coordinates in the CAM16-UCS space, called J*,
+     * a*, b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+     * specification, and is used to measure distances between colors.
+     */
+    distance(other: Cam16): number;
+    /**
+     * @param argb ARGB representation of a color.
+     * @return CAM16 color, assuming the color was viewed in default viewing
+     *     conditions.
+     */
+    static fromInt(argb: number): Cam16;
+    /**
+     * @param argb ARGB representation of a color.
+     * @param viewingConditions Information about the environment where the color
+     *     was observed.
+     * @return CAM16 color.
+     */
+    static fromIntInViewingConditions(argb: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param j CAM16 lightness
+     * @param c CAM16 chroma
+     * @param h CAM16 hue
+     */
+    static fromJch(j: number, c: number, h: number): Cam16;
+    /**
+     * @param j CAM16 lightness
+     * @param c CAM16 chroma
+     * @param h CAM16 hue
+     * @param viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromJchInViewingConditions(j: number, c: number, h: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     * @param jstar CAM16-UCS lightness.
+     * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     */
+    static fromUcs(jstar: number, astar: number, bstar: number): Cam16;
+    /**
+     * @param jstar CAM16-UCS lightness.
+     * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the Y axis.
+     * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+     *     coordinate on the X axis.
+     * @param viewingConditions Information about the environment where the color
+     *     was observed.
+     */
+    static fromUcsInViewingConditions(jstar: number, astar: number, bstar: number, viewingConditions: ViewingConditions): Cam16;
+    /**
+     *  @return ARGB representation of color, assuming the color was viewed in
+     *     default viewing conditions, which are near-identical to the default
+     *     viewing conditions for sRGB.
+     */
+    toInt(): number;
+    /**
+     * @param viewingConditions Information about the environment where the color
+     *     will be viewed.
+     * @return ARGB representation of color
+     */
+    viewed(viewingConditions: ViewingConditions): number;
+    static fromXyzInViewingConditions(x: number, y: number, z: number, viewingConditions: ViewingConditions): Cam16;
+    xyzInViewingConditions(viewingConditions: ViewingConditions): number[];
+}

package/types/util/color/hct/hct.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ViewingConditions } from './viewing_conditions';
+/**
+ * HCT, hue, chroma, and tone. A color system that provides a perceptually
+ * accurate color measurement system that can also accurately render what colors
+ * will appear as in different lighting environments.
+ */
+export declare class Hct {
+    private argb;
+    /**
+     * @param hue 0 <= hue < 360; invalid values are corrected.
+     * @param chroma 0 <= chroma < ?; Informally, colorfulness. The color
+     *     returned may be lower than the requested chroma. Chroma has a different
+     *     maximum for any given hue and tone.
+     * @param tone 0 <= tone <= 100; invalid values are corrected.
+     * @return HCT representation of a color in default viewing conditions.
+     */
+    internalHue: number;
+    internalChroma: number;
+    internalTone: number;
+    static from(hue: number, chroma: number, tone: number): Hct;
+    /**
+     * @param argb ARGB representation of a color.
+     * @return HCT representation of a color in default viewing conditions
+     */
+    static fromInt(argb: number): Hct;
+    toInt(): number;
+    /**
+     * A number, in degrees, representing ex. red, orange, yellow, etc.
+     * Ranges from 0 <= hue < 360.
+     */
+    get hue(): number;
+    /**
+     * @param newHue 0 <= newHue < 360; invalid values are corrected.
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set hue(newHue: number);
+    get chroma(): number;
+    /**
+     * @param newChroma 0 <= newChroma < ?
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set chroma(newChroma: number);
+    /** Lightness. Ranges from 0 to 100. */
+    get tone(): number;
+    /**
+     * @param newTone 0 <= newTone <= 100; invalid valids are corrected.
+     * Chroma may decrease because chroma has a different maximum for any given
+     * hue and tone.
+     */
+    set tone(newTone: number);
+    private constructor();
+    private setInternalState;
+    /**
+     * Translates a color into different [ViewingConditions].
+     *
+     * Colors change appearance. They look different with lights on versus off,
+     * the same color, as in hex code, on white looks different when on black.
+     * This is called color relativity, most famously explicated by Josef Albers
+     * in Interaction of Color.
+     *
+     * In color science, color appearance models can account for this and
+     * calculate the appearance of a color in different settings. HCT is based on
+     * CAM16, a color appearance model, and uses it to make these calculations.
+     *
+     * See [ViewingConditions.make] for parameters affecting color appearance.
+     */
+    inViewingConditions(vc: ViewingConditions): Hct;
+}