@gradient-ui/core 0.4.0 → 0.5.0-rc.0

package/dist/types/theme/default.d.ts

@@ -1,97 +1,43 @@
+import type { ThemeColorExtensions, ThemeMode, ThemeTokens } from './types';
 import type { ColorInput } from '@/types/Colors';
 import { type App, type Ref, type ShallowRef } from 'vue';
 export declare const DEFAULT_SEED = "#4e51ff";
 export interface SeedTheme {
     seedColor: ColorInput;
 }
-export type ThemeMode = 'light' | 'dark';
+export type { ThemeMode } from './types';
 export interface GradientUIThemeOptions {
     seed?: ColorInput;
     mode?: ThemeMode;
     autoApply?: boolean;
+    colors?: ThemeColorExtensions;
 }
-export interface GradientUITheme {
-    seed: Ref<ColorInput>;
-    mode: Ref<ThemeMode>;
-    result: ShallowRef<ReturnType<typeof createDefaultTheme> | null>;
-    apply: () => ReturnType<typeof createDefaultTheme> | null;
-    setSeed: (seed: ColorInput) => ReturnType<typeof createDefaultTheme> | null;
-    setMode: (mode: ThemeMode) => ReturnType<typeof createDefaultTheme> | null;
-    toggleMode: () => ReturnType<typeof createDefaultTheme> | null;
+export interface CreateDefaultThemeOptions {
+    colors?: ThemeColorExtensions;
 }
-export declare function createDefaultLightTheme(seed?: ColorInput): {
-    tokens: {
-        theme: {
-            warning: string;
-            onWarning: string;
-            warningContainer: string;
-            onWarningContainer: string;
-            success: string;
-            onSuccess: string;
-            successContainer: string;
-            onSuccessContainer: string;
-        };
-        colors: Record<string, string>;
-        gradient: {
-            main: string;
-            error: string;
-            warning: string;
-            success: string;
-        };
-    };
-    themeCSS: HTMLStyleElement;
-    colorsCSS: HTMLStyleElement;
-    gradientCSS: HTMLStyleElement;
-};
-export declare function createDefaultDarkTheme(seed?: ColorInput): {
-    tokens: {
-        theme: {
-            warning: string;
-            onWarning: string;
-            warningContainer: string;
-            onWarningContainer: string;
-            success: string;
-            onSuccess: string;
-            successContainer: string;
-            onSuccessContainer: string;
-        };
-        colors: Record<string, string>;
-        gradient: {
-            main: string;
-            error: string;
-            warning: string;
-            success: string;
-        };
-    };
-    themeCSS: HTMLStyleElement;
-    colorsCSS: HTMLStyleElement;
-    gradientCSS: HTMLStyleElement;
-};
-export declare function createDefaultTheme(seed?: ColorInput, mode?: ThemeMode): {
+export interface GeneratedTheme {
     tokens: {
-        theme: {
-            warning: string;
-            onWarning: string;
-            warningContainer: string;
-            onWarningContainer: string;
-            success: string;
-            onSuccess: string;
-            successContainer: string;
-            onSuccessContainer: string;
-        };
-        colors: Record<string, string>;
-        gradient: {
-            main: string;
-            error: string;
-            warning: string;
-            success: string;
-        };
+        theme: ThemeTokens;
+        colors: ThemeTokens;
+        gradients: ThemeTokens;
     };
     themeCSS: HTMLStyleElement;
     colorsCSS: HTMLStyleElement;
     gradientCSS: HTMLStyleElement;
-};
-export declare function createTheme(options?: GradientUIThemeOptions): GradientUITheme;
-export declare function provideTheme(theme?: GradientUITheme): GradientUITheme;
-export declare function installTheme(app: App, theme: GradientUITheme): void;
-export declare function useTheme(): GradientUITheme | null;
+}
+export interface GradientUITheme {
+    seed: Ref<ColorInput>;
+    mode: Ref<ThemeMode>;
+    result: ShallowRef<GeneratedTheme | null>;
+    apply: () => GeneratedTheme | null;
+    setSeed: (seed: ColorInput) => GeneratedTheme | null;
+    setMode: (mode: ThemeMode) => GeneratedTheme | null;
+    toggleMode: () => GeneratedTheme | null;
+}
+export declare const createDefaultLightTheme: (seed?: ColorInput, options?: CreateDefaultThemeOptions) => GeneratedTheme;
+export declare const createDefaultDarkTheme: (seed?: ColorInput, options?: CreateDefaultThemeOptions) => GeneratedTheme;
+export declare const createDefaultTheme: (seed?: ColorInput, mode?: ThemeMode, options?: CreateDefaultThemeOptions) => GeneratedTheme;
+export declare const createTheme: (options?: GradientUIThemeOptions) => GradientUITheme;
+export declare const provideTheme: (theme?: GradientUITheme) => GradientUITheme;
+export declare const installTheme: (app: App, theme: GradientUITheme) => void;
+export declare const useTheme: () => GradientUITheme | null;

package/dist/types/theme/gradient/animation/css.d.ts

@@ -0,0 +1,12 @@
+import type { GradientAnimationOptions } from '../types';
+export declare const getGradientAnimationOptions: (options?: GradientAnimationOptions) => {
+    duration: string;
+    easing: string;
+    name: string;
+    preset: import("../types").GradientAnimationPreset;
+    selector: string;
+};
+export declare const toGradientAnimationKeyframes: (options?: GradientAnimationOptions) => string;
+export declare const toGradientAnimationValue: (options?: GradientAnimationOptions) => string;
+export declare const toGradientAnimationStyles: (options?: GradientAnimationOptions) => string;
+export declare const toGradientAnimationCSS: (options?: GradientAnimationOptions) => string;

package/dist/types/theme/gradient/animation/index.d.ts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine/animation';

package/dist/types/theme/gradient/colorMath.d.ts

@@ -0,0 +1,3 @@
+export declare const changeTone: (hex: string, tone: number) => string;
+export declare const shiftHue: (hex: string, hueShift: number, tone: number, chromaMultiplier?: number) => string;
+export declare const getComplementaryColor: (hex: string) => string;

package/dist/types/theme/gradient/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_GRADIENT_DIRECTION = 135;
+export declare const DEFAULT_GRADIENT_POSITION = "center";
+export declare const DEFAULT_GRADIENT_SIZE = "farthest-corner";

package/dist/types/theme/gradient/core.d.ts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine/core';

package/dist/types/theme/gradient/effects/index.d.ts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine/effects';

package/dist/types/theme/gradient/effects/morph.d.ts

@@ -0,0 +1,5 @@
+import type { GradientModel, GradientMorphBlob, GradientMorphOptions } from '../types';
+export declare const createGradientMorphBlobs: (model: GradientModel, options?: GradientMorphOptions) => GradientMorphBlob[];
+export declare const toGradientMorphFilter: (options?: GradientMorphOptions) => string;
+export declare const toGradientMorphFilterMarkup: (options?: GradientMorphOptions) => string;
+export declare const toGradientMorphCSS: (model: GradientModel, options?: GradientMorphOptions) => string;

package/dist/types/theme/gradient/effects/shadow.d.ts

@@ -0,0 +1,3 @@
+import type { GradientModel, GradientShadowOptions } from '../types';
+export declare const toGradientBoxShadow: (model: GradientModel, options?: GradientShadowOptions) => string;
+export declare const toGradientDropShadow: (model: GradientModel, options?: GradientShadowOptions) => string;

package/dist/types/theme/gradient/formatters/canvas.d.ts

@@ -0,0 +1,2 @@
+import type { CanvasGradientOptions, GradientModel } from '../types';
+export declare const toCanvasGradient: (context: CanvasRenderingContext2D, model: GradientModel, options?: CanvasGradientOptions) => CanvasGradient;

package/dist/types/theme/gradient/formatters/css.d.ts

@@ -0,0 +1,3 @@
+import type { GradientDirection, GradientModel } from '../types';
+export declare const createLinearGradient: (stops: readonly string[], direction?: GradientDirection) => string;
+export declare const toCssGradient: (model: GradientModel) => string;

package/dist/types/theme/gradient/formatters/index.d.ts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine/formatters';

package/dist/types/theme/gradient/formatters/svg.d.ts

@@ -0,0 +1,5 @@
+import type { GradientModel, SvgGradientOptions, SvgPathAnimationOptions, SvgSourceAnimationOptions } from '../types';
+export declare const toSvgGradient: (model: GradientModel, options?: SvgGradientOptions) => string;
+export declare const toSvgGradientMarkup: (model: GradientModel, options?: SvgGradientOptions) => string;
+export declare const toSvgSourceAnimationMarkup: (sourceSvg: string, model: GradientModel, options?: SvgSourceAnimationOptions) => string;
+export declare const toSvgPathAnimationMarkup: (model: GradientModel, options?: SvgPathAnimationOptions) => string;

package/dist/types/theme/gradient/index.d.ts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine';

package/dist/types/theme/gradient/material.d.ts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine/material';

package/dist/types/theme/gradient/model.d.ts

@@ -0,0 +1,5 @@
+import { type ColorPalette } from '../palette';
+import type { GradientModel, GradientOptions } from './types';
+import type { ColorInput } from '@/types/Colors';
+export declare const createGradientModel: (palette: ColorPalette, options?: GradientOptions) => GradientModel;
+export declare const createGradientModelFromColor: (color: ColorInput, options?: GradientOptions) => GradientModel;

package/dist/types/theme/gradient/presets.d.ts

@@ -0,0 +1,158 @@
+import type { GradientAnimationOptions, GradientAnimationPreset, GradientOptions, GradientRecipe, GradientShadowOptions, GradientType } from './types';
+export interface GradientPreset {
+    label: string;
+    description?: string;
+    gradient: Omit<GradientOptions, 'shade' | 'colors'> & {
+        recipe: GradientRecipe;
+        type?: GradientType;
+    };
+    shadow?: GradientShadowOptions;
+    dropShadow?: GradientShadowOptions;
+    animation?: Omit<GradientAnimationOptions, 'name' | 'selector'> & {
+        preset: GradientAnimationPreset;
+    };
+}
+export type GradientPresetRegistry = Record<string, GradientPreset>;
+export declare const defineGradientPreset: <T extends GradientPreset>(preset: T) => T;
+export declare const defineGradientPresetRegistry: <T extends GradientPresetRegistry>(presets: T) => T;
+export declare const gradientPresets: {
+    brandGlare: {
+        label: string;
+        description: string;
+        gradient: {
+            recipe: "glare";
+            type: "linear";
+            direction: number;
+        };
+        shadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+            spread: number;
+        };
+        dropShadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+        };
+        animation: {
+            preset: "shift";
+            duration: number;
+            easing: string;
+        };
+    };
+    softMono: {
+        label: string;
+        description: string;
+        gradient: {
+            recipe: "monochrome";
+            type: "linear";
+            direction: number;
+        };
+        shadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+            spread: number;
+        };
+        dropShadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+        };
+        animation: {
+            preset: "pulse";
+            duration: number;
+            easing: string;
+        };
+    };
+    neonDuo: {
+        label: string;
+        description: string;
+        gradient: {
+            recipe: "duotone";
+            type: "linear";
+            direction: number;
+        };
+        shadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+            spread: number;
+        };
+        dropShadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+        };
+        animation: {
+            preset: "shift";
+            duration: number;
+            easing: string;
+        };
+    };
+    orbitalConic: {
+        label: string;
+        description: string;
+        gradient: {
+            recipe: "triadic";
+            type: "conic";
+            direction: number;
+            position: string;
+        };
+        shadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+            spread: number;
+        };
+        dropShadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+        };
+        animation: {
+            preset: "rotate";
+            duration: number;
+        };
+    };
+    auroraRadial: {
+        label: string;
+        description: string;
+        gradient: {
+            recipe: "analogous";
+            type: "radial";
+            direction: number;
+            position: string;
+            shape: "circle";
+        };
+        shadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+            spread: number;
+        };
+        dropShadow: {
+            layers: number;
+            opacity: number;
+            blur: number;
+            y: number;
+        };
+        animation: {
+            preset: "hue-rotate";
+            duration: number;
+            easing: string;
+        };
+    };
+};
+export type GradientPresetName = keyof typeof gradientPresets;
+export declare const getGradientPreset: (name: GradientPresetName | string, registry?: GradientPresetRegistry) => GradientPreset;

package/dist/types/theme/gradient/recipes.d.ts

@@ -0,0 +1,14 @@
+import type { GradientRecipe } from './types';
+export declare const gradientRecipes: {
+    glare: (base: string) => import("./types").GradientStop[];
+    monochrome: (base: string) => import("./types").GradientStop[];
+    complementary: (base: string) => import("./types").GradientStop[];
+    'split-complementary': (base: string) => import("./types").GradientStop[];
+    analogous: (base: string) => import("./types").GradientStop[];
+    triadic: (base: string) => import("./types").GradientStop[];
+    tetradic: (base: string) => import("./types").GradientStop[];
+    rectangle: (base: string) => import("./types").GradientStop[];
+    square: (base: string) => import("./types").GradientStop[];
+    duotone: (base: string, colors: readonly string[] | undefined) => import("./types").GradientStop[];
+};
+export declare const createRecipeStops: (base: string, recipe: GradientRecipe, colors?: readonly string[]) => import("./types").GradientStop[];

package/dist/types/theme/gradient/tokens.d.ts

@@ -0,0 +1,72 @@
+import type { ColorInput } from '@/types/Colors';
+import { type GradientPresetName, type GradientPresetRegistry } from './presets';
+import type { GradientAnimationOptions, GradientMorphOptions, GradientModel, GradientOptions, GradientRecipe, GradientShadowOptions, GradientStop } from './types';
+export type GradientTokenRecipe = GradientRecipe | GradientPresetName | 'mesh' | 'soft';
+export interface GradientTokenEntry {
+    value: string;
+    cssVar: string;
+    model?: GradientModel;
+    layers?: string[];
+    stops?: GradientStop[];
+    svg?: string;
+}
+export interface GradientEffectTokenEntry {
+    boxShadow?: {
+        value: string;
+        cssVar: string;
+    };
+    dropShadow?: {
+        value: string;
+        cssVar: string;
+    };
+    morph?: {
+        value: string;
+        cssVar: string;
+        svg: string;
+    };
+}
+export interface GradientAnimationTokenEntry {
+    name: string;
+    value: string;
+    css: string;
+    keyframes: string;
+    cssVar: string;
+}
+export interface CreatedGradientPreset {
+    name: string;
+    label: string;
+    description?: string;
+    gradient: GradientTokenEntry;
+    effects?: GradientEffectTokenEntry;
+    animation?: GradientAnimationTokenEntry;
+    cssVars: Record<string, string>;
+    cssText: string;
+    keyframes: string;
+}
+export interface GradientTokenOptions {
+    recipes?: readonly GradientTokenRecipe[];
+    effects?: boolean;
+    animations?: boolean;
+    morph?: GradientMorphOptions;
+    registry?: GradientPresetRegistry;
+    prefix?: string;
+}
+export interface CreatedGradientTokens {
+    gradients: Record<string, GradientTokenEntry>;
+    effects: Record<string, GradientEffectTokenEntry>;
+    animations: Record<string, GradientAnimationTokenEntry>;
+    cssVars: Record<string, string>;
+    cssText: string;
+    keyframes: string;
+}
+export declare const createGradientPreset: (seed: ColorInput, recipe?: GradientTokenRecipe, options?: GradientOptions & {
+    animation?: GradientAnimationOptions;
+    dropShadow?: GradientShadowOptions;
+    effects?: boolean;
+    morph?: GradientMorphOptions;
+    prefix?: string;
+    registry?: GradientPresetRegistry;
+    shadow?: GradientShadowOptions;
+    animations?: boolean;
+}) => CreatedGradientPreset;
+export declare const createGradientTokens: (seed: ColorInput, options?: GradientTokenOptions) => CreatedGradientTokens;

package/dist/types/theme/gradient/types.d.ts

@@ -0,0 +1,117 @@
+import type { ColorShade } from '../palette';
+export type GradientDirection = number | string;
+export type GradientType = 'linear' | 'radial' | 'conic';
+export type GradientRecipe = 'glare' | 'monochrome' | 'complementary' | 'split-complementary' | 'analogous' | 'triadic' | 'tetradic' | 'rectangle' | 'square' | 'duotone';
+export type GradientShape = 'circle' | 'ellipse';
+export type GradientAnimationPreset = 'shift' | 'pulse' | 'rotate' | 'hue-rotate';
+export interface GradientStop {
+    color: string;
+    position: number;
+    opacity?: number;
+}
+export interface GradientModel {
+    type: GradientType;
+    stops: GradientStop[];
+    direction: GradientDirection;
+    shape?: GradientShape;
+    position?: string;
+    size?: string;
+}
+export interface GradientOptions {
+    direction?: GradientDirection;
+    recipe?: GradientRecipe;
+    shade?: ColorShade;
+    type?: GradientType;
+    shape?: GradientShape;
+    position?: string;
+    size?: string;
+    colors?: readonly string[];
+}
+export interface GradientShadowOptions {
+    x?: number | string;
+    y?: number | string;
+    blur?: number | string;
+    spread?: number | string;
+    opacity?: number;
+    layers?: number;
+}
+export type GradientMorphPreset = 'soft' | 'liquid' | 'ripple';
+export interface GradientMorphOptions {
+    id?: string;
+    preset?: GradientMorphPreset;
+    blobCount?: number;
+    blur?: number;
+    contrast?: number;
+    duration?: number | string;
+    opacity?: number;
+    scale?: number;
+    selector?: string;
+}
+export interface GradientMorphBlob {
+    animationName: string;
+    blur: number;
+    color: string;
+    delay: number;
+    dx: number;
+    dx2: number;
+    dy: number;
+    dy2: number;
+    duration: number | string;
+    opacity: number;
+    originX: string;
+    originY: string;
+    rotateMid: number;
+    rotateTo: number;
+    scaleMid: number;
+    scaleTo: number;
+    size: number;
+    x: number;
+    y: number;
+}
+export interface SvgGradientOptions {
+    id?: string;
+    width?: number;
+    height?: number;
+    rx?: number;
+    x1?: string;
+    x2?: string;
+    y1?: string;
+    y2?: string;
+    cx?: string;
+    cy?: string;
+    r?: string;
+}
+export interface SvgPathAnimationOptions extends SvgGradientOptions {
+    path?: string;
+    strokeWidth?: number;
+    linecap?: 'butt' | 'round' | 'square';
+    duration?: number | string;
+    repeatCount?: number | string;
+    backgroundStroke?: string;
+    activeStroke?: string;
+    backgroundOpacity?: number;
+}
+export interface SvgSourceAnimationOptions extends SvgPathAnimationOptions {
+    normalizeStrokeWidth?: boolean;
+    sourceOpacity?: number;
+    viewBoxPadding?: number | false;
+    strokeWidthBase?: number;
+}
+export interface CanvasGradientOptions {
+    x0?: number;
+    y0?: number;
+    x1?: number;
+    y1?: number;
+    r0?: number;
+    r1?: number;
+    startAngle?: number;
+    width?: number;
+    height?: number;
+}
+export interface GradientAnimationOptions {
+    name?: string;
+    preset?: GradientAnimationPreset;
+    duration?: number | string;
+    easing?: string;
+    selector?: string;
+}

package/dist/types/theme/gradient/utils.d.ts

@@ -0,0 +1,10 @@
+import type { GradientDirection, GradientStop } from './types';
+export declare const normalizeDirection: (direction?: GradientDirection) => string;
+export declare const toCssLength: (value: number | string) => string;
+export declare const addCssLength: (value: number | string, offset: number) => string;
+export declare const toCssDuration: (value: number | string) => string;
+export declare const clamp: (value: number, min?: number, max?: number) => number;
+export declare const toCssColor: (color: string, opacity?: number) => string;
+export declare const formatStop: ({ color, opacity, position }: GradientStop) => string;
+export declare const createStop: (color: string, position: number, opacity?: number) => GradientStop;
+export declare const getConicStops: (stops: readonly GradientStop[]) => readonly GradientStop[];

package/dist/types/theme/gradient.d.ts

@@ -0,0 +1 @@
+export * from './gradient/index';

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

@@ -1 +1,12 @@
-export { DEFAULT_SEED, createTheme, createDefaultDarkTheme, createDefaultLightTheme, createDefaultTheme, installTheme, provideTheme, useTheme, type GradientUITheme, type GradientUIThemeOptions, type SeedTheme, type ThemeMode } from './default';
+export { colorToHex, getContrastingColor, parseColor, rgbToChannels, rgbToHex, type RgbColor } from './color';
+export { COLOR_SHADES, ON_SHADE_TONES, SHADE_TONES, createOnPalette, createPalette, createPalettePair, type ColorPalette, type ColorPalettePair, type ColorShade } from './palette';
+export * as gradientAnimation from './gradient/animation';
+export * as gradientCore from './gradient/core';
+export * as gradientEffects from './gradient/effects';
+export * as gradientFormatters from './gradient/formatters';
+export * as gradientMaterial from './gradient/material';
+export { createGradient, createGradientModel, createGradientModelFromColor, createGradientFromColor, createGradientMaterial, createGradientPreset, createGradientTokens, createLinearGradient, defineGradientPreset, defineGradientPresetRegistry, getGradientPreset, gradientPresets, toCssGradient, toGradientAnimationCSS, toGradientBoxShadow, toGradientDropShadow, createGradientMorphBlobs, toGradientMorphCSS, toGradientMorphFilter, toGradientMorphFilterMarkup, toCanvasGradient, toSvgGradient, toSvgGradientMarkup, toSvgPathAnimationMarkup, toSvgSourceAnimationMarkup, type GradientAnimationOptions, type GradientAnimationPreset, type CanvasGradientOptions, type CreatedGradientPreset, type CreatedGradientTokens, type CreatedGradientMaterial, type GradientAnimationTokenEntry, type GradientDirection, type GradientEffectTokenEntry, type GradientModel, type GradientMaterialOptions, type GradientMorphBlob, type GradientMorphOptions, type GradientMorphPreset, type GradientOptions, type GradientPreset, type GradientPresetName, type GradientPresetRegistry, type GradientRecipe, type GradientShadowOptions, type GradientShape, type GradientStop, type GradientTokenEntry, type GradientTokenOptions, type GradientTokenRecipe, type GradientType, type SvgGradientOptions, type SvgPathAnimationOptions, type SvgSourceAnimationOptions } from './gradient';
+export { createColorSystem, type ColorSystem, type ColorSystemOptions } from './colorSystem';
+export { createSemanticTokens } from './scheme';
+export { DEFAULT_SEED, createDefaultDarkTheme, createDefaultLightTheme, createDefaultTheme, createTheme, installTheme, provideTheme, useTheme, type CreateDefaultThemeOptions, type GeneratedTheme, type GradientUITheme, type GradientUIThemeOptions, type SeedTheme, type ThemeMode } from './default';
+export type { ThemeColorDefinition, ThemeColorExtensions, ThemeColorValue, ThemeTokens } from './types';

package/dist/types/theme/palette.d.ts

@@ -0,0 +1,13 @@
+import type { ColorInput } from '@/types/Colors';
+export declare const COLOR_SHADES: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+export type ColorShade = (typeof COLOR_SHADES)[number];
+export type ColorPalette = Record<ColorShade, string>;
+export interface ColorPalettePair {
+    colors: ColorPalette;
+    onColors: ColorPalette;
+}
+export declare const SHADE_TONES: Record<ColorShade, number>;
+export declare const ON_SHADE_TONES: Record<ColorShade, number>;
+export declare const createPalette: (seed: ColorInput) => ColorPalette;
+export declare const createOnPalette: (seed: ColorInput) => ColorPalette;
+export declare const createPalettePair: (seed: ColorInput) => ColorPalettePair;

package/dist/types/theme/scheme.d.ts

@@ -0,0 +1,2 @@
+import type { ThemeMode, ThemeTokens } from './types';
+export declare const createSemanticTokens: (seed: string, mode: ThemeMode) => ThemeTokens;

package/dist/types/theme/types.d.ts

@@ -0,0 +1,11 @@
+import type { ColorInput } from '@/types/Colors';
+export type ThemeMode = 'light' | 'dark';
+export type ThemeTokens = Record<string, string>;
+export interface ThemeColorDefinition {
+    color: ColorInput;
+    onColor?: ColorInput;
+    palette?: boolean;
+    gradient?: string | false;
+}
+export type ThemeColorValue = ColorInput | ThemeColorDefinition;
+export type ThemeColorExtensions = Record<string, ThemeColorValue>;