@gradient-ui/gradient-engine 0.5.0

package/dist/tokens-OfSofVKl.js

@@ -0,0 +1,204 @@
+import { h as w, b as $, g as v, c as p, s as u, j as x, k as y } from "./presets-55krt4L_.js";
+import { toGradientAnimationValue as k, toGradientAnimationKeyframes as G, toGradientAnimationCSS as C } from "./animation.mjs";
+import { createGradientMorphBlobs as V, toGradientMorphFilter as j, toGradientMorphFilterMarkup as T, toGradientDropShadow as A, toGradientBoxShadow as O } from "./effects.mjs";
+import { t as E } from "./css-CaOuUhfh.js";
+import { t as P } from "./svg-CZThYPKf.js";
+const M = ["glare", "soft", "mesh"], N = (a) => a.replace(/[A-Z]/g, (r) => `-${r.toLowerCase()}`), B = (a) => N(a), I = (a, r, e) => `${a}-${r}`, g = (a) => Object.entries(a).map(([r, e]) => `${r}: ${e};`).join(`
+`), D = (a) => a.replace(/[A-Z]/g, (r) => `-${r.toLowerCase()}`), F = (a) => Object.entries(a).map(([r, e]) => `${D(r)}: ${e};`).join(`
+`), h = (a) => a === null || typeof a != "object" ? JSON.stringify(a) : Array.isArray(a) ? `[${a.map(h).join(",")}]` : `{${Object.entries(a).filter(([, r]) => r !== void 0).sort(([r], [e]) => r.localeCompare(e)).map(
+  ([r, e]) => `${JSON.stringify(r)}:${h(e)}`
+).join(",")}}`, K = (a) => {
+  let r = 5381;
+  for (let e = 0; e < a.length; e += 1)
+    r = r * 33 ^ a.charCodeAt(e);
+  return (r >>> 0).toString(36);
+}, L = (a, r, e, n) => {
+  const o = g(r), s = F(e), t = [o, s].filter(Boolean).join(`
+`);
+  return [`.${a} {
+${t}
+}`, n].filter(Boolean).join(`
+
+`);
+}, J = (a, r) => a in r, S = (a, r) => J(a, r) ? v(a, r) : a === "soft" ? {
+  label: "Soft",
+  description: "Quiet monochrome radial gradient.",
+  gradient: {
+    recipe: "monochrome",
+    type: "radial",
+    position: "center",
+    shape: "ellipse"
+  },
+  shadow: {
+    layers: 2,
+    opacity: 0.18,
+    blur: 18,
+    y: 7,
+    spread: -4
+  },
+  dropShadow: {
+    layers: 2,
+    opacity: 0.26,
+    blur: 16,
+    y: 6
+  },
+  animation: {
+    preset: "pulse",
+    duration: 7200,
+    easing: "ease-in-out"
+  }
+} : a === "mesh" ? null : {
+  label: a,
+  gradient: {
+    recipe: a,
+    type: "linear",
+    direction: a === "glare" ? 135 : 145
+  }
+}, Z = (a) => {
+  const r = [
+    `radial-gradient(circle at 16% 18%, ${u(a, -42, 72, 1.05)} 0%, transparent 34%)`,
+    `radial-gradient(circle at 86% 20%, ${x(a)} 0%, transparent 32%)`,
+    `radial-gradient(circle at 50% 84%, ${u(a, 56, 64, 1.08)} 0%, transparent 38%)`,
+    `linear-gradient(135deg, ${y(a, 94)}, ${y(a, 28)})`
+  ];
+  return {
+    layers: r,
+    value: r.join(", ")
+  };
+}, _ = (a, r, e, n, o) => {
+  if (r === "mesh") {
+    const f = Z(a);
+    return {
+      cssVar: e,
+      layers: f.layers,
+      value: f.value
+    };
+  }
+  const s = S(r, o), t = $(a), l = p(t, {
+    ...s == null ? void 0 : s.gradient,
+    ...n
+  });
+  return {
+    cssVar: e,
+    model: l,
+    stops: l.stops,
+    svg: P(l, { id: e.replace(/^--/, "") }),
+    value: E(l)
+  };
+}, z = (a, r, e, n) => {
+  var t;
+  if (!a) return {};
+  const o = `${r.replace(/^--/, "")}-morph`, s = {
+    ...n == null ? void 0 : n.morph,
+    id: ((t = n == null ? void 0 : n.morph) == null ? void 0 : t.id) ?? o
+  };
+  return {
+    boxShadow: {
+      cssVar: `${r}-shadow`,
+      value: O(a, (n == null ? void 0 : n.shadow) ?? (e == null ? void 0 : e.shadow))
+    },
+    dropShadow: {
+      cssVar: `${r}-drop-shadow`,
+      value: A(
+        a,
+        (n == null ? void 0 : n.dropShadow) ?? (e == null ? void 0 : e.dropShadow)
+      )
+    },
+    morph: {
+      cssVar: `${r}-morph`,
+      svg: T(s),
+      value: j(s)
+    }
+  };
+}, H = (a, r, e, n) => {
+  var s;
+  const o = {
+    ...e == null ? void 0 : e.animation,
+    ...n,
+    name: `g-gradient-${a}-${(n == null ? void 0 : n.preset) ?? ((s = e == null ? void 0 : e.animation) == null ? void 0 : s.preset) ?? "shift"}`,
+    selector: `.g-gradient-${a}`
+  };
+  return {
+    css: C(o),
+    cssVar: `${r}-animation`,
+    keyframes: G(o),
+    name: o.name,
+    value: k(o)
+  };
+}, b = (a, r = "glare", e = {}) => {
+  const n = e.registry ?? w, o = B(r), s = I(e.prefix ?? "--g-gradient", o), t = S(r, n), f = $(a)[500], c = _(
+    f,
+    r,
+    s,
+    e,
+    n
+  ), d = {
+    [s]: c.value
+  }, i = e.effects ? z(c.model, s, t, {
+    dropShadow: e.dropShadow,
+    morph: e.morph,
+    shadow: e.shadow
+  }) : void 0, m = e.animations ? H(o, s, t, e.animation) : void 0;
+  return i != null && i.boxShadow && (d[i.boxShadow.cssVar] = i.boxShadow.value), i != null && i.dropShadow && (d[i.dropShadow.cssVar] = i.dropShadow.value), i != null && i.morph && (d[i.morph.cssVar] = i.morph.value), m && (d[m.cssVar] = m.value), {
+    animation: m,
+    cssText: g(d),
+    cssVars: d,
+    description: t == null ? void 0 : t.description,
+    effects: i,
+    gradient: c,
+    keyframes: (m == null ? void 0 : m.keyframes) ?? "",
+    label: (t == null ? void 0 : t.label) ?? o,
+    name: o
+  };
+}, X = (a, r = {}) => {
+  const e = r.recipes ?? M, n = {}, o = {}, s = {}, t = {}, l = [];
+  for (const f of e) {
+    const c = b(a, f, {
+      animations: r.animations,
+      effects: r.effects,
+      morph: r.morph,
+      prefix: r.prefix,
+      registry: r.registry
+    });
+    n[c.name] = c.gradient, Object.assign(t, c.cssVars), c.effects && (o[c.name] = c.effects), c.animation && (s[c.name] = c.animation, l.push(c.animation.keyframes));
+  }
+  return {
+    animations: s,
+    cssText: g(t),
+    cssVars: t,
+    effects: o,
+    gradients: n,
+    keyframes: l.join(`
+`)
+  };
+}, Y = (a, r = {}) => {
+  var i, m;
+  const { className: e, id: n, recipe: o = "glare", ...s } = r, t = b(a, o, s), l = t.gradient.model && r.effects && r.morph ? V(t.gradient.model, r.morph) : void 0, f = n ?? `g-gradient-${t.name}-${K(
+    h({ options: r, seed: a })
+  )}`, c = e ?? f, d = {
+    backgroundImage: `var(${t.gradient.cssVar})`
+  };
+  return (i = t.effects) != null && i.boxShadow && (d.boxShadow = `var(${t.effects.boxShadow.cssVar})`), (m = t.effects) != null && m.dropShadow && (d.filter = `var(${t.effects.dropShadow.cssVar})`), t.animation && (d.animation = `var(${t.animation.cssVar})`), {
+    animation: t.animation,
+    className: c,
+    cssText: L(
+      c,
+      t.cssVars,
+      d,
+      t.keyframes
+    ),
+    cssVars: t.cssVars,
+    effects: t.effects,
+    gradient: t.gradient,
+    id: f,
+    keyframes: t.keyframes,
+    morphBlobs: l,
+    preset: t,
+    style: d
+  };
+};
+export {
+  b as a,
+  X as b,
+  Y as c
+};

package/dist/types/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("..").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/animation/index.d.ts

@@ -0,0 +1 @@
+export { getGradientAnimationOptions, toGradientAnimationCSS, toGradientAnimationKeyframes, toGradientAnimationStyles, toGradientAnimationValue } from './css';

package/dist/types/color.d.ts

@@ -0,0 +1,10 @@
+export type ColorInput = string | number;
+export interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare const parseColor: (input: ColorInput) => RgbColor | null;
+export declare const rgbToHex: ({ r, g, b }: RgbColor) => string;
+export declare const rgbToChannels: ({ r, g, b }: RgbColor) => string;
+export declare const colorToHex: (input: ColorInput, fallback: string) => string;

package/dist/types/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/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/core.d.ts

@@ -0,0 +1,9 @@
+import { type ColorPalette } from './palette';
+import type { ColorInput } from './color';
+import type { GradientOptions } from './types';
+export * from './types';
+export { createGradientModel, createGradientModelFromColor } from './model';
+export { createRecipeStops, gradientRecipes } from './recipes';
+export { defineGradientPreset, defineGradientPresetRegistry, getGradientPreset, gradientPresets, type GradientPreset, type GradientPresetName, type GradientPresetRegistry } from './presets';
+export declare const createGradient: (palette: ColorPalette, options?: GradientOptions) => string;
+export declare const createGradientFromColor: (color: ColorInput, options?: GradientOptions) => string;

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

@@ -0,0 +1,2 @@
+export { createGradientMorphBlobs, toGradientMorphCSS, toGradientMorphFilter, toGradientMorphFilterMarkup } from './morph';
+export { toGradientBoxShadow, toGradientDropShadow } from './shadow';

package/dist/types/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/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/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/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/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export { createLinearGradient, toCssGradient } from './css';
+export { toCanvasGradient } from './canvas';
+export { toSvgGradient, toSvgGradientMarkup, toSvgPathAnimationMarkup, toSvgSourceAnimationMarkup } from './svg';

package/dist/types/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/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core';
+export * from './color';
+export * from './palette';
+export * from './formatters';
+export * from './effects';
+export { toGradientAnimationCSS } from './animation';
+export * from './material';

package/dist/types/material.d.ts

@@ -0,0 +1 @@
+export { createGradientMaterial, createGradientPreset, createGradientTokens, type CreatedGradientMaterial, type CreatedGradientPreset, type CreatedGradientTokens, type GradientAnimationTokenEntry, type GradientEffectTokenEntry, type GradientMaterialOptions, type GradientTokenEntry, type GradientTokenOptions, type GradientTokenRecipe } from './tokens';

package/dist/types/model.d.ts

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

package/dist/types/palette.d.ts

@@ -0,0 +1,6 @@
+import { type ColorInput } from './color';
+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 declare const SHADE_TONES: Record<ColorShade, number>;
+export declare const createPalette: (seed: ColorInput) => ColorPalette;

package/dist/types/presets.d.ts

@@ -0,0 +1,239 @@
+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: {
+    materialBorder: {
+        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;
+        };
+    };
+    materialAction: {
+        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;
+        };
+    };
+    materialSurface: {
+        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;
+        };
+    };
+    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/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/tokens.d.ts

@@ -0,0 +1,99 @@
+import type { ColorInput } from './color';
+import { type GradientPresetName, type GradientPresetRegistry } from './presets';
+import type { GradientAnimationOptions, GradientMorphBlob, 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 interface GradientMaterialOptions extends Omit<GradientOptions, 'recipe'> {
+    animation?: GradientAnimationOptions;
+    animations?: boolean;
+    className?: string;
+    dropShadow?: GradientShadowOptions;
+    effects?: boolean;
+    id?: string;
+    morph?: GradientMorphOptions;
+    prefix?: string;
+    recipe?: GradientTokenRecipe;
+    registry?: GradientPresetRegistry;
+    shadow?: GradientShadowOptions;
+}
+export interface CreatedGradientMaterial {
+    id: string;
+    className: string;
+    style: Record<string, string>;
+    cssVars: Record<string, string>;
+    cssText: string;
+    keyframes: string;
+    preset: CreatedGradientPreset;
+    gradient: GradientTokenEntry;
+    effects?: GradientEffectTokenEntry;
+    animation?: GradientAnimationTokenEntry;
+    morphBlobs?: GradientMorphBlob[];
+}
+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;
+export declare const createGradientMaterial: (seed: ColorInput, options?: GradientMaterialOptions) => CreatedGradientMaterial;