@sugarcube-org/core 0.0.1-alpha.4 → 0.0.1-alpha.6

package/dist/index.d.ts

@@ -1,445 +1,588 @@
 import { z } from 'zod';
 
-type ColorFormat = "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3";
-type ColorConfig = {
-    format?: ColorFormat;
-};
-type FluidConfig = {
-    min: number;
-    max: number;
-};
-type TokenCollection = {
-    source: string[];
-    type: "starter-kit" | "custom";
-    themes?: Record<string, string[]>;
-};
-type TokenCollections = Record<string, TokenCollection>;
-type OptionsConfig = {
-    fluid?: FluidConfig;
-    prefix?: string;
-    color?: ColorFormat;
-};
-type DirectoriesConfig = {
-    tokens: string;
-    components?: string;
-    css: string;
-};
-type CSSOutputConfig = {
-    /**
-     * Controls how CSS variables are organized in output files:
-     * - When false: Generates one file per collection, combining all tokens within each collection
-     *   (e.g., base/tokens.variables.css, ui/tokens.variables.css)
-     * - When true: Generates separate files by token type within each collection
-     *   (e.g., base/colors.variables.css, base/space.variables.css)
-     * @default false
-     */
-    separate: boolean;
-    manageIndex?: boolean;
-    format?: "css" | "scss" | "less";
-};
-type OutputConfig = {
-    directories: DirectoriesConfig;
-    css: CSSOutputConfig;
-};
-interface SugarcubeConfig {
-    tokens: TokenCollection | TokenCollections;
-    options?: OptionsConfig;
-    output: OutputConfig;
-}
-
-/**
- * Represents a single CSS file output with its name and content
- */
-type CSSFile = {
-    path: string;
-    css: string;
-};
-/**
- * Represents the output from generateCSS which always returns exactly one file
- */
-type SingleFileOutput = [CSSFile];
-/**
- * Represents multiple CSS file outputs from generateSeparateFiles or generateSingleFile
- */
-type CSSFileOutput = CSSFile[];
-/**
- * Result of the CSS generation process
- * For generateCSS: Contains exactly one file
- * For generate: Contains one or more files
- */
-type CSSGenerationResult = {
-    output: SingleFileOutput | CSSFileOutput;
-};
-
 /**
- * A token value that can either be a raw value or a reference
+ * A token value that can either be a raw value or a reference.
+ * This is the base type for all token values in the W3C Design Token Format.
+ * @template T - The type of token (e.g., "color", "dimension", etc.)
  */
 type TokenValue<T extends TokenType> = RawTokenValue<T> | Reference<T>;
 /**
- * The actual value of a token without references
+ * The actual value of a token without references.
+ * This represents the concrete value that will be used in the final output.
+ * @template T - The type of token (e.g., "color", "dimension", etc.)
  */
 type RawTokenValue<T extends TokenType> = T extends SimpleTokenType ? SimpleTokenValue<T> : T extends CompositeTokenType ? CompositeTokenValue<T> : never;
 /**
- * A reference to another token, with optional type checking
+ * A reference to another token, with optional type checking.
+ * References are strings that point to other tokens in the token tree.
+ * The phantom type parameter ensures type safety when resolving references.
+ * @template T - The type of token being referenced
  */
 type Reference<T extends TokenType = TokenType> = string & {
+    /** Phantom type for type safety during reference resolution */
     __tokenType?: T;
 };
 /**
- * Metadata that can be attached to any node in the token tree
+ * Metadata that can be attached to any node in the token tree.
+ * This includes descriptions and custom extensions as defined in the W3C spec.
  */
 type NodeMetadata = {
+    /** Optional description of the token or group */
     $description?: string;
+    /** Optional custom extensions as defined in the W3C spec */
     $extensions?: {
         [key: string]: unknown;
     };
 };
 /**
- * A single token with its value and metadata
+ * A single token with its value and metadata.
+ * This is the basic building block of the token system.
  */
 type Token = NodeMetadata & {
+    /** The value of the token, which can be a raw value or a reference */
     $value: TokenValue<TokenType>;
+    /** Optional type specification, can be inherited from parent groups */
     $type?: TokenType;
 };
 /**
- * A group of tokens that can be nested. The type allows for:
+ * A group of tokens that can be nested.
+ * The type allows for:
  * - Regular token properties (non-$ prefixed) which must be Token | TokenGroup
  * - Metadata properties from NodeMetadata (like $description, $extensions)
  * - $type property for type inheritance as specified in the W3C spec
  * - undefined to support optional metadata properties
  */
 type TokenGroup = NodeMetadata & {
+    /** Optional type specification for the group, can be inherited by child tokens */
     $type?: TokenType;
+    /** Dynamic properties that can be either tokens, token groups, or undefined */
     [key: string]: Token | TokenGroup | TokenType | undefined;
 };
 /**
- * All possible token types, either simple or composite
+ * All possible token types, either simple or composite.
+ * This is the union of all supported token types in the system.
  */
 type TokenType = SimpleTokenType | CompositeTokenType;
 /**
- * Token types that contain a single value
+ * Token types that contain a single value.
+ * These are the basic building blocks of the token system.
  */
 type SimpleTokenType = "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "number";
 /**
- * Values for simple token types
+ * Values for simple token types.
+ * Maps each simple token type to its corresponding value type.
+ * @template T - The type of token (e.g., "color", "dimension", etc.)
  */
 type SimpleTokenValue<T extends SimpleTokenType = SimpleTokenType> = T extends "color" ? Color : T extends "dimension" ? Dimension : T extends "fluidDimension" ? FluidDimension : T extends "duration" ? Duration : T extends "cubicBezier" ? CubicBezier : T extends "fontFamily" ? FontFamily : T extends "fontWeight" ? FontWeight : T extends "number" ? number : never;
 /**
- * Token types that contain multiple values or are structurally complex
+ * Token types that contain multiple values or are structurally complex.
+ * These types combine multiple simple types to create more complex tokens.
  */
 type CompositeTokenType = AlwaysDecomposedType | "border" | "shadow" | "gradient" | "transition" | StructuralCompositeType;
 /**
- * Token types that must always be broken down into their constituent parts
+ * Token types that must always be broken down into their constituent parts.
+ * These types are never used directly in CSS output.
  */
 type AlwaysDecomposedType = "typography";
 /**
- * Token types that define structural patterns
+ * Token types that define structural patterns.
+ * These types are used to define reusable patterns in the token system.
  */
 type StructuralCompositeType = "strokeStyle";
 /**
- * Values for composite token types
+ * Values for composite token types.
+ * Maps each composite token type to its corresponding value type.
+ * @template T - The type of token (e.g., "typography", "border", etc.)
  */
 type CompositeTokenValue<T extends CompositeTokenType = CompositeTokenType> = T extends "typography" ? Typography : T extends "border" ? Border : T extends "shadow" ? Shadow : T extends "gradient" ? Gradient : T extends "transition" ? Transition : T extends "strokeStyle" ? StrokeStyle : never;
 /**
- * A color value in any valid CSS color format
+ * A color value in any valid CSS color format.
+ * This can be any string that is valid in CSS color contexts.
  */
 type Color = string;
 /**
- * A dimensional value with a numeric value and unit
+ * A dimensional value with a numeric value and unit.
+ * Used for measurements like width, height, spacing, etc.
  */
 type Dimension = {
+    /** The numeric value of the dimension */
     value: number;
+    /** The unit of measurement (px or rem) */
     unit: "px" | "rem";
 };
 /**
- * A fluid dimension that scales between min and max values
+ * A fluid dimension that scales between min and max values.
+ * Used for responsive design tokens that need to scale with viewport size.
  */
 type FluidDimension = {
+    /** The minimum value at the smallest viewport size */
     min: Dimension;
+    /** The maximum value at the largest viewport size */
     max: Dimension;
 };
 /**
- * A duration value with a numeric value and time unit
+ * A duration value with a numeric value and time unit.
+ * Used for animations, transitions, and other time-based values.
  */
 type Duration = {
+    /** The numeric value of the duration */
     value: number;
+    /** The unit of time (milliseconds or seconds) */
     unit: "ms" | "s";
 };
 /**
- * A cubic bezier curve defined by four control points
+ * A cubic bezier curve defined by four control points.
+ * Used for defining custom easing functions in animations and transitions.
+ * The four numbers represent the x,y coordinates of the two control points.
  */
 type CubicBezier = [number, number, number, number];
 /**
- * A font family name or list of fallback fonts
+ * A font family name or list of fallback fonts.
+ * Can be a single font name or an array of fonts in order of preference.
  */
 type FontFamily = string | string[];
 /**
- * A font weight value as either a number or semantic string
+ * A font weight value as either a number or semantic string.
+ * Numbers range from 100-900, strings are semantic names for common weights.
  */
 type FontWeight = number | FontWeightString;
 /**
- * Semantic font weight names
+ * Semantic font weight names.
+ * These are standardized names for common font weights.
  */
 type FontWeightString = "thin" | "hairline" | "extra-light" | "ultra-light" | "light" | "normal" | "regular" | "book" | "medium" | "semi-bold" | "demi-bold" | "bold" | "extra-bold" | "ultra-bold" | "black" | "heavy" | "extra-black" | "ultra-black";
 /**
- * Line cap style for strokes
+ * Line cap style for strokes.
+ * Defines how the end of a stroke should be rendered.
  */
 type LineCap = "round" | "butt" | "square";
 /**
- * Typography token combining font properties
+ * Typography token combining font properties.
+ * This is a composite type that combines multiple font-related properties.
  */
 type Typography = {
+    /** The font family to use */
     fontFamily: TokenValue<"fontFamily">;
+    /** The size of the font */
     fontSize: TokenValue<"dimension">;
+    /** Optional font weight */
     fontWeight?: TokenValue<"fontWeight">;
+    /** Optional letter spacing */
     letterSpacing?: TokenValue<"dimension">;
+    /** Optional line height as a multiplier */
     lineHeight?: TokenValue<"number">;
 };
 /**
- * Transition token defining animation properties
+ * Transition token defining animation properties.
+ * Used to define how properties should animate between states.
  */
 type Transition = {
+    /** How long the transition should take */
     duration: TokenValue<"duration">;
+    /** Optional delay before the transition starts */
     delay?: TokenValue<"duration">;
+    /** The easing function to use for the transition */
     timingFunction: TokenValue<"cubicBezier">;
 };
 /**
- * Predefined stroke style keywords
+ * Predefined stroke style keywords.
+ * These are the standard stroke styles available in CSS.
  */
 type StrokeStyleKeyword = "solid" | "dashed" | "dotted" | "double" | "groove" | "ridge" | "outset" | "inset";
 /**
- * Custom stroke style definition
+ * Custom stroke style definition.
+ * Used when the predefined stroke styles are not sufficient.
  */
 type StrokeStyleCustom = {
+    /** Array of dimensions defining the dash pattern */
     dashArray: Array<TokenValue<"dimension">>;
+    /** How the ends of the stroke should be rendered */
     lineCap: LineCap;
 };
 /**
- * A stroke style that can be either a keyword or custom definition
+ * A stroke style can be either a predefined keyword or a custom definition.
+ * This allows for both simple and complex stroke styles.
  */
 type StrokeStyle = StrokeStyleKeyword | StrokeStyleCustom;
 /**
- * Border token combining color, width, and style
+ * Border token combining color, width, and style.
+ * This is a composite type that defines a complete border.
  */
 type Border = {
+    /** The color of the border */
     color: TokenValue<"color">;
+    /** The width of the border */
     width: TokenValue<"dimension">;
+    /** The style of the border, either a stroke style or a reference to one */
     style: StrokeStyle | Reference<"strokeStyle">;
 };
 /**
- * Individual shadow definition
+ * A single shadow definition.
+ * This is the basic building block for shadow tokens.
  */
 type ShadowObject = {
+    /** The color of the shadow */
     color: TokenValue<"color">;
+    /** Horizontal offset of the shadow */
     offsetX: TokenValue<"dimension">;
+    /** Vertical offset of the shadow */
     offsetY: TokenValue<"dimension">;
+    /** How much the shadow should blur */
     blur: TokenValue<"dimension">;
+    /** How much the shadow should spread */
     spread: TokenValue<"dimension">;
+    /** Whether the shadow should be inset */
     inset?: boolean;
 };
 /**
- * Shadow token that can be single or multiple shadows
+ * A shadow can be either a single shadow or multiple shadows.
+ * Multiple shadows are rendered in order, with later shadows appearing on top.
  */
 type Shadow = ShadowObject | ShadowObject[];
 /**
- * Color stop in a gradient
+ * A single stop in a gradient.
+ * Defines the color and position of a point in the gradient.
  */
 type GradientStop = {
+    /** The color at this point in the gradient */
     color: TokenValue<"color">;
+    /** The position of this point in the gradient (0-1) */
     position: number | Reference<"number">;
 };
 /**
- * Gradient defined as a list of color stops
+ * A gradient is defined by a series of stops.
+ * The stops define how the gradient transitions between colors.
  */
 type Gradient = GradientStop[];
 
 /**
- * Source information for a token, tracking its collection and theme
+ * Directional variants for utility properties
  */
-type TokenSource = {
-    collection: string;
-    theme?: string;
-    sourcePath: string;
-};
+type DirectionalVariant = "top" | "right" | "bottom" | "left" | "x" | "y" | "full";
 /**
- * A complete token tree with collection and theme information
+ * Configuration for utility generation
  */
-type TokenTree = {
-    collection: string;
-    theme?: string;
-    tokens: TokenGroup;
-    sourcePath: string;
+type UtilityConfig = {
+    properties?: string[];
+    typeMap?: Partial<Record<TokenType, string[]>>;
+    custom?: Record<string, string>;
+    prefix?: string;
+    stripLevels?: number;
+    directions?: DirectionalVariant | DirectionalVariant[];
 };
-
 /**
- * Base error type that all other error types extend from.
- * Used as the foundation for all error types in the system.
+ * Definition of a generated utility class
  */
-type BaseError = {
-    message: string;
+type UtilityDefinition = {
+    className: string;
+    property: string;
+    value: string;
+    tokenPath: string[];
 };
 
 /**
- * A flattened token with its source information and path
+ * Supported color formats for CSS output
  */
-type FlattenedToken<T extends TokenType = TokenType> = NodeMetadata & {
-    $type: T;
-    $value: TokenValue<T>;
-    $path: string;
-    $source: TokenSource;
-    $originalPath: string;
-};
+type ColorFormat = "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3";
 /**
- * A map of flattened tokens and metadata by their lookup path, with an index for quick reference lookups
+ * Configuration for fluid (responsive) values
  */
-type FlattenedTokens = {
-    tokens: {
-        [lookupKey: string]: FlattenedToken | NodeMetadata;
-    };
-    pathIndex: Map<string, string>;
+type FluidConfig = {
+    /** Minimum viewport width in pixels */
+    min: number;
+    /** Maximum viewport width in pixels */
+    max: number;
 };
 /**
- * An error that occurred during token flattening
+ * A collection of token files with shared namespace.
+ * Represents either a starter kit or custom token collection.
  */
-type FlattenError = BaseError & {
-    path: string;
-    source: TokenSource;
+type TokenCollection = {
+    /** Array of source file paths for this collection */
+    source: string[];
+    /** Optional theme-specific source files */
+    themes?: Record<string, string[]>;
 };
-
 /**
- * An error that occurred during token validation
+ * Multiple named collections of tokens.
+ * Each key is a collection name (e.g., "base", "ui", "marketing").
  */
-type ValidationError = BaseError & {
-    path: string;
-    source: TokenSource;
+type TokenCollections = Record<string, TokenCollection>;
+/**
+ * Configuration for transforms applied to tokens during processing
+ */
+type TransformsConfig = {
+    /** Configuration for fluid (responsive) values */
+    fluid?: FluidConfig;
+    /** Default color format for all color tokens */
+    colorFormat?: ColorFormat;
+    /** Prefix to add to all CSS variable names */
+    prefix?: string;
 };
-
 /**
- * A resolved token with its final value
+ * Configuration for output directories (user config - optional fields)
  */
-type ResolvedToken<T extends TokenType = TokenType> = NodeMetadata & {
-    $type: T;
-    $value: RawTokenValue<T>;
-    $path: string;
-    $source: TokenSource;
-    $originalPath: string;
-    $resolvedValue: RawTokenValue<T>;
+type UserOutputConfig = {
+    /** Directory where CSS files will be written */
+    css?: string;
+    /** Directory containing token source files */
+    tokens?: string;
+    /** Directory for component files */
+    components?: string;
+    /** Whether to generate separate CSS files by token type (default: false) */
+    separate?: boolean;
 };
 /**
- * A map of resolved tokens by their lookup path
+ * Configuration for output directories (internal config - required fields)
  */
-type ResolvedTokens = {
-    [lookupKey: string]: ResolvedToken | NodeMetadata;
+type OutputConfig = {
+    /** Directory where CSS files will be written */
+    css: string;
+    /** Directory containing token source files */
+    tokens: string;
+    /** Directory for component files */
+    components?: string;
+    /** Whether to generate separate CSS files by token type */
+    separate: boolean;
 };
 /**
- * Type of resolution error that occurred
+ * Configuration for utility class generation
  */
-type ResolutionErrorType = "circular" | "missing" | "type-mismatch";
+type UtilitiesConfig = {
+    /** Include core utilities (static, always-available utilities) */
+    core?: boolean;
+} & Record<string, UtilityConfig | UtilityConfig[]>;
 /**
- * An error that occurred during token resolution
+ * Configuration for component framework integration
  */
-type ResolutionError = BaseError & {
-    type: ResolutionErrorType;
-    path: string;
-    source: TokenSource;
+type ComponentsConfig = {
+    /** The component framework to use */
+    framework?: "react" | "astro";
+    /** List of installed component names */
+    installed?: string[];
 };
+/**
+ * User configuration type - what users write (minimal, optional fields)
+ */
+interface UserConfig {
+    /** Token source configuration, either a single collection or multiple named collections */
+    tokens: TokenCollection | TokenCollections;
+    /** Optional transforms applied during token processing */
+    transforms?: TransformsConfig;
+    /** Optional output configuration for generated files */
+    output?: UserOutputConfig;
+    /** Configuration for utility class generation */
+    utilities?: UtilitiesConfig;
+    /** Configuration for component framework integration */
+    components?: ComponentsConfig;
+    /** List of plugin names to load */
+    plugins?: string[];
+}
+/**
+ * Internal configuration type - what code uses (complete, required fields)
+ */
+interface SugarcubeConfig {
+    /** Token source configuration, either a single collection or multiple named collections */
+    tokens: TokenCollection | TokenCollections;
+    /** Optional transforms applied during token processing */
+    transforms?: TransformsConfig;
+    /** Required output configuration for generated files */
+    output: OutputConfig;
+    /** Configuration for utility class generation */
+    utilities?: UtilitiesConfig;
+    /** Configuration for component framework integration */
+    components?: ComponentsConfig;
+    /** List of plugin names to load */
+    plugins?: string[];
+}
 
 /**
- * A warning that occurred during token normalization
+ * Base error type that all other error types extend from.
+ * Used as the foundation for all error types in the system.
+ * Provides a consistent structure for error messages across the codebase.
  */
-type NormalizationWarning = {
-    type: "warning";
+type BaseError = {
+    /** A human-readable error message describing what went wrong */
     message: string;
-    file: string;
-    collection: string;
-    theme?: string;
 };
+
 /**
- * An error that occurred during token normalization
+ * Source information for a token, tracking its collection and theme.
+ * This metadata helps with error reporting and token organization.
  */
-type NormalizationError = ValidationError & {
+type TokenSource = {
+    /** The collection this token belongs to (e.g., "base", "ui", "marketing") */
     collection: string;
-    theme: string;
+    /** Optional theme name (e.g., "dark", "light", "high-contrast") */
+    theme?: string;
+    /** The path to the source file containing this token */
+    sourcePath: string;
 };
 /**
- * A set of tokens for a theme, including metadata nodes
+ * A complete token tree with collection and theme information.
+ * This represents a single token file's contents with its metadata.
  */
-type ThemeTokenSet = {
-    default: ResolvedTokens;
-    [theme: string]: ResolvedTokens;
+type TokenTree = {
+    /** The collection this token tree belongs to (e.g., "base", "ui", "marketing") */
+    collection: string;
+    /** Optional theme name (e.g., "dark", "light", "high-contrast") */
+    theme?: string;
+    /** The actual token data following the W3C design tokens format */
+    tokens: TokenGroup;
+    /** The path to the source file containing these tokens */
+    sourcePath: string;
 };
+
 /**
- * Normalized tokens organized by collection and theme
+ * An error that occurred during token flattening.
+ * Extends the base error type with flattening-specific information.
  */
-type NormalizedTokens = {
-    [collection: string]: ThemeTokenSet;
+type FlattenError = BaseError & {
+    /** The path to the token that failed flattening */
+    path: string;
+    /** Source information about where the token was loaded from */
+    source: TokenSource;
 };
+
 /**
- * Result of the normalization process
+ * Represents a single CSS file output with its path and content
  */
-type NormalizeResult = {
-    tokens: NormalizedTokens;
-    errors: NormalizationError[];
-    warnings: NormalizationWarning[];
+type CSSFile = {
+    /** The path where the CSS file will be written */
+    path: string;
+    /** The CSS content to write to the file */
+    css: string;
 };
-
 /**
- * Result of loading token trees from files or memory
+ * Represents multiple CSS file outputs from generateSeparateFiles or generateSingleFile
  */
-type LoadResult = {
-    trees: TokenTree[];
-    errors: LoadError[];
-};
+type CSSFileOutput = CSSFile[];
+
 /**
- * Data structure for loading tokens from memory
+ * Data structure for loading tokens from memory.
+ * Maps file paths to their token content and metadata.
+ * Used for programmatic token loading.
  */
 type TokenMemoryData = Record<string, {
+    /** The collection name this token belongs to */
     collection: string;
+    /** Optional theme name for themed tokens */
     theme?: string;
+    /** The raw token content as a string */
     content: string;
 }>;
 /**
- * An error that occurred during token loading
+ * An error that occurred during token loading.
+ * Extends the base error type with file-specific information.
  */
 type LoadError = BaseError & {
+    /** The file path where the error occurred */
     file: string;
 };
 
 /**
- * Result of running the tokens-to-CSS pipeline
+ * A resolved token with its final value.
+ * Contains both the original token data and its resolved value after reference resolution.
+ * @template T - The type of token (e.g., "color", "dimension", etc.)
+ */
+type ResolvedToken<T extends TokenType = TokenType> = NodeMetadata & {
+    /** The type of the token */
+    $type: T;
+    /** The original value of the token, which may contain references */
+    $value: RawTokenValue<T>;
+    /** The path to this token in the token tree */
+    $path: string;
+    /** Information about where this token was loaded from */
+    $source: TokenSource;
+    /** The original path before any resolution */
+    $originalPath: string;
+    /** The final resolved value after all references are resolved */
+    $resolvedValue: RawTokenValue<T>;
+};
+/**
+ * A map of resolved tokens by their lookup path.
+ * Used to store the final resolved state of all tokens in a collection.
+ * Keys are token paths, values are either resolved tokens or node metadata.
+ */
+type ResolvedTokens = {
+    /** Token path as key, resolved token or metadata as value */
+    [lookupKey: string]: ResolvedToken | NodeMetadata;
+};
+/**
+ * Type of resolution error that occurred.
+ * - "circular": A circular reference was detected
+ * - "missing": A referenced token could not be found
+ * - "type-mismatch": A referenced token's type doesn't match the expected type
+ */
+type ResolutionErrorType = "circular" | "missing" | "type-mismatch";
+/**
+ * An error that occurred during token resolution.
+ * Extends the base error type with resolution-specific information.
+ */
+type ResolutionError = BaseError & {
+    /** The type of resolution error that occurred */
+    type: ResolutionErrorType;
+    /** The path to the token that failed resolution */
+    path: string;
+    /** Source information about where the token was loaded from */
+    source: TokenSource;
+};
+
+/**
+ * An error that occurred during token validation.
+ * Extends the base error type with token-specific information.
+ */
+type ValidationError = BaseError & {
+    /** The path to the token that failed validation */
+    path: string;
+    /** Source information about where the token was loaded from */
+    source: TokenSource;
+};
+
+/**
+ * Result of running any pipeline.
+ * Contains the generated output, token trees, and any errors.
  */
-type TokensToCSSPipelineResult = {
+type PipelineResult = {
+    /** The generated output (e.g. CSS files) */
     output: CSSFileOutput;
+    /** The loaded token trees */
     trees: TokenTree[];
+    /** Any errors that occurred during pipeline execution */
     errors: PipelineErrors;
-    warnings: PipelineWarnings;
 };
 /**
- * Common error types that can occur during pipeline execution
+ * Common error types that can occur during pipeline execution.
+ * Organizes errors by the pipeline stage where they occurred.
  */
 type PipelineErrors = {
+    /** Errors that occurred during token loading */
     load: LoadError[];
+    /** Errors that occurred during token flattening */
     flatten: FlattenError[];
+    /** Errors that occurred during token validation */
     validation: ValidationError[];
+    /** Errors that occurred during token resolution */
     resolution: ResolutionError[];
 };
 /**
- * Common warning types that can occur during pipeline execution
- */
-type PipelineWarnings = {
-    normalization: NormalizationWarning[];
-};
-/**
- * Result of running the validation pipeline
+ * Defines how tokens should be loaded and processed.
+ * Either from files using a config, or from memory with token data.
  */
-type ValidationPipelineResult = {
-    trees: TokenTree[];
-    flattenedTokens: FlattenedTokens;
-    resolved: ResolvedTokens;
-    errors: PipelineErrors;
+type TokenPipelineSource = {
+    type: "files";
+    config: SugarcubeConfig;
+} | {
+    type: "memory";
+    data: Record<string, {
+        collection: string;
+        content: string;
+    }>;
+    config: SugarcubeConfig;
 };
 /**
- * Options for loading tokens in the validation pipeline
+ * Options for loading tokens in the pipeline.
+ * Specifies whether to load tokens from files or memory.
  */
 type TokenLoader = {
     type: "files";
@@ -448,389 +591,1350 @@ type TokenLoader = {
     type: "memory";
     data: TokenMemoryData;
 };
+
 /**
- * Options for configuring the validation pipeline
- */
-type ValidationPipelineOptions = {
-    loader: TokenLoader;
-};
-/**
- * Result of running the generation pipeline
+ * Core token processing pipeline that handles loading, validation, and resolution of tokens.
+ * This is the foundation for all other token processing operations.
+ *
+ * This pipeline:
+ * 1. Loads token trees from config or memory
+ * 2. Flattens trees into a single structure
+ * 3. Validates tokens for correctness
+ * 4. Resolves all token references
+ *
+ * Each stage can produce errors which are collected and returned in the result.
+ *
+ * @param source - The source of tokens to process, either from memory or config
+ * @returns An object containing the processed trees, resolved tokens, and any errors
+ *
+ * @example
+ * const result = await tokenProcessingPipeline({ type: "config", config });
+ * if (result.errors.validation.length > 0) {
+ *   console.error("Validation failed:", result.errors.validation);
+ * }
  */
-type GenerationPipelineResult = {
-    output: CSSFileOutput;
-    warnings: PipelineWarnings;
-};
-
-declare function tokensToCSSPipeline(config: SugarcubeConfig, options?: {
-    loader?: TokenLoader;
-}): Promise<TokensToCSSPipelineResult>;
-
-declare function validationPipeline(config: SugarcubeConfig, options: ValidationPipelineOptions): Promise<ValidationPipelineResult>;
-
-declare function generationPipeline(trees: TokenTree[], resolved: ResolvedTokens, configState: SugarcubeConfig): Promise<GenerationPipelineResult>;
-
-declare function loadTreesFromConfig(config: SugarcubeConfig): Promise<LoadResult>;
-declare function loadTreesFromMemory(data: TokenMemoryData): Promise<LoadResult>;
-
-declare function validate(tokens: FlattenedTokens): ValidationError[];
-
-declare function flatten(trees: TokenTree[]): {
-    tokens: FlattenedTokens;
-    errors: FlattenError[];
-};
-
-declare function resolve(tokens: FlattenedTokens): {
+declare function tokenProcessingPipeline(source: TokenPipelineSource): Promise<{
+    trees: TokenTree[];
     resolved: ResolvedTokens;
-    errors: ResolutionError[];
-};
+    errors: PipelineResult["errors"];
+}>;
 
 /**
- * A processed token tree that has been filtered to only include tokens
- * from its specific collection and theme, with resolved values
+ * Result of loading a Sugarcube configuration file
  */
-type ProcessedTree = {
-    collection: string;
-    theme?: string;
-    tokens: ResolvedTokens;
+type LoadConfigResult = {
+    /** The validated configuration */
+    config: SugarcubeConfig;
+    /** The path to the config file that was loaded */
+    configPath: string;
 };
-
 /**
- * Process token trees by filtering resolved tokens based on collection and theme.
- * Uses a two-level index (collection -> theme) for O(1) lookups.
+ * Loads and validates the sugarcube configuration file from disk.
+ *
+ * This function:
+ * 1. Reads the config file from the specified path
+ * 2. Parses and validates the configuration
+ * 3. Returns the validated configuration object and the path used
+ *
+ * @param configPath - Path to the config file (default: "sugarcube.config.json")
+ * @returns A promise that resolves to the validated configuration and config path
+ * @throws Error if the config file is not found or invalid
+ *
+ * @example
+ * // Load default config file
+ * const { config, configPath } = await loadConfig();
+ *
+ * // Load custom config file
+ * const { config, configPath } = await loadConfig("./config/sugarcube.json");
  */
-declare function processTrees(trees: TokenTree[], resolved: ResolvedTokens): ProcessedTree[];
+declare function loadConfig(configPath?: string): Promise<LoadConfigResult>;
 
 /**
- * A token that has been converted to CSS properties
+ * Validates a user configuration object against the schema and normalizes it.
+ *
+ * This function:
+ * 1. Validates the configuration structure using the user schema
+ * 2. Normalizes the configuration by filling in defaults
+ * 3. Validates the complete configuration using the internal schema
+ * 4. Checks for duplicate filenames across collections
+ * 5. Returns the validated and normalized configuration
+ *
+ * @param config - The user configuration object to validate
+ * @returns The validated and normalized configuration
+ * @throws Error if the configuration is invalid or contains duplicate filenames
+ *
+ * @example
+ * const config = {
+ *   tokens: {
+ *     source: ["tokens.json"]
+ *   }
+ * };
+ * const validatedConfig = validateConfig(config);
+ * // validatedConfig.output.css === "src/styles" (default filled in)
  */
-type ConvertedToken<T extends TokenType = TokenType> = ResolvedToken<T> & {
-    $cssProperties: CSSProperties<T>;
-};
+declare function validateConfig(config: Partial<UserConfig>): SugarcubeConfig;
 /**
- * A collection of converted tokens
+ * Parses and validates a JSON configuration string.
+ *
+ * This function:
+ * 1. Parses the JSON string into a configuration object
+ * 2. Validates and normalizes the configuration using validateConfig
+ * 3. Returns the validated and normalized configuration
+ *
+ * @param configString - The JSON configuration string to parse and validate
+ * @returns The validated and normalized configuration
+ * @throws Error if the JSON is invalid or the configuration is invalid
+ *
+ * @example
+ * const configString = `{
+ *   "tokens": {
+ *     "source": ["tokens.json"]
+ *   }
+ * }`;
+ * const config = parseAndValidateConfig(configString);
+ * // config.output.css === "src/styles" (default filled in)
  */
-type ConvertedTokens = {
-    [lookupKey: string]: ConvertedToken | NodeMetadata;
-};
+declare function parseAndValidateConfig(configString: string): SugarcubeConfig;
+
 /**
- * A collection of converted tokens organized by theme
+ * Default configuration values
  */
-type ConvertedThemeTokenSet = {
-    default: ConvertedTokens;
-    [theme: string]: ConvertedTokens;
+declare const DEFAULT_CONFIG: {
+    readonly output: {
+        readonly css: "src/styles";
+        readonly tokens: "src/design-tokens";
+        readonly components: "src/ui/components";
+        readonly separate: false;
+    };
 };
 /**
- * A collection of converted tokens organized by collection and theme
- */
-type NormalizedConvertedTokens = {
-    [collection: string]: ConvertedThemeTokenSet;
-};
+ * Normalizes a user configuration by filling in default values.
+ *
+ * This function takes a minimal user config (with optional fields) and
+ * returns a complete internal config (with all required fields).
+ *
+ * @param userConfig - The user configuration with optional fields
+ * @returns A complete configuration with all defaults filled in
+ *
+ * @example
+ * const userConfig = {
+ *   tokens: { source: ["tokens/*.json"] }
+ * };
+ * const completeConfig = normalizeConfig(userConfig);
+ * // completeConfig.output.css === "src/styles"
+ * // completeConfig.output.tokens === "src/design-tokens"
+ * // completeConfig.output.components === "src/ui/components"
+ * // completeConfig.output.separate === false
+ */
+declare function normalizeConfig(userConfig: UserConfig): SugarcubeConfig;
+
 /**
- * CSS property types for different token types
+ * Gets all token source file paths from the configuration.
+ *
+ * This function handles both single and multiple collection configurations:
+ * - Single collection: Returns the source array directly
+ * - Multiple collections: Flattens and returns all source paths from all collections
+ *
+ * @param config - The sugarcube configuration
+ * @returns An array of all token source file paths
+ *
+ * @example
+ * // Single collection
+ * getTokenPathsFromConfig({ tokens: { source: ["tokens.json"] } })
+ * // Returns: ["tokens.json"]
+ *
+ * // Multiple collections
+ * getTokenPathsFromConfig({
+ *   tokens: {
+ *     base: { source: ["base.json"] },
+ *     ui: { source: ["ui.json"] }
+ *   }
+ * })
+ * // Returns: ["base.json", "ui.json"]
  */
-type CSSProperties<T extends TokenType> = T extends SimpleTokenType ? SimpleCSSProperties : T extends AlwaysDecomposedType ? AlwaysDecomposedProperties : T extends "border" ? CSSBorderProperties : T extends "shadow" ? CSSShadowProperties : T extends "gradient" ? CSSGradientProperties : T extends "transition" ? CSSTransitionProperties : T extends StructuralCompositeType ? SimpleCSSProperties : never;
+declare function getTokenPathsFromConfig(config: SugarcubeConfig): string[];
 /**
- * Simple CSS properties with a single value
+ * Writes CSS files to disk, creating directories as needed.
+ *
+ * This function:
+ * 1. Creates any missing directories in the file path
+ * 2. Adds a warning banner to prevent direct edits
+ * 3. Only writes files if the content has changed
+ * 4. Handles both single and multiple CSS file outputs
+ *
+ * @param output - Array of CSS file outputs to write
+ * @returns The original output array
+ * @throws Error if file writing fails
+ *
+ * @example
+ * await writeCSSFilesToDisk([
+ *   { path: "styles/tokens.css", css: "body { color: red; }" }
+ * ]);
  */
-type SimpleCSSProperties = {
-    value: string | number;
-    featureValues?: Array<{
-        query: string;
-        value: string;
-    }>;
-};
+declare function writeCSSVariablesToDisk(output: CSSFileOutput): Promise<CSSFileOutput>;
 /**
- * CSS properties that are always broken down into multiple properties
+ * Writes utility CSS files to disk, creating directories as needed.
+ *
+ * This function:
+ * 1. Creates any missing directories in the file path
+ * 2. Adds a warning banner specific to utility classes
+ * 3. Only writes files if the content has changed
+ *
+ * @param output - The CSS file output to write
+ * @param config - The sugarcube configuration
+ * @returns The CSS file output that was written
+ * @throws Error if file writing fails
+ *
+ * @example
+ * await writeCSSUtilitiesToDisk(
+ *   [{ path: "src/styles/utilities/utilities.css", css: ".p-4 { padding: var(--spacing-4); }" }],
+ *   config
+ * );
  */
-type AlwaysDecomposedProperties = CSSTypographyProperties;
+declare function writeCSSUtilitiesToDisk(output: CSSFileOutput): Promise<CSSFileOutput>;
+
 /**
- * CSS properties specific to typography tokens
+ * Generates utility CSS classes from resolved tokens based on utility configuration.
+ * This function creates CSS utility classes that map token values to CSS properties.
+ *
+ * The generation process:
+ * 1. Iterates through all resolved tokens
+ * 2. Matches tokens against utility configurations
+ * 3. Generates CSS rules for each matching token and property
+ * 4. Handles directional variants (e.g., padding-top, margin-right) if configured
+ * 5. Formats and returns the final CSS string
+ *
+ * The generated CSS uses CSS custom properties (variables) to reference token values,
+ * maintaining the connection between tokens and their usage in utilities.
+ *
+ * @param tokens - The resolved tokens to generate utilities from
+ * @param config - The sugarcube configuration containing utility settings
+ * @returns An object containing the generated CSS, errors, and warnings
+ *
+ * @example
+ * const { css } = generateUtilityCSS(resolvedTokens, config);
+ * // css = ".u-p-4 { padding: var(--spacing-4); }\n.u-mt-2 { margin-top: var(--spacing-2); }"
  */
-type CSSTypographyProperties = {
-    "font-family": string;
-    "font-size": string;
-    "font-weight"?: number | string;
-    "letter-spacing"?: string;
-    "line-height"?: number | string;
-};
-/**
- * CSS properties for specific token types
- */
-type CSSBorderProperties = {
-    value: string;
-};
-type CSSShadowProperties = {
-    value: string;
-};
-type CSSGradientProperties = {
-    value: string;
-};
-type CSSTransitionProperties = {
-    value: string;
+declare function generateCSSUtilityClasses(tokens: ResolvedTokens, config: SugarcubeConfig): {
+    output: CSSFileOutput;
+    errors: Error[];
 };
 
-declare function convert(tokens: NormalizedTokens, config: SugarcubeConfig): NormalizedConvertedTokens;
-
 /**
- * Normalizes processed token trees into a collection-theme-token structure.
+ * Generates CSS variables from processed token trees and resolved tokens.
+ * This pipeline handles the conversion of tokens into CSS variable format.
  *
- * This stage:
- * 1. Organizes tokens by collection and theme
- * 2. Removes collection prefixes from token keys (e.g., "default.color.primary" -> "color.primary")
- * 3. Preserves metadata nodes
- * 4. Maintains theme isolation (tokens only appear in their specified theme)
+ * This pipeline:
+ * 1. Processes trees with resolved tokens
+ * 2. Normalizes tokens into a collection-theme structure
+ * 3. Converts tokens to CSS-ready format
+ * 4. Generates final CSS output
  *
- * The output structure is:
- * {
- *   [collection]: {
- *     [theme]: {
- *       [tokenKey]: Token
- *     }
- *   }
- * }
+ * @param trees - The processed token trees
+ * @param resolved - The resolved tokens
+ * @param config - The sugarcube configuration
+ * @returns An object containing the generated CSS output
  *
- * For example:
- * {
- *   default: {
- *     default: { "color.primary": { $value: "#FF0000" } },
- *     dark: { "color.primary": { $value: "#000000" } }
- *   },
- *   components: {
- *     default: { "button.primary": { $value: "#00FF00" } }
- *   }
- * }
+ * @example
+ * const { output } = await cssVariablesPipeline(trees, resolved, config);
+ * // output = [{ path: "path/to/output.css", css: ":root { ... }" }]
  */
-declare function normalizeTokens(trees: ProcessedTree[]): NormalizeResult;
+declare function generateCSSVariables(trees: TokenTree[], resolved: ResolvedTokens, config: SugarcubeConfig): Promise<{
+    output: CSSFileOutput;
+}>;
 
-/**
- * Generates CSS variable files from normalized and converted design tokens.
- * Output organization is controlled by config.output.css.separate:
- *
- * When separate=false (default):
- * - Generates one file per collection
- * - Each collection's tokens are combined into a single file named 'tokens.variables.css'
- * - Example for collections 'base' and 'ui':
- *   - base/tokens.variables.css
- *   - ui/tokens.variables.css
- *
- * When separate=true:
- * - Generates multiple files per collection, based on source filenames
- * - Files are organized in directories by collection name
- * - Example for collection 'base' with source 'base.json' and collection 'ui' with source 'ui.json':
- *   - base/base.variables.css
- *   - ui/ui.variables.css
- *
- * Note: Each collection gets its own directory regardless of the 'separate' setting.
- * This maintains a clear separation between different token collections.
- */
-declare function generate(tokens: NormalizedConvertedTokens, config: SugarcubeConfig): Promise<CSSGenerationResult>;
+declare function generateIndex(stylesDir: string, config: SugarcubeConfig): Promise<string>;
+declare function shouldRegenerateIndex(stylesDir: string, config: SugarcubeConfig): Promise<boolean>;
 
-/**
- * Adds a warning banner to generated CSS content
- */
-declare function addWarningBanner(cssContent: string): string;
-/**
- * Gets the token file paths from config for use in warning banners
- */
-declare function getTokenPathsFromConfig(config: SugarcubeConfig): string[];
-/**
- * Writes CSS files to disk with directory creation
- */
-declare function writeCSSFilesToDisk(output: CSSFileOutput, addBanner?: boolean, tokenPaths?: string[]): Promise<CSSFileOutput>;
+interface CSSImport {
+    path: string;
+    layer: string;
+    relativePath: string;
+}
+declare function discoverAllFiles(stylesDir: string, config: SugarcubeConfig): Promise<CSSImport[]>;
 
-/**
- * Validates the configuration object against the schema
- */
-declare function validateConfig(config: Partial<SugarcubeConfig>): SugarcubeConfig;
-/**
- * Parses and validates a JSON configuration string
- */
-declare function parseAndValidateConfig(configString: string): SugarcubeConfig;
+declare function generateIndexContent(files: CSSImport[]): string;
 
-/**
- * Loads and validates the config file from disk
- */
-declare function loadConfig(configPath?: string): Promise<SugarcubeConfig>;
+declare const SUGARCUBE_FILE = "_sugarcube.css";
+declare const GLOBAL_DIR = "global";
+declare const UTILITIES_DIR = "utilities";
+declare const VARIABLES_FILE_SUFFIX = ".variables.css";
+declare const TOKENS_FILE_SUFFIX = ".tokens.json";
+declare const DEFAULT_VARIABLES_FILENAME = "tokens";
+declare const DEFAULT_UTILITIES_FILENAME = "utilities.css";
+declare const DEFAULT_STYLES_PATH = "src/styles";
+declare const DEFAULT_DESIGN_TOKENS_PATH = "src/design-tokens";
+declare const SUGARCUBE_CONFIG_FILE = "sugarcube.config.json";
 
-/**
- * Manages the CSS index file that imports all CSS files.
- * @param options.cssOutputDirectory - Directory where the index.css will be created/updated
- * @param options.files - CSS files to include in the index
- * @returns Path to the generated index file
- */
-declare function manageCSSIndex({ cssOutputDirectory, files, }: {
-    cssOutputDirectory: string;
-    files: string[];
-}): Promise<string>;
+declare class Instrumentation implements Disposable {
+    #private;
+    private defaultFlush;
+    constructor(defaultFlush?: (message: string) => undefined);
+    hit(label: string): void;
+    start(label: string): void;
+    end(label: string): void;
+    report(flush?: (message: string) => undefined): void;
+    [Symbol.dispose](): void;
+}
 
-/**
- * Schema for configuration
- */
-declare const configSchema: z.ZodObject<{
+declare const userConfigSchema: z.ZodObject<{
     tokens: z.ZodUnion<[z.ZodObject<{
         source: z.ZodArray<z.ZodString, "many">;
-        type: z.ZodEnum<["starter-kit", "custom"]>;
         themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
     }, "strip", z.ZodTypeAny, {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     }, {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     }>, z.ZodRecord<z.ZodString, z.ZodObject<{
         source: z.ZodArray<z.ZodString, "many">;
-        type: z.ZodEnum<["starter-kit", "custom"]>;
         themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
     }, "strip", z.ZodTypeAny, {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     }, {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     }>>]>;
-    options: z.ZodOptional<z.ZodObject<{
+    transforms: z.ZodOptional<z.ZodObject<{
         fluid: z.ZodOptional<z.ZodObject<{
             min: z.ZodNumber;
             max: z.ZodNumber;
-        }, "strict", z.ZodTypeAny, {
+        }, "strip", z.ZodTypeAny, {
             min: number;
             max: number;
         }, {
             min: number;
             max: number;
         }>>;
+        colorFormat: z.ZodOptional<z.ZodEnum<["hex", "rgb", "rgba", "hsl", "hsla", "oklch", "p3"]>>;
         prefix: z.ZodOptional<z.ZodString>;
-        color: z.ZodOptional<z.ZodEnum<["hex", "rgb", "rgba", "hsl", "hsla", "oklch", "p3"]>>;
     }, "strip", z.ZodTypeAny, {
-        color?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+        prefix?: string | undefined;
         fluid?: {
             min: number;
             max: number;
         } | undefined;
-        prefix?: string | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
     }, {
-        color?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+        prefix?: string | undefined;
         fluid?: {
             min: number;
             max: number;
         } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    }>>;
+    output: z.ZodOptional<z.ZodObject<{
+        css: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodString>;
+        components: z.ZodOptional<z.ZodString>;
+        separate: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    }, {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    }>>;
+    utilities: z.ZodOptional<z.ZodObject<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, z.objectOutputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
         prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip">, z.objectInputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip">>>;
+    components: z.ZodOptional<z.ZodObject<{
+        framework: z.ZodOptional<z.ZodEnum<["react", "astro"]>>;
+        installed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    }, {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
     }>>;
-    output: z.ZodObject<{
-        directories: z.ZodObject<{
-            tokens: z.ZodString;
-            components: z.ZodOptional<z.ZodString>;
-            css: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            css: string;
-            tokens: string;
-            components?: string | undefined;
-        }, {
-            css: string;
-            tokens: string;
-            components?: string | undefined;
-        }>;
-        css: z.ZodObject<{
-            separate: z.ZodBoolean;
-            manageIndex: z.ZodOptional<z.ZodBoolean>;
-            format: z.ZodOptional<z.ZodEnum<["css", "scss", "less"]>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    tokens: {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    } | Record<string, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>;
+    utilities?: z.objectOutputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip"> | undefined;
+    output?: {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    } | undefined;
+    transforms?: {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    } | undefined;
+    components?: {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
+}, {
+    tokens: {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    } | Record<string, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>;
+    utilities?: z.objectInputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip"> | undefined;
+    output?: {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    } | undefined;
+    transforms?: {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    } | undefined;
+    components?: {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
+}>;
+declare const internalConfigSchema: z.ZodObject<{
+    tokens: z.ZodUnion<[z.ZodObject<{
+        source: z.ZodArray<z.ZodString, "many">;
+        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>, z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodArray<z.ZodString, "many">;
+        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>>]>;
+    transforms: z.ZodOptional<z.ZodObject<{
+        fluid: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            separate: boolean;
-            manageIndex?: boolean | undefined;
-            format?: "css" | "scss" | "less" | undefined;
+            min: number;
+            max: number;
         }, {
-            separate: boolean;
-            manageIndex?: boolean | undefined;
-            format?: "css" | "scss" | "less" | undefined;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        css: {
-            separate: boolean;
-            manageIndex?: boolean | undefined;
-            format?: "css" | "scss" | "less" | undefined;
-        };
-        directories: {
-            css: string;
-            tokens: string;
-            components?: string | undefined;
-        };
-    }, {
-        css: {
-            separate: boolean;
-            manageIndex?: boolean | undefined;
-            format?: "css" | "scss" | "less" | undefined;
-        };
-        directories: {
-            css: string;
-            tokens: string;
-            components?: string | undefined;
-        };
+            min: number;
+            max: number;
+        }>>;
+        colorFormat: z.ZodOptional<z.ZodEnum<["hex", "rgb", "rgba", "hsl", "hsla", "oklch", "p3"]>>;
+        prefix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    }, {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    }>>;
+    output: z.ZodObject<{
+        css: z.ZodString;
+        tokens: z.ZodString;
+        components: z.ZodString;
+        separate: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        tokens: string;
+        css: string;
+        components: string;
+        separate: boolean;
+    }, {
+        tokens: string;
+        css: string;
+        components: string;
+        separate: boolean;
     }>;
+    utilities: z.ZodOptional<z.ZodObject<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, z.objectOutputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip">, z.objectInputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip">>>;
+    components: z.ZodOptional<z.ZodObject<{
+        framework: z.ZodOptional<z.ZodEnum<["react", "astro"]>>;
+        installed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    }, {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    }>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     tokens: {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     } | Record<string, {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     }>;
     output: {
-        css: {
-            separate: boolean;
-            manageIndex?: boolean | undefined;
-            format?: "css" | "scss" | "less" | undefined;
-        };
-        directories: {
-            css: string;
-            tokens: string;
-            components?: string | undefined;
-        };
+        tokens: string;
+        css: string;
+        components: string;
+        separate: boolean;
     };
-    options?: {
-        color?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    utilities?: z.objectOutputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip"> | undefined;
+    transforms?: {
+        prefix?: string | undefined;
         fluid?: {
             min: number;
             max: number;
         } | undefined;
-        prefix?: string | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
     } | undefined;
+    components?: {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
 }, {
     tokens: {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     } | Record<string, {
         source: string[];
-        type: "starter-kit" | "custom";
         themes?: Record<string, string[]> | undefined;
     }>;
     output: {
-        css: {
-            separate: boolean;
-            manageIndex?: boolean | undefined;
-            format?: "css" | "scss" | "less" | undefined;
-        };
-        directories: {
-            css: string;
-            tokens: string;
-            components?: string | undefined;
-        };
+        tokens: string;
+        css: string;
+        components: string;
+        separate: boolean;
     };
-    options?: {
-        color?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    utilities?: z.objectInputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip"> | undefined;
+    transforms?: {
+        prefix?: string | undefined;
         fluid?: {
             min: number;
             max: number;
         } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    } | undefined;
+    components?: {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
+}>;
+declare const configSchema: z.ZodObject<{
+    tokens: z.ZodUnion<[z.ZodObject<{
+        source: z.ZodArray<z.ZodString, "many">;
+        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>, z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodArray<z.ZodString, "many">;
+        themes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>>]>;
+    transforms: z.ZodOptional<z.ZodObject<{
+        fluid: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            min: number;
+            max: number;
+        }, {
+            min: number;
+            max: number;
+        }>>;
+        colorFormat: z.ZodOptional<z.ZodEnum<["hex", "rgb", "rgba", "hsl", "hsla", "oklch", "p3"]>>;
+        prefix: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
         prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    }, {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    }>>;
+    output: z.ZodOptional<z.ZodObject<{
+        css: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodString>;
+        components: z.ZodOptional<z.ZodString>;
+        separate: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    }, {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    }>>;
+    utilities: z.ZodOptional<z.ZodObject<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, z.objectOutputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip">, z.objectInputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip">>>;
+    components: z.ZodOptional<z.ZodObject<{
+        framework: z.ZodOptional<z.ZodEnum<["react", "astro"]>>;
+        installed: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    }, {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    }>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    tokens: {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    } | Record<string, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>;
+    utilities?: z.objectOutputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip"> | undefined;
+    output?: {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    } | undefined;
+    transforms?: {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    } | undefined;
+    components?: {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
+    } | undefined;
+    plugins?: string[] | undefined;
+}, {
+    tokens: {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    } | Record<string, {
+        source: string[];
+        themes?: Record<string, string[]> | undefined;
+    }>;
+    utilities?: z.objectInputType<{
+        core: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodUnion<[z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        typeMap: z.ZodOptional<z.ZodRecord<z.ZodEnum<["color", "dimension", "fluidDimension", "duration", "cubicBezier", "fontFamily", "fontWeight", "number", "border", "shadow", "gradient", "transition", "strokeStyle"]>, z.ZodArray<z.ZodString, "many">>>;
+        directions: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, z.ZodArray<z.ZodEnum<["top", "right", "bottom", "left", "x", "y", "full"]>, "many">]>>;
+        properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        prefix: z.ZodOptional<z.ZodString>;
+        stripLevels: z.ZodOptional<z.ZodNumber>;
+        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }, {
+        properties?: string[] | undefined;
+        custom?: Record<string, string> | undefined;
+        typeMap?: Partial<Record<"number" | "color" | "dimension" | "fluidDimension" | "duration" | "cubicBezier" | "fontFamily" | "fontWeight" | "border" | "shadow" | "gradient" | "transition" | "strokeStyle", string[]>> | undefined;
+        directions?: "top" | "right" | "bottom" | "left" | "x" | "y" | "full" | ("top" | "right" | "bottom" | "left" | "x" | "y" | "full")[] | undefined;
+        prefix?: string | undefined;
+        stripLevels?: number | undefined;
+    }>, "many">]>, "strip"> | undefined;
+    output?: {
+        tokens?: string | undefined;
+        css?: string | undefined;
+        components?: string | undefined;
+        separate?: boolean | undefined;
+    } | undefined;
+    transforms?: {
+        prefix?: string | undefined;
+        fluid?: {
+            min: number;
+            max: number;
+        } | undefined;
+        colorFormat?: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "oklch" | "p3" | undefined;
+    } | undefined;
+    components?: {
+        framework?: "react" | "astro" | undefined;
+        installed?: string[] | undefined;
     } | undefined;
+    plugins?: string[] | undefined;
 }>;
 
-export { type CSSFileOutput, type CSSGenerationResult, type CSSOutputConfig, type ColorConfig, type ColorFormat, type DirectoriesConfig, type FluidConfig, type LoadError, type LoadResult, type OptionsConfig, type OutputConfig, type ResolutionError, type ResolvedToken, type ResolvedTokens, type SugarcubeConfig, type TokenCollection, type TokenCollections, type TokenLoader, type TokenMemoryData, type TokenSource, type TokenTree, type ValidationError, addWarningBanner, configSchema, convert, flatten, generate, generationPipeline, getTokenPathsFromConfig, loadConfig, loadTreesFromConfig, loadTreesFromMemory, manageCSSIndex, normalizeTokens, parseAndValidateConfig, processTrees, resolve, tokensToCSSPipeline, validate, validateConfig, validationPipeline, writeCSSFilesToDisk };
+export { type CSSFileOutput, DEFAULT_CONFIG, DEFAULT_DESIGN_TOKENS_PATH, DEFAULT_STYLES_PATH, DEFAULT_UTILITIES_FILENAME, DEFAULT_VARIABLES_FILENAME, GLOBAL_DIR, Instrumentation, type LoadConfigResult, type OutputConfig, type PipelineResult, type ResolvedToken, type ResolvedTokens, SUGARCUBE_CONFIG_FILE, SUGARCUBE_FILE, type SugarcubeConfig, TOKENS_FILE_SUFFIX, type TokenCollection, type TokenCollections, type TokenLoader, type TokenPipelineSource, type TokenTree, UTILITIES_DIR, type UserConfig, type UserOutputConfig, type UtilitiesConfig, type UtilityDefinition, VARIABLES_FILE_SUFFIX, configSchema, discoverAllFiles, generateCSSUtilityClasses, generateCSSVariables, generateIndex, generateIndexContent, getTokenPathsFromConfig, internalConfigSchema, loadConfig, normalizeConfig, parseAndValidateConfig, shouldRegenerateIndex, tokenProcessingPipeline, userConfigSchema, validateConfig, writeCSSUtilitiesToDisk, writeCSSVariablesToDisk };