@apple-pie/slice 0.1.9 → 0.1.10

package/dist/types/index.d.ts

@@ -0,0 +1,74 @@
+export type { ToolTip, ToolTipInfo } from './components/sharedTypes';
+export { ToolTipType } from './components/sharedTypes';
+export { light, dark, lightTheme, darkTheme, motion, elevations, Elevation, } from './theme';
+export type { SliceTheme, Colors, Type, Corners, Elevations, } from './theme';
+export { type KeyboardShortcut, type KeyboardShortcuts, type BreakPoints, type WindowGeolocation, type WindowGeolocationError, useKeyboardShortcuts, useTheme, useObserveTheme, useToolTip, useLastUpdated, useLocalStore, useWindow, useDoubleClick, useObserveResize, } from './hooks';
+export { Avatar } from './components/Avatar/index';
+export type { AvatarProps } from './components/Avatar/index';
+export { AvatarGroup } from './components/AvatarGroup';
+export type { AvatarGroupProps, AvatarInfo } from './components/AvatarGroup';
+export { Badge } from './components/Badge';
+export type { BadgeProps } from './components/Badge';
+export { IconButton } from './components/IconButton';
+export type { IconButtonProps } from './components/IconButton';
+export { Camera } from './components/Camera';
+export type { CameraElement, CameraProps, CameraSnapshotOptions, Controls, UserProfile, Settings, } from './components/Camera';
+export { CheckBox } from './components/CheckBox';
+export type { CheckBoxProps } from './components/CheckBox';
+export { DivInput } from './components/DivInput';
+export type { DivInputProps } from './components/DivInput';
+export { Dot } from './components/Dot';
+export type { DotProps } from './components/Dot';
+export { DraggablePanel } from './components/DraggablePanel';
+export type { DraggablePanelProps } from './components/DraggablePanel';
+export { DropDown } from './components/DropDown';
+export type { DropDownOption, DropDownProps } from './components/DropDown';
+export { ErrorSummary } from './components/ErrorSummary';
+export type { ErrorMessage, ErrorSummaryProps, } from './components/ErrorSummary';
+export { Grouper } from './components/Grouper';
+export type { GrouperProps } from './components/Grouper';
+export { Overlay } from './components/Overlay';
+export type { OverlayProps } from './components/Overlay';
+export { FlexDiv } from './components/FlexDiv';
+export type { FlexDivProps } from './components/FlexDiv';
+export { Pager } from './components/Pager';
+export type { PagerProps } from './components/Pager';
+export { PromptInput } from './components/PromptInput';
+export type { PromptProps } from './components/PromptInput';
+export { DoneCheck, ProgressIndicator } from './components/Progress';
+export type { DoneCheckProps, ProgressIndicatorProps, } from './components/Progress';
+export { RadioButton } from './components/RadioButton';
+export type { RadioButtonProps, RadioButtonOption, } from './components/RadioButton';
+export { RadioButtonList } from './components/RadioButtonList';
+export type { RadioButtonListProps } from './components/RadioButtonList';
+export { Slider } from './components/Slider';
+export type { SliderProps } from './components/Slider';
+export { Spacer } from './components/Spacer';
+export { Switch } from './components/Switch';
+export type { SwitchProps } from './components/Switch';
+export { TabBar } from './components/TabBar';
+export type { TabOption, TabBarProps } from './components/TabBar';
+export { TextArea } from './components/TextArea';
+export type { TextAreaProps } from './components/TextArea';
+export { TextField } from './components/Textfield';
+export type { TextFieldProps } from './components/Textfield';
+export { ThemeProvider } from './providers';
+export { Tip } from './components/Tip';
+export type { ToolTipProps } from './components/Tip';
+export { Toast, ToastType } from './components/Toast';
+export type { ToastProps } from './components/Toast';
+export { Button } from './components/Button';
+export type { ButtonProps, ButtonHandle } from './components/Button';
+export { Chip } from './components/Chip';
+export type { ChipProps } from './components/Chip';
+export { FileIcon, FileIconNames } from './components/FileIcon';
+export type { FileIconProps } from './components/FileIcon/_types';
+export { Icon, SliceIcons } from './components/Icon';
+export type { IconProps } from './components/Icon/_types';
+export { ButtonBar } from './components/ButtonBar';
+export type { BarButton, ButtonBarProps } from './components/ButtonBar/_types';
+export { Label } from './components/Label';
+export type { LabelProps } from './components/Label';
+export { UploadArea } from './components/UploadArea';
+export type { UploadAreaProps } from './components/UploadArea/_types';
+export { imageTypes, videoTypes, documentTypes, audioTypes, textTypes, allTypes, } from './components/UploadArea/_types';

package/dist/types/providers/ThemeProvider.d.ts

@@ -0,0 +1,13 @@
+import type React from 'react';
+import '../theme/colors/colors.css';
+import '../theme/elevations/elevation.css';
+import '../theme/type/type.css';
+import '../theme/breakpoints/custom-media.css';
+import '../theme/motion/motion.css';
+interface ThemeProviderProps {
+    children?: React.ReactNode;
+    theme?: string;
+    system?: boolean;
+}
+export declare function ThemeProvider(props: Readonly<ThemeProviderProps>): React.ReactNode;
+export {};

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

@@ -0,0 +1 @@
+export { ThemeProvider } from './ThemeProvider';

package/dist/types/stores/LocalDB/_types.d.ts

@@ -0,0 +1,43 @@
+import type { IndexedDB, IndexedDBOptions } from '../../utils';
+export interface LocalDBRecord<TValue = unknown> {
+    key: IDBValidKey;
+    value: TValue;
+}
+export interface LocalDBConnection<TValue = unknown> {
+    name: string;
+    connection: IndexedDB<TValue>;
+    key: string | null;
+    records: LocalDBRecord<TValue>[];
+    initialized: boolean;
+    error: string | null;
+}
+export interface LocalDBStoreOptions extends Omit<IndexedDBOptions, 'databaseName'> {
+    create?: boolean;
+}
+export type LocalDBActionResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: Error;
+};
+export type LocalDBActionValueResult<TValue> = {
+    ok: true;
+    value: TValue;
+} | {
+    ok: false;
+    error: Error;
+};
+export interface LocalDBActions {
+    addStore: (name: string, options?: LocalDBStoreOptions) => Promise<LocalDBActionResult>;
+    removeStore: (name: string) => Promise<LocalDBActionResult>;
+    refreshStore: (name: string) => Promise<LocalDBActionResult>;
+    setValue: (name: string, value: unknown | unknown[]) => Promise<LocalDBActionValueResult<IDBValidKey | IDBValidKey[]>>;
+    addValue: (name: string, value: unknown | unknown[]) => Promise<LocalDBActionValueResult<IDBValidKey | IDBValidKey[]>>;
+    removeValue: (name: string, value: unknown | unknown[]) => Promise<LocalDBActionResult>;
+    clearStore: (name: string) => Promise<LocalDBActionResult>;
+    destroyStore: (name: string) => Promise<LocalDBActionResult>;
+}
+export interface LocalDBStoreState {
+    stores: LocalDBConnection[];
+    actions: LocalDBActions;
+}

package/dist/types/stores/LocalDB/index.d.ts

@@ -0,0 +1,2 @@
+export { useLocalDBStore, useManageLocalDB, useLocalDB, useLocalDBValues, useLocalDBError, localDBActions, } from './localDBStore';
+export type { LocalDBActions, LocalDBActionResult, LocalDBActionValueResult, LocalDBStoreOptions, LocalDBStoreState, } from './_types';

package/dist/types/stores/LocalDB/localDBStore.d.ts

@@ -0,0 +1,18 @@
+import type { LocalDBActions, LocalDBStoreState } from './_types';
+export declare const useLocalDBStore: import("zustand").UseBoundStore<import("zustand").StoreApi<LocalDBStoreState>>;
+type BoundLocalDBActions = {
+    refresh: () => ReturnType<LocalDBActions['refreshStore']>;
+    set: (value: unknown) => ReturnType<LocalDBActions['setValue']>;
+    add: (value: unknown) => ReturnType<LocalDBActions['addValue']>;
+    remove: (value: unknown) => ReturnType<LocalDBActions['removeValue']>;
+    clear: () => ReturnType<LocalDBActions['clearStore']>;
+    destroy: () => ReturnType<LocalDBActions['destroyStore']>;
+};
+export declare const useLocalDB: (name: string) => BoundLocalDBActions;
+export declare function useLocalDBValues<TValue = Record<string, unknown>>(name: string): TValue[];
+export declare function useLocalDBValues<TValue = Record<string, unknown>>(name: string, key: IDBValidKey): TValue | null;
+export declare function useLocalDBValues<TValue = Record<string, unknown>>(name: string, field: keyof TValue, value: TValue[keyof TValue]): TValue[];
+export declare const useLocalDBError: (name: string) => string | null;
+export declare const useManageLocalDB: () => LocalDBActions;
+export declare const localDBActions: LocalDBActions;
+export {};

package/dist/types/stores/SSE/_types.d.ts

@@ -0,0 +1,17 @@
+import type { SSEConnection, SSEConnectionOptions, SSEEventMap, SSEUnifiedMessage } from '../../utils';
+export type SSEStoreConnectionOptions = Omit<SSEConnectionOptions<unknown, SSEEventMap>, 'unifiedOnMessage'> & {
+    onMessageCallback?: (message: SSEUnifiedMessage<unknown, SSEEventMap>) => void;
+};
+export interface SSEStoreConnection {
+    name: string;
+    connection: SSEConnection<unknown, SSEEventMap>;
+}
+export interface SSEStore {
+    connections: SSEStoreConnection[];
+    message: SSEUnifiedMessage<unknown, SSEEventMap> | null;
+    closedConnection: string | null;
+    actions: {
+        addConnection: (name: string, options: SSEStoreConnectionOptions) => SSEStoreConnection;
+        removeConnection: (name: string) => void;
+    };
+}

package/dist/types/stores/SSE/index.d.ts

@@ -0,0 +1,2 @@
+export { useSSEStore, useSSE, useConnectionClose, useConnectionMessage, useIsConnected, useMessage, useSSEActions, useLastSSEMessage, } from './sseStore';
+export type { SSEStore, SSEStoreConnection, SSEStoreConnectionOptions, } from './_types';

package/dist/types/stores/SSE/sseStore.d.ts

@@ -0,0 +1,28 @@
+import { type SSEEventMap, type SSEUnifiedMessage } from '../../utils';
+import type { SSEStore, SSEStoreConnectionOptions } from './_types';
+export declare const useSSEStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SSEStore>>;
+export declare const useSSE: () => {
+    addConnection: (name: string, options: SSEStoreConnectionOptions) => import("./_types").SSEStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useConnectionClose: () => string | null;
+export declare const useConnectionMessage: (connection: string) => {
+    type: "error";
+    event: Event;
+} | {
+    type: "open";
+    event: Event;
+} | {
+    type: "close";
+    event: Event;
+} | import("../../utils").SSEUnifiedCustomMessage<SSEEventMap, string> | null;
+export declare const useIsConnected: (connection?: string) => boolean;
+export declare function useMessage(): SSEUnifiedMessage<unknown, SSEEventMap> | null;
+export declare function useMessage<T = unknown>(type: 'message', connection?: string): T | string | null;
+export declare function useMessage(type: 'open' | 'error' | 'close', connection?: string): Event | null;
+export declare function useMessage<T = unknown>(type: string, connection?: string): T | string | null;
+export declare const useSSEActions: {
+    addConnection: (name: string, options: SSEStoreConnectionOptions) => import("./_types").SSEStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useLastSSEMessage: () => SSEUnifiedMessage<unknown, SSEEventMap> | null;

package/dist/types/stores/WS/_types.d.ts

@@ -0,0 +1,17 @@
+import type { UnifiedMessageEvent, WSConnection, WSConnectionOptions } from '../../utils';
+export type WSStoreConnectionOptions = Omit<WSConnectionOptions<unknown>, 'unifiedMessages'> & {
+    onMessageCallback?: (message: UnifiedMessageEvent<unknown>) => void;
+};
+export interface WSStoreConnection {
+    name: string;
+    connection: WSConnection<unknown>;
+}
+export interface WSStore {
+    connections: WSStoreConnection[];
+    message: UnifiedMessageEvent<unknown> | null;
+    closedConnection: string | null;
+    actions: {
+        addConnection: (name: string, options: WSStoreConnectionOptions) => WSStoreConnection;
+        removeConnection: (name: string) => void;
+    };
+}

package/dist/types/stores/WS/index.d.ts

@@ -0,0 +1,2 @@
+export { useWSStore, useWS, useConnectionClose, useConnectionMessage, useIsConnected, useMessage, useWSActions, useLastWSMessage, } from './wsStore';
+export type { WSStore, WSStoreConnection, WSStoreConnectionOptions, } from './_types';

package/dist/types/stores/WS/wsStore.d.ts

@@ -0,0 +1,19 @@
+import { type UnifiedMessageEvent } from '../../utils';
+import type { WSStore, WSStoreConnectionOptions } from './_types';
+export declare const useWSStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WSStore>>;
+export declare const useWS: () => {
+    addConnection: (name: string, options: WSStoreConnectionOptions) => import("./_types").WSStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useConnectionClose: () => string | null;
+export declare const useConnectionMessage: (connection: string) => UnifiedMessageEvent<unknown> | null;
+export declare const useIsConnected: (connection?: string) => boolean;
+export declare function useMessage(): UnifiedMessageEvent<unknown> | null;
+export declare function useMessage<T = unknown>(type: 'message', connection?: string): T | string | Blob | ArrayBuffer | null;
+export declare function useMessage(type: 'open' | 'error' | 'close', connection?: string): Event | ErrorEvent | CloseEvent | null;
+export declare function useMessage<T = unknown>(type: string, connection?: string): T | string | Blob | ArrayBuffer | null;
+export declare const useWSActions: {
+    addConnection: (name: string, options: WSStoreConnectionOptions) => import("./_types").WSStoreConnection;
+    removeConnection: (name: string) => void;
+};
+export declare const useLastWSMessage: () => UnifiedMessageEvent<unknown> | null;

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

@@ -0,0 +1,6 @@
+export * from './LocalDB';
+export * from './SSE';
+export * from './toast';
+export * from './tip';
+export * from './uploads';
+export * from './window';

package/dist/types/stores/tip/_types.d.ts

@@ -0,0 +1,8 @@
+import type { ToolTip } from '../../components/sharedTypes';
+export interface TipStore {
+    tip: ToolTip | null;
+    actions: {
+        push: (tip: ToolTip | null) => void;
+        clear: () => void;
+    };
+}

package/dist/types/stores/tip/index.d.ts

@@ -0,0 +1,2 @@
+export { useTipStore, useTip, useTipActions, tipActions, getTip, } from './tipStore';
+export type { TipStore } from './_types';

package/dist/types/stores/tip/tipStore.d.ts

@@ -0,0 +1,12 @@
+import type { TipStore } from './_types';
+export declare const useTipStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TipStore>>;
+export declare const useTip: () => import("../..").ToolTip | null;
+export declare const useTipActions: () => {
+    push: (tip: import("../..").ToolTip | null) => void;
+    clear: () => void;
+};
+export declare const tipActions: {
+    push: (tip: import("../..").ToolTip | null) => void;
+    clear: () => void;
+};
+export declare const getTip: () => import("../..").ToolTip | null;

package/dist/types/stores/toast/_types.d.ts

@@ -0,0 +1,14 @@
+import type { ToastType } from '../../components/Toast';
+export type Toast = {
+    message: string | null;
+    duration?: number;
+    type?: ToastType;
+    close?: boolean;
+};
+export interface ToastStore {
+    toast: Toast | null;
+    actions: {
+        push: (toast: Toast | null) => void;
+        clear: () => void;
+    };
+}

package/dist/types/stores/toast/index.d.ts

@@ -0,0 +1,2 @@
+export { useToastStore, useToast, useToastActions, toastActions, getToast, } from './toastStore';
+export type { Toast, ToastStore } from './_types';

package/dist/types/stores/toast/toastStore.d.ts

@@ -0,0 +1,12 @@
+import type { Toast, ToastStore } from './_types';
+export declare const useToastStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ToastStore>>;
+export declare const useToast: () => Toast | null;
+export declare const useToastActions: () => {
+    push: (toast: Toast | null) => void;
+    clear: () => void;
+};
+export declare const toastActions: {
+    push: (toast: Toast | null) => void;
+    clear: () => void;
+};
+export declare const getToast: () => Toast | null;

package/dist/types/stores/uploads/_types.d.ts

@@ -0,0 +1,16 @@
+import type { ConfigurationOptions, Upload, UploadInput, UploadWorkerMessage, UploadWorkerResponse, WorkerStatus } from '../../workers/uploads/uploads-worker';
+export type UploadsStoreState = {
+    uploads: Upload[];
+    workerStatus: WorkerStatus;
+    initialized: boolean;
+    error: string | null;
+    actions: {
+        initialize: (options: ConfigurationOptions, worker: UploadsWorkerInstance) => UploadsWorkerInstance;
+        push: (files: File | UploadInput | Array<File | UploadInput>) => void;
+        reset: () => void;
+    };
+};
+export type UploadsWorkerInstance = Worker & {
+    postMessage: (message: UploadWorkerMessage) => void;
+    onmessage: ((event: MessageEvent<UploadWorkerResponse>) => void) | null;
+};

package/dist/types/stores/uploads/index.d.ts

@@ -0,0 +1,2 @@
+export * from './_types';
+export * from './uploadsStore';

package/dist/types/stores/uploads/uploadsStore.d.ts

@@ -0,0 +1,22 @@
+import { type ConfigurationOptions, type UploadInput, WorkerStatus } from '../../workers/uploads/uploads-worker';
+import type { UploadsStoreState, UploadsWorkerInstance } from './_types';
+export declare function createUploadsWorker(workerUrl?: string | URL): UploadsWorkerInstance;
+export declare const useUploadsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<UploadsStoreState>>;
+export declare const useUploads: () => import("../../workers/uploads/uploads-worker").Upload[];
+export declare const useUploadsWorkerStatus: () => WorkerStatus;
+export declare const useUploadsInitialized: () => boolean;
+export declare const useUploadsError: () => string | null;
+export declare const useUploadsActions: () => {
+    initialize: (options: ConfigurationOptions, worker: UploadsWorkerInstance) => UploadsWorkerInstance;
+    push: (files: File | UploadInput | Array<File | UploadInput>) => void;
+    reset: () => void;
+};
+export declare const uploadsActions: {
+    initialize: (options: ConfigurationOptions, worker: UploadsWorkerInstance) => UploadsWorkerInstance;
+    push: (files: File | UploadInput | Array<File | UploadInput>) => void;
+    reset: () => void;
+};
+export declare const getUploads: () => import("../../workers/uploads/uploads-worker").Upload[];
+export declare const getUploadsWorkerStatus: () => WorkerStatus;
+export declare const uploadsInitialized: () => boolean;
+export declare const getUploadsError: () => string | null;

package/dist/types/stores/window/_types.d.ts

@@ -0,0 +1,33 @@
+import type { WindowGeolocation } from '../../hooks/useWindow/useWindow';
+export type WindowStore = {
+    formFactor: FormFactor;
+    dpr: 1 | 2 | 3;
+    isAppleDevice: boolean;
+    isTouchDevice: boolean;
+    isElectron: boolean;
+    height: string;
+    viewportWidth: number;
+    viewportHeight: number;
+    location: WindowGeolocation | null;
+    locationError: Error | null;
+    gettingLocation: boolean;
+    actions: {
+        initialize: () => () => void;
+        getLocation: () => Promise<WindowGeolocation>;
+    };
+};
+/**
+ * Form factor names
+ */
+export declare enum FormFactor {
+    Mobile = "mobile",
+    Tablet = "tablet",
+    Desktop = "desktop",
+    DesktopL = "desktopL",
+    DesktopXL = "desktopXL"
+}
+export type BreakPoints = Record<FormFactor, number>;
+/**
+ * Use bootstrap breakpoints
+ */
+export declare const bootstrapBreakPoints: BreakPoints;

package/dist/types/stores/window/index.d.ts

@@ -0,0 +1,3 @@
+export { useWindowStore, useFormFactor, useViewportWidth, useViewportHeight, useIsAppleDevice, useIsTouchDevice, useIsElectron, useDpr, useLocation, useLocationError, useGettingLocation, useInitializeWindow, useGetLocation, formFactor, viewportWidth, viewportHeight, isAppleDevice, isTouchDevice, isElectron, dpr, location, locationError, gettingLocation, } from './windowStore';
+export { FormFactor, type BreakPoints, type WindowStore } from './_types';
+export type { WindowGeolocation, WindowGeolocationError, } from '../../hooks/useWindow/useWindow';

package/dist/types/stores/window/windowStore.d.ts

@@ -0,0 +1,25 @@
+import type { WindowGeolocation } from '../../hooks/useWindow/useWindow';
+import { FormFactor, type WindowStore } from './_types';
+export declare const useWindowStore: import("zustand").UseBoundStore<import("zustand").StoreApi<WindowStore>>;
+export declare const useFormFactor: () => FormFactor;
+export declare const useViewportWidth: () => number;
+export declare const useViewportHeight: () => number;
+export declare const useIsAppleDevice: () => boolean;
+export declare const useIsTouchDevice: () => boolean;
+export declare const useIsElectron: () => boolean;
+export declare const useDpr: () => 2 | 1 | 3;
+export declare const useLocation: () => WindowGeolocation | null;
+export declare const useLocationError: () => Error | null;
+export declare const useGettingLocation: () => boolean;
+export declare const useInitializeWindow: () => () => () => void;
+export declare const useGetLocation: () => () => Promise<WindowGeolocation>;
+export declare const formFactor: () => FormFactor;
+export declare const viewportWidth: () => number;
+export declare const viewportHeight: () => number;
+export declare const isAppleDevice: () => boolean;
+export declare const isTouchDevice: () => boolean;
+export declare const isElectron: () => boolean;
+export declare const dpr: () => 2 | 1 | 3;
+export declare const location: () => WindowGeolocation | null;
+export declare const locationError: () => Error | null;
+export declare const gettingLocation: () => boolean;

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

@@ -0,0 +1,6 @@
+import type { Colors, CoreColors } from './types';
+export declare const coreColors: CoreColors;
+export declare const light: Colors;
+export declare const dark: Colors;
+export declare const colorCssVars: Record<keyof Colors, string>;
+export declare const colorClass: Record<keyof Colors, string>;

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

@@ -0,0 +1,174 @@
+export type CoreColors = {
+    'brand-grey-100': string;
+    'brand-grey-200': string;
+    'brand-grey-300': string;
+    'brand-grey-400': string;
+    'brand-grey-50': string;
+    'brand-grey-500': string;
+    'brand-grey-600': string;
+    'brand-grey-700': string;
+    'brand-grey-800': string;
+    'brand-grey-900': string;
+    'brand-grey-950': string;
+    'brand-land-100': string;
+    'brand-land-200': string;
+    'brand-land-300': string;
+    'brand-land-400': string;
+    'brand-land-50': string;
+    'brand-land-500': string;
+    'brand-land-600': string;
+    'brand-land-700': string;
+    'brand-land-800': string;
+    'brand-land-900': string;
+    'brand-land-950': string;
+    'brand-magenta-100': string;
+    'brand-magenta-200': string;
+    'brand-magenta-300': string;
+    'brand-magenta-400': string;
+    'brand-magenta-50': string;
+    'brand-magenta-500': string;
+    'brand-magenta-600': string;
+    'brand-magenta-700': string;
+    'brand-magenta-800': string;
+    'brand-magenta-900': string;
+    'brand-magenta-950': string;
+    'brand-orange-100': string;
+    'brand-orange-200': string;
+    'brand-orange-300': string;
+    'brand-orange-400': string;
+    'brand-orange-50': string;
+    'brand-orange-500': string;
+    'brand-orange-600': string;
+    'brand-orange-700': string;
+    'brand-orange-800': string;
+    'brand-orange-900': string;
+    'brand-orange-950': string;
+    'brand-purple-100': string;
+    'brand-purple-200': string;
+    'brand-purple-300': string;
+    'brand-purple-400': string;
+    'brand-purple-50': string;
+    'brand-purple-500': string;
+    'brand-purple-600': string;
+    'brand-purple-700': string;
+    'brand-purple-800': string;
+    'brand-purple-900': string;
+    'brand-purple-950': string;
+    'brand-sea-100': string;
+    'brand-sea-200': string;
+    'brand-sea-300': string;
+    'brand-sea-400': string;
+    'brand-sea-50': string;
+    'brand-sea-500': string;
+    'brand-sea-600': string;
+    'brand-sea-700': string;
+    'brand-sea-800': string;
+    'brand-sea-900': string;
+    'brand-sea-950': string;
+    'brand-sky-100': string;
+    'brand-sky-200': string;
+    'brand-sky-300': string;
+    'brand-sky-400': string;
+    'brand-sky-50': string;
+    'brand-sky-500': string;
+    'brand-sky-600': string;
+    'brand-sky-700': string;
+    'brand-sky-800': string;
+    'brand-sky-900': string;
+    'brand-sky-950': string;
+    'brand-white-0': string;
+    'brand-yellow-100': string;
+    'brand-yellow-200': string;
+    'brand-yellow-300': string;
+    'brand-yellow-400': string;
+    'brand-yellow-50': string;
+    'brand-yellow-500': string;
+    'brand-yellow-600': string;
+    'brand-yellow-700': string;
+    'brand-yellow-800': string;
+    'brand-yellow-900': string;
+    'brand-yellow-950': string;
+    'product-red-400': string;
+    'product-red-500': string;
+    'core-drop-shadow-light': string;
+    'core-drop-shadow-dark': string;
+    'core-surface-coverup-translucent-light': string;
+    'core-surface-coverup-translucent-dark': string;
+    'core-surface-overlay-translucent-light': string;
+    'core-surface-overlay-translucent-dark': string;
+    'scroll-bar-light': string;
+    'scroll-bar-dark': string;
+    'scroll-bar-hover-light': string;
+    'scroll-bar-hover-dark': string;
+    'surface-shadow-soft-light': string;
+    'surface-shadow-soft-dark': string;
+    'surface-shadow-strong-light': string;
+    'surface-shadow-strong-dark': string;
+};
+export type Colors = {
+    'array-land': string;
+    'array-land-label': string;
+    'array-magenta': string;
+    'array-magenta-label': string;
+    'array-orange': string;
+    'array-orange-label': string;
+    'array-purple': string;
+    'array-purple-label': string;
+    'array-sea': string;
+    'array-sea-label': string;
+    'array-sky': string;
+    'array-sky-label': string;
+    'array-yellow': string;
+    'array-yellow-label': string;
+    'core-badge-primary': string;
+    'core-badge-secondary': string;
+    'core-button-disabled': string;
+    'core-button-primary': string;
+    'core-drop-shadow': string;
+    'core-gp-logo-primary': string;
+    'core-gp-logo-secondary': string;
+    'core-icon-dark': string;
+    'core-icon-disabled': string;
+    'core-icon-error': string;
+    'core-icon-light': string;
+    'core-icon-primary': string;
+    'core-icon-secondary': string;
+    'core-icon-tertiary': string;
+    'core-outline-secondary': string;
+    'core-outline-primary': string;
+    'core-outline-special': string;
+    'core-outline-tertiary': string;
+    'core-surface-coverup-translucent': string;
+    'core-surface-overlay-translucent': string;
+    'core-surface-primary': string;
+    'core-surface-secondary': string;
+    'core-surface-special': string;
+    'core-text-dark': string;
+    'core-text-disabled': string;
+    'core-text-error': string;
+    'core-text-light': string;
+    'core-text-primary': string;
+    'core-text-secondary': string;
+    'core-text-special': string;
+    'core-text-tertiary': string;
+    'core-link-primary': string;
+    'eor-tag-employee': string;
+    'eor-tag-overdue': string;
+    'eor-tag-paid': string;
+    'eor-tag-pending': string;
+    'eor-tag-professional': string;
+    'feedback-attention': string;
+    'feedback-informative': string;
+    'feedback-positive': string;
+    'feedback-urgency': string;
+    'feedback-warning': string;
+    'gia-tag-risk-high': string;
+    'gia-tag-risk-low': string;
+    'gia-tag-risk-moderate': string;
+    'gia-text-excerpt-highlight': string;
+    'gia-text-selection': string;
+    'scroll-bar': string;
+    'scroll-bar-hover': string;
+    'surface-shadow-soft': string;
+    'surface-shadow-strong': string;
+};

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

@@ -0,0 +1,2 @@
+import type { Corners } from './types';
+export declare const corners: Corners;

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

@@ -0,0 +1,10 @@
+export type Corners = {
+    'corner-0': number;
+    'corner-4': number;
+    'corner-6': number;
+    'corner-8': number;
+    'corner-12': number;
+    'corner-16': number;
+    'corner-24': number;
+    'corner-full': number;
+};

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

@@ -0,0 +1,10 @@
+export type Elevations = {
+    'elevation-below-surface': number;
+    'elevation-surface': number;
+    'elevation-float': number;
+    'elevation-describe': number;
+    'elevation-status': number;
+    'elevation-notify': number;
+    'elevation-overlay': number;
+    'elevation-confirm': number;
+};