stoop 0.1.0 → 0.2.1

package/dist/types/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Core TypeScript type definitions for Stoop.
+ * Defines CSS objects, themes, variants, styled components, and instance types.
+ */
+import type { ComponentType, ElementType, JSX, ReactNode } from "react";
+import type { PolymorphicPropsWithRef } from "react-polymorphic-types";
+import type { createTheme } from "../api/create-theme";
+import type { createCSSFunction } from "../api/css";
+import type { createGlobalCSSFunction } from "../api/global-css";
+import type { createKeyframesFunction } from "../api/keyframes";
+import type { createStyledFunction } from "../api/styled";
+export type CSSPropertyValue = string | number;
+export interface StyledComponentRef {
+    readonly __stoopClassName: string;
+    readonly __isStoopStyled: true;
+    toString(): string;
+}
+export interface CSS {
+    [property: string]: CSSPropertyValue | CSS | Variants | unknown[] | undefined;
+}
+export interface Variants {
+    [variantName: string]: {
+        [variantValue: string]: CSS;
+    };
+}
+export interface VariantProps {
+    [variantName: string]: string | number | boolean | undefined;
+}
+export type HTMLElements = keyof JSX.IntrinsicElements;
+export type StylableElement = HTMLElements | ElementType;
+export interface StyledBaseProps {
+    css?: CSS;
+}
+export type UtilityFunction = (value: CSSPropertyValue | CSS | undefined) => CSS;
+/**
+ * Theme scale type - represents valid keys from DefaultTheme.
+ * Used for type-safe theme scale references throughout the codebase.
+ */
+export type ThemeScale = keyof DefaultTheme;
+/**
+ * Theme interface - strictly enforces only these 12 approved scales.
+ * Custom theme scales are NOT allowed.
+ * Media queries are also supported as part of the theme.
+ */
+export interface DefaultTheme {
+    colors?: Record<string, string>;
+    opacities?: Record<string, string | number>;
+    space?: Record<string, string>;
+    radii?: Record<string, string>;
+    sizes?: Record<string, string>;
+    fonts?: Record<string, string>;
+    fontWeights?: Record<string, string | number>;
+    fontSizes?: Record<string, string>;
+    letterSpacings?: Record<string, string>;
+    shadows?: Record<string, string>;
+    zIndices?: Record<string, string | number>;
+    transitions?: Record<string, string>;
+    media?: Record<string, string>;
+}
+/**
+ * Theme type - strictly enforces DefaultTheme structure.
+ * No custom scales are allowed.
+ */
+export type Theme = DefaultTheme;
+export interface StoopConfig {
+    theme: DefaultTheme;
+    themes?: Record<string, DefaultTheme>;
+    media?: Record<string, string>;
+    utils?: Record<string, UtilityFunction>;
+    prefix?: string;
+    themeMap?: Record<string, ThemeScale>;
+}
+export type VariantKeys<T extends Variants> = keyof T;
+export type VariantPropsFromConfig<T extends Variants> = {
+    [K in VariantKeys<T>]?: keyof T[K] | boolean | number;
+};
+type StyledOwnProps<VariantsConfig extends Variants> = StyledBaseProps & (VariantsConfig extends Record<string, never> ? {} : VariantPropsFromConfig<VariantsConfig>);
+export type StyledComponentProps<DefaultElement extends ElementType, VariantsConfig extends Variants = {}> = PolymorphicPropsWithRef<StyledOwnProps<VariantsConfig>, DefaultElement>;
+export interface ThemeContextValue {
+    theme: Theme;
+    themeName?: string;
+}
+export interface ThemeManagementContextValue {
+    theme: Theme;
+    themeName: string;
+    setTheme: (themeName: string) => void;
+    toggleTheme: () => void;
+    availableThemes: readonly string[];
+}
+export interface GetCssTextOptions {
+    theme?: Theme;
+    includeThemeVars?: boolean;
+}
+export interface ProviderProps {
+    children: ReactNode;
+    defaultTheme?: string;
+    storageKey?: string;
+    attribute?: string;
+}
+export interface StoopInstance {
+    styled: ReturnType<typeof createStyledFunction>;
+    css: ReturnType<typeof createCSSFunction>;
+    createTheme: ReturnType<typeof createTheme>;
+    globalCss: ReturnType<typeof createGlobalCSSFunction>;
+    keyframes: ReturnType<typeof createKeyframesFunction>;
+    theme: DefaultTheme;
+    /**
+     * Gets all generated CSS text for server-side rendering.
+     * Always includes theme CSS variables.
+     *
+     * @param theme - Optional theme (name or object) to include vars for (defaults to default theme)
+     * @returns CSS text string with theme variables and component styles
+     */
+    getCssText: (theme?: string | Theme) => string;
+    config: StoopConfig;
+    /**
+     * Pre-compiles CSS objects to warm the cache.
+     * Useful for eliminating FOUC by pre-compiling common styles.
+     *
+     * @param styles - Array of CSS objects to pre-compile
+     */
+    warmCache: (styles: CSS[]) => void;
+    /**
+     * Preloads a theme by injecting its CSS variables before React renders.
+     * Useful for preventing FOUC when loading a non-default theme from localStorage.
+     *
+     * @param theme - Theme to preload (theme name string or Theme object)
+     */
+    preloadTheme: (theme: string | Theme) => void;
+    /**
+     * Provider component for managing theme state and updates.
+     * Only available if themes were provided in createStoop config.
+     */
+    Provider?: ComponentType<ProviderProps>;
+    /**
+     * Hook to access theme management context.
+     * Only available if themes were provided in createStoop config.
+     */
+    useTheme?: () => ThemeManagementContextValue;
+}
+export {};

package/dist/types/react-polymorphic-types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type declaration for react-polymorphic-types to work around package.json exports issue.
+ */
+
+declare module "react-polymorphic-types" {
+  import type { ElementType, ComponentPropsWithRef, ComponentPropsWithoutRef } from "react";
+
+  export type PolymorphicPropsWithRef<
+    OwnProps,
+    DefaultElement extends ElementType,
+  > = OwnProps & ComponentPropsWithRef<DefaultElement>;
+
+  export type PolymorphicPropsWithoutRef<
+    OwnProps,
+    DefaultElement extends ElementType,
+  > = OwnProps & ComponentPropsWithoutRef<DefaultElement>;
+}

package/dist/utils/string.d.ts

@@ -0,0 +1,102 @@
+/**
+ * String utility functions.
+ * Provides hashing for class name generation, camelCase to kebab-case conversion,
+ * and CSS sanitization utilities for security.
+ */
+/**
+ * Generates a hash string from an input string.
+ *
+ * @param str - String to hash
+ * @returns Hashed string
+ */
+export declare function hash(str: string): string;
+/**
+ * Generates a hash string from an object by stringifying it.
+ *
+ * @param obj - Object to hash
+ * @returns Hashed string
+ */
+export declare function hashObject(obj: unknown): string;
+/**
+ * Converts a camelCase string to kebab-case.
+ *
+ * @param str - String to convert
+ * @returns Kebab-case string
+ */
+export declare function toKebabCase(str: string): string;
+/**
+ * Escapes CSS property values to prevent injection attacks.
+ * Escapes quotes, semicolons, and other special characters.
+ *
+ * @param value - Value to escape
+ * @returns Escaped value string
+ */
+export declare function escapeCSSValue(value: string | number): string;
+/**
+ * Validates and sanitizes CSS selectors to prevent injection attacks.
+ * Only allows safe selector characters. Returns empty string for invalid selectors.
+ *
+ * @param selector - Selector to sanitize
+ * @returns Sanitized selector string or empty string if invalid
+ */
+export declare function sanitizeCSSSelector(selector: string): string;
+/**
+ * Validates and sanitizes CSS variable names to prevent injection attacks.
+ * CSS custom properties must start with -- and contain only valid characters.
+ *
+ * @param name - Variable name to sanitize
+ * @returns Sanitized variable name
+ */
+export declare function sanitizeCSSVariableName(name: string): string;
+/**
+ * Escapes CSS variable values to prevent injection attacks.
+ *
+ * @param value - Value to escape
+ * @returns Escaped value string
+ */
+export declare function escapeCSSVariableValue(value: string | number): string;
+/**
+ * Sanitizes prefix for use in CSS selectors and class names.
+ * Only allows alphanumeric characters, hyphens, and underscores.
+ *
+ * @param prefix - Prefix to sanitize
+ * @returns Sanitized prefix string
+ */
+export declare function sanitizePrefix(prefix: string): string;
+/**
+ * Escapes prefix for use in CSS attribute selectors.
+ *
+ * @param prefix - Prefix to escape
+ * @returns Escaped prefix string
+ */
+export declare function escapePrefixForSelector(prefix: string): string;
+/**
+ * Sanitizes media query strings to prevent injection attacks.
+ * Only allows safe characters for media queries.
+ *
+ * @param mediaQuery - Media query string to sanitize
+ * @returns Sanitized media query string or empty string if invalid
+ */
+export declare function sanitizeMediaQuery(mediaQuery: string): string;
+/**
+ * Sanitizes CSS class names to prevent injection attacks.
+ * Only allows valid CSS class name characters.
+ *
+ * @param className - Class name(s) to sanitize
+ * @returns Sanitized class name string
+ */
+export declare function sanitizeClassName(className: string): string;
+/**
+ * Sanitizes CSS property names to prevent injection attacks.
+ *
+ * @param propertyName - Property name to sanitize
+ * @returns Sanitized property name
+ */
+export declare function sanitizeCSSPropertyName(propertyName: string): string;
+/**
+ * Validates keyframe percentage keys (e.g., "0%", "50%", "from", "to").
+ *
+ * @param key - Keyframe key to validate
+ * @returns True if key is valid
+ */
+export declare function validateKeyframeKey(key: string): boolean;

package/dist/utils/theme-map.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ThemeMap utilities for property-aware token resolution.
+ * Maps CSS properties to theme scales for deterministic token resolution.
+ */
+import type { ThemeScale } from "../types";
+import { APPROVED_THEME_SCALES, DEFAULT_THEME_MAP } from "../constants";
+export { APPROVED_THEME_SCALES, DEFAULT_THEME_MAP };
+export type { ThemeScale };
+/**
+ * Auto-detects theme scale from CSS property name using pattern matching.
+ * Used as fallback when property is not in DEFAULT_THEME_MAP.
+ *
+ * @param property - CSS property name
+ * @returns Theme scale name or undefined if no pattern matches
+ */
+export declare function autoDetectScale(property: string): ThemeScale | undefined;
+/**
+ * Gets the theme scale for a CSS property.
+ * Checks user themeMap first, then default themeMap, then pattern matching.
+ *
+ * @param property - CSS property name
+ * @param userThemeMap - Optional user-provided themeMap override
+ * @returns Theme scale name or undefined if no mapping found
+ */
+export declare function getScaleForProperty(property: string, userThemeMap?: Record<string, ThemeScale>): ThemeScale | undefined;

package/dist/utils/theme-validation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Theme validation utilities.
+ * Ensures theme objects only contain approved scales.
+ */
+import type { DefaultTheme } from "../types";
+/**
+ * Validates that a theme object only contains approved scales.
+ *
+ * @param theme - Theme object to validate
+ * @returns Validated theme as DefaultTheme
+ * @throws Error if theme contains invalid scales (in development)
+ */
+export declare function validateTheme(theme: unknown): DefaultTheme;

package/dist/utils/theme.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Theme token resolution utilities.
+ * Converts theme tokens to CSS variables for runtime theme switching.
+ * Uses cached token index for efficient lookups and theme comparison.
+ */
+import type { CSS, Theme, ThemeScale } from "../types";
+/**
+ * Compares two themes for equality by structure and values.
+ * Excludes 'media' property from comparison since it's not a CSS variable scale.
+ *
+ * @param theme1 - First theme to compare
+ * @param theme2 - Second theme to compare
+ * @returns True if themes are equal, false otherwise
+ */
+export declare function themesAreEqual(theme1: Theme | null, theme2: Theme | null): boolean;
+/**
+ * Converts a theme token string to a CSS variable reference.
+ *
+ * @param token - Token string (e.g., "$primary" or "$colors$primary")
+ * @param theme - Optional theme for token resolution
+ * @param property - Optional CSS property name for scale detection
+ * @param themeMap - Optional theme scale mappings
+ * @returns CSS variable reference string
+ */
+export declare function tokenToCSSVar(token: string, theme?: Theme, property?: string, themeMap?: Record<string, ThemeScale>): string;
+/**
+ * Generates CSS custom properties from a theme object.
+ *
+ * @param theme - Theme object to convert to CSS variables
+ * @param prefix - Optional prefix for CSS variable names
+ * @returns CSS string with :root selector and CSS variables
+ */
+export declare function generateCSSVariables(theme: Theme, prefix?: string): string;
+/**
+ * Recursively replaces theme tokens with CSS variable references in a CSS object.
+ *
+ * @param obj - CSS object to process
+ * @param theme - Optional theme for token resolution
+ * @param themeMap - Optional theme scale mappings
+ * @param property - Optional CSS property name for scale detection
+ * @returns CSS object with tokens replaced by CSS variables
+ */
+export declare function replaceThemeTokensWithVars(obj: CSS, theme?: Theme, themeMap?: Record<string, ThemeScale>, property?: string): CSS;

package/dist/utils/type-guards.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Type guard utilities.
+ * Provides runtime type checking for CSS objects, themes, and styled component references.
+ */
+import type { CSS, Theme } from "../types";
+/**
+ * Type guard for CSS objects.
+ *
+ * @param value - Value to check
+ * @returns True if value is a CSS object
+ */
+export declare function isCSSObject(value: unknown): value is CSS;
+/**
+ * Type guard for valid CSS objects (excludes styled component references).
+ *
+ * @param value - Value to check
+ * @returns True if value is a valid CSS object
+ */
+export declare function isValidCSSObject(value: unknown): value is CSS;
+/**
+ * Type guard for theme objects.
+ *
+ * @param value - Value to check
+ * @returns True if value is a theme object
+ */
+export declare function isThemeObject(value: unknown): value is Theme;

package/dist/utils/utilities.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Utility function application.
+ * Applies utility functions (e.g., px, py) to transform shorthand properties into CSS.
+ * Recursively processes nested CSS objects.
+ */
+import type { CSS, UtilityFunction } from "../types";
+/**
+ * Applies utility functions to transform shorthand properties into CSS.
+ *
+ * @param styles - CSS object to process
+ * @param utils - Optional utility functions object
+ * @returns CSS object with utilities applied
+ */
+export declare function applyUtilities(styles: CSS, utils?: Record<string, UtilityFunction>): CSS;

package/package.json

@@ -1,14 +1,32 @@
 {
   "name": "stoop",
-  "description": "A lightweight, polymorphic React component library with intuitive design tokens and built-in styling system.",
-  "version": "0.1.0",
+  "description": "CSS-in-JS library with type inference, theme creation, and variants support.",
+  "version": "0.2.1",
   "author": "Jackson Dolman <mail@dolmios.com>",
-  "license": "MIT",
-  "type": "module",
-  "sideEffects": false,
   "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dolmios/stoop.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dolmios/stoop/issues"
+  },
+  "homepage": "https://github.com/dolmios/stoop#readme",
+  "dependencies": {
+    "react-polymorphic-types": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.17.0",
+    "@types/react": "^19.1.9",
+    "@types/react-dom": "^19.1.7",
+    "bun-types": "^1.2.19",
+    "eslint": "^9.32.0",
+    "eslint-config-dolmios": "^2.0.10",
+    "prettier": "^3.6.2",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "typescript": "^5.9.2"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -20,46 +38,52 @@
     "dist"
   ],
   "keywords": [
+    "css variables",
+    "css-in-ts",
+    "css-in-ts alternative",
+    "css-in-js",
+    "css-in-js alternative",
+    "emotion",
+    "emotion alternative",
+    "lightweight",
+    "minimal",
+    "next.js",
+    "nextjs",
+    "performance",
     "react",
-    "components",
-    "ui",
-    "design-system",
+    "react styling",
+    "stitches",
+    "stitches alternative",
+    "stitches-alternative",
     "styled-components",
-    "polymorphic",
-    "css-in-js",
-    "layout",
-    "typescript"
+    "styled-components alternative",
+    "styling",
+    "theme",
+    "theme switching",
+    "type-safe",
+    "typescript",
+    "variants"
   ],
-  "devDependencies": {
-    "@types/node": "^22.17.0",
-    "@types/react": "^19.1.9",
-    "@types/react-dom": "^19.1.7",
-    "bun-types": "^1.2.19",
-    "clsx": "^2.1.1",
-    "eslint": "^9.32.0",
-    "eslint-config-dolmios": "^2.0.10",
-    "prettier": "^3.6.2",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
-    "typescript": "^5.9.2"
-  },
+  "license": "MIT",
   "peerDependencies": {
-    "react": ">=19.0.0",
-    "react-dom": ">=19.0.0"
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
   },
+  "prettier": "eslint-config-dolmios/configs/prettier",
+  "sideEffects": false,
+  "type": "module",
   "scripts": {
-    "build": "bun run build:clean && bun run build:types && bun run build:js",
+    "build": "bun run build:clean && bun run build:js && bun run build:types && bun run build:copy-declarations",
     "build:clean": "rm -rf dist",
+    "build:copy-declarations": "mkdir -p dist/types && cp src/types/react-polymorphic-types.d.ts dist/types/react-polymorphic-types.d.ts 2>/dev/null || true",
     "build:js": "bun build ./src/index.ts --outdir ./dist --target browser --minify --jsx=react --splitting --external react --external react-dom",
-    "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist --jsx react-jsx src/index.ts",
-    "dev": "bun run build && bun run preview/dev.ts",
-    "lint": "eslint src --fix",
-    "format": "prettier --write src",
-    "prepare": "bun run build",
-    "kill": "kill $(lsof -t -i:3000)"
-  },
-  "prettier": "eslint-config-dolmios/configs/prettier",
-  "dependencies": {
-    "@floating-ui/dom": "^1.7.3"
+    "build:types": "bunx tsc src/index.ts src/**/*.ts --declaration --emitDeclarationOnly --outDir dist --skipLibCheck --jsx react-jsx --module ESNext --moduleResolution bundler --target ES2022 --lib dom,dom.iterable,esnext --rootDir src",
+    "dev": "bun run build && bun --bun preview/index.html",
+    "format": "prettier --write src preview",
+    "kill": "lsof -ti:3000,420 | xargs kill -9 2>/dev/null || true",
+    "lint": "eslint . --ext .ts,.tsx --fix",
+    "test": "bun test",
+    "test:coverage": "bun test --coverage",
+    "test:watch": "bun test --watch"
   }
-}
+}

package/dist/components/Badge/index.d.ts

@@ -1,13 +0,0 @@
-import type { JSX } from "react";
-import type { BadgeProps } from "./types";
-/**
- * Badge - Display component for labels, status, and categories
- *
- * Solid color design with dark background and light text
- * Can be clickable with hover states
- *
- * Examples:
- * <Badge>New</Badge>
- * <Badge clickable>Interactive</Badge>
- */
-export declare function Badge({ bottom, clickable, css, top, ...props }: BadgeProps): JSX.Element;

package/dist/components/Badge/styles.d.ts

@@ -1,3 +0,0 @@
-export declare const BadgeStyled: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("../../styles/types").StyledBaseProps & {
-    clickable?: boolean | "false" | "true";
-} & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/Badge/types.d.ts

@@ -1,13 +0,0 @@
-import type { ComponentPropsWithoutRef } from "react";
-import type { SpacingToken } from "../../styles/theme";
-import type { CSSObject } from "../../styles/types";
-export interface BadgeProps extends ComponentPropsWithoutRef<"span"> {
-    /** Whether the badge is clickable */
-    clickable?: boolean;
-    /** Add margin-top */
-    top?: SpacingToken;
-    /** Add margin-bottom */
-    bottom?: SpacingToken;
-    /** Custom CSS styles */
-    css?: CSSObject;
-}

package/dist/components/Button/index.d.ts

@@ -1,14 +0,0 @@
-import type { JSX } from "react";
-import type { ButtonProps } from "./types";
-/**
- * Button - Interactive button component
- *
- * Sharp edges design with brand colors and multiple variants
- * Supports loading states, sizing, and polymorphic rendering
- *
- * Examples:
- * <Button variant="primary">Primary Action</Button>
- * <Button variant="secondary" size="small">Secondary</Button>
- * <Button as="a" href="/link">Link Button</Button>
- */
-export declare function Button({ block, bottom, children, css, disabled, loading, size, top, variant, ...props }: ButtonProps): JSX.Element;

package/dist/components/Button/styles.d.ts

@@ -1,6 +0,0 @@
-export declare const ButtonStyled: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & import("../../styles/types").StyledBaseProps & {
-    variant?: boolean | "minimal" | "primary" | "secondary";
-    block?: boolean | "false" | "true";
-    loading?: boolean | "false" | "true";
-    size?: boolean | "small" | "normal";
-} & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/components/Button/types.d.ts

@@ -1,22 +0,0 @@
-import type { ComponentPropsWithoutRef } from "react";
-import type { SpacingToken } from "../../styles/theme";
-import type { CSSObject } from "../../styles/types";
-/**
- * Button component props
- */
-export interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
-    /** Button variant */
-    variant?: "primary" | "secondary" | "minimal";
-    /** Button size */
-    size?: "normal" | "small";
-    /** Full width button */
-    block?: boolean;
-    /** Loading state */
-    loading?: boolean;
-    /** Add margin-top */
-    top?: SpacingToken;
-    /** Add margin-bottom */
-    bottom?: SpacingToken;
-    /** Custom CSS styles */
-    css?: CSSObject;
-}

package/dist/components/Card/index.d.ts

@@ -1,14 +0,0 @@
-import type { JSX } from "react";
-import type { CardProps } from "./types";
-/**
- * Card - Container component for grouping related content
- *
- * Sharp edges design with multiple variants and optional header/footer
- * Supports interactive states and flexible padding
- *
- * Examples:
- * <Card variant="default">Basic card content</Card>
- * <Card variant="bordered" header="Title">Card with header</Card>
- * <Card clickable padding="default">Interactive card</Card>
- */
-export declare function Card({ as, children, clickable, css, footer, header, onClick, padding, variant, ...props }: CardProps): JSX.Element;

package/dist/components/Card/styles.d.ts

@@ -1,16 +0,0 @@
-export declare const CardStyled: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("../../styles/types").StyledBaseProps & {
-    variant?: boolean | "default" | "bordered";
-    padding?: boolean | "small" | "default" | "minimal";
-    clickable?: boolean | "false" | "true";
-} & import("react").RefAttributes<HTMLDivElement>>;
-export declare const CardHeaderStyled: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("../../styles/types").StyledBaseProps & {
-    padding?: boolean | "small" | "default" | "minimal";
-} & import("react").RefAttributes<HTMLDivElement>>;
-export declare const CardFooterStyled: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("../../styles/types").StyledBaseProps & {
-    padding?: boolean | "small" | "default" | "minimal";
-} & import("react").RefAttributes<HTMLDivElement>>;
-export declare const CardContentStyled: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("../../styles/types").StyledBaseProps & {
-    padding?: boolean | "small" | "default" | "minimal";
-    hasFooter?: boolean | "false" | "true";
-    hasHeader?: boolean | "false" | "true";
-} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Card/types.d.ts

@@ -1,18 +0,0 @@
-import type { ComponentPropsWithoutRef, ReactNode, JSX } from "react";
-import type { CSSObject } from "../../styles/types";
-export interface CardProps extends ComponentPropsWithoutRef<"div"> {
-    /** HTML element to render as */
-    as?: keyof JSX.IntrinsicElements;
-    /** Header content */
-    header?: ReactNode;
-    /** Footer content */
-    footer?: ReactNode;
-    /** Card variant */
-    variant?: "default" | "bordered";
-    /** Padding size */
-    padding?: "default" | "small" | "minimal";
-    /** Whether the card is interactive/clickable */
-    clickable?: boolean;
-    /** Custom CSS styles */
-    css?: CSSObject;
-}

package/dist/components/Input/index.d.ts

@@ -1,13 +0,0 @@
-import { JSX } from "react";
-import type { InputProps } from "./types";
-/**
- * Input - Form input component with clean, accessible design
- *
- * Sharp edges design with consistent styling and form validation support
- * Supports all native input attributes
- *
- * Examples:
- * <Input placeholder="Enter text" />
- * <Input state="error" />
- */
-export declare function Input({ state, ...props }: InputProps): JSX.Element;