worked on GarageApp stuff

node_modules/@emotion/react/dist/declarations/src/_isolated-hnrs.d.ts

@@ -0,0 +1,3 @@
+import hoistNonReactStatics from 'hoist-non-react-statics';
+declare const _default: <T extends import("react").ComponentType<any>, S extends import("react").ComponentType<any>>(targetComponent: T, sourceComponent: S) => T & hoistNonReactStatics.NonReactStatics<S, {}>;
+export default _default;

node_modules/@emotion/react/dist/declarations/src/class-names.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { CSSInterpolation } from '@emotion/serialize';
+import { Theme } from "./theming.js";
+export interface ArrayClassNamesArg extends Array<ClassNamesArg> {
+}
+export type ClassNamesArg = undefined | null | string | boolean | {
+    [className: string]: boolean | null | undefined;
+} | ArrayClassNamesArg;
+export interface ClassNamesContent {
+    css(template: TemplateStringsArray, ...args: Array<CSSInterpolation>): string;
+    css(...args: Array<CSSInterpolation>): string;
+    cx(...args: Array<ClassNamesArg>): string;
+    theme: Theme;
+}
+export interface ClassNamesProps {
+    children(content: ClassNamesContent): React.ReactNode;
+}
+export declare const ClassNames: React.FC<ClassNamesProps & React.RefAttributes<any>> | React.ForwardRefExoticComponent<ClassNamesProps & React.RefAttributes<any>>;

node_modules/@emotion/react/dist/declarations/src/context.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { EmotionCache } from '@emotion/cache';
+export declare let CacheProvider: React.Provider<EmotionCache | null>;
+export declare let __unsafe_useEmotionCache: () => EmotionCache | null;
+declare let withEmotionCache: <Props, RefType = any>(func: (props: React.PropsWithoutRef<Props>, context: EmotionCache, ref?: React.ForwardedRef<RefType>) => React.ReactNode) => React.FC<React.PropsWithoutRef<Props> & React.RefAttributes<RefType>> | React.ForwardRefExoticComponent<React.PropsWithoutRef<Props> & React.RefAttributes<RefType>>;
+export { withEmotionCache };

node_modules/@emotion/react/dist/declarations/src/css.d.ts

@@ -0,0 +1,5 @@
+import type { SerializedStyles } from '@emotion/utils';
+import type { CSSInterpolation } from '@emotion/serialize';
+declare function css(template: TemplateStringsArray, ...args: CSSInterpolation[]): SerializedStyles;
+declare function css(...args: CSSInterpolation[]): SerializedStyles;
+export default css;

node_modules/@emotion/react/dist/declarations/src/global.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { Theme } from "./theming.js";
+import { Interpolation } from '@emotion/serialize';
+export interface GlobalProps {
+    styles: Interpolation<Theme>;
+}
+export declare let Global: React.FC<GlobalProps & React.RefAttributes<any>> | React.ForwardRefExoticComponent<GlobalProps & React.RefAttributes<any>>;

node_modules/@emotion/react/dist/declarations/src/index.d.ts

@@ -0,0 +1,14 @@
+export type { EmotionCache } from '@emotion/cache';
+export type { ArrayInterpolation, ComponentSelector, CSSObject, FunctionInterpolation, Interpolation, Keyframes, SerializedStyles } from '@emotion/serialize';
+export { withEmotionCache, CacheProvider, __unsafe_useEmotionCache } from "./context.js";
+export { jsx } from "./jsx.js";
+export { jsx as createElement } from "./jsx.js";
+export { Global } from "./global.js";
+export type { GlobalProps } from "./global.js";
+export { keyframes } from "./keyframes.js";
+export { ClassNames } from "./class-names.js";
+export type { ClassNamesArg, ClassNamesContent, ClassNamesProps, ArrayClassNamesArg } from "./class-names.js";
+export { ThemeContext, useTheme, ThemeProvider, withTheme } from "./theming.js";
+export type { Theme, ThemeProviderProps, WithTheme } from "./theming.js";
+export { default as css } from "./css.js";
+export type { DistributiveOmit, PropsOf } from "./types.js";

node_modules/@emotion/react/dist/declarations/src/jsx-dev-runtime.d.ts

@@ -0,0 +1,6 @@
+import * as ReactJSXRuntimeDev from 'react/jsx-dev-runtime';
+export type { EmotionJSX as JSX } from "./jsx-namespace.js";
+export declare const Fragment: import("react").ExoticComponent<{
+    children?: import("react").ReactNode;
+}>;
+export declare const jsxDEV: typeof ReactJSXRuntimeDev.jsxDEV;

node_modules/@emotion/react/dist/declarations/src/jsx-namespace.d.ts

@@ -0,0 +1,64 @@
+import 'react';
+import { Interpolation } from '@emotion/serialize';
+import { Theme } from "./theming.js";
+type IsPreReact19 = 2 extends Parameters<React.FunctionComponent<any>>['length'] ? true : false;
+type WithConditionalCSSProp<P> = 'className' extends keyof P ? string extends P['className' & keyof P] ? {
+    css?: Interpolation<Theme>;
+} : {} : {};
+/** @ts-ignore */
+type ReactJSXElement = true extends IsPreReact19 ? JSX.Element : React.JSX.Element;
+/** @ts-ignore */
+type ReactJSXElementClass = true extends IsPreReact19 ? JSX.ElementClass : React.JSX.ElementClass;
+/** @ts-ignore */
+type ReactJSXElementAttributesProperty = true extends IsPreReact19 ? JSX.ElementAttributesProperty : React.JSX.ElementAttributesProperty;
+/** @ts-ignore */
+type ReactJSXElementChildrenAttribute = true extends IsPreReact19 ? JSX.ElementChildrenAttribute : React.JSX.ElementChildrenAttribute;
+/** @ts-ignore */
+type ReactJSXLibraryManagedAttributes<C, P> = true extends IsPreReact19 ? JSX.LibraryManagedAttributes<C, P> : React.JSX.LibraryManagedAttributes<C, P>;
+/** @ts-ignore */
+type ReactJSXIntrinsicAttributes = true extends IsPreReact19 ? JSX.IntrinsicAttributes : React.JSX.IntrinsicAttributes;
+/** @ts-ignore */
+type ReactJSXIntrinsicClassAttributes<T> = true extends IsPreReact19 ? JSX.IntrinsicClassAttributes<T> : React.JSX.IntrinsicClassAttributes<T>;
+/** @ts-ignore */
+type ReactJSXIntrinsicElements = true extends IsPreReact19 ? JSX.IntrinsicElements : React.JSX.IntrinsicElements;
+/** @ts-ignore */
+type ReactJSXElementType = true extends IsPreReact19 ? string | React.JSXElementConstructor<any> : React.JSX.ElementType;
+export declare namespace ReactJSX {
+    type ElementType = ReactJSXElementType;
+    interface Element extends ReactJSXElement {
+    }
+    interface ElementClass extends ReactJSXElementClass {
+    }
+    interface ElementAttributesProperty extends ReactJSXElementAttributesProperty {
+    }
+    interface ElementChildrenAttribute extends ReactJSXElementChildrenAttribute {
+    }
+    type LibraryManagedAttributes<C, P> = ReactJSXLibraryManagedAttributes<C, P>;
+    interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {
+    }
+    interface IntrinsicClassAttributes<T> extends ReactJSXIntrinsicClassAttributes<T> {
+    }
+    type IntrinsicElements = ReactJSXIntrinsicElements;
+}
+export declare namespace EmotionJSX {
+    type ElementType = ReactJSXElementType;
+    interface Element extends ReactJSXElement {
+    }
+    interface ElementClass extends ReactJSXElementClass {
+    }
+    interface ElementAttributesProperty extends ReactJSXElementAttributesProperty {
+    }
+    interface ElementChildrenAttribute extends ReactJSXElementChildrenAttribute {
+    }
+    type LibraryManagedAttributes<C, P> = P extends unknown ? WithConditionalCSSProp<P> & ReactJSXLibraryManagedAttributes<C, P> : never;
+    interface IntrinsicAttributes extends ReactJSXIntrinsicAttributes {
+    }
+    interface IntrinsicClassAttributes<T> extends ReactJSXIntrinsicClassAttributes<T> {
+    }
+    type IntrinsicElements = {
+        [K in keyof ReactJSXIntrinsicElements]: ReactJSXIntrinsicElements[K] & {
+            css?: Interpolation<Theme>;
+        };
+    };
+}
+export {};

node_modules/@emotion/react/dist/declarations/src/jsx-runtime.d.ts

@@ -0,0 +1,7 @@
+import * as ReactJSXRuntime from 'react/jsx-runtime';
+export type { EmotionJSX as JSX } from "./jsx-namespace.js";
+export declare const Fragment: import("react").ExoticComponent<{
+    children?: import("react").ReactNode;
+}>;
+export declare const jsx: typeof ReactJSXRuntime.jsx;
+export declare const jsxs: typeof ReactJSXRuntime.jsxs;

node_modules/@emotion/react/dist/declarations/src/jsx.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { EmotionJSX } from "./jsx-namespace.js";
+export declare const jsx: typeof React.createElement;
+export declare namespace jsx {
+    namespace JSX {
+        type ElementType = EmotionJSX.ElementType;
+        interface Element extends EmotionJSX.Element {
+        }
+        interface ElementClass extends EmotionJSX.ElementClass {
+        }
+        interface ElementAttributesProperty extends EmotionJSX.ElementAttributesProperty {
+        }
+        interface ElementChildrenAttribute extends EmotionJSX.ElementChildrenAttribute {
+        }
+        type LibraryManagedAttributes<C, P> = EmotionJSX.LibraryManagedAttributes<C, P>;
+        interface IntrinsicAttributes extends EmotionJSX.IntrinsicAttributes {
+        }
+        interface IntrinsicClassAttributes<T> extends EmotionJSX.IntrinsicClassAttributes<T> {
+        }
+        type IntrinsicElements = EmotionJSX.IntrinsicElements;
+    }
+}

node_modules/@emotion/react/dist/declarations/src/keyframes.d.ts

@@ -0,0 +1,10 @@
+import { CSSInterpolation } from '@emotion/serialize';
+type Keyframes = {
+    name: string;
+    styles: string;
+    anim: 1;
+    toString: () => string;
+} & string;
+export declare function keyframes(template: TemplateStringsArray, ...args: CSSInterpolation[]): Keyframes;
+export declare function keyframes(...args: CSSInterpolation[]): Keyframes;
+export {};

node_modules/@emotion/react/dist/declarations/src/theming.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { DistributiveOmit, PropsOf } from "./types.js";
+export interface Theme {
+}
+export interface ThemeProviderProps {
+    theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
+    children: React.ReactNode;
+}
+export interface ThemeProvider {
+    (props: ThemeProviderProps): React.ReactElement;
+}
+export type WithTheme<P, T> = P extends {
+    theme: infer Theme;
+} ? P & {
+    theme: Exclude<Theme, undefined>;
+} : P & {
+    theme: T;
+};
+export declare const ThemeContext: React.Context<Theme>;
+export declare const useTheme: () => Theme;
+export interface ThemeProviderProps {
+    theme: Partial<Theme> | ((outerTheme: Theme) => Theme);
+    children: React.ReactNode;
+}
+export declare const ThemeProvider: (props: ThemeProviderProps) => React.JSX.Element;
+export declare function withTheme<C extends React.ComponentType<React.ComponentProps<C>>>(Component: C): React.ForwardRefExoticComponent<DistributiveOmit<PropsOf<C>, 'theme'> & {
+    theme?: Theme;
+}>;

node_modules/@emotion/react/dist/declarations/src/types.d.ts

@@ -0,0 +1,7 @@
+import { ReactJSX } from "./jsx-namespace.js";
+/**
+ * @desc Utility type for getting props type of React component.
+ * It takes `defaultProps` into an account - making props with defaults optional.
+ */
+export type PropsOf<C extends keyof ReactJSX.IntrinsicElements | React.JSXElementConstructor<any>> = ReactJSX.LibraryManagedAttributes<C, React.ComponentProps<C>>;
+export type DistributiveOmit<T, U> = T extends any ? Pick<T, Exclude<keyof T, U>> : never;