@greese/ui 0.0.0-stage → 1.1.0

package/dist/effects/definitions.d.ts

@@ -0,0 +1,555 @@
+/** The built-in effects' definitions: base effects, combos, and how far they reach. */
+export type Value = string | number;
+/** greese.js keyframes: property → values spread over 0–1, or a list of frames. */
+export type EffectFrames = {
+    readonly [property: string]: Value | readonly Value[];
+} | ReadonlyArray<{
+    readonly [property: string]: Value | undefined;
+    offset?: number;
+}>;
+/**
+ * How far an effect travels, in the form its player needs. In JavaScript these
+ * are plain lengths flipped for the writing direction; in CSS they are
+ * `calc()`s over `--greese-motion-distance` and `--greese-motion-dir`.
+ */
+export interface Reach {
+    /** The `distance` option. */
+    distance: string;
+    /** A length the other way. */
+    negate: (length: string) => string;
+    /** A length towards the inline start (left in LTR). */
+    start: (length: string) => string;
+    /** A length towards the inline end. */
+    end: (length: string) => string;
+}
+/** Keys every call accepts, in the order positional arguments fill them. */
+export declare const timingKeys: readonly ["duration", "offset", "ease"];
+/** What a call may set about its timing, as parsed: seconds, and an ease name. */
+export interface Timing {
+    /** Seconds this effect takes. Overrides the instance's `duration`. */
+    duration?: number;
+    /** Seconds after its step starts. */
+    offset?: number;
+    /** A greese.js ease. */
+    ease?: string;
+}
+export type Stop = readonly [offset: number, value: Value];
+export type Params = Readonly<Record<string, Value>>;
+export interface BaseDefinition<P extends Params = Params> {
+    /** The one property it animates, as greese.js names it (`opacity`, `y`, `scale`…). */
+    property: string;
+    /** Every parameter and its default; `start` and `end` come first. */
+    params: P;
+    /** Where the values sit in time, 0–1. Default: `start` at 0, `end` at 1. */
+    stops?(params: P): readonly Stop[];
+    /** A parameter as the property's value (`8` → `blur(8px)`). */
+    format?(value: Value): Value;
+    /** Properties that hold one value throughout, beside the animated one (a mask's image). */
+    fixed?: Readonly<Record<string, Value>>;
+}
+export declare const base: <const P extends Params>(definition: BaseDefinition<P>) => BaseDefinition<P>;
+export declare const px: (fn: string) => (value: Value) => string;
+export declare const plain: (fn: string) => (value: Value) => string;
+export declare const ZERO = "0px";
+/**
+ * Wipes and pockets: a mask that shows everything, anchored at one side (or
+ * the middle), sized from `start` to `end`. A mask, not `clip-path`, because
+ * the clip belongs to the element's shape and a mask composes with it (ADR
+ * 0024); it exists only while the effect plays.
+ */
+export declare const SOLID = "linear-gradient(black, black)";
+export declare const WHOLE = "100% 100%";
+export declare const masked: (position: string, start: string, end: string) => BaseDefinition<{
+    readonly start: string;
+    readonly end: string;
+}>;
+/** The directions wipes and pockets go in (physical, like the slides): x, y. */
+export declare const DIRECTIONS: {
+    readonly Right: readonly [1, 0];
+    readonly Left: readonly [-1, 0];
+    readonly Up: readonly [0, -1];
+    readonly Down: readonly [0, 1];
+    readonly DownRight: readonly [1, 1];
+    readonly DownLeft: readonly [-1, 1];
+    readonly UpRight: readonly [1, -1];
+    readonly UpLeft: readonly [-1, -1];
+};
+export type Direction = keyof typeof DIRECTIONS;
+/** The directions wipes and pockets go in, by name: `Right`, `DownLeft`… */
+export declare const effectDirections: Direction[];
+/** `50% 0%` for a side: where a direction comes from (`-1`) or goes to (`1`). */
+export declare const side: (dx: number, dy: number, toward: 1 | -1) => string;
+/** The mask's size with the moving axes at `amount`. */
+export declare const sized: (dx: number, dy: number, amount: string) => string;
+/**
+ * A wipe in `direction`: arriving, the edge sweeps that way and reveals the
+ * element from the side it leaves; leaving, it sweeps that way and covers it.
+ */
+export declare const wipes: Record<`wipe${Direction}` | `wipeOut${Direction}`, BaseDefinition>;
+/**
+ * An iris: an opening the element's shape (an ellipse in its proportions)
+ * that grows from, or shrinks to, a point: the middle, a side or a corner. The
+ * mask is anchored at that point, so it stays put while the opening changes
+ * size. `IRIS_OPEN` is where it just covers the farthest corner from any of
+ * those points, so the whole run is visible change, in and out alike.
+ */
+export declare const iris: (at: string, start: string, end: string) => BaseDefinition<{
+    readonly start: string;
+    readonly end: string;
+}>;
+export declare const OPEN = "142% 142%";
+export declare const SHUT = "0% 0%";
+/**
+ * Leaving, the opening closes toward the side it goes to; arriving, it plays
+ * that backwards, opening from the same side, so an entrance is its exit
+ * reversed.
+ */
+export declare const irises: Record<`iris${Direction}` | `irisOut${Direction}`, BaseDefinition>;
+/**
+ * Three-dimensional turns and depth: `transform`, with its own perspective, so
+ * they foreshorten wherever they play, with no `perspective` on a parent. Not
+ * the individual `translate`/`rotate`/`scale` the other effects animate, so
+ * they compose with those, and never with a shape's clip-path (applied before
+ * the transform, it turns with the element).
+ */
+export declare const PERSPECTIVE = "perspective(800px)";
+export declare const turn: (axis: "X" | "Y", start: number, end: number, origin?: string) => BaseDefinition<{
+    readonly start: number;
+    readonly end: number;
+}>;
+/** The flips' directions: the axis each turns about, and which way. */
+export declare const FLIPS: {
+    readonly Up: readonly ["X", 1];
+    readonly Down: readonly ["X", -1];
+    readonly Left: readonly ["Y", 1];
+    readonly Right: readonly ["Y", -1];
+};
+/**
+ * A flip over: a panel turned half a turn about its middle, its two faces
+ * the old and the new: arriving, it turns from its back (180 degrees) to its
+ * front; leaving, from its front to its back, the same way, so a pair played
+ * together turns as one panel. The back face is hidden, so each shows only
+ * while it faces the viewer, and the switch is at the quarter turn. A longer
+ * perspective than a flip's, so a panel as wide as the screen doesn't swing
+ * through the viewer at the quarter turn.
+ */
+export declare const FLIP_OVER_PERSPECTIVE = "perspective(2000px)";
+export declare const flipOvers: Record<`flipOver${keyof typeof FLIPS}` | `flipOverOut${keyof typeof FLIPS}`, BaseDefinition>;
+export declare const baseEffects: {
+    readonly flipOverRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverOutRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverOutLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverOutUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly flipOverOutDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly turnX: BaseDefinition<{
+        readonly start: number;
+        readonly end: number;
+    }>;
+    readonly turnY: BaseDefinition<{
+        readonly start: number;
+        readonly end: number;
+    }>;
+    readonly depth: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 0;
+    }>;
+    readonly hinge: BaseDefinition<{
+        readonly start: number;
+        readonly end: number;
+    }>;
+    readonly irisRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly irisOutUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOpenX: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    readonly wipeOpenY: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    readonly wipeCloseX: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    readonly wipeCloseY: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    readonly irisIn: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    readonly irisOut: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    readonly wipeRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly wipeOutUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    readonly fadeIn: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 1;
+    }>;
+    readonly fadeOut: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 0;
+    }>;
+    readonly scaleIn: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 1;
+    }>;
+    readonly scaleOut: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 0;
+    }>;
+    readonly blurIn: BaseDefinition<{
+        readonly start: 8;
+        readonly end: 0;
+    }>;
+    readonly blurOut: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 8;
+    }>;
+    readonly slideUp: BaseDefinition<{
+        readonly start: "100%";
+        readonly end: "0%";
+    }>;
+    readonly slideDown: BaseDefinition<{
+        readonly start: "-100%";
+        readonly end: "0%";
+    }>;
+    readonly slideRight: BaseDefinition<{
+        readonly start: "-100%";
+        readonly end: "0%";
+    }>;
+    readonly slideLeft: BaseDefinition<{
+        readonly start: "100%";
+        readonly end: "0%";
+    }>;
+    readonly pop: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 1;
+        readonly peak: 1.075;
+        readonly peakAt: 0.6;
+    }>;
+    readonly squish: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 0.96;
+    }>;
+    readonly tilt: BaseDefinition<{
+        readonly start: 0;
+        readonly end: -2;
+    }>;
+    readonly glow: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 1.12;
+    }>;
+};
+export type BaseEffect = keyof typeof baseEffects;
+export type ParamsOf<K extends BaseEffect> = (typeof baseEffects)[K]['params'];
+/** What a call to a base effect may set: any of its parameters. */
+export type BaseArgs<K extends BaseEffect> = {
+    [P in keyof ParamsOf<K>]?: Value;
+};
+/** A base effect inside a combo, and where in the combo's time it plays. */
+export interface Part {
+    effect: BaseEffect;
+    args: Record<string, Value | undefined>;
+    /** The share of the combo it spans, `[from, to]` in 0–1. Default: all of it. */
+    at: readonly [from: number, to: number];
+}
+/** `effect` must be a base effect's name: a typo, or a combo, fails to compile. */
+export declare const part: <K extends BaseEffect>(effect: K, args?: BaseArgs<K>, at?: readonly [number, number]) => Part;
+export interface ComboDefinition {
+    /** Every parameter and its default; it may read how far things travel. */
+    params: (reach: Reach) => Params;
+    parts: (params: Params, reach: Reach) => readonly Part[];
+}
+export declare const combo: (definition: ComboDefinition) => ComboDefinition;
+export declare const away: ({ distance }: Reach) => {
+    distance: string;
+};
+/**
+ * A pocket: the element moves out of (or into) an invisible slot at one of
+ * its own edges. It slides `distance` (its whole size, by default, so it
+ * starts or ends out of sight) while a mask anchored where it's going grows or
+ * shrinks by the same amount, so the window it shows through stays where the
+ * element rests. Arriving, it moves `direction`; leaving, it moves on that
+ * way, into the slot on that side.
+ */
+export declare const pocket: (direction: Direction, leaving: boolean) => ComboDefinition;
+export declare const pockets: Record<`pocket${Direction}` | `pocketOut${Direction}`, ComboDefinition>;
+/**
+ * A flip: the element turns into place about its middle, from `angle` degrees
+ * (75 by default) toward the direction it arrives in: `flipUp` rises, its
+ * bottom edge leading; `flipRight` swings in from the left. Leaving, it turns
+ * back out the same way.
+ */
+export declare const flips: Record<`flip${keyof typeof FLIPS}` | `flipOut${keyof typeof FLIPS}`, ComboDefinition>;
+export declare const comboEffects: {
+    readonly depthIn: ComboDefinition;
+    readonly depthOut: ComboDefinition;
+    readonly swingIn: ComboDefinition;
+    readonly swingOut: ComboDefinition;
+    readonly flipRight: ComboDefinition;
+    readonly flipLeft: ComboDefinition;
+    readonly flipUp: ComboDefinition;
+    readonly flipDown: ComboDefinition;
+    readonly flipOutRight: ComboDefinition;
+    readonly flipOutLeft: ComboDefinition;
+    readonly flipOutUp: ComboDefinition;
+    readonly flipOutDown: ComboDefinition;
+    readonly pocketRight: ComboDefinition;
+    readonly pocketLeft: ComboDefinition;
+    readonly pocketUp: ComboDefinition;
+    readonly pocketDown: ComboDefinition;
+    readonly pocketDownRight: ComboDefinition;
+    readonly pocketDownLeft: ComboDefinition;
+    readonly pocketUpRight: ComboDefinition;
+    readonly pocketUpLeft: ComboDefinition;
+    readonly pocketOutRight: ComboDefinition;
+    readonly pocketOutLeft: ComboDefinition;
+    readonly pocketOutUp: ComboDefinition;
+    readonly pocketOutDown: ComboDefinition;
+    readonly pocketOutDownRight: ComboDefinition;
+    readonly pocketOutDownLeft: ComboDefinition;
+    readonly pocketOutUpRight: ComboDefinition;
+    readonly pocketOutUpLeft: ComboDefinition;
+    readonly fadeUp: ComboDefinition;
+    readonly fadeDown: ComboDefinition;
+    readonly fadeStart: ComboDefinition;
+    readonly fadeEnd: ComboDefinition;
+    readonly fadeOutUp: ComboDefinition;
+    readonly fadeOutDown: ComboDefinition;
+    readonly popIn: ComboDefinition;
+    readonly popOut: ComboDefinition;
+    readonly rise: ComboDefinition;
+    readonly fall: ComboDefinition;
+};
+export type ComboEffect = keyof typeof comboEffects;
+/** Base effects and combos together: every effect the library ships. */
+export declare const builtInEffects: {
+    depthIn: ComboDefinition;
+    depthOut: ComboDefinition;
+    swingIn: ComboDefinition;
+    swingOut: ComboDefinition;
+    flipRight: ComboDefinition;
+    flipLeft: ComboDefinition;
+    flipUp: ComboDefinition;
+    flipDown: ComboDefinition;
+    flipOutRight: ComboDefinition;
+    flipOutLeft: ComboDefinition;
+    flipOutUp: ComboDefinition;
+    flipOutDown: ComboDefinition;
+    pocketRight: ComboDefinition;
+    pocketLeft: ComboDefinition;
+    pocketUp: ComboDefinition;
+    pocketDown: ComboDefinition;
+    pocketDownRight: ComboDefinition;
+    pocketDownLeft: ComboDefinition;
+    pocketUpRight: ComboDefinition;
+    pocketUpLeft: ComboDefinition;
+    pocketOutRight: ComboDefinition;
+    pocketOutLeft: ComboDefinition;
+    pocketOutUp: ComboDefinition;
+    pocketOutDown: ComboDefinition;
+    pocketOutDownRight: ComboDefinition;
+    pocketOutDownLeft: ComboDefinition;
+    pocketOutUpRight: ComboDefinition;
+    pocketOutUpLeft: ComboDefinition;
+    fadeUp: ComboDefinition;
+    fadeDown: ComboDefinition;
+    fadeStart: ComboDefinition;
+    fadeEnd: ComboDefinition;
+    fadeOutUp: ComboDefinition;
+    fadeOutDown: ComboDefinition;
+    popIn: ComboDefinition;
+    popOut: ComboDefinition;
+    rise: ComboDefinition;
+    fall: ComboDefinition;
+    flipOverRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverOutRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverOutLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverOutUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    flipOverOutDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    turnX: BaseDefinition<{
+        readonly start: number;
+        readonly end: number;
+    }>;
+    turnY: BaseDefinition<{
+        readonly start: number;
+        readonly end: number;
+    }>;
+    depth: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 0;
+    }>;
+    hinge: BaseDefinition<{
+        readonly start: number;
+        readonly end: number;
+    }>;
+    irisRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    irisOutUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOpenX: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    wipeOpenY: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    wipeCloseX: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    wipeCloseY: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    irisIn: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    irisOut: BaseDefinition<{
+        readonly start: string;
+        readonly end: string;
+    }>;
+    wipeRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutUp: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutDown: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutDownRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutDownLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutUpRight: BaseDefinition<Readonly<Record<string, Value>>>;
+    wipeOutUpLeft: BaseDefinition<Readonly<Record<string, Value>>>;
+    fadeIn: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 1;
+    }>;
+    fadeOut: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 0;
+    }>;
+    scaleIn: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 1;
+    }>;
+    scaleOut: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 0;
+    }>;
+    blurIn: BaseDefinition<{
+        readonly start: 8;
+        readonly end: 0;
+    }>;
+    blurOut: BaseDefinition<{
+        readonly start: 0;
+        readonly end: 8;
+    }>;
+    slideUp: BaseDefinition<{
+        readonly start: "100%";
+        readonly end: "0%";
+    }>;
+    slideDown: BaseDefinition<{
+        readonly start: "-100%";
+        readonly end: "0%";
+    }>;
+    slideRight: BaseDefinition<{
+        readonly start: "-100%";
+        readonly end: "0%";
+    }>;
+    slideLeft: BaseDefinition<{
+        readonly start: "100%";
+        readonly end: "0%";
+    }>;
+    pop: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 1;
+        readonly peak: 1.075;
+        readonly peakAt: 0.6;
+    }>;
+    squish: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 0.96;
+    }>;
+    tilt: BaseDefinition<{
+        readonly start: 0;
+        readonly end: -2;
+    }>;
+    glow: BaseDefinition<{
+        readonly start: 1;
+        readonly end: 1.12;
+    }>;
+};
+export type BuiltInEffect = BaseEffect | ComboEffect;
+/** Every built-in effect name, base effects first. */
+export declare const effectNames: BuiltInEffect[];
+/** Own keys only, so `constructor` is no effect. */
+export declare const isBuiltInEffect: (name: string) => name is BuiltInEffect;
+export declare const isBase: (name: BuiltInEffect) => name is BaseEffect;
+export declare const PLAIN: RegExp;
+/**
+ * A length the other way. Plain ones (`1rem`, `-12px`) flip textually,
+ * anything else (`calc(…)`, `var(…)`) through `calc()`.
+ */
+export declare const negate: (length: string) => string;
+/** The reach for JavaScript: lengths, flipped when the element is right to left. */
+export declare const jsReach: (distance: string, rtl: boolean) => Reach;
+export declare const CSS_DIR = "var(--greese-motion-dir, 1)";
+/** The reach for CSS: `--greese-motion-dir` is 1, or -1 in right-to-left (Motion.scss). */
+export declare const cssReach: Reach;