/**
 * Signal-Σ Extensions
 * Advanced primitives for extensibility following mathematical patterns
 */
export { DragContainer, createDragContainer, composeDragBehaviors, type DragState, type DragOperation, type DraggableConfig, } from './drag-drop';
export { RealtimeSync, createRealtimeSync, createSyncedCounter, createSyncedSet, createSyncedRegister, type SyncMessage, type SyncConfig, type SyncContext, type ConnectionState, } from './realtime-sync';
export { ThemeManager, createThemeManager, createLightTheme, createDarkTheme, composeThemes, mapThemeColors, type CSSVar, type CSSVars, type Theme, type ThemeConfig, type ColorUtils, } from './theme-system';
export { UndoRedoManager, createUndoRedoManager, createCommand, createTextCommand, createArrayCommand, type Memento, type Command, type TimeTravel, type UndoRedoConfig, } from './undo-redo';
export declare const ExtensionPatterns: {
    Operad: {
        compose: <A, B, C>(f: (a: A) => B, g: (b: B) => C) => (a: A) => C;
        plug: <T, U, V>(outer: (u: U) => V, inner: (t: T) => U) => (t: T) => V;
        identity: <T_1>(x: T_1) => T_1;
    };
    CommutativeMonoid: {
        empty: <T_2>() => T_2[];
        combine: <T_3>(a: T_3[], b: T_3[]) => T_3[];
        isCommutative: boolean;
        isAssociative: boolean;
        hasIdentity: boolean;
    };
    Functor: {
        map: <A_1, B_1>(f: (a: A_1) => B_1) => (fa: A_1[]) => B_1[];
        identity: <A_2>(fa: A_2[]) => A_2[];
        composition: <A_3, B_2, C_1>(f: (a: A_3) => B_2, g: (b: B_2) => C_1) => (a: A_3) => C_1;
    };
    Coalgebra: {
        unfold: <S, A_4>(seed: S, next: (s: S) => [A_4, S]) => A_4[];
        observe: <S_1, A_5>(state: S_1, observer: (s: S_1) => A_5) => A_5;
        transition: <S_2>(state: S_2, transition: (s: S_2) => S_2) => S_2;
    };
};
export declare const createExtension: <T, Config = any>(name: string, pattern: 'operad' | 'monoid' | 'functor' | 'coalgebra', implementation: {
    create: (config: Config) => T;
    compose?: (a: T, b: T) => T;
    map?: <U>(f: (x: any) => U, t: T) => any;
    unfold?: (seed: any, next: (s: any) => [any, any]) => any;
}) => {
    name: string;
    pattern: "operad" | "monoid" | "functor" | "coalgebra";
    create: (config: Config) => T;
    compose: (a: T, b: T) => T;
    map: <U>(f: (x: any) => U, t: T) => any;
    unfold: (seed: any, next: (s: any) => [any, any]) => any;
    verify: () => {
        hasIdentity: boolean;
        hasComposition: boolean;
        isAssociative: boolean;
        isCommutative?: undefined;
        hasMap?: undefined;
        preservesIdentity?: undefined;
        preservesComposition?: undefined;
        hasUnfold?: undefined;
        isObservable?: undefined;
        hasTransitions?: undefined;
    } | {
        hasIdentity: boolean;
        hasComposition: boolean;
        isAssociative: boolean;
        isCommutative: boolean;
        hasMap?: undefined;
        preservesIdentity?: undefined;
        preservesComposition?: undefined;
        hasUnfold?: undefined;
        isObservable?: undefined;
        hasTransitions?: undefined;
    } | {
        hasMap: boolean;
        preservesIdentity: boolean;
        preservesComposition: boolean;
        hasIdentity?: undefined;
        hasComposition?: undefined;
        isAssociative?: undefined;
        isCommutative?: undefined;
        hasUnfold?: undefined;
        isObservable?: undefined;
        hasTransitions?: undefined;
    } | {
        hasUnfold: boolean;
        isObservable: boolean;
        hasTransitions: boolean;
        hasIdentity?: undefined;
        hasComposition?: undefined;
        isAssociative?: undefined;
        isCommutative?: undefined;
        hasMap?: undefined;
        preservesIdentity?: undefined;
        preservesComposition?: undefined;
    } | {
        hasIdentity?: undefined;
        hasComposition?: undefined;
        isAssociative?: undefined;
        isCommutative?: undefined;
        hasMap?: undefined;
        preservesIdentity?: undefined;
        preservesComposition?: undefined;
        hasUnfold?: undefined;
        isObservable?: undefined;
        hasTransitions?: undefined;
    };
};
export declare const ExampleExtensions: {
    DragDropOperad: {
        name: string;
        pattern: "operad" | "monoid" | "functor" | "coalgebra";
        create: (config: any) => any;
        compose: (a: any, b: any) => any;
        map: <U>(f: (x: any) => U, t: any) => any;
        unfold: (seed: any, next: (s: any) => [any, any]) => any;
        verify: () => {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative: boolean;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasMap: boolean;
            preservesIdentity: boolean;
            preservesComposition: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasUnfold: boolean;
            isObservable: boolean;
            hasTransitions: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
        } | {
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        };
    };
    SyncMonoid: {
        name: string;
        pattern: "operad" | "monoid" | "functor" | "coalgebra";
        create: (config: any) => any;
        compose: (a: any, b: any) => any;
        map: <U>(f: (x: any) => U, t: any) => any;
        unfold: (seed: any, next: (s: any) => [any, any]) => any;
        verify: () => {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative: boolean;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasMap: boolean;
            preservesIdentity: boolean;
            preservesComposition: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasUnfold: boolean;
            isObservable: boolean;
            hasTransitions: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
        } | {
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        };
    };
    ThemeFunctor: {
        name: string;
        pattern: "operad" | "monoid" | "functor" | "coalgebra";
        create: (config: any) => any;
        compose: (a: any, b: any) => any;
        map: <U>(f: (x: any) => U, t: any) => any;
        unfold: (seed: any, next: (s: any) => [any, any]) => any;
        verify: () => {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative: boolean;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasMap: boolean;
            preservesIdentity: boolean;
            preservesComposition: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasUnfold: boolean;
            isObservable: boolean;
            hasTransitions: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
        } | {
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        };
    };
    UndoRedoCoalgebra: {
        name: string;
        pattern: "operad" | "monoid" | "functor" | "coalgebra";
        create: (config: any) => {
            initialState: any;
            options: any;
        };
        compose: (a: {
            initialState: any;
            options: any;
        }, b: {
            initialState: any;
            options: any;
        }) => {
            initialState: any;
            options: any;
        };
        map: <U_1>(f: (x: any) => U_1, t: {
            initialState: any;
            options: any;
        }) => any;
        unfold: (seed: any, next: (s: any) => [any, any]) => any;
        verify: () => {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasIdentity: boolean;
            hasComposition: boolean;
            isAssociative: boolean;
            isCommutative: boolean;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasMap: boolean;
            preservesIdentity: boolean;
            preservesComposition: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        } | {
            hasUnfold: boolean;
            isObservable: boolean;
            hasTransitions: boolean;
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
        } | {
            hasIdentity?: undefined;
            hasComposition?: undefined;
            isAssociative?: undefined;
            isCommutative?: undefined;
            hasMap?: undefined;
            preservesIdentity?: undefined;
            preservesComposition?: undefined;
            hasUnfold?: undefined;
            isObservable?: undefined;
            hasTransitions?: undefined;
        };
    };
};
export declare const composeExtensions: <T>(...extensions: T[]) => T;
export declare const validateExtension: (extension: any) => boolean;
export declare class ExtensionRegistry {
    private extensions;
    register<T>(name: string, extension: T): void;
    get<T>(name: string): T | undefined;
    list(): string[];
    compose(names: string[]): any;
}
export declare const globalExtensionRegistry: ExtensionRegistry;