@rchemist/listgrid 0.2.6

package/dist/listgrid/api/ApiClient.d.ts

@@ -0,0 +1,20 @@
+import type { ResponseData } from './types';
+export type ApiMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export interface ApiRequestOptions {
+    url: string;
+    method?: ApiMethod;
+    formData?: unknown;
+    entityFormName?: string;
+    extensionPoint?: string;
+    serverProxy?: boolean;
+    [key: string]: unknown;
+}
+export interface ApiClient {
+    callExternalHttpRequest<T = any>(options: ApiRequestOptions): Promise<ResponseData<T>>;
+    getExternalApiData<T = any>(urlOrOptions: string | ApiRequestOptions): Promise<ResponseData<T>>;
+    getExternalApiDataWithError<T = any>(urlOrOptions: string | ApiRequestOptions): Promise<ResponseData<T>>;
+}
+export declare function configureApiClient(client: ApiClient): void;
+export declare function callExternalHttpRequest<T = any>(options: ApiRequestOptions): Promise<ResponseData<T>>;
+export declare function getExternalApiData<T = any>(urlOrOptions: string | ApiRequestOptions): Promise<ResponseData<T>>;
+export declare function getExternalApiDataWithError<T = any>(urlOrOptions: string | ApiRequestOptions): Promise<ResponseData<T>>;

package/dist/listgrid/api/ApiClient.js

@@ -0,0 +1,32 @@
+// Stage 5 — Host-supplied API client contract.
+//
+// Listgrid needs to call the RCM-framework backend but cannot itself know
+// about HTTP transport concerns (auth headers, CSRF, base URL, logging,
+// retries). Host apps inject an ApiClient via `configureApiClient(client)`;
+// library code uses the module-level `callExternalHttpRequest` /
+// `getExternalApiData` / `getExternalApiDataWithError` wrappers that
+// delegate to the configured client.
+//
+// This is a module-scope registry (not React Context) because the API is
+// called from static class methods (PageResult.fetchListData, EntityForm
+// initialize) where Context is unavailable.
+let _client;
+export function configureApiClient(client) {
+    _client = client;
+}
+function mustClient(caller) {
+    if (!_client) {
+        throw new Error(`[@rchemist/listgrid] ${caller} called but no ApiClient has been configured. ` +
+            'Call configureApiClient(yourClient) at app bootstrap.');
+    }
+    return _client;
+}
+export function callExternalHttpRequest(options) {
+    return mustClient('callExternalHttpRequest').callExternalHttpRequest(options);
+}
+export function getExternalApiData(urlOrOptions) {
+    return mustClient('getExternalApiData').getExternalApiData(urlOrOptions);
+}
+export function getExternalApiDataWithError(urlOrOptions) {
+    return mustClient('getExternalApiDataWithError').getExternalApiDataWithError(urlOrOptions);
+}

package/dist/listgrid/api/index.d.ts

@@ -0,0 +1,4 @@
+export type { IEntityError, IEntityErrorBody } from './types';
+export { ResponseData, createResponseData } from './types';
+export type { ApiMethod, ApiRequestOptions, ApiClient } from './ApiClient';
+export { configureApiClient, callExternalHttpRequest, getExternalApiData, getExternalApiDataWithError, } from './ApiClient';

package/dist/listgrid/api/index.js

@@ -0,0 +1,2 @@
+export { ResponseData, createResponseData } from './types';
+export { configureApiClient, callExternalHttpRequest, getExternalApiData, getExternalApiDataWithError, } from './ApiClient';

package/dist/listgrid/api/types.d.ts

@@ -0,0 +1,21 @@
+export interface IEntityError {
+    error: IEntityErrorBody;
+    [key: string]: unknown;
+}
+export interface IEntityErrorBody {
+    error?: boolean | string;
+    message?: string;
+    fieldError?: Map<string, string[]> | Record<string, string[]>;
+    [key: string]: unknown;
+}
+export declare class ResponseData<T = any> {
+    data: T;
+    status?: number;
+    error?: string;
+    entityError?: IEntityError;
+    constructor(init?: Partial<ResponseData<T>>);
+    isError(): boolean;
+}
+export declare function createResponseData<T = any>(init: Partial<ResponseData<T>> & {
+    data?: T;
+}): ResponseData<T>;

package/dist/listgrid/api/types.js

@@ -0,0 +1,30 @@
+// Stage 5 — Backend contract types.
+//
+// The RCM-framework backend returns a consistent response shape across
+// CRUD endpoints. `ResponseData` wraps the payload + metadata and
+// exposes `isError()` as a convenience for call sites that predate the
+// optional `error` / `entityError` fields.
+//
+// Host applications inject a concrete ApiClient (see ApiClient.ts) that
+// produces ResponseData instances from HTTP calls; listgrid code consumes
+// the shape but never constructs a real HTTP layer.
+// ResponseData is a class so call sites can `new ResponseData()` to construct
+// synthetic responses (e.g. client-side 500s when session is missing).
+// The legacy ResponseData was also a class; instance methods like
+// `isError()` are preserved.
+// T defaults to `any` — callers dereference `response.data.field` directly
+// on generic entity payloads. Tightening to `unknown` breaks downstream
+// components.
+export class ResponseData {
+    constructor(init) {
+        this.data = null;
+        if (init)
+            Object.assign(this, init);
+    }
+    isError() {
+        return !!(this.error || this.entityError || (this.status && this.status >= 400));
+    }
+}
+export function createResponseData(init) {
+    return new ResponseData(init);
+}

package/dist/listgrid/auth/AuthContext.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import type { Session } from './types';
+export interface AuthContextValue {
+    readonly session: Session | undefined;
+}
+export interface AuthProviderProps {
+    session: Session | undefined;
+    children: ReactNode;
+}
+export declare function AuthProvider({ session, children }: AuthProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useSession(): Session | undefined;
+export declare function useAuth(): AuthContextValue;

package/dist/listgrid/auth/AuthContext.js

@@ -0,0 +1,25 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+// Sentinel for "no provider" so undefined can legitimately mean "no session".
+const NO_PROVIDER = Symbol('rcm-listgrid-no-auth-provider');
+const AuthContext = createContext(NO_PROVIDER);
+export function AuthProvider({ session, children }) {
+    return _jsx(AuthContext.Provider, { value: { session }, children: children });
+}
+export function useSession() {
+    const ctx = useContext(AuthContext);
+    if (ctx === NO_PROVIDER) {
+        throw new Error('[@rchemist/listgrid] useSession must be called within an <AuthProvider>. ' +
+            'Wrap your app with <AuthProvider session={...}> imported from @rchemist/listgrid.');
+    }
+    return ctx.session;
+}
+export function useAuth() {
+    const ctx = useContext(AuthContext);
+    if (ctx === NO_PROVIDER) {
+        throw new Error('[@rchemist/listgrid] useAuth must be called within an <AuthProvider>. ' +
+            'Wrap your app with <AuthProvider session={...}> imported from @rchemist/listgrid.');
+    }
+    return ctx;
+}

package/dist/listgrid/auth/SessionProvider.d.ts

@@ -0,0 +1,4 @@
+type SignOutFn = () => Promise<void> | void;
+export declare function registerSignOut(fn: SignOutFn): void;
+export declare function signOut(): Promise<void>;
+export {};

package/dist/listgrid/auth/SessionProvider.js

@@ -0,0 +1,16 @@
+// Stage 3a placeholder for host-supplied signOut().
+// Non-component code (e.g. PageResult.fetchListData) cannot read React context,
+// so sign-out needs a module-scope registry. Full integration lands in Stage 5
+// (ApiClientProvider / host services registry).
+let _signOut;
+export function registerSignOut(fn) {
+    _signOut = fn;
+}
+export async function signOut() {
+    if (_signOut) {
+        await _signOut();
+        return;
+    }
+    console.warn('[@rchemist/listgrid] signOut() called but no host implementation is registered. ' +
+        'Call registerSignOut(yourImpl) at app bootstrap.');
+}

package/dist/listgrid/auth/index.d.ts

@@ -0,0 +1,6 @@
+export type { Session, SessionUser } from './types';
+export { AuthProvider, useSession, useAuth } from './AuthContext';
+export type { AuthContextValue, AuthProviderProps } from './AuthContext';
+export { registerSignOut, signOut } from './SessionProvider';
+import type { Session } from './types';
+export declare function hasAnyRole(session: Session | undefined | null, ...allowedRoles: string[]): boolean;

package/dist/listgrid/auth/index.js

@@ -0,0 +1,17 @@
+export { AuthProvider, useSession, useAuth } from './AuthContext';
+export { registerSignOut, signOut } from './SessionProvider';
+export function hasAnyRole(session, ...allowedRoles) {
+    if (!session)
+        return false;
+    const user = typeof session.getUser === 'function' ? session.getUser() : undefined;
+    const roles = user?.roles ?? session.roles ?? session.authentication?.roles;
+    if (Array.isArray(roles)) {
+        return roles.some((role) => allowedRoles.includes(role));
+    }
+    const userType = user?.userType ?? session.userType;
+    if (userType) {
+        const normalized = userType.startsWith('ROLE_') ? userType : `ROLE_${userType}`;
+        return allowedRoles.includes(normalized);
+    }
+    return false;
+}

package/dist/listgrid/auth/types.d.ts

@@ -0,0 +1,15 @@
+export interface SessionUser {
+    id?: string | number;
+    name?: string;
+    roles?: string[];
+    [key: string]: unknown;
+}
+export interface Session {
+    roles?: string[];
+    authentication?: {
+        roles?: string[];
+        [key: string]: unknown;
+    };
+    getUser?: () => SessionUser | null | undefined;
+    [key: string]: unknown;
+}

package/dist/listgrid/auth/types.js

@@ -0,0 +1,12 @@
+// Auth contract consumed by @rchemist/listgrid.
+//
+// Host applications provide a concrete Session implementation via <AuthProvider>.
+// The shape mirrors the original listgrid usage: roles can live directly on
+// the session or under `authentication.roles`, and `getUser()` is expected
+// to be present (host apps with plain session objects should wrap their data
+// before passing to AuthProvider).
+//
+// The [key: string]: unknown index signature lets host apps pass richer Session
+// objects without type errors. ListGrid itself only reads the fields declared
+// explicitly below.
+export {};

package/dist/listgrid/common/func.d.ts

@@ -0,0 +1,16 @@
+import { AdditionalColorType, ColorType, GutterType, ResponsiveValue, ShapeType, SizeType, VariantType, WindowPositionType } from './type';
+export declare function getWindowPositionClassName(position: WindowPositionType): string;
+export declare function isAdditionalColorType(color: string): color is AdditionalColorType | ColorType;
+export declare function getAdditionalColorClass(color: string): "bg-dark" | "bg-gray" | "bg-red" | "bg-pink" | "bg-grape" | "bg-violet" | "bg-indigo" | "bg-blue" | "bg-cyan" | "bg-green" | "bg-lime" | "bg-yellow" | "bg-orange" | "bg-teal" | "bg-black" | "bg-white border" | "bg-primary" | "bg-info" | "bg-success" | "bg-warning" | "bg-danger" | "bg-secondary";
+export declare function getTextColorClass(color: string): "text-dark" | "text-gray" | "text-red" | "text-pink" | "text-grape" | "text-violet" | "text-indigo" | "text-blue" | "text-cyan" | "text-green" | "text-lime" | "text-yellow" | "text-orange" | "text-teal" | "text-black" | "text-white" | "text-primary" | "text-info" | "text-success" | "text-warning" | "text-danger" | "text-secondary";
+export declare function getOppositeTextColorClass(color: string): "text-dark" | "text-white";
+export declare function getOrderedColorType(num: number): ColorType | undefined;
+export declare function getBgColor(color: ColorType | AdditionalColorType | string): string;
+export declare function getColorSuffix(color: ColorType | string): string;
+export declare function getMaxWidthClassName(size: SizeType | undefined): string;
+export declare function getAlignClassName(alignType: 'left' | 'center' | 'right', flex?: boolean): "justify-start" | "justify-center" | "justify-end" | "text-left" | "text-center" | "text-right";
+export declare function getGutterValue(gutter: GutterType): string;
+export declare function getResponsiveClasses(value: ResponsiveValue<string | number>, prefix: string, valueMap?: Record<string, string> | ((val: string | number) => string)): string;
+export declare function getShapeClassName(shape: ShapeType): string;
+export declare function getSizeClassName(size: SizeType): string;
+export declare function getColorClass(color: ColorType | string, variant: VariantType): string;

package/dist/listgrid/common/func.js

@@ -0,0 +1,351 @@
+import { AdditionalColorTypes, ColorTypes, } from './type';
+const valign = {
+    top: 'items-start',
+    center: 'items-center',
+    bottom: 'items-end',
+};
+const justifyAlign = {
+    left: 'justify-start',
+    center: 'justify-center',
+    right: 'justify-end',
+};
+export function getWindowPositionClassName(position) {
+    // use tailwindCss
+    switch (position) {
+        case 'center':
+            return `${valign.center} ${justifyAlign.center} `;
+        case 'top':
+            return `${valign.top} ${justifyAlign.center} `;
+        case 'top-left':
+            return `${valign.top} ${justifyAlign.left} `;
+        case 'top-right':
+            return `${valign.top} ${justifyAlign.right} `;
+        case 'top-center':
+            return `${valign.top} ${justifyAlign.center} `;
+        case 'bottom':
+            return `${valign.bottom} ${justifyAlign.center} `;
+        case 'bottom-left':
+            return `${valign.bottom} ${justifyAlign.left} `;
+        case 'bottom-right':
+            return `${valign.bottom} ${justifyAlign.right} `;
+        case 'center-left':
+            return `${valign.center} ${justifyAlign.left} `;
+        case 'center-right':
+            return `${valign.center} ${justifyAlign.right} `;
+    }
+}
+export function isAdditionalColorType(color) {
+    return (AdditionalColorTypes.includes(color) ||
+        ColorTypes.includes(color));
+}
+export function getAdditionalColorClass(color) {
+    color = isAdditionalColorType(color) ? color : 'primary';
+    switch (color) {
+        case 'dark':
+            return 'bg-dark';
+        case 'gray':
+            return 'bg-gray';
+        case 'red':
+            return 'bg-red';
+        case 'pink':
+            return 'bg-pink';
+        case 'grape':
+            return 'bg-grape';
+        case 'violet':
+            return 'bg-violet';
+        case 'indigo':
+            return 'bg-indigo';
+        case 'blue':
+            return 'bg-blue';
+        case 'cyan':
+            return 'bg-cyan';
+        case 'green':
+            return 'bg-green';
+        case 'lime':
+            return 'bg-lime';
+        case 'yellow':
+            return 'bg-yellow';
+        case 'orange':
+            return 'bg-orange';
+        case 'teal':
+            return 'bg-teal';
+        case 'black':
+            return 'bg-black';
+        case 'white':
+            return 'bg-white border';
+        case 'primary':
+            return 'bg-primary';
+        case 'info':
+            return 'bg-info';
+        case 'success':
+            return 'bg-success';
+        case 'warning':
+            return 'bg-warning';
+        case 'danger':
+            return 'bg-danger';
+        case 'secondary':
+            return 'bg-secondary';
+        default:
+            return 'bg-indigo';
+    }
+}
+export function getTextColorClass(color) {
+    color = isAdditionalColorType(color) ? color : 'primary';
+    switch (color) {
+        case 'dark':
+            return 'text-dark';
+        case 'gray':
+            return 'text-gray';
+        case 'red':
+            return 'text-red';
+        case 'pink':
+            return 'text-pink';
+        case 'grape':
+            return 'text-grape';
+        case 'violet':
+            return 'text-violet';
+        case 'indigo':
+            return 'text-indigo';
+        case 'blue':
+            return 'text-blue';
+        case 'cyan':
+            return 'text-cyan';
+        case 'green':
+            return 'text-green';
+        case 'lime':
+            return 'text-lime';
+        case 'yellow':
+            return 'text-yellow';
+        case 'orange':
+            return 'text-orange';
+        case 'teal':
+            return 'text-teal';
+        case 'black':
+            return 'text-black';
+        case 'white':
+            return 'text-white';
+        case 'primary':
+            return 'text-primary';
+        case 'info':
+            return 'text-info';
+        case 'success':
+            return 'text-success';
+        case 'warning':
+            return 'text-warning';
+        case 'danger':
+            return 'text-danger';
+        case 'secondary':
+            return 'text-secondary';
+        default:
+            return 'text-indigo';
+    }
+}
+export function getOppositeTextColorClass(color) {
+    color = isAdditionalColorType(color) ? color : 'primary';
+    switch (color) {
+        case 'dark':
+            return 'text-white';
+        case 'gray':
+            return 'text-white';
+        case 'red':
+            return 'text-white';
+        case 'pink':
+            return 'text-white';
+        case 'grape':
+            return 'text-white';
+        case 'violet':
+            return 'text-white';
+        case 'indigo':
+            return 'text-white';
+        case 'blue':
+            return 'text-white';
+        case 'cyan':
+            return 'text-white';
+        case 'green':
+            return 'text-white';
+        case 'lime':
+            return 'text-white';
+        case 'yellow':
+            return 'text-white';
+        case 'orange':
+            return 'text-white';
+        case 'teal':
+            return 'text-white';
+        case 'black':
+            return 'text-white';
+        case 'white':
+            return 'text-dark';
+        case 'primary':
+            return 'text-white';
+        case 'info':
+            return 'text-white';
+        case 'success':
+            return 'text-white';
+        case 'warning':
+            return 'text-white';
+        case 'danger':
+            return 'text-white';
+        case 'secondary':
+            return 'text-white';
+        default:
+            return 'text-dark';
+    }
+}
+export function getOrderedColorType(num) {
+    // num 은 0 부터 ColorTypes.length - 1 까지
+    return ColorTypes[num % ColorTypes.length];
+}
+const bgColorClasses = {
+    primary: 'bg-primary',
+    info: 'bg-info',
+    success: 'bg-success',
+    warning: 'bg-warning',
+    danger: 'bg-danger',
+    secondary: 'bg-secondary',
+    dark: 'bg-dark',
+};
+export function getBgColor(color) {
+    if (bgColorClasses[color]) {
+        return bgColorClasses[color];
+    }
+    if (AdditionalColorTypes.includes(color)) {
+        return getAdditionalColorClass(color);
+    }
+    const colorValue = color.startsWith('#') ? color.slice(1) : color;
+    return `bg-[#${colorValue}]`;
+}
+export function getColorSuffix(color) {
+    return color.startsWith('#') ? `[${color}]` : color;
+}
+export function getMaxWidthClassName(size) {
+    switch (size) {
+        case 'xs':
+            return 'max-w-xs';
+        case 'sm':
+            return 'max-w-sm';
+        case 'md':
+            return 'max-w-md';
+        case 'lg':
+            return 'max-w-lg';
+        case 'xl':
+            return 'max-w-xl';
+        case '2xl':
+            return 'max-w-2xl';
+        case '3xl':
+            return 'max-w-3xl';
+        case '4xl':
+            return 'max-w-4xl';
+        case '5xl':
+            return 'max-w-5xl';
+        case '6xl':
+            return 'max-w-6xl';
+        case 'full':
+            return 'max-w-full';
+        default:
+            return 'max-w-md';
+    }
+}
+export function getAlignClassName(alignType, flex) {
+    if (flex) {
+        return alignType === 'left'
+            ? 'justify-start'
+            : alignType === 'center'
+                ? 'justify-center'
+                : 'justify-end';
+    }
+    return alignType === 'left' ? 'text-left' : alignType === 'center' ? 'text-center' : 'text-right';
+}
+export function getGutterValue(gutter) {
+    if (typeof gutter === 'number') {
+        return gutter.toString();
+    }
+    switch (gutter) {
+        case 'xs':
+            return '0.5rem';
+        case 'sm':
+            return '1rem';
+        case 'md':
+            return '1.5rem';
+        case 'lg':
+            return '2rem';
+        case 'xl':
+            return '3rem';
+        default:
+            return '1rem';
+    }
+}
+export function getResponsiveClasses(value, prefix, valueMap) {
+    const getValue = (val) => {
+        if (typeof valueMap === 'function') {
+            return valueMap(val);
+        }
+        if (typeof valueMap === 'object' && valueMap !== null && val in valueMap) {
+            return valueMap[val];
+        }
+        return val.toString();
+    };
+    if (typeof value === 'object' && value !== null) {
+        const classes = [];
+        if (value.base)
+            classes.push(`${prefix}-${getValue(value.base)}`);
+        if (value.xs)
+            classes.push(`sm:${prefix}-${getValue(value.xs)}`);
+        if (value.sm)
+            classes.push(`sm:${prefix}-${getValue(value.sm)}`);
+        if (value.md)
+            classes.push(`md:${prefix}-${getValue(value.md)}`);
+        if (value.lg)
+            classes.push(`lg:${prefix}-${getValue(value.lg)}`);
+        if (value.xl)
+            classes.push(`xl:${prefix}-${getValue(value.xl)}`);
+        return classes.join(' ');
+    }
+    return `${prefix}-${getValue(value)}`;
+}
+export function getShapeClassName(shape) {
+    switch (shape) {
+        case 'pill':
+            return 'rounded-full';
+        case 'box':
+            return 'rounded-none';
+        case 'rounded':
+            return 'rounded';
+        default:
+            return 'rounded';
+    }
+}
+export function getSizeClassName(size) {
+    switch (size) {
+        case 'xs':
+            return 'px-2 py-1 text-xs';
+        case 'sm':
+            return 'px-3 py-1.5 text-sm';
+        case 'md':
+            return 'px-4 py-2 text-sm';
+        case 'lg':
+            return 'px-6 py-3 text-base';
+        case 'xl':
+            return 'px-8 py-4 text-lg';
+        case '2xl':
+            return 'px-10 py-5 text-xl';
+        case '5xl':
+            return 'px-16 py-8 text-3xl';
+        case 'full':
+            return 'w-full h-full';
+        default:
+            return 'px-4 py-2 text-sm';
+    }
+}
+export function getColorClass(color, variant) {
+    const baseColor = isAdditionalColorType(color) ? color : 'primary';
+    switch (variant) {
+        case 'filled':
+            return `${getAdditionalColorClass(baseColor)} ${getOppositeTextColorClass(baseColor)}`;
+        case 'outline':
+            return `border border-${baseColor} ${getTextColorClass(baseColor)} bg-transparent`;
+        case 'solid':
+            return `bg-${baseColor} text-white`;
+        default:
+            return `${getAdditionalColorClass(baseColor)} ${getOppositeTextColorClass(baseColor)}`;
+    }
+}

package/dist/listgrid/common/type.d.ts

@@ -0,0 +1,35 @@
+export type WindowPositionType = 'center' | 'top' | 'top-left' | 'top-right' | 'top-center' | 'bottom' | 'bottom-left' | 'bottom-right' | 'center-left' | 'center-right';
+export type PlacementType = 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'right-start' | 'right-end' | 'left-start' | 'left-end';
+export type ColorType = 'primary' | 'info' | 'success' | 'warning' | 'danger' | 'secondary' | 'dark';
+export type AdditionalColorType = 'dark' | 'gray' | 'red' | 'pink' | 'grape' | 'violet' | 'indigo' | 'blue' | 'cyan' | 'green' | 'lime' | 'yellow' | 'orange' | 'teal' | 'black' | 'white';
+export type SizeType = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | 'full';
+export type TextAlignType = 'left' | 'center' | 'right';
+export type SpanValue = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export type FlexAlign = 'flex-start' | 'flex-end' | 'center' | 'baseline' | 'stretch';
+export type FlexJustify = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+export type FlexDirection = 'row' | 'row-reverse' | 'column' | 'column-reverse';
+export type FlexWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
+export type GridAlign = 'start' | 'end' | 'center' | 'stretch' | 'baseline';
+export type GridJustify = 'start' | 'end' | 'center' | 'stretch' | 'space-between' | 'space-around' | 'space-evenly';
+export type GridDirection = 'row' | 'row-reverse' | 'column' | 'column-reverse';
+export type GridWrap = 'nowrap' | 'wrap' | 'wrap-reverse';
+export type GutterType = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+export type SpacingType = number | string;
+export type ResponsiveValue<T> = T | {
+    base?: T;
+    xs?: T;
+    sm?: T;
+    md?: T;
+    lg?: T;
+    xl?: T;
+};
+export type PopoverPosition = PlacementType | 'top' | 'bottom' | 'left' | 'right';
+export type PopoverShadow = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type VariantType = 'filled' | 'outline' | 'solid';
+export type ShapeType = 'pill' | 'box' | 'rounded';
+export declare const ColorTypes: ColorType[];
+export declare const AdditionalColorTypes: AdditionalColorType[];
+export declare const AllColorTypes: (ColorType | AdditionalColorType)[];
+export declare const VariantTypes: VariantType[];
+export declare const ShapeTypes: ShapeType[];
+export declare const SizeTypes: SizeType[];