import { StyleResult } from '../pipeline';
import { StyleInjector } from './injector';
import { GlobalInjectResult, InjectResult, StyleInjectorConfig } from './types';
/**
 * Allocate a className for a cacheKey without injecting styles yet
 */
export declare function allocateClassName(cacheKey: string, options?: {
    root?: Document | ShadowRoot;
}): {
    className: string;
    isNewAllocation: boolean;
};
/**
 * Inject styles and return className with dispose function
 */
export declare function inject(rules: StyleResult[], options?: {
    root?: Document | ShadowRoot;
    cacheKey?: string;
}): InjectResult;
/**
 * Inject global rules that should not reserve tasty class names
 */
export declare function injectGlobal(rules: StyleResult[], options?: {
    root?: Document | ShadowRoot;
}): GlobalInjectResult;
/**
 * Inject raw CSS text directly without parsing
 * This is a low-overhead method for injecting raw CSS that doesn't need tasty processing.
 * The CSS is inserted into a separate style element to avoid conflicts with tasty's chunking.
 *
 * @example
 * ```tsx
 * // Inject raw CSS
 * const { dispose } = injectRawCSS(`
 *   body { margin: 0; padding: 0; }
 *   .my-class { color: red; }
 * `);
 *
 * // Later, remove the injected CSS
 * dispose();
 * ```
 */
export declare function injectRawCSS(css: string, options?: {
    root?: Document | ShadowRoot;
}): {
    dispose: () => void;
};
/**
 * Get raw CSS text for SSR
 */
export declare function getRawCSSText(options?: {
    root?: Document | ShadowRoot;
}): string;
/**
 * Inject keyframes and return object with toString() and dispose()
 */
export declare function keyframes(steps: import('./types').KeyframesSteps, nameOrOptions?: string | {
    root?: Document | ShadowRoot;
    name?: string;
}): import('./types').KeyframesResult;
export interface PropertyOptions {
    /**
     * CSS syntax string for the property (e.g., '<color>', '<length>', '<angle>')
     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@property/syntax
     */
    syntax?: string;
    /**
     * Whether the property inherits from parent elements
     * @default true
     */
    inherits?: boolean;
    /**
     * Initial value for the property
     */
    initialValue?: string | number;
    /**
     * Shadow root or document to inject into
     */
    root?: Document | ShadowRoot;
}
/**
 * Define a CSS @property custom property.
 * This enables advanced features like animating custom properties.
 *
 * Note: @property rules are global and persistent once defined.
 * Re-registering the same property name is a no-op.
 *
 * @param name - The custom property name (must start with --)
 * @param options - Property configuration
 *
 * @example
 * ```ts
 * // Define a color property that can be animated
 * property('--my-color', {
 *   syntax: '<color>',
 *   initialValue: 'red',
 * });
 *
 * // Define an angle property
 * property('--rotation', {
 *   syntax: '<angle>',
 *   inherits: false,
 *   initialValue: '0deg',
 * });
 * ```
 */
export declare function property(name: string, options?: PropertyOptions): void;
/**
 * Check if a CSS @property has already been defined
 *
 * @param name - The custom property name to check
 * @param options - Options including root
 */
export declare function isPropertyDefined(name: string, options?: {
    root?: Document | ShadowRoot;
}): boolean;
/**
 * Get CSS text from all sheets (for SSR)
 */
export declare function getCssText(options?: {
    root?: Document | ShadowRoot;
}): string;
/**
 * Collect only CSS used by a rendered subtree (like jest-styled-components).
 * Pass the container returned by render(...).
 */
export declare function getCssTextForNode(node: ParentNode | Element | DocumentFragment, options?: {
    root?: Document | ShadowRoot;
}): string;
/**
 * Force cleanup of unused rules
 */
export declare function cleanup(root?: Document | ShadowRoot): void;
/**
 * Check if we're currently running in a test environment
 */
export declare function getIsTestEnvironment(): boolean;
/**
 * Get the global injector instance for debugging
 */
export declare const injector: {
    readonly instance: StyleInjector;
};
/**
 * Destroy all resources and clean up
 */
export declare function destroy(root?: Document | ShadowRoot): void;
/**
 * Create a new isolated injector instance
 */
export declare function createInjector(config?: Partial<StyleInjectorConfig>): StyleInjector;
export type { StyleInjectorConfig, InjectResult, DisposeFunction, RuleInfo, SheetInfo, RootRegistry, StyleRule, KeyframesInfo, KeyframesResult, KeyframesSteps, KeyframesCacheEntry, CacheMetrics, RawCSSResult, PropertyDefinition, } from './types';
export { StyleInjector } from './injector';
export { SheetManager } from './sheet-manager';
