@mui/material 9.0.1 → 9.1.1

package/internal/Transition.mjs

@@ -0,0 +1,442 @@
+/// <reference path="./react-transition-group.d.ts" />
+'use client';
+
+import * as React from 'react';
+import PropTypes from 'prop-types';
+import useEnhancedEffect from '@mui/utils/useEnhancedEffect';
+import useValueAsRef from '@mui/utils/useValueAsRef';
+// Material UI transitions must still work inside react-transition-group's TransitionGroup.
+// Import only its context module; do not import its Transition or TransitionGroup components.
+import TransitionGroupContext from 'react-transition-group/TransitionGroupContext';
+import { reflow } from "../transitions/utils.mjs";
+import { jsx as _jsx } from "react/jsx-runtime";
+function resolveTimeouts(timeout) {
+  if (timeout == null) {
+    return {
+      appear: undefined,
+      enter: undefined,
+      exit: undefined
+    };
+  }
+  if (typeof timeout === 'number') {
+    return {
+      appear: timeout,
+      enter: timeout,
+      exit: timeout
+    };
+  }
+  const enter = timeout.enter;
+  const exit = timeout.exit;
+  const appear = timeout.appear !== undefined ? timeout.appear : enter;
+  return {
+    appear,
+    enter,
+    exit
+  };
+}
+
+/**
+ * Resolves the authored completion timeout for the current transition phase.
+ * Auto durations are read by the caller at scheduling time so Grow/Collapse
+ * can pass the latest measured value without storing it in React state.
+ */
+function getCompletionTimeout(params) {
+  if (params.autoTimeout != null) {
+    return params.autoTimeout;
+  }
+  const resolved = resolveTimeouts(params.timeout);
+  if (params.currentStatus === 'entering') {
+    return params.isAppearing ? resolved.appear ?? resolved.enter ?? null : resolved.enter ?? null;
+  }
+  return resolved.exit ?? null;
+}
+function Transition(props) {
+  const {
+    in: inProp = false,
+    appear = false,
+    enter = true,
+    exit = true,
+    mountOnEnter = false,
+    unmountOnExit = false,
+    timeout,
+    addEndListener,
+    reduceMotion = false,
+    getAutoTimeout,
+    nodeRef,
+    onEnter,
+    onEntering,
+    onEntered,
+    onExit,
+    onExiting,
+    onExited,
+    children,
+    ...childProps
+  } = props;
+  const parentGroup = React.useContext(TransitionGroupContext);
+
+  // react-transition-group's TransitionGroup tells children whether the group
+  // is still mounting. Material UI needs two values from that:
+  // - shouldEnterOnMount: whether this child should run an enter animation now.
+  // - isAppearing: the value passed to enter callbacks.
+  // A child added after the group mounted still enters, but callbacks receive
+  // isAppearing=false because the parent group is no longer mounting.
+  const shouldEnterOnMount = parentGroup && !parentGroup.isMounting ? enter : appear;
+  const [status, setStatus] = React.useState(() => {
+    if (inProp) {
+      return shouldEnterOnMount ? 'exited' : 'entered';
+    }
+    if (mountOnEnter || unmountOnExit) {
+      return 'unmounted';
+    }
+    return 'exited';
+  });
+  const statusRef = React.useRef(status);
+  statusRef.current = status;
+
+  // Opening from `unmounted`: mount the child in the same commit that `in` turns
+  // true so its ref is attached before effects run. react-transition-group did
+  // this by deriving the status from props during render; handling it in a
+  // layout effect instead would add a commit where the child is still null,
+  // breaking consumers that read the ref right after `in` flips.
+  if (inProp && status === 'unmounted') {
+    statusRef.current = 'exited';
+    setStatus('exited');
+  }
+  const shouldAppearOnMountRef = React.useRef(inProp && shouldEnterOnMount);
+  const mountedRef = React.useRef(false);
+  const nextCallbackRef = React.useRef(null);
+  // Remember which status already fired lifecycle callbacks. React StrictMode
+  // can run effects twice in development; this prevents duplicate callbacks.
+  const lastFiredStatusRef = React.useRef(status);
+  // Store the isAppearing value for the current enter transition. performEnter
+  // sets it before the status effect later calls onEntering/onEntered.
+  const isAppearingRef = React.useRef(false);
+  // Capture reduced motion at the start of each phase so prop updates do not
+  // change the completion timing for an active transition.
+  const transitionReduceMotionRef = React.useRef(reduceMotion);
+
+  // Transition end callbacks can run after props changed. Read props through
+  // this ref so delayed work uses the latest callbacks and timeout settings.
+  const propsRef = useValueAsRef({
+    timeout,
+    addEndListener,
+    reduceMotion,
+    getAutoTimeout,
+    onEnter,
+    onEntering,
+    onEntered,
+    onExit,
+    onExiting,
+    onExited,
+    enter,
+    exit,
+    mountOnEnter,
+    unmountOnExit,
+    nodeRef,
+    parentGroup
+  });
+
+  // Effects below depend on these helpers. Keep their identity stable; they read
+  // changing props through propsRef.
+  const cancelPendingCallback = React.useCallback(() => {
+    if (nextCallbackRef.current !== null) {
+      nextCallbackRef.current.cancel();
+      nextCallbackRef.current = null;
+    }
+  }, []);
+  const makeCallback = React.useCallback(handler => {
+    let active = true;
+    const wrapped = () => {
+      if (active) {
+        active = false;
+        nextCallbackRef.current = null;
+        handler();
+      }
+    };
+    wrapped.cancel = () => {
+      active = false;
+    };
+    nextCallbackRef.current = wrapped;
+    return wrapped;
+  }, []);
+  const scheduleTransitionEnd = React.useCallback((nextStatus, currentStatus) => {
+    let timeoutId;
+    const clearTimer = () => {
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+        timeoutId = undefined;
+      }
+    };
+    const done = makeCallback(() => {
+      clearTimer();
+      statusRef.current = nextStatus;
+      setStatus(nextStatus);
+    });
+    const cancelDone = done.cancel;
+    done.cancel = () => {
+      clearTimer();
+      cancelDone();
+    };
+    const node = propsRef.current.nodeRef.current;
+    const listener = propsRef.current.addEndListener;
+    const hasAutoTimeout = propsRef.current.getAutoTimeout !== undefined;
+    const autoTimeout = propsRef.current.getAutoTimeout?.();
+    const authoredTimeout = getCompletionTimeout({
+      currentStatus,
+      isAppearing: isAppearingRef.current,
+      timeout: propsRef.current.timeout,
+      autoTimeout
+    });
+    const transitionReduceMotion = transitionReduceMotionRef.current;
+    // Auto-duration consumers may skip measurement under reduced motion, but
+    // still need a 0ms timeout when they provide addEndListener.
+    const fallbackTimeout = authoredTimeout ?? (transitionReduceMotion && hasAutoTimeout ? 0 : null);
+    const scheduleTimer = value => {
+      timeoutId = setTimeout(done, value);
+    };
+    if (!node) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn(['MUI: The transition child does not expose a DOM element.', 'Make sure the child accepts a ref and forwards it to the underlying DOM element.', 'The transition animation cannot be observed without a DOM element and will be skipped.'].join('\n'));
+      }
+
+      // Match react-transition-group: if there is no DOM node, there is no
+      // transition to observe, so finish on the next tick.
+      scheduleTimer(0);
+      return;
+    }
+    if (listener) {
+      if (fallbackTimeout != null) {
+        scheduleTimer(transitionReduceMotion ? 0 : fallbackTimeout);
+      }
+
+      // With nodeRef, react-transition-group calls addEndListener(done).
+      // Material UI has long supported addEndListener(node, done). Keep both call
+      // shapes so existing transition wrappers do not have to change.
+      if (listener.length >= 2) {
+        listener(node, done);
+      } else {
+        listener(done);
+      }
+      return;
+    }
+    scheduleTimer(transitionReduceMotion ? 0 : authoredTimeout ?? 0);
+  }, [makeCallback, propsRef]);
+  const performEnter = React.useCallback(mounting => {
+    const current = propsRef.current;
+    const isAppearing = current.parentGroup ? current.parentGroup.isMounting : mounting;
+    isAppearingRef.current = isAppearing;
+
+    // On updates, enter=false skips the enter animation. Move straight to
+    // entered; the status effect will call onEntered, but onEnter/onEntering
+    // must not fire.
+    if (!mounting && !current.enter) {
+      statusRef.current = 'entered';
+      setStatus('entered');
+      return;
+    }
+    transitionReduceMotionRef.current = current.reduceMotion;
+    current.onEnter?.(isAppearing);
+    statusRef.current = 'entering';
+    setStatus('entering');
+  }, [propsRef]);
+  const performExit = React.useCallback(() => {
+    const current = propsRef.current;
+    if (!current.exit) {
+      statusRef.current = 'exited';
+      setStatus('exited');
+      return;
+    }
+    transitionReduceMotionRef.current = current.reduceMotion;
+    current.onExit?.();
+    statusRef.current = 'exiting';
+    setStatus('exiting');
+  }, [propsRef]);
+  const updateStatus = React.useCallback((mounting, nextStatus) => {
+    cancelPendingCallback();
+    if (nextStatus === 'entering') {
+      const current = propsRef.current;
+      // If the node was just mounted, read layout before entering so the
+      // browser applies the starting styles before the animation begins.
+      if (current.mountOnEnter || current.unmountOnExit) {
+        const node = current.nodeRef.current;
+        if (node) {
+          reflow(node);
+        }
+      }
+      performEnter(mounting);
+    } else {
+      performExit();
+    }
+  }, [cancelPendingCallback, performEnter, performExit, propsRef]);
+
+  // Runs on mount. useEnhancedEffect is needed because the initial appear
+  // transition may read layout before paint. In StrictMode development builds,
+  // React mounts, cleans up, and mounts again; cleanup cancels pending work and
+  // the second mount restarts the same transition.
+  useEnhancedEffect(() => {
+    mountedRef.current = true;
+    if (shouldAppearOnMountRef.current) {
+      shouldAppearOnMountRef.current = false;
+      updateStatus(true, 'entering');
+    }
+    return () => {
+      mountedRef.current = false;
+      cancelPendingCallback();
+    };
+  }, [cancelPendingCallback, updateStatus]);
+
+  // Reconcile the rendered status after `in` or status changes:
+  // - opening from unmounted is handled during render (see above) so the child
+  //   is committed as exited with its ref attached before this effect runs.
+  // - unmountOnExit removes the child after the exited state commits.
+  // This matches react-transition-group's observable status steps without
+  // running work after unrelated commits.
+  useEnhancedEffect(() => {
+    if (!mountedRef.current) {
+      return;
+    }
+    const current = statusRef.current;
+    if (inProp) {
+      if (current !== 'entering' && current !== 'entered') {
+        updateStatus(false, 'entering');
+      }
+    } else if (current === 'entering' || current === 'entered') {
+      updateStatus(false, 'exiting');
+    } else if (current === 'exited' && unmountOnExit) {
+      statusRef.current = 'unmounted';
+      setStatus('unmounted');
+    }
+  }, [inProp, status, unmountOnExit, updateStatus]);
+
+  // Fire lifecycle callbacks for committed status changes. The guard prevents
+  // duplicate callbacks in StrictMode; propsRef keeps delayed callbacks fresh.
+  useEnhancedEffect(() => {
+    // `unmounted` is bookkeeping, not a real transition state. Do not fire
+    // callbacks when moving into or out of it; otherwise the first open with
+    // mountOnEnter/unmountOnExit would look like a completed exit.
+    if (status === 'unmounted' || lastFiredStatusRef.current === 'unmounted') {
+      lastFiredStatusRef.current = status;
+      return;
+    }
+    const prev = lastFiredStatusRef.current;
+    if (prev === status) {
+      return;
+    }
+    lastFiredStatusRef.current = status;
+    const current = propsRef.current;
+    if (status === 'entering') {
+      current.onEntering?.(isAppearingRef.current);
+      scheduleTransitionEnd('entered', 'entering');
+    } else if (status === 'exiting') {
+      current.onExiting?.();
+      scheduleTransitionEnd('exited', 'exiting');
+    } else if (status === 'entered') {
+      current.onEntered?.(isAppearingRef.current);
+    } else if (status === 'exited') {
+      current.onExited?.();
+    }
+  }, [propsRef, scheduleTransitionEnd, status]);
+  if (status === 'unmounted') {
+    return null;
+  }
+
+  // Nested Material UI transitions should not inherit this transition's parent group.
+  // A null context keeps an outer TransitionGroup from controlling them.
+  return /*#__PURE__*/_jsx(TransitionGroupContext.Provider, {
+    value: null,
+    children: children(status, childProps)
+  });
+}
+process.env.NODE_ENV !== "production" ? Transition.propTypes /* remove-proptypes */ = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  addEndListener: PropTypes.func,
+  /**
+   * @ignore
+   */
+  appear: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  children: PropTypes.func.isRequired,
+  /**
+   * @ignore
+   */
+  enter: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  exit: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  getAutoTimeout: PropTypes.func,
+  /**
+   * @ignore
+   */
+  in: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  mountOnEnter: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  nodeRef: PropTypes.shape({
+    current: (props, propName) => {
+      if (props[propName] == null) {
+        return null;
+      }
+      if (typeof props[propName] !== 'object' || props[propName].nodeType !== 1) {
+        return new Error(`Expected prop '${propName}' to be of type Element`);
+      }
+      return null;
+    }
+  }).isRequired,
+  /**
+   * @ignore
+   */
+  onEnter: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onEntered: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onEntering: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onExit: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onExited: PropTypes.func,
+  /**
+   * @ignore
+   */
+  onExiting: PropTypes.func,
+  /**
+   * @ignore
+   */
+  reduceMotion: PropTypes.bool,
+  /**
+   * @ignore
+   */
+  timeout: PropTypes.oneOfType([PropTypes.number, PropTypes.shape({
+    appear: PropTypes.number,
+    enter: PropTypes.number,
+    exit: PropTypes.number
+  })]),
+  /**
+   * @ignore
+   */
+  unmountOnExit: PropTypes.bool
+} : void 0;
+export default Transition;

package/internal/react-transition-group.d.mts

@@ -0,0 +1,8 @@
+declare module 'react-transition-group/TransitionGroupContext' {
+  import * as React from 'react';
+  interface TransitionGroupContextValue {
+    isMounting: boolean;
+  }
+  const TransitionGroupContext: React.Context<TransitionGroupContextValue | null>;
+  export default TransitionGroupContext;
+}

package/internal/react-transition-group.d.ts

@@ -0,0 +1,8 @@
+declare module 'react-transition-group/TransitionGroupContext' {
+  import * as React from 'react';
+  interface TransitionGroupContextValue {
+    isMounting: boolean;
+  }
+  const TransitionGroupContext: React.Context<TransitionGroupContextValue | null>;
+  export default TransitionGroupContext;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/material",
-  "version": "9.0.1",
+  "version": "9.1.1",
   "author": "MUI Team",
   "description": "Material UI is an open-source React component library that implements Google's Material Design. It's comprehensive and can be used in production out of the box.",
   "license": "MIT",
@@ -31,12 +31,12 @@
     "clsx": "^2.1.1",
     "csstype": "^3.2.3",
     "prop-types": "^15.8.1",
-    "react-is": "^19.2.4",
+    "react-is": "^19.2.6",
     "react-transition-group": "^4.4.5",
-    "@mui/core-downloads-tracker": "^9.0.1",
-    "@mui/system": "^9.0.1",
-    "@mui/types": "^9.0.0",
-    "@mui/utils": "^9.0.1"
+    "@mui/core-downloads-tracker": "^9.1.1",
+    "@mui/system": "^9.1.1",
+    "@mui/types": "^9.1.1",
+    "@mui/utils": "^9.1.1"
   },
   "peerDependencies": {
     "@emotion/react": "^11.5.0",
@@ -44,7 +44,7 @@
     "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
     "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
     "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@mui/material-pigment-css": "^9.0.1"
+    "@mui/material-pigment-css": "^9.1.1"
   },
   "peerDependenciesMeta": {
     "@types/react": {

package/styles/ThemeProviderWithVars.d.mts

@@ -27,19 +27,19 @@ declare const getInitColorSchemeScript: typeof deprecatedGetInitColorSchemeScrip
  */
 export declare const CssVarsProvider: (props: import("react").PropsWithChildren<Partial<import("@mui/system").CssVarsProviderConfig<SupportedColorScheme>> & {
   theme?: {
-    cssVariables?: false | undefined;
-    cssVarPrefix?: string | undefined;
-    colorSchemes: Partial<Record<SupportedColorScheme, any>>;
-    colorSchemeSelector?: "media" | "class" | "data" | string | undefined;
-  } | {
     $$material: {
       cssVariables?: false | undefined;
       cssVarPrefix?: string | undefined;
       colorSchemes: Partial<Record<SupportedColorScheme, any>>;
-      colorSchemeSelector?: "media" | "class" | "data" | string | undefined;
+      colorSchemeSelector?: 'media' | 'class' | 'data' | string | undefined;
     };
+  } | {
+    cssVariables?: false | undefined;
+    cssVarPrefix?: string | undefined;
+    colorSchemes: Partial<Record<SupportedColorScheme, any>>;
+    colorSchemeSelector?: 'media' | 'class' | 'data' | string | undefined;
   } | undefined;
-  defaultMode?: "light" | "dark" | "system" | undefined;
+  defaultMode?: 'light' | 'dark' | 'system' | undefined;
   documentNode?: Document | null | undefined;
   colorSchemeNode?: Element | null | undefined;
   storageManager?: import("@mui/system").StorageManager | null | undefined;

package/styles/ThemeProviderWithVars.d.ts

@@ -27,19 +27,19 @@ declare const getInitColorSchemeScript: typeof deprecatedGetInitColorSchemeScrip
  */
 export declare const CssVarsProvider: (props: import("react").PropsWithChildren<Partial<import("@mui/system").CssVarsProviderConfig<SupportedColorScheme>> & {
   theme?: {
-    cssVariables?: false | undefined;
-    cssVarPrefix?: string | undefined;
-    colorSchemes: Partial<Record<SupportedColorScheme, any>>;
-    colorSchemeSelector?: "media" | "class" | "data" | string | undefined;
-  } | {
     $$material: {
       cssVariables?: false | undefined;
       cssVarPrefix?: string | undefined;
       colorSchemes: Partial<Record<SupportedColorScheme, any>>;
-      colorSchemeSelector?: "media" | "class" | "data" | string | undefined;
+      colorSchemeSelector?: 'media' | 'class' | 'data' | string | undefined;
     };
+  } | {
+    cssVariables?: false | undefined;
+    cssVarPrefix?: string | undefined;
+    colorSchemes: Partial<Record<SupportedColorScheme, any>>;
+    colorSchemeSelector?: 'media' | 'class' | 'data' | string | undefined;
   } | undefined;
-  defaultMode?: "light" | "dark" | "system" | undefined;
+  defaultMode?: 'light' | 'dark' | 'system' | undefined;
   documentNode?: Document | null | undefined;
   colorSchemeNode?: Element | null | undefined;
   storageManager?: import("@mui/system").StorageManager | null | undefined;

package/styles/createGetSelector.d.mts

@@ -1,10 +1,10 @@
 declare const _default: <T extends {
   rootSelector?: string | undefined;
-  colorSchemeSelector?: "media" | "class" | "data" | string | undefined;
+  colorSchemeSelector?: 'media' | 'class' | 'data' | string | undefined;
   colorSchemes?: Record<string, any> | undefined;
   defaultColorScheme?: string | undefined;
   cssVarPrefix?: string | undefined;
-}>(theme: T) => (colorScheme: keyof T["colorSchemes"] | undefined, css: Record<string, any>) => string | {
+}>(theme: T) => (colorScheme: keyof T['colorSchemes'] | undefined, css: Record<string, any>) => string | {
   [x: string]: Record<string, any>;
   "@media (prefers-color-scheme: dark)": {
     [x: string]: Record<string, any>;

package/styles/createGetSelector.d.ts

@@ -1,10 +1,10 @@
 declare const _default: <T extends {
   rootSelector?: string | undefined;
-  colorSchemeSelector?: "media" | "class" | "data" | string | undefined;
+  colorSchemeSelector?: 'media' | 'class' | 'data' | string | undefined;
   colorSchemes?: Record<string, any> | undefined;
   defaultColorScheme?: string | undefined;
   cssVarPrefix?: string | undefined;
-}>(theme: T) => (colorScheme: keyof T["colorSchemes"] | undefined, css: Record<string, any>) => string | {
+}>(theme: T) => (colorScheme: keyof T['colorSchemes'] | undefined, css: Record<string, any>) => string | {
   [x: string]: Record<string, any>;
   "@media (prefers-color-scheme: dark)": {
     [x: string]: Record<string, any>;

package/styles/createMotion.d.mts

@@ -0,0 +1,8 @@
+export type ReducedMotionMode = 'never' | 'system' | 'always';
+export interface Motion {
+  reducedMotion: ReducedMotionMode;
+}
+export interface MotionOptions {
+  reducedMotion?: ReducedMotionMode | undefined;
+}
+export default function createMotion(inputMotion?: MotionOptions): Motion;

package/styles/createMotion.d.ts

@@ -0,0 +1,8 @@
+export type ReducedMotionMode = 'never' | 'system' | 'always';
+export interface Motion {
+  reducedMotion: ReducedMotionMode;
+}
+export interface MotionOptions {
+  reducedMotion?: ReducedMotionMode | undefined;
+}
+export default function createMotion(inputMotion?: MotionOptions): Motion;

package/styles/createMotion.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createMotion;
+const EMPTY_MOTION = {};
+function createMotion(inputMotion = EMPTY_MOTION) {
+  return {
+    reducedMotion: 'never',
+    ...inputMotion
+  };
+}

package/styles/createMotion.mjs

@@ -0,0 +1,7 @@
+const EMPTY_MOTION = {};
+export default function createMotion(inputMotion = EMPTY_MOTION) {
+  return {
+    reducedMotion: 'never',
+    ...inputMotion
+  };
+}

package/styles/createThemeFoundation.d.mts

@@ -3,6 +3,7 @@ import { SxConfig, SxProps, CSSObject, ApplyStyles, Theme as SystemTheme, Shape
 import { ExtractTypographyTokens } from '@mui/system/cssVars';
 import { Palette, PaletteOptions } from "./createPalette.mjs";
 import { Shadows } from "./shadows.mjs";
+import { Motion } from "./createMotion.mjs";
 import { Transitions } from "./createTransitions.mjs";
 import { Mixins } from "./createMixins.mjs";
 import { TypographyVariants } from "./createTypography.mjs";
@@ -260,6 +261,7 @@ export interface CssVarsTheme extends ColorSystem {
   breakpoints: SystemTheme['breakpoints'];
   shape: Shape;
   typography: TypographyVariants;
+  motion: Motion;
   transitions: Transitions;
   shadows: Shadows;
   mixins: Mixins;

package/styles/createThemeFoundation.d.ts

@@ -3,6 +3,7 @@ import { SxConfig, SxProps, CSSObject, ApplyStyles, Theme as SystemTheme, Shape
 import { ExtractTypographyTokens } from '@mui/system/cssVars';
 import { Palette, PaletteOptions } from "./createPalette.js";
 import { Shadows } from "./shadows.js";
+import { Motion } from "./createMotion.js";
 import { Transitions } from "./createTransitions.js";
 import { Mixins } from "./createMixins.js";
 import { TypographyVariants } from "./createTypography.js";
@@ -260,6 +261,7 @@ export interface CssVarsTheme extends ColorSystem {
   breakpoints: SystemTheme['breakpoints'];
   shape: Shape;
   typography: TypographyVariants;
+  motion: Motion;
   transitions: Transitions;
   shadows: Shadows;
   mixins: Mixins;

package/styles/createThemeNoVars.d.mts

@@ -3,6 +3,7 @@ import { Mixins, MixinsOptions } from "./createMixins.mjs";
 import { Palette, PaletteOptions } from "./createPalette.mjs";
 import { TypographyVariants, TypographyVariantsOptions } from "./createTypography.mjs";
 import { Shadows } from "./shadows.mjs";
+import { Motion, MotionOptions } from "./createMotion.mjs";
 import { Transitions, TransitionsOptions } from "./createTransitions.mjs";
 import { ZIndex, ZIndexOptions } from "./zIndex.mjs";
 import { Components } from "./components.mjs";
@@ -25,6 +26,7 @@ type CssVarsOptions = CssThemeVariables extends {
 export interface ThemeOptions extends Omit<SystemThemeOptions, 'zIndex'>, CssVarsOptions {
   mixins?: MixinsOptions | undefined;
   components?: Components<Omit<Theme, 'components'>> | undefined;
+  motion?: MotionOptions | undefined;
   palette?: PaletteOptions | undefined;
   shadows?: Shadows | undefined;
   shape?: ShapeOptions | undefined;
@@ -37,6 +39,7 @@ export interface ThemeOptions extends Omit<SystemThemeOptions, 'zIndex'>, CssVar
 }
 export interface BaseTheme extends SystemTheme {
   mixins: Mixins;
+  motion: Motion;
   palette: Palette & (CssThemeVariables extends {
     enabled: true;
   } ? CssVarsPalette : {});