@omnia/fx-models 8.0.457-dev → 8.0.458-dev

package/internal-do-not-import-from-here/shared/aurora/stores/ColorManager.d.ts

@@ -0,0 +1,9 @@
+import { ColorDefinition } from "internal/fx/shared/models";
+export declare function useColorManager(): {
+    isWcagCompliant: (color1: string, color2: string, level: "AA" | "AAA") => boolean;
+    getColorDefinition: (color: string, isBaseColorDark: boolean) => ColorDefinition;
+    isDarkColor: (color: any) => boolean;
+    addOpacityToColor: (color: any, opacity: any) => any;
+    isValidColor: (color: string) => boolean;
+    hasOpacity: (color: string) => boolean;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ColorSchemaStore.d.ts

@@ -0,0 +1,46 @@
+import { type StoreEvents, type StoreReturnDefineAction } from "internal/fx/shared";
+import { ColorDefinition, ColorGradientValue, ColorSchema, ColorSchemaType, ColorSchemaTypes, ColorTypes, ColorValue, guid } from "internal/fx/shared/models";
+import { useThemeStore } from "./ThemeStore";
+export type ColorSchemaStoreType = {
+    state: {
+        base: ColorDefinition;
+        onBase: ColorDefinition;
+        name: string;
+        colorSchemaType: ColorSchemaTypes | ColorSchemaType;
+        id: guid;
+    };
+    events: StoreEvents<{
+        base: ColorDefinition;
+        onBase: ColorDefinition;
+        name: string;
+        colorSchemaType: ColorSchemaTypes | ColorSchemaType;
+        id: guid;
+    }>;
+    actions: StoreReturnDefineAction<{
+        setColorSchema(colorSchemaType: ColorSchemaTypes | ColorSchemaType, container?: boolean): void;
+        setCustomColorSchema(colorSchema: ColorSchema, container?: boolean): void;
+        setColor(colorDefinition: ColorDefinition, colorType: ColorTypes): void;
+        setThemeStore(themeStoreInstance: ReturnType<typeof useThemeStore>): void;
+    }>;
+    get: {
+        themeStore: ReturnType<typeof useThemeStore>;
+        colorValue(color: ColorValue | ColorGradientValue, colorSchema?: ColorSchema): string;
+        colorSchema: ColorSchema;
+        theme: "dark" | "light";
+        base: ColorDefinition;
+        onBase: ColorDefinition;
+    };
+    dispose(force?: boolean): void;
+};
+export type InternalColorSchemaStoreType = ColorSchemaStoreType & {
+    actions: {
+        disableAutoDispose(): void;
+    };
+};
+export declare const useColorSchemaStore: () => ColorSchemaStoreType & {
+    actions: {
+        disableAutoDispose(): void;
+    };
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ComponentBlueprintStore.d.ts

@@ -0,0 +1,54 @@
+import { Blueprint, BlueprintsStrategyBase, BlueprintVariant, ButtonBlueprint, ButtonBlueprintVariant, ComponentBlueprints, ContainerFillValue, HeaderBlueprint, IconBlueprint, InputBlueprint, OIconSizes, TabsBlueprint, TextStyleDefinition, TypographyBlueprint, WebBlueprintItemDefintionType } from "internal/fx/shared/models";
+type blueprintType = "default";
+export declare const useComponentBlueprintStore: () => {
+    state: {
+        blueprints: ComponentBlueprints;
+    };
+    events: import("internal/fx/shared").StoreEvents<{
+        blueprints: ComponentBlueprints;
+    }, Record<string, import("internal/fx/shared").IMessageBusTopicPublishSubscriber<any>>>;
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        ensure(): {
+            buttons: () => void;
+        };
+        setBlueprint(type: blueprintType): void;
+        setBluePrints(componentBlueprints: ComponentBlueprints): void;
+    }>;
+    get: {
+        byType<TType extends Blueprint>(type: WebBlueprintItemDefintionType): any;
+        readonly blueprints: ComponentBlueprints;
+        fallbackBlueprints: {
+            get(): ComponentBlueprints;
+            byType(strategyType: BlueprintsStrategyBase): ComponentBlueprints;
+        };
+        button: {
+            iconBlueprintBySize(sizeType: OIconSizes): ButtonBlueprint;
+            blueprintByType(type: ButtonBlueprintVariant | ButtonBlueprint): any;
+        };
+        input: {
+            blueprintByType(type: BlueprintVariant | InputBlueprint): InputBlueprint;
+        };
+        tabs: {
+            blueprintByType(type: BlueprintVariant | TabsBlueprint): TabsBlueprint;
+        };
+        icon: {
+            blueprint(size: OIconSizes): IconBlueprint;
+            size: {
+                byBluePrint(blueprint: IconBlueprint, typographyBlueprint: TypographyBlueprint): TextStyleDefinition;
+                byIconSize(size: OIconSizes, typographyBlueprint: TypographyBlueprint): TextStyleDefinition;
+            };
+        };
+        containerFill: {
+            hasVariant(type: BlueprintVariant | string): boolean;
+            getByType(type: ContainerFillValue): any;
+        };
+        header: {
+            hasVariant(type: BlueprintVariant | string): boolean;
+            blueprintByType(type: BlueprintVariant | HeaderBlueprint): HeaderBlueprint;
+        };
+    };
+    deactivated(): void;
+} & {
+    dispose?: () => void;
+};
+export {};

package/internal-do-not-import-from-here/shared/aurora/stores/DefineThemeProvider.d.ts

@@ -0,0 +1,4 @@
+import { useThemeProviderStore } from "./ThemeProvider";
+type SetupThemeProvider = Pick<ReturnType<typeof useThemeProviderStore>["actions"], "registerStore" | "registerDefaultTypographyBlueprints" | "registerDefaultSpacingBlueprints" | "registerDefaultLightColorSchema" | "registerDefaultDarkColorSchema" | "registerComponentBlueprintStrategy" | "defineCustomFontLoader">;
+export declare function defineThemeProvider(setup: (ctx: SetupThemeProvider) => void): void;
+export {};

package/internal-do-not-import-from-here/shared/aurora/stores/FontStore.d.ts

@@ -0,0 +1,18 @@
+import { Future, ITemplateRegistration, TypographyFontDefinition } from "internal/fx/shared/models";
+export declare const useFontStore: () => {
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        ensureLoadFonts: () => Future<ITemplateRegistration<TypographyFontDefinition, import("internal/fx/shared").TemplateRegistrationType>[]>;
+        addFont(font: TypographyFontDefinition): void;
+        editFont(font: TypographyFontDefinition): void;
+        onFinishLoad(): Future<Record<string, ITemplateRegistration<any, import("internal/fx/shared").TemplateRegistrationType>>>;
+        saveFont(): Promise<boolean>;
+        delete(font: TypographyFontDefinition): Promise<void>;
+    }>;
+    get: {
+        readonly availableFonts: TypographyFontDefinition[];
+        findFont(family: string): ITemplateRegistration<TypographyFontDefinition, import("internal/fx/shared").TemplateRegistrationType>;
+        readonly finishLoad: boolean;
+    };
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/SpacingBlueprintStore.d.ts

@@ -0,0 +1,42 @@
+import { BlueprintVariant, guid } from "internal/fx/shared/models";
+import { useThemeStore } from "./ThemeStore";
+export declare const useSpacingBlueprintStore: () => {
+    state: {
+        blueprint: import("internal/fx/shared").SpacingBlueprint;
+        blueprintType: BlueprintVariant;
+        id: guid;
+        isCustomBlueprint: boolean;
+    };
+    events: import("internal/fx/shared").StoreEvents<{
+        blueprint: import("internal/fx/shared").SpacingBlueprint;
+        blueprintType: BlueprintVariant;
+        id: guid;
+        isCustomBlueprint: boolean;
+    }, Record<string, import("internal/fx/shared").IMessageBusTopicPublishSubscriber<any>>>;
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        setBlueprint(): void;
+        setThemeStore(themeStoreInstance: ReturnType<typeof useThemeStore>): void;
+    }>;
+    get: {
+        readonly defaultSpacingBlueprint: import("internal/fx/shared").SpacingBlueprint;
+        readonly themeStore: ReturnType<typeof useThemeStore>;
+        readonly blueprint: import("internal/fx/shared").SpacingBlueprint;
+        readonly spacingScaling: {
+            get: {
+                valueWithoutScale: (value: import("internal/fx/shared").SpacingValue) => string | number;
+                scaleFromValue: (value: import("internal/fx/shared").SpacingValue) => import("internal/fx/shared").SpacingScale;
+                scale: (value: import("internal/fx/shared").Spacing | import("internal/fx/shared").SpacingValue) => import("internal/fx/shared").SpacingScale;
+            };
+            add: {
+                scaleToValue: (value: import("internal/fx/shared").SpacingValue, scale: import("internal/fx/shared").SpacingScale) => string | number;
+                fallBackScale: (value: import("internal/fx/shared").SpacingValue, scale: import("internal/fx/shared").SpacingScale) => string | number;
+            };
+            has: {
+                scaling: (value: import("internal/fx/shared").SpacingValue) => boolean;
+            };
+        };
+    };
+    deactivated(): void;
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/TemplateRegistrationStore.d.ts

@@ -0,0 +1,20 @@
+import { guid, ITemplateRegistration, TemplateRegistrationType, Future } from "internal/fx/shared/models";
+export declare const useTemplateRegistrationStore: () => {
+    state: {
+        registrations: Record<string, ITemplateRegistration<any, TemplateRegistrationType>>;
+    };
+    events: import("internal/fx/shared").StoreEvents<{
+        registrations: Record<string, ITemplateRegistration<any, TemplateRegistrationType>>;
+    }, Record<string, import("internal/fx/shared").IMessageBusTopicPublishSubscriber<any>>>;
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        upsertRegistration<TTemplateRegistration extends ITemplateRegistration<any>>(registration: TTemplateRegistration): Promise<boolean>;
+        deleteRegistration(registrationId: guid): Promise<boolean>;
+        ensureLoadTemplates: () => Future<Record<string, ITemplateRegistration<any, TemplateRegistrationType>>>;
+    }>;
+    get: {
+        byId: <TTemplateRegistration extends ITemplateRegistration<any>>(id: guid) => ITemplateRegistration<any, TemplateRegistrationType>;
+        getByType: <TTemplateRegistration extends ITemplateRegistration<any>>(type: TemplateRegistrationType) => Array<TTemplateRegistration>;
+    };
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ThemeContextStore.d.ts

@@ -0,0 +1,16 @@
+import { ThemeContextType } from "internal/fx/shared/models";
+import { useThemeStore } from "./ThemeStore";
+export declare const useThemeContextStore: () => {
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        saveTheme(variant: ThemeContextType): void;
+    }>;
+    get: {
+        readonly defaultTheme: ReturnType<typeof useThemeStore>;
+        readonly adminTheme: ReturnType<typeof useThemeStore>;
+        readonly previewTheme: ReturnType<typeof useThemeStore>;
+        readonly designerTheme: ReturnType<typeof useThemeStore>;
+        byType(type: ThemeContextType): ReturnType<typeof useThemeStore>;
+    };
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ThemeMigrations.d.ts

@@ -0,0 +1,12 @@
+import { SpacingBlueprint, TypographyBlueprint } from "internal/fx/shared/models";
+export declare function ThemeMigrations(): {
+    spacing: {
+        migrate: (blueprint: SpacingBlueprint) => SpacingBlueprint;
+    };
+    typography: {
+        migrate: (blueprint: TypographyBlueprint) => TypographyBlueprint;
+    };
+    theme: {
+        migrate(themeDefinition: any): any;
+    };
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ThemeNormalizer.d.ts

@@ -0,0 +1,5 @@
+import { ResolvedThemeDefinition, TypographyBlueprint } from "internal/fx/shared/models";
+export declare function ThemeNormalizer(): {
+    normalizeTypography: (typography: TypographyBlueprint) => TypographyBlueprint;
+    normalize: (themeDefinition: ResolvedThemeDefinition) => ResolvedThemeDefinition;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ThemeProvider.d.ts

@@ -0,0 +1,39 @@
+import { ColorSchemas, guid, ResolvedThemeDefinition, SpacingBlueprint, TypographyBlueprint, TypographyFontDefinition } from "internal/fx/shared/models";
+import { ThemeRegistrationStoreType, ThemeRegistration, ComponentBlueprintStrategyType } from "./ThemeSharedModels";
+export declare const useThemeProviderStore: () => {
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        registerStore(store: () => ThemeRegistrationStoreType): void;
+        initiateStore(): void;
+        registerDefaultTypographyBlueprints(blueprints: TypographyBlueprint): void;
+        registerDefaultSpacingBlueprints(blueprints: SpacingBlueprint): void;
+        registerDefaultLightColorSchema(blueprints: ColorSchemas): void;
+        registerDefaultDarkColorSchema(blueprints: ColorSchemas): void;
+        registerComponentBlueprintStrategy(strategy: ComponentBlueprintStrategyType): void;
+        defineCustomFontLoader(loader: (font: TypographyFontDefinition) => void): void;
+        loadAll(): Promise<import("./ThemeSharedModels").ThemesResolved>;
+        save(theme: ThemeRegistration): Promise<any>;
+        delete(id: guid): Promise<any>;
+        setAdminTheme(theme: ResolvedThemeDefinition): void;
+        setDefaultTheme(theme: ResolvedThemeDefinition): void;
+        loadCustomFont(font: TypographyFontDefinition): void;
+    }>;
+    get: {
+        readonly adminTheme: ResolvedThemeDefinition;
+        readonly defaultTheme: ResolvedThemeDefinition;
+        readonly defaultTypographyBlueprints: TypographyBlueprint;
+        readonly defaultSpacingBlueprints: SpacingBlueprint;
+        readonly defaultLightColorSchema: ColorSchemas;
+        readonly defaultDarkColorSchema: ColorSchemas;
+        readonly componentBlueprintStrategy: ComponentBlueprintStrategyType;
+    };
+    readonly events: {
+        onMutatedAdminTheme: import("internal/fx/shared").MessageBusExposeOnlySubscription<ResolvedThemeDefinition>;
+        onMutatedDefaultTheme: import("internal/fx/shared").MessageBusExposeOnlySubscription<ResolvedThemeDefinition>;
+    };
+    validations: {
+        checkPlatformStoreRegistered(): void;
+        checkDefaultBlueprintsRegistered(type: "typography" | "spacing" | "light" | "dark" | "component"): void;
+    };
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ThemeSharedModels.d.ts

@@ -0,0 +1,33 @@
+import { ColorSchema, ComponentBlueprints, guid, ITemplateRegistration, ResolvedThemeDefinition, SpacingBlueprint, TemplateRegistrationType, ThemeDefinition, TypographyBlueprint } from "internal/fx/shared/models";
+import { StoreEvents, StoreReturnDefineAction } from "internal/fx/shared";
+export type ThemeRegistration = ITemplateRegistration<ResolvedThemeDefinition, TemplateRegistrationType> | ITemplateRegistration<ColorSchema> | ITemplateRegistration<TypographyBlueprint> | ITemplateRegistration<ComponentBlueprints> | ITemplateRegistration<SpacingBlueprint>;
+export type ThemesResolved = Array<ThemeDefinition | ColorSchema | TypographyBlueprint | SpacingBlueprint | ComponentBlueprints>;
+export type ThemeRegistrationStoreType = {
+    state: {
+        adminTheme: ResolvedThemeDefinition;
+        defaultTheme: ResolvedThemeDefinition;
+    };
+    events: StoreEvents<{
+        adminTheme: ResolvedThemeDefinition;
+        defaultTheme: ResolvedThemeDefinition;
+    }>;
+    actions: StoreReturnDefineAction<{
+        loadAll(): Promise<ThemesResolved>;
+        save(theme: ThemeRegistration): Promise<any>;
+        delete(id: guid): Promise<any>;
+    }>;
+    get: {
+        readonly adminTheme: ResolvedThemeDefinition;
+        readonly defaultTheme: ResolvedThemeDefinition;
+    };
+};
+export type ComponentBlueprintStrategyType = {
+    roundness: {
+        readonly none: ComponentBlueprints;
+        readonly xs: ComponentBlueprints;
+        readonly s: ComponentBlueprints;
+        readonly m: ComponentBlueprints;
+        readonly l: ComponentBlueprints;
+        readonly full: ComponentBlueprints;
+    };
+};

package/internal-do-not-import-from-here/shared/aurora/stores/ThemeStore.d.ts

@@ -0,0 +1,91 @@
+import { ColorSchema, ColorSchemaType, ColorSchemaTypes, ColorType, ColorTypes, BlueprintVariant, ResolvedThemeDefinition, guid, TextFillDefinitionValue, ContainerFillValue, ContainerFillBlueprint } from "internal/fx/shared/models";
+import { type ColorSchemaStoreType } from "./ColorSchemaStore";
+export declare const useThemeStore: () => {
+    id: guid;
+    state: {
+        currentTheme: ResolvedThemeDefinition;
+    };
+    events: import("internal/fx/shared").StoreEvents<{
+        currentTheme: ResolvedThemeDefinition;
+    }, Record<string, import("internal/fx/shared").IMessageBusTopicPublishSubscriber<any>>>;
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        setTheme(themeDefinition: ResolvedThemeDefinition): void;
+    }>;
+    get: {
+        getOrSetColorSchema(colorSchemaType: ColorSchemaTypes | ColorSchemaType): {
+            value: ColorSchemaStoreType;
+            setValue(value: ColorSchemaStoreType): void;
+        };
+        componentBlueprintStore(): {
+            state: {
+                blueprints: import("internal/fx/shared").ComponentBlueprints;
+            };
+            events: import("internal/fx/shared").StoreEvents<{
+                blueprints: import("internal/fx/shared").ComponentBlueprints;
+            }, Record<string, import("internal/fx/shared").IMessageBusTopicPublishSubscriber<any>>>;
+            actions: import("internal/fx/shared").StoreReturnDefineAction<{
+                ensure(): {
+                    buttons: () => void;
+                };
+                setBlueprint(type: "default"): void;
+                setBluePrints(componentBlueprints: import("internal/fx/shared").ComponentBlueprints): void;
+            }>;
+            get: {
+                byType<TType extends import("internal/fx/shared").Blueprint>(type: import("internal/fx/shared").WebBlueprintItemDefintionType): any;
+                readonly blueprints: import("internal/fx/shared").ComponentBlueprints;
+                fallbackBlueprints: {
+                    get(): import("internal/fx/shared").ComponentBlueprints;
+                    byType(strategyType: import("internal/fx/shared").BlueprintsStrategyBase): import("internal/fx/shared").ComponentBlueprints;
+                };
+                button: {
+                    iconBlueprintBySize(sizeType: import("internal/fx/shared").OIconSizes): import("internal/fx/shared").ButtonBlueprint;
+                    blueprintByType(type: import("internal/fx/shared").ButtonBlueprintVariant | import("internal/fx/shared").ButtonBlueprint): any;
+                };
+                input: {
+                    blueprintByType(type: BlueprintVariant | import("internal/fx/shared").InputBlueprint): import("internal/fx/shared").InputBlueprint;
+                };
+                tabs: {
+                    blueprintByType(type: BlueprintVariant | import("internal/fx/shared").TabsBlueprint): import("internal/fx/shared").TabsBlueprint;
+                };
+                icon: {
+                    blueprint(size: import("internal/fx/shared").OIconSizes): import("internal/fx/shared").IconBlueprint;
+                    size: {
+                        byBluePrint(blueprint: import("internal/fx/shared").IconBlueprint, typographyBlueprint: import("internal/fx/shared").TypographyBlueprint): import("internal/fx/shared").TextStyleDefinition;
+                        byIconSize(size: import("internal/fx/shared").OIconSizes, typographyBlueprint: import("internal/fx/shared").TypographyBlueprint): import("internal/fx/shared").TextStyleDefinition;
+                    };
+                };
+                containerFill: {
+                    hasVariant(type: BlueprintVariant | string): boolean;
+                    getByType(type: ContainerFillValue): any;
+                };
+                header: {
+                    hasVariant(type: BlueprintVariant | string): boolean;
+                    blueprintByType(type: BlueprintVariant | import("internal/fx/shared").HeaderBlueprint): import("internal/fx/shared").HeaderBlueprint;
+                };
+            };
+            deactivated(): void;
+        } & {
+            dispose?: () => void;
+        };
+        colorSchema(colorSchemaType: ColorSchemaTypes | ColorSchemaType | ColorSchema): ColorSchema;
+        typography(): import("internal/fx/shared").TypographyBlueprint;
+        fills(): {
+            text: {
+                hasVariant(type: BlueprintVariant | string): boolean;
+                byValue(value: TextFillDefinitionValue): TextFillDefinitionValue;
+            };
+            container: {
+                hasVariant(type: BlueprintVariant | string): boolean;
+                bluePrints(): import("internal/fx/shared").ContainerFillBlueprints;
+                byValue(value: ContainerFillValue): ContainerFillBlueprint;
+            };
+        };
+        spacing(): import("internal/fx/shared").SpacingBlueprint;
+        component(): import("internal/fx/shared").ComponentBlueprints;
+        color(colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType): string;
+        colorDefinition(colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType): import("internal/fx/shared").ColorDefinition;
+        currentTheme(): ResolvedThemeDefinition;
+    };
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/TypographyBlueprintManager.d.ts

@@ -0,0 +1,22 @@
+import { TextStyleDefinition, TypographyBlueprint } from "internal/fx/shared/models";
+interface BreakpointScale {
+    lg: number;
+    md: number;
+    sm: number;
+}
+export declare function useTypographyBlueprintManager(): {
+    typeScale: {
+        getFontSize: (blueprint: TypographyBlueprint, scaleSlots: BreakpointScale) => void;
+        createTextStyleDefinition: (blueprint: TypographyBlueprint, scaleSlots: BreakpointScale) => TextStyleDefinition;
+    };
+    textStyledefinition: {
+        createAll(blueprint: TypographyBlueprint): TypographyBlueprint;
+        update(definition: TextStyleDefinition, blueprint: TypographyBlueprint): TextStyleDefinition;
+        strip(definition: TextStyleDefinition): TextStyleDefinition;
+    };
+    blueprint: {
+        initFromScale(blueprint: TypographyBlueprint): TypographyBlueprint;
+        strip(blueprint: TypographyBlueprint): TypographyBlueprint;
+    };
+};
+export {};

package/internal-do-not-import-from-here/shared/aurora/stores/TypographyBlueprintStore.d.ts

@@ -0,0 +1,34 @@
+import { guid, TextStyleDefinition, TextStyleSize, TextStyleSizes, TextStyleType, TextStyleTypes, TypographyBlueprint, TypographyFontDefinition } from "internal/fx/shared/models";
+import { useThemeStore } from "./ThemeStore";
+export declare const useTypographyBlueprintStore: () => {
+    state: {
+        blueprint: TypographyBlueprint;
+        id: guid;
+        availableFonts: TypographyFontDefinition[];
+        isCustomBlueprint: boolean;
+    };
+    events: import("internal/fx/shared").StoreEvents<{
+        blueprint: TypographyBlueprint;
+        id: guid;
+        availableFonts: TypographyFontDefinition[];
+        isCustomBlueprint: boolean;
+    }, Record<string, import("internal/fx/shared").IMessageBusTopicPublishSubscriber<any>>>;
+    rules: {
+        isStyleActive: (textStyleType: TextStyleType, size: TextStyleSizes) => boolean;
+    };
+    actions: import("internal/fx/shared").StoreReturnDefineAction<{
+        normalize(blueprint: TypographyBlueprint): TypographyBlueprint;
+        setBlueprint(): void;
+        setThemeStore(themeStoreInstance: ReturnType<typeof useThemeStore>): void;
+    }>;
+    get: {
+        readonly defaultTypographyBlueprint: TypographyBlueprint;
+        textStyleName: (textStyle: TextStyleType, size: TextStyleSizes) => any;
+        readonly themeStore: ReturnType<typeof useThemeStore>;
+        readonly blueprint: TypographyBlueprint;
+        typography(typographyType: TextStyleTypes | TextStyleType, size: TextStyleSize | TextStyleSizes): TextStyleDefinition;
+    };
+    deactivated(): void;
+} & {
+    dispose?: () => void;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/VariantManager.d.ts

@@ -0,0 +1,7 @@
+export declare function useVariantManager<TVariants extends Record<string, any>, TVariant>(): {
+    countVariants: (variants: TVariants, variantTypes: Array<string>) => number;
+    getEmptyVariant: (variants: TVariants, variantTypes: Array<string>) => string;
+    hasEmptySlots: (variants: TVariants, variantTypes: Array<string>) => boolean;
+    hasVariant: (variants: TVariants, variant: string) => boolean;
+    getVariant: (variants: TVariants, variant: string) => any;
+};

package/internal-do-not-import-from-here/shared/aurora/stores/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./ColorManager";
+export * from "./ComponentBlueprintStore";
+export * from "./FontStore";
+export { useColorSchemaStore, type ColorSchemaStoreType } from "./ColorSchemaStore";
+export * from "./SpacingBlueprintStore";
+export * from "./TemplateRegistrationStore";
+export * from "./ThemeContextStore";
+export * from "./ThemeMigrations";
+export * from "./ThemeNormalizer";
+export * from "./DefineThemeProvider";
+export * from "./ThemeSharedModels";
+export * from "./ThemeStore";
+export * from "./TypographyBlueprintManager";
+export * from "./TypographyBlueprintStore";
+export * from "./VariantManager";

package/internal-do-not-import-from-here/shared/aurora/styles/StyleFormatters.d.ts

@@ -0,0 +1,4 @@
+export declare namespace StyleFormatters {
+    function formatPixelValue(value: any): string;
+    function formatMediaUrl(url: string): string;
+}

package/internal-do-not-import-from-here/shared/aurora/styles/index.d.ts

@@ -0,0 +1 @@
+export * from "./StyleFormatters";

package/internal-do-not-import-from-here/shared/models/theme/Blueprints.d.ts

@@ -3,6 +3,7 @@ import { SpacingDefinition, Spacing, SpacingValue } from "./Spacing";
 import { TypographyFontDefinition, TextStyleValue } from "./Typography";
 import { ThemeBase } from "./ThemeBase";
 import { VelcronRendererResolverReference } from "../velcron";
+import { TextAlignment } from "@omnia/fx-models";
 export interface BlueprintStrategy {
     buttons: {
         primary: ButtonBlueprint;
@@ -30,12 +31,24 @@ export interface VariantBlueprints<T> extends Blueprints {
     variant7?: T;
     variant8?: T;
 }
+export interface HeaderIconSettings {
+    blueprint?: IconBlueprint;
+    background?: BackgroundDefinition;
+    spacing?: Spacing;
+}
 export interface HeaderBlueprint extends Blueprint {
+    /**velcron */
     renderer?: VelcronRendererResolverReference;
     state?: any;
+    /**Settings */
+    background?: BackgroundDefinition;
+    textAlign?: TextAlignment;
+    padding?: SpacingValue;
+    text?: TextBlueprint;
+    iconSettings?: HeaderIconSettings;
 }
 export interface HeaderBlueprints extends Blueprints, VariantBlueprints<HeaderBlueprint>, BlueprintsReference {
-    primary?: TabsBlueprint;
+    primary?: HeaderBlueprint;
 }
 export interface TextFillBlueprints extends VariantBlueprints<TextFillBlueprint>, Blueprints, BlueprintsReference {
 }
@@ -156,7 +169,7 @@ export interface TabsBlueprint extends Blueprint {
     text?: TextBlueprint;
     icon?: IconBlueprint;
     active?: {
-        viewTemplate?: VelcronRendererResolverReference;
+        renderer?: VelcronRendererResolverReference;
         padding?: Spacing;
         iconPadding?: SpacingValue;
         background?: BackgroundDefinition;
@@ -165,7 +178,7 @@ export interface TabsBlueprint extends Blueprint {
     };
     inactive?: {
         background?: BackgroundDefinition;
-        viewTemplate?: VelcronRendererResolverReference;
+        renderer?: VelcronRendererResolverReference;
     };
 }
 export interface TextBlueprint extends Blueprint {

package/internal-do-not-import-from-here/velcron/core/models/VelcronDefinitions.d.ts

@@ -1,11 +1,11 @@
 import { VelcronOnUpdatedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnPressEvent, VelcronSpacing, VelcronStyling, VelcronCustomComponentDefinition, VelcronAppDefinition, VelcronRendererResolverReference, EventHook, Future, TextBlueprint, VelcronBindableProp, VelcronEditor, ContainerFillBlueprint, BackgroundDefinition, BlueprintVariant, IconBlueprint, ButtonBlueprint, VelcronOnPressOutsideEvent, VelcronOnPointerEnterEvent, VelcronOnPointerLeaveEvent, VelcronColorStyling, VelcronOverflowValues, VelcronImageRatios } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
 import { VelcronComponentArrayType, VelcronPrimitiveType } from "./VelcronTypes";
 import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, VelcronActionTypes, VelcronVerticalAlignments } from "./Enums";
-import { DynamicState, VelcronDefinition, VelcronEffects, useVelcronThemingStore } from "..";
+import { DynamicState, VelcronDefinition, VelcronEffects } from "..";
 import { guid, PropertyConfiguration, PropertyValue, PropertyDefinition, PropertySetupBase } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
-import { useVelcronColorSchemaStore } from "../stores/VelcronColorSchema";
 import { Properties } from "csstype";
 import type { AnimationOptionsWithOverrides, InViewOptions, VariantDefinition, Variants } from "motion";
+import { useColorSchemaStore, useThemeStore } from "internal/fx/ux/mobile";
 export interface ResolvedComponentRenderer {
     component: unknown;
     definition: VelcronDefinition;
@@ -83,8 +83,8 @@ export interface VelcronRenderContext {
     id?: string;
     rootContext: DynamicState;
     currentContext: DynamicState;
-    theming?: ReturnType<typeof useVelcronThemingStore>;
-    colors?: ReturnType<typeof useVelcronColorSchemaStore>;
+    theming?: ReturnType<typeof useThemeStore>;
+    colors?: ReturnType<typeof useColorSchemaStore>;
     actions?: {
         [name: string]: Array<string>;
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx-models",
   "license": "MIT",
-  "version": "8.0.457-dev",
+  "version": "8.0.458-dev",
   "description": "Provide Omnia Fx Models Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"