declare module "@myop/sdk/dynamicImport/defineDynamicImport" {
    export const __federation__ = "__federation__";
    export const onLoadKey = "onLoad";
    export const moduleInstanceKey = "moduleInstance";
    export const defineDynamicImport: (globalName: string, module: any) => void;
}
declare module "@myop/sdk/dynamicImport/load__federation__" { }
declare module "@myop/sdk/common/MyopMessages" {
    type StringWithAutocomplete<T> = T | (string & Record<never, never>);
    export type MyopMessageKey = StringWithAutocomplete<keyof typeof MyopMessages | keyof typeof MyopMessages.In>;
    export const MyopMessages: {
        InitRequest: string;
        InitResponse: string;
        InitMessage: string;
        DisposeMessage: string;
        ChangeTextMessage: string;
        BindClickMessage: string;
        DetectMyopRefsMessage: string;
        ExecuteScriptMessage: string;
        AddEventListenerMessage: string;
        SetAttributeMessage: string;
        CreateRefComponentMessage: string;
        EnvelopedMessage: string;
        GetElementValueMessage: string;
        GetAttributeMessage: string;
        SetInnerHtml: string;
        ExecuteComponentMethod: string;
        SetMutationObserverMessage: string;
        SetResizeObserverMessage: string;
        CleanupMessage: string;
        In: {
            DetectedMyopRefsMessage: string;
            ClickReplayMessage: string;
            ExecuteScriptReplyMessage: string;
            EventListenerCallbackMessage: string;
            ElementValueReplayMessage: string;
            GetAttributeReplayMessage: string;
            RefComponentCreatedMessage: string;
            EnvelopedMessage: string;
            MutationObserverMessage: string;
            CleanupReplayMessage: string;
            ResizeObserverMessage: string;
        };
    };
}
declare module "@myop/sdk/utils/uuid" {
    export const uuidv4: () => string;
    export const uuidToBytes: (uuid: string) => Uint8Array;
    export const bytesToUuid: (bytes: Uint8Array) => string;
    export const base64UrlEncode: (bytes: Uint8Array) => string;
    export const base64UrlDecode: (str: string) => Uint8Array;
    export const compressUUIDs: (uuids: string[]) => string;
    export const decompressUUIDs: (encoded: string) => string[];
}
declare module "@myop/sdk/utils/utils" {
    export * from "@myop/sdk/utils/uuid";
    export const wait: (ms: number) => Promise<unknown>;
}
declare module "@myop/sdk/common/MyopElementRef" {
    export interface IElementRef {
        myopId?: string;
        htmlTagName: string;
        BoundingRect?: DOMRect;
        offsetTop?: number;
        offsetLeft?: number;
        type: string;
    }
    export class XPathElementRef implements IElementRef {
        xPath: string;
        htmlTagName: string;
        BoundingRect?: DOMRect;
        offsetTop?: number;
        offsetLeft?: number;
        constructor(xPath: string, htmlTagName: string, BoundingRect?: DOMRect, offsetTop?: number, offsetLeft?: number);
        readonly type: string;
    }
    export class MyopElementRef implements IElementRef {
        myopId: string;
        htmlTagName: string;
        BoundingRect?: DOMRect;
        offsetTop?: number;
        offsetLeft?: number;
        constructor(myopId: string, htmlTagName: string, BoundingRect?: DOMRect, offsetTop?: number, offsetLeft?: number);
        readonly type: string;
    }
}
declare module "@myop/sdk/common/baseMessageHandler" {
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages";
    import { CleanupHandler } from "@myop/sdk/common";
    export type IMessageExecutorCleanup = CleanupHandler | Promise<CleanupHandler> | Promise<void> | void;
    export const runExecutorCleanup: (task: IMessageExecutorCleanup) => Promise<void>;
    type IMessageExecutor<T extends BaseMyopMessage> = (message: T) => IMessageExecutorCleanup;
    interface IMessageHandler<T extends BaseMyopMessage> {
        messageType: MyopMessageKey;
        executor: IMessageExecutor<T>;
        messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
    }
    export abstract class BaseMessageHandler<T extends BaseMyopMessage = any> implements IMessageHandler<T> {
        messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
        constructor(messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void);
        abstract messageType: MyopMessageKey;
        abstract executor: IMessageExecutor<T>;
    }
    export abstract class BaseContextMessageHandler<T extends BaseMyopMessage = any, E = any> extends BaseMessageHandler<T> {
        messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
        context?: E;
        constructor(messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void, context?: E);
    }
}
declare module "@myop/sdk/common/BaseMyopSDK" {
    import { CleanupHandler } from "@myop/sdk/common";
    import { BaseMessageHandler } from "@myop/sdk/common/baseMessageHandler";
    import { BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages";
    export class HostedComponent<T = any> {
        id: string;
        context?: T;
        send: (message: BaseMyopMessage) => void;
        constructor(id: string, context?: T);
    }
    export interface IMyopSDK {
        init: () => void;
        messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
        supportedHandlers: BaseMessageHandler[];
        handleIncomeMessages: (message: BaseMyopMessage) => void;
        components: Record<string, HostedComponent>;
    }
    export abstract class BaseMyopSDK implements IMyopSDK {
        abstract messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
        abstract supportedHandlers: BaseMessageHandler[];
        messageToHandleAfterInit: BaseMyopMessage[];
        components: Record<string, HostedComponent>;
        alwaysPassEnvelopesToHost: boolean;
        messageCleanupCache: Record<string, CleanupHandler | Promise<CleanupHandler>> | Promise<void>;
        handleIncomeMessages(event: any): void;
        abstract init: () => void;
    }
}
declare module "@myop/sdk/common" {
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    export * from "@myop/sdk/common/MyopElementRef";
    export * from "@myop/sdk/common/baseMessageHandler";
    export * from "@myop/sdk/common/BaseMyopSDK";
    export type CleanupHandler = () => void;
    export type Dictionary<T> = {
        [key: string]: T;
    };
    export const SkinLoaders: {
        readonly IframeLoader: "IframeLoader";
        readonly WebComponentLoader: "WebComponentLoader";
        readonly HTMLLoader: "HTMLLoader";
        readonly MinimizedLoader: "MinimizedLoader";
    };
    export type SkinLoaderType = keyof typeof SkinLoaders;
    export type PropType = 'any' | 'string' | 'number' | string;
    export type RefSelectorType = 'id-attribute' | 'css-selector' | 'xpath' | string;
    export const LoaderFrameworks: {
        readonly react: "react";
        readonly vue: "vue";
        readonly angular: "angular";
    };
    export type LoaderFrameworkType = keyof typeof LoaderFrameworks;
    export interface IWebComponentLoaderConfig extends ISkinLoaderConfig {
        type: "WebComponentLoader";
        url: string;
        tag: string;
        framework?: LoaderFrameworkType;
    }
    export interface IIframeLoaderConfig extends ISkinLoaderConfig {
        type: "IframeLoader";
        url: string;
        autoHeight: boolean;
        height?: string;
        width?: string;
    }
    export const ShadowRootModeType: {
        readonly open: "open";
        readonly closed: "closed";
        readonly none: "none";
        readonly localFrame: "localFrame";
    };
    export interface IHTMLLoaderConfig extends ISkinLoaderConfig {
        type: "HTMLLoader";
        HTML: string;
        shadowRootMode?: keyof typeof ShadowRootModeType;
        autoHeight?: boolean;
        height?: string;
        width?: string;
    }
    export interface IMinimizedLoaderConfig extends ISkinLoaderConfig {
        type: "MinimizedLoader";
    }
    interface DashboardObject {
        _temp_client_id?: string;
    }
    type ExtendRecursively<T, E> = {
        [K in keyof E]: E[K];
    } & {
        [K in keyof T]: T[K] extends object ? ExtendRecursively<T[K], E> : T[K];
    };
    export type IDashboard<T> = ExtendRecursively<T, DashboardObject>;
    export interface ISkinLoaderConfig {
        type: SkinLoaderType;
        [key: string]: any;
    }
    export interface v2_IReleaseMetadata {
        environmentId: string;
        environmentIdentifier: string;
        releasedOn?: string;
        releasedBy?: string;
    }
    export interface v2_IVariantConfig extends v2_IMyopStoredObject {
        loader: ISkinLoaderConfig;
        componentId: string;
        releases?: v2_IReleaseMetadata[];
    }
    export interface ISkinConfig {
        id: string;
        name: string;
        description: string;
        loader: ISkinLoaderConfig;
        createdBy?: string;
        createdOn?: string;
    }
    export interface v2_ISkinConfig extends ISkinConfig {
        componentId: string;
    }
    export interface IMessagePropConfig extends IPropConfig {
        type: PropType;
        messageType: MyopMessageKey;
    }
    export interface IBindMessagePropConfig extends IPropConfig {
        type: PropType;
        messageType: MyopMessageKey;
    }
    export const PropMessageModes: {
        readonly input: "input";
        readonly output: "output";
    };
    export const PropConfigBehaviorTypes: {
        readonly message: "message";
        readonly code: "code";
    };
    export interface IPropMessageBehaviorParam {
        value: string;
    }
    export interface IPropBehavior {
        type: keyof typeof PropConfigBehaviorTypes;
    }
    export interface IPropCodeBehavior extends IPropBehavior {
        type: "code";
        remap?: string;
    }
    export interface IPropMessageBehavior extends IPropBehavior {
        type: "message";
        message: MyopMessageKey;
        ref: string;
        params: IPropMessageBehaviorParam[];
        mode: keyof typeof PropMessageModes;
    }
    export interface IPropConfig {
        id: string;
        name: string;
        description: string;
        type: PropType;
        behavior: IPropBehavior;
    }
    export class RefBehaviorType {
        static code: "code";
        static component: "component";
    }
    export type IRefBehaviorType = 'code' | 'component';
    export interface IRefBehavior {
        type: IRefBehaviorType;
    }
    export interface IComponentRefBehavior extends IRefBehavior {
        type: 'component';
        componentId: string;
        /**
         * @deprecated
         * Property instance is deprecated and will be removed in future versions.
         */
        instance: IComponentInstanceConfig;
    }
    export interface ICodeRefBehavior extends IRefBehavior {
        type: 'code';
    }
    export interface IRefConfig {
        id: string;
        name: string;
        description: string;
        selectorType: RefSelectorType;
        selector: string;
        behavior: IRefBehavior;
    }
    /**
     * Experience segment rule
     */
    export interface IExperienceSegmentRule {
        property: string;
        operator: string;
        value: string;
    }
    /**
     * Experience A/B split version
     */
    export interface IExperienceABSplitVersion {
        id: string;
        percentage: number;
    }
    /**
     * Experience A/B split configuration
     */
    export interface IExperienceABSplit {
        versions: IExperienceABSplitVersion[];
    }
    /**
     * Experience segment configuration
     */
    export interface IExperienceSegment {
        id: string;
        name: string;
        description: string;
        rules: IExperienceSegmentRule[];
        useAb: boolean;
        componentVariants: Record<string, string | Record<string, string>>;
        abSplit?: IExperienceABSplit;
        stickyProperties?: string[];
    }
    /**
     * Experience definition config (v2)
     */
    export interface IExperienceDefinitionConfig extends v2_IMyopStoredObject {
        /** Selected component IDs */
        components: string[];
        /** Segment configurations */
        segments: IExperienceSegment[];
        /** Fallback variant per component */
        fallback: Record<string, string>;
        /** Tags */
        tags: string[];
    }
    export interface IComponentDefinitionConfig {
        id: string;
        name: string;
        description: string;
        props: IPropConfig[];
        refs: IRefConfig[];
        skins: ISkinConfig[];
        defaultSkin: number;
        createdOn?: string;
        createdBy?: string;
        updatedBy?: string;
    }
    export interface v2_IBaseMyopObject {
        id: string;
        name: string;
        description: string;
    }
    export interface v2_IMyopStoredObject extends v2_IBaseMyopObject {
        updatedOn?: string;
        updatedBy?: string;
    }
    export interface ComponentAccess {
        visibility: 'private' | 'unlisted' | 'public';
        unlisted?: {
            slug: string;
        };
        marketplace?: {
            status: 'draft' | 'submitted' | 'claimed' | 'closed';
            description: string;
            contactEmail: string;
            deadline: string;
        };
    }
    export interface v2_IComponentDefinitionConfig extends v2_IMyopStoredObject {
        variants_ids: string[];
        DTOs: v2_IDTO[];
        tags: string[];
        access?: ComponentAccess;
        variants_names: string[];
        variants_data: {
            name: string;
            id: string;
            description?: string;
            updatedOn?: string;
            updatedBy?: string;
            has_releases?: boolean;
        }[];
        preview_variant: v2_IVariantConfig;
        extra?: {
            firstVariant: v2_IVariantConfig;
        };
    }
    export interface v2_IDTO extends v2_IMyopStoredObject {
        data: object;
        methodName: string;
    }
    export interface ISkinInstanceConfig {
        id: string;
    }
    export interface ISkinSelectorConfig {
        type: keyof typeof SkinSelectorTypes;
    }
    export const SegmentType: {
        readonly FunctionResult: "FunctionResult";
    };
    export interface ISegmentInstance {
        segmentId: string;
        skinSelector: ISkinSelectorConfig;
    }
    export interface ISegmentDefinition {
        id: string;
        type: keyof typeof SegmentType;
    }
    export interface IFunctionResultsSegment extends ISegmentDefinition {
        id: string;
        type: typeof SegmentType.FunctionResult;
        name: string;
        description: string;
        function: string;
    }
    export const SkinSelectorTypes: {
        readonly Segmented: "Segmented";
        readonly Dedicated: "Dedicated";
        /**
         * This Selector Type is not yet supported but will be added in a future release.
         * Please check the documentation for updates.
         *
         * @type {string}
         */
        readonly Default: "Default";
    };
    /**
     * This Skin Config Type is not yet supported but will be added in a future release.
     * Please check the documentation for updates.
     *
     * @type {IDefaultSkinConfig}
     */
    export interface IDefaultSkinConfig extends ISkinSelectorConfig {
        type: typeof SkinSelectorTypes.Default;
    }
    export interface ISegmentedSkinConfig extends ISkinSelectorConfig {
        type: typeof SkinSelectorTypes.Segmented;
        segments: ISegmentInstance[];
    }
    export interface IDedicatedSkinConfig extends ISkinSelectorConfig {
        type: typeof SkinSelectorTypes.Dedicated;
        /**
         * @deprecated Use {@link skin} instead.
         * Property skins is deprecated and will be removed in future versions.
         * Please update your code to use {@link skin} for better compatibility.
         *
         * @type {string}
         */
        skins?: ISkinInstanceConfig[];
        skin: ISkinInstanceConfig;
    }
    export interface IComponentInstanceConfig {
        id: string;
        componentId: string;
        componentName: string;
        skinSelector: ISkinSelectorConfig;
        nestedComponents?: IComponentInstanceConfig[];
        resolvedExperiences?: IExperience[];
        resolvedNestedComponents?: IComponentConfig[];
    }
    export const ExperienceTypes: {
        readonly Segment: "Segment";
        readonly Promo: "Promo";
        readonly AB: "AB";
    };
    export interface IExperience {
        id: string;
        name: string;
        description: string;
        type: keyof typeof ExperienceTypes;
        experiences: IExperience[];
    }
    export interface IABExperience extends IExperience {
        type: typeof ExperienceTypes.AB;
        experiences: IExperience[];
        percentage: number;
    }
    export interface IDateRange {
        id: string;
        start: Date;
        end: Date;
        timezone: string;
    }
    export interface ISegmentExperience extends IExperience {
        type: keyof typeof ExperienceTypes;
        segment: ISegmentDefinition;
        dateRange?: IDateRange;
    }
    export interface IUserFlowDefinition {
        id: string;
        name: string;
        description: string;
        components: IComponentInstanceConfig[];
        origins: string[];
        experiences: IExperience[];
        branch?: string;
    }
    export interface IComponentConfig {
        instance: IComponentInstanceConfig;
        type: IComponentDefinitionConfig;
        name: string;
    }
    interface IBranchable {
        branch?: string;
    }
    export interface IUserFlow extends Omit<IUserFlowDefinition, 'components'>, IBranchable {
        components: IComponentConfig[];
    }
    export class RootRef {
        container: HTMLElement;
        shadowRoot?: ShadowRoot;
        constructor(container: HTMLElement, shadowRoot?: ShadowRoot);
        getRootDiv: () => HTMLDivElement;
        getRoot: () => HTMLElement | ShadowRoot;
    }
}
declare module "@myop/sdk/common/utils/serialization" {
    export type Serializable<T> = T extends Function ? never : T extends Array<infer U> ? Serializable<U>[] : T extends object ? {
        [K in keyof T as T[K] extends Function ? never : K]: Serializable<T[K]>;
    } : T;
    export const containsPrimitivesOnly: (obj: any) => boolean;
    export type SerializableSkeleton<T> = Partial<Record<keyof T, boolean | Partial<Record<string, boolean>>>> | boolean;
    export const makeSerializable: <T>(obj: T, skeleton?: SerializableSkeleton<T>, includeFalsyKeys?: boolean, // TODO : use that arg
    seen?: WeakMap<object, Serializable<any>>) => Serializable<T>;
}
declare module "@myop/sdk/host/logMessages" {
    export const Errors: {
        notSerializableRefCall: (prop: any, arg: any) => never;
    };
}
declare module "@myop/sdk/messages/EnvelopedMessage" {
    import { BaseMyopMessage } from "@myop/sdk/messages/BaseMessage";
    export class EnvelopedMessage extends BaseMyopMessage {
        destination: string;
        message: BaseMyopMessage;
        messageType: string;
        constructor(destination: string, message: BaseMyopMessage);
    }
}
declare module "@myop/sdk/host/components/myopRefComponent" {
    import { BaseMyopComponent, IMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { BaseMyopMessage } from "@myop/sdk/messages";
    import { IComponentDefinitionConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    export class MyopRefComponent extends BaseMyopComponent {
        componentDefinition: IComponentDefinitionConfig;
        parent: IMyopComponent;
        constructor(componentDefinition: IComponentDefinitionConfig, parent: IMyopComponent, options?: loaderOptions);
        hide(): void;
        show(): void;
        inspect(): import("common").CleanupHandler;
        setHeightBasedOnDocumentElement(): void;
        setHeightBasedOnScrollHeight(): void;
        onMessageReceived(incomeMessage: BaseMyopMessage): boolean;
        send: (message: BaseMyopMessage) => import("common").CleanupHandler;
        dispose: () => void;
    }
}
declare module "@myop/sdk/host/componentCore" {
    import { IMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { Ref } from "@myop/sdk/messages";
    import { CleanupHandler, IComponentConfig, type IComponentDefinitionConfig, IPropConfig, ISkinConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    type componentDefinitionProps = IComponentDefinitionConfig['props'];
    export const setDebugStyle: (id: string, type: string, top: number, container: HTMLElement, componentElement: HTMLElement, componentDefinitionConfig: IComponentDefinitionConfig) => CleanupHandler;
    export const connectProps: <T extends componentDefinitionProps>(component: IMyopComponent, propsConfig: IPropConfig[], selectedSkin: ISkinConfig) => (Omit<IMyopComponent, "props"> & {
        props: propTypes<T>;
    });
    export const createRefProxy: (target: Ref, component: IMyopComponent) => Ref;
    export const createRefComponent: <T extends IMyopComponent = IMyopComponent>(ref: Ref, componentConfig: IComponentConfig, components: IMyopComponent[], options?: loaderOptions) => Promise<T>;
    export const connectRefs: (component: IMyopComponent, componentConfig: IComponentConfig, components: IMyopComponent[], withoutRefComponents?: boolean) => Promise<void>;
    export type propTypes<T extends componentDefinitionProps> = {
        [Property in keyof T]: T[Property] extends {
            mode: 'input';
        } ? T[Property]['type'] : Promise<T[Property]['type']>;
    };
    export const exec: (getter: any) => Promise<any>;
    export const actAs: <T>(ref: Ref) => FunctionifyRef<T>;
    export type FunctionifyRef<T = any> = {
        [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<R> : T[K];
    };
}
declare module "@myop/sdk/host/components/myopExtractedWebComponent" {
    import { BaseMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { BaseMyopMessage } from "@myop/sdk/messages";
    import { CleanupHandler, IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    /**
     * Component wrapper for Myop Web Components that are extracted from HTML
     * and run directly on the host document (not in an iframe).
     *
     * These components use the native Web Components API (Custom Elements + Shadow DOM)
     * and communicate via direct method calls and CustomEvents instead of postMessage.
     */
    export class MyopExtractedWebComponent extends BaseMyopComponent {
        container: HTMLElement;
        private customElement;
        private tagName;
        private ctaCleanup?;
        private _ctaHandler?;
        private _ctaQueue;
        constructor(componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, customElement: HTMLElement, tagName: string, options?: loaderOptions);
        cleanupInspect: CleanupHandler;
        inspect(): CleanupHandler;
        hide(): void;
        show(): void;
        /**
         * Initialize the component with data by calling myop_init_interface directly
         */
        initWithData(data: unknown): void;
        /**
         * Get current data from the component
         */
        getData(): unknown;
        /**
         * Set CTA handler - unified API with iframe components.
         * Called via props.myop_cta_handler = handler
         */
        setCtaHandler(handler: (action: string, payload: unknown) => void): void;
        /**
         * For compatibility with message-based components.
         * Web components don't use postMessage, so this is a no-op for most messages.
         */
        send: (message: BaseMyopMessage<any>) => CleanupHandler;
        dispose: () => void;
    }
}
declare module "@myop/sdk/host/myopLoader" {
    export const LOADER_GRADIENT = "linear-gradient(135deg, #FF8651 0%, #FFBEA8 50%, #A397F5 100%)";
    export const FALLBACK_GRADIENT = "linear-gradient(135deg, #9CA3AF 0%, #D1D5DB 50%, #E5E7EB 100%)";
    /**
     * Creates the Myop logo SVG element
     */
    export function createMyopLogoSvg(): SVGSVGElement;
    /**
     * Returns the inline HTML string for the Myop logo SVG
     */
    export function getMyopLogoHtml(): string;
    /**
     * Returns the inline styles for the loader container
     */
    export function getLoaderStyles(fadeDuration?: number): string;
    /**
     * Returns the inline styles for the fallback container
     */
    export function getFallbackStyles(): string;
    /**
     * Creates a loader DOM element with the Myop branding
     */
    export function createLoaderElement(fadeDuration?: number): HTMLDivElement;
    /**
     * Creates a fallback DOM element with the Myop branding
     */
    export function createFallbackElement(): HTMLDivElement;
    /**
     * Returns the complete loader HTML as a string (for use in templates)
     */
    export function getLoaderHtml(fadeDuration?: number): string;
    /**
     * Returns the complete fallback HTML as a string (for use in templates)
     */
    export function getFallbackHtml(): string;
    /**
     * Interface for loader options used by host frameworks
     */
    export interface MyopLoaderOptions {
        /** Fade duration in milliseconds (default: 200) */
        fadeDuration?: number;
        /** Initial opacity (default: 1) */
        opacity?: number;
    }
    /**
     * CSS-in-JS style objects for frameworks that support them
     */
    export const loaderStyleObject: {
        position: "absolute";
        top: number;
        left: number;
        right: number;
        bottom: number;
        zIndex: number;
        background: string;
        display: string;
        justifyContent: string;
        alignItems: string;
    };
    export const fallbackStyleObject: {
        position: "absolute";
        top: number;
        left: number;
        right: number;
        bottom: number;
        background: string;
        display: string;
        justifyContent: string;
        alignItems: string;
    };
    export const containerStyleObject: {
        position: "absolute";
        top: number;
        left: number;
        right: number;
        bottom: number;
        zIndex: number;
        display: string;
        justifyContent: string;
        alignItems: string;
    };
}
declare module "@myop/sdk/host" {
    export { hostSDK } from "@myop/sdk/host/hostSDK";
    export type { loaderOptions } from "@myop/sdk/host/hostSDK";
    export * from "@myop/sdk/host/components/IMyopComponent";
    export * from "@myop/sdk/host/components/myopExtractedWebComponent";
    export * from "@myop/sdk/host/loaders/IMyopLoader";
    export * from "@myop/sdk/host/componentCore";
    export * from "@myop/sdk/host/myopLoader";
    export type { CleanupHandler } from "@myop/sdk/common";
}
declare module "@myop/sdk/messages/BaseMessage" {
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { IMyopComponent } from "@myop/sdk/host";
    import { IRefConfig } from "@myop/sdk/common";
    export class MessageDirection {
        static down: "down";
        static up: "up";
    }
    export type MessageDirectionOption = 'up' | 'down';
    export abstract class BaseMyopMessage<T = any> {
        id: string;
        static create<T, U extends new (...args: ConstructorParameters<U>) => T = typeof this>(this: U, ...args: ConstructorParameters<U>): InstanceType<typeof this>;
        constructor();
        myop: boolean;
        abstract messageType: MyopMessageKey | string;
        content?: T;
        source?: string;
        destination?: string;
        route?: string[];
        ref?: Ref;
        direction?: MessageDirectionOption;
        cleanable: boolean;
        isTypeof(msg: BaseMyopMessage): boolean;
    }
    export abstract class MyopElementMessage<T = any> extends BaseMyopMessage<T> {
        ref: Ref;
        constructor(ref: Ref);
    }
    export abstract class MyopBindReplayMessage<T = any> extends BaseMyopMessage<T> {
        replayToHandler?: string;
        constructor(replayToHandler?: string);
    }
    export abstract class MyopBindMessage<T = any, R extends MyopBindReplayMessage = any> extends BaseMyopMessage<T> {
        handler: (message: R) => void;
        abstract replyMessageKey: MyopMessageKey;
        handlerUniqueId: string;
        constructor(handler: (message: R) => void);
    }
    export class Ref {
        refConfig: IRefConfig;
        component?: IMyopComponent;
        myop: boolean;
        __nonProxied?: Ref;
        static create(selector: string, refConfig?: IRefConfig, component?: IMyopComponent): Ref;
        constructor(refConfig: IRefConfig, component?: IMyopComponent);
    }
}
declare module "@myop/sdk/messages/BindClickMessage" {
    import { MyopBindMessage, MyopBindReplayMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    export class BindClickMessage extends MyopBindMessage<void, ClickReplayMessage> {
        ref: Ref;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        cleanable: boolean;
        constructor(ref: Ref, handler: (message: ClickReplayMessage) => void);
    }
    export class ClickReplayMessage extends MyopBindReplayMessage {
        messageType: string;
    }
}
declare module "@myop/sdk/messages/ChangeTextMessage" {
    import { BaseMyopMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    export class ChangeTextMessage extends BaseMyopMessage<string> {
        ref: Ref;
        messageType: string;
        constructor(ref: Ref, text: string);
    }
}
declare module "@myop/sdk/messages/ExecuteScriptMessage" {
    import { MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { RootRef } from "@myop/sdk/common";
    import { makeSerializable } from "@myop/sdk/common/utils/serialization";
    export const stripFunction: (content: string) => string;
    export type scriptInputs = {
        [key: string]: string | number | boolean;
    } | {};
    export type scriptVars<T> = {
        send: (data: T) => void;
        rootRef: RootRef;
        makeSerializable: typeof makeSerializable;
    };
    export type extendedScriptVars<T, I> = {
        [K in keyof I]: I[K];
    } & scriptVars<T>;
    export class ExecuteScriptMessage<T = any, I extends scriptInputs = any> extends MyopBindMessage<string, ExecuteScriptReplyMessage<T>> {
        scriptInputs?: I;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        script: string;
        static replierKey: string;
        static completeStreamKey: string;
        constructor(script: (vars: extendedScriptVars<T, I>) => T, handler?: (message: ExecuteScriptReplyMessage<T>) => void, scriptInputs?: I);
    }
    export class ExecuteScriptReplyMessage<T = any> extends MyopBindReplayMessage<T> {
        replayToHandler: string;
        content: T;
        messageType: string;
        constructor(replayToHandler: string, content: T);
    }
}
declare module "@myop/sdk/messages/CustomRefMessage" {
    import { ExecuteScriptMessage, ExecuteScriptReplyMessage, extendedScriptVars, scriptInputs } from "@myop/sdk/messages/ExecuteScriptMessage";
    export type customRefScriptInputs = {
        elementId: string;
        ref?: HTMLElement;
        _script?: string;
        __scriptInputs?: Object;
    };
    export class CustomRefMessage<T = any, I extends scriptInputs = customRefScriptInputs> extends ExecuteScriptMessage<T, I & customRefScriptInputs> {
        scriptInputs: I & customRefScriptInputs;
        constructor(script: (vars: extendedScriptVars<T, I & customRefScriptInputs>) => T, scriptInputs: I & customRefScriptInputs, handler?: (message: ExecuteScriptReplyMessage<T>) => void);
    }
}
declare module "@myop/sdk/messages/AddEventListenerMessage" {
    import { MyopBindMessage, MyopBindReplayMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { Serializable, SerializableSkeleton } from "@myop/sdk/common/utils/serialization";
    export class AddEventListenerMessage<T extends keyof HTMLElementEventMap = keyof HTMLElementEventMap> extends MyopBindMessage {
        ref: Ref;
        type: T;
        handler: (message: EventListenerCallbackMessage) => void;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        cleanable: boolean;
        serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]>;
        constructor(ref: Ref, type: T, handler: (message: EventListenerCallbackMessage) => void);
        withSerializableSkeleton(serializableSkeleton: SerializableSkeleton<HTMLElementEventMap[T]>): this;
    }
    export class EventListenerCallbackMessage extends MyopBindReplayMessage {
        replayToHandler: string;
        e: Serializable<Event>;
        messageType: string;
        constructor(replayToHandler: string, e: Serializable<Event>);
    }
}
declare module "@myop/sdk/messages/SetAttributeMessage" {
    import { BaseMyopMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    export class SetAttributeMessage extends BaseMyopMessage {
        ref: Ref;
        name: string;
        value: string;
        messageType: string;
        constructor(ref: Ref, name: string, value: string);
    }
}
declare module "@myop/sdk/messages/GetElementValueMessage" {
    import { MyopBindMessage, MyopBindReplayMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { Serializable } from "@myop/sdk/common/utils/serialization";
    export class GetElementValueMessage extends MyopBindMessage<void, ElementValueReplayMessage> {
        ref: Ref;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        constructor(ref: Ref, handler: (message: ElementValueReplayMessage) => void);
    }
    export type FormDataEntry = {
        id?: string;
        name?: string;
        value?: InputElementValue;
        required?: boolean;
        validity?: Serializable<ValidityState>;
        myopId?: string;
    };
    export type InputElementFormValue = {
        formData?: {
            [key: string]: FormDataEntry;
        };
        unmappedData?: FormDataEntry[];
    };
    export type InputElementValue = string | InputElementFormValue | null | undefined;
    export class ElementValueReplayMessage extends MyopBindReplayMessage {
        content: InputElementValue;
        messageType: string;
        constructor(content: InputElementValue);
    }
}
declare module "@myop/sdk/messages/SetInnerHtml" {
    import { BaseMyopMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    export class SetInnerHtml extends BaseMyopMessage<string> {
        ref: Ref;
        messageType: string;
        constructor(ref: Ref, innerHtml: string);
    }
}
declare module "@myop/sdk/messages/InitMessage" {
    import { BaseMyopMessage } from "@myop/sdk/messages/BaseMessage";
    export class InitMessage extends BaseMyopMessage<{
        id: string;
    }> {
        messageType: string;
        constructor(id: string);
        isTypeof(msg: BaseMyopMessage): boolean;
    }
    export class InitResponse extends InitMessage {
        messageType: string;
    }
    export class InitRequest extends BaseMyopMessage {
        messageType: string;
    }
}
declare module "@myop/sdk/messages/CreateRefComponentMessage" {
    import { MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { IComponentConfig, IRefConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    export class CreateRefComponentMessage extends MyopBindMessage<void, RefComponentCreatedMessage> {
        refConfig: IRefConfig;
        nestedComponentConfig: IComponentConfig;
        options: loaderOptions;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        constructor(refConfig: IRefConfig, nestedComponentConfig: IComponentConfig, options: loaderOptions, handler: (message: RefComponentCreatedMessage) => void);
    }
    export type NestedRef = {
        refName: string;
        componentDefinitionId: string;
    };
    export class RefComponentCreatedMessage extends MyopBindReplayMessage {
        replayToHandler: string;
        nestedRefs: NestedRef[];
        failed?: boolean;
        messageType: string;
        constructor(replayToHandler: string, nestedRefs: NestedRef[], failed?: boolean);
    }
}
declare module "@myop/sdk/messages/DetectMyopRefsMessage" {
    import { BaseMyopMessage, MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages/BaseMessage";
    import { IElementRef } from "@myop/sdk/common";
    export class DetectMyopRefsMessage extends MyopBindMessage<any, DetectedMyopRefsMessage> {
        messageType: string;
        replyMessageKey: string;
    }
    export class DetectedMyopRefsMessage extends MyopBindReplayMessage<IElementRef[]> {
        replayToHandler: string;
        messageType: string;
        constructor(replayToHandler: string, myopElementRefs: IElementRef[]);
        isTypeof(msg: BaseMyopMessage<any>): boolean;
    }
}
declare module "@myop/sdk/messages/GetAttributeMessage" {
    import { MyopBindMessage, MyopBindReplayMessage, Ref } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    export class GetAttributeMessage extends MyopBindMessage<void, GetAttributeReplayMessage> {
        ref: Ref;
        name: string;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        constructor(ref: Ref, name: string, handler: (message: GetAttributeReplayMessage) => void);
    }
    export class GetAttributeReplayMessage extends MyopBindReplayMessage {
        content: string | null;
        messageType: string;
        constructor(content: string | null);
    }
}
declare module "@myop/sdk/messages/componentMessages/ExecuteComponentMethod" {
    import { BaseMyopMessage } from "@myop/sdk/messages/BaseMessage";
    import { IMyopComponent } from "@myop/sdk/host";
    type MethodNames<T> = {
        [K in keyof T]: T[K] extends () => void ? K : never;
    }[keyof T];
    type MethodString<T> = MethodNames<T> extends infer M ? M extends string ? M : never : never;
    export class ExecuteComponentMethod extends BaseMyopMessage {
        method: MethodString<IMyopComponent>;
        messageType: string;
        constructor(method: MethodString<IMyopComponent>);
    }
}
declare module "@myop/sdk/messages/componentMessages/SetMutationObserverMessage" {
    import { BaseMyopMessage } from "@myop/sdk/messages/BaseMessage";
    export class SetMutationObserverMessage extends BaseMyopMessage {
        messageType: string;
    }
    export class MutationObserverMessage extends BaseMyopMessage {
        messageType: string;
    }
}
declare module "@myop/sdk/messages/CleanupMessage" {
    import { MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages/BaseMessage";
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    export class CleanupMessage extends MyopBindMessage<void, CleanupReplayMessage> {
        cleanupForMessageId: string;
        replyMessageKey: MyopMessageKey;
        messageType: string;
        constructor(cleanupForMessageId: string, handler: (message: CleanupReplayMessage) => void);
    }
    export class CleanupReplayMessage extends MyopBindReplayMessage {
        customCleanup: boolean;
        messageType: string;
        constructor(customCleanup: boolean);
    }
}
declare module "@myop/sdk/messages/DisposeMessage" {
    import { BaseMyopMessage } from "@myop/sdk/messages/BaseMessage";
    export class DisposeMessage extends BaseMyopMessage {
        messageType: string;
    }
}
declare module "@myop/sdk/messages/componentMessages/SetResizeObserverMessage" {
    import { BaseMyopMessage } from "@myop/sdk/messages/BaseMessage";
    export class SetResizeObserverMessage extends BaseMyopMessage {
        cleanable: boolean;
        messageType: string;
    }
    export class ResizeObserverMessage extends BaseMyopMessage {
        messageType: string;
    }
}
declare module "@myop/sdk/messages" {
    export * from "@myop/sdk/messages/BaseMessage";
    export * from "@myop/sdk/messages/BindClickMessage";
    export * from "@myop/sdk/messages/ChangeTextMessage";
    export * from "@myop/sdk/messages/ExecuteScriptMessage";
    export * from "@myop/sdk/messages/CustomRefMessage";
    export * from "@myop/sdk/messages/AddEventListenerMessage";
    export * from "@myop/sdk/messages/SetAttributeMessage";
    export * from "@myop/sdk/messages/GetElementValueMessage";
    export * from "@myop/sdk/messages/SetInnerHtml";
    export * from "@myop/sdk/messages/InitMessage";
    export * from "@myop/sdk/messages/CreateRefComponentMessage";
    export * from "@myop/sdk/messages/EnvelopedMessage";
    export * from "@myop/sdk/messages/DetectMyopRefsMessage";
    export * from "@myop/sdk/messages/GetElementValueMessage";
    export * from "@myop/sdk/messages/GetAttributeMessage";
    export * from "@myop/sdk/messages/componentMessages/ExecuteComponentMethod";
    export * from "@myop/sdk/messages/componentMessages/SetMutationObserverMessage";
    export * from "@myop/sdk/messages/CleanupMessage";
    export * from "@myop/sdk/messages/DisposeMessage";
    export * from "@myop/sdk/messages/componentMessages/SetResizeObserverMessage";
}
declare module "@myop/sdk/host/components/IMyopComponent" {
    import { MyopMessageKey } from "@myop/sdk/common/MyopMessages";
    import { BaseMyopMessage, Ref } from "@myop/sdk/messages";
    import { CleanupHandler, IComponentDefinitionConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    /**
     * Result returned by observeAutoSize callback
     */
    export interface AutoSizeResult {
        /** Current width (from content) */
        width: number;
        /** Current height (from content) */
        height: number;
        /** Whether width is being auto-sized */
        autoSizingWidth: boolean;
        /** Whether height is being auto-sized */
        autoSizingHeight: boolean;
    }
    /**
     * Options for observeAutoSize method
     */
    export interface AutoSizeOptions {
        /** Callback called with size info whenever size changes */
        onSizeChange?: (result: AutoSizeResult) => void;
        /** Minimum width constraint */
        minWidth?: number | string;
        /** Maximum width constraint */
        maxWidth?: number | string;
        /** Minimum height constraint */
        minHeight?: number | string;
        /** Maximum height constraint */
        maxHeight?: number | string;
        /** Explicit width set by host - if defined, don't auto-size width */
        explicitWidth?: string | number;
        /** Explicit height set by host - if defined, don't auto-size height */
        explicitHeight?: string | number;
        /** Force auto-size even if container has dimensions */
        forceAutoSize?: boolean;
        /** Min height used by loader to detect collapse (default: 50) */
        loaderMinHeight?: number;
    }
    type RefTypes = {
        [key: string]: IMyopComponent | Ref;
    };
    export interface IMyopComponent<P = any, R = any> {
        id: string;
        isInitiated: boolean;
        markedForDisposed: boolean;
        setInitiated: () => void;
        componentDefinition: IComponentDefinitionConfig;
        container: HTMLElement;
        element?: HTMLElement;
        send: (msg: BaseMyopMessage) => CleanupHandler;
        bind(messageType: MyopMessageKey, handler: () => boolean): void;
        bind<T extends BaseMyopMessage>(messageType: MyopMessageKey, handler: (message: T) => boolean): void;
        onMessageReceived: (msg: BaseMyopMessage) => boolean;
        initiated: () => Promise<any>;
        dispose: () => void;
        hide(): void;
        show(): void;
        inspect(): void;
        /**
         * Observes the iframe content size and automatically syncs it to the iframe element.
         * Only available for iframe-based components. Uses direct contentDocument access.
         * @param options - Configuration options including size change callback and min/max constraints
         * @returns Cleanup function to stop observing
         */
        observeAutoSize?: (options?: AutoSizeOptions) => CleanupHandler;
        /**
         * Parsed myop:size meta tag from the component HTML.
         * Set by HTMLComponentLoader before iframe creation.
         * Used by the React host to determine sizing mode (fill vs content).
         */
        sizeMeta?: {
            width?: string | number;
            height?: string | number;
            minWidth?: number;
            maxWidth?: number;
            minHeight?: number;
            maxHeight?: number;
        } | null;
        parent?: IMyopComponent;
        props: P;
        refs: R;
    }
    type messageHandler<T> = (message: T) => boolean;
    export abstract class BaseMyopComponent<P = any, R extends RefTypes = RefTypes> implements IMyopComponent<P> {
        componentDefinition: IComponentDefinitionConfig;
        container: HTMLElement;
        id: string;
        messageHandlers: Record<string, messageHandler<any>[]>;
        element?: HTMLElement;
        protected constructor(componentDefinition: IComponentDefinitionConfig, container: HTMLElement, options?: loaderOptions);
        _markedForDisposed: boolean;
        get markedForDisposed(): boolean;
        set markedForDisposed(value: boolean);
        abstract hide(): void;
        abstract show(): void;
        abstract inspect(): CleanupHandler;
        bind: <T extends BaseMyopMessage>(messageType: string, handler: (message: T) => boolean) => void;
        bindWhen: <T extends BaseMyopMessage>(messageType: string, predicate: (message: T) => boolean, handler: (message: T) => void) => CleanupHandler;
        onMessageReceived(incomeMessage: BaseMyopMessage): boolean;
        setInitiated: () => void;
        isInitiated: boolean;
        _whenInitiatedResolve?: (value?: any) => any;
        _whenInitiatedReject?: (value?: any) => any;
        _whenInitiated: Promise<any>;
        initiated: () => Promise<any>;
        private sendCleanupMessage;
        send(message: BaseMyopMessage): CleanupHandler;
        dispose(): void;
        props: P;
        refs: R;
    }
}
declare module "@myop/sdk/host/loaders/IMyopLoader" {
    import { IMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    import { IComponentDefinitionConfig, ISkinConfig, SkinLoaderType } from "@myop/sdk/common";
    export interface IMyopLoader {
        type: SkinLoaderType;
        load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;
    }
    export abstract class BaseMyopLoader implements IMyopLoader {
        abstract type: SkinLoaderType;
        abstract load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<IMyopComponent>;
        appendChild: (container: HTMLElement, element: HTMLElement, options?: loaderOptions) => HTMLElement;
    }
}
declare module "@myop/sdk/host/components/myopIframeComponent" {
    import { AutoSizeOptions, BaseMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { BaseMyopMessage } from "@myop/sdk/messages";
    import { CleanupHandler, IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    export class MyopIframeComponent extends BaseMyopComponent {
        componentConfig: IComponentDefinitionConfig;
        container: HTMLElement;
        private IframeElement;
        private _autoSizeCleanup?;
        private _autoSizeOptions?;
        private _autoSizeUpdate?;
        constructor(componentConfig: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, IframeElement: HTMLIFrameElement, options?: loaderOptions);
        sizeMeta?: {
            width?: string | number;
            height?: string | number;
            minWidth?: number;
            maxWidth?: number;
            minHeight?: number;
            maxHeight?: number;
        } | null;
        cleanupInspect?: CleanupHandler;
        inspect(): CleanupHandler;
        hide(): void;
        show(): void;
        setHeightBasedOnDocumentElement: () => void;
        observeSizeBasedOnDocumentElement: () => CleanupHandler;
        /**
         * Observes the iframe content size and automatically syncs it to the iframe element.
         * Uses direct contentDocument access (same-origin only) for accurate measurements.
         *
         * Reentrant: when called again while observers already exist, updates options and
         * re-evaluates sizing without recreating observers. Cleanup + re-call (e.g. React
         * re-render) creates fresh observers since cleanup clears the existing ones.
         *
         * @param options - Configuration options including size change callback and min/max constraints
         * @returns Cleanup function to stop observing
         */
        observeAutoSize: (options?: AutoSizeOptions) => CleanupHandler;
        setSizeBasedOnDocumentElement: () => void;
        setHeightBasedOnScrollHeight: () => void;
        send: (message: BaseMyopMessage) => CleanupHandler;
        onMessageReceived(incomeMessage: BaseMyopMessage): boolean;
        dispose: () => void;
    }
}
declare module "@myop/sdk/host/loaders/iframeLoader" {
    import { MyopIframeComponent } from "@myop/sdk/host/components/myopIframeComponent";
    import { BaseMyopLoader } from "@myop/sdk/host/loaders/IMyopLoader";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    import { IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    export class MyopIframeLoader extends BaseMyopLoader {
        type: "IframeLoader";
        load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<MyopIframeComponent>;
    }
}
declare module "@myop/sdk/webcomponent/consts" {
    export const myopWebcomponentConsts: {
        webcomponent_message_key: string;
    };
}
declare module "@myop/sdk/host/components/myopWebcomponent" {
    import { BaseMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { BaseMyopMessage } from "@myop/sdk/messages";
    import { CleanupHandler, IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    export class MyopWebComponent extends BaseMyopComponent {
        container: HTMLElement;
        private customElement;
        constructor(componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, customElement: HTMLElement, options?: loaderOptions);
        cleanupInspect: CleanupHandler;
        inspect(): CleanupHandler;
        hide(): void;
        show(): void;
        send: (message: BaseMyopMessage<any>) => CleanupHandler;
        dispose: () => void;
    }
}
declare module "@myop/sdk/host/loaders/webcomponentLoader" {
    import { MyopWebComponent } from "@myop/sdk/host/components/myopWebcomponent";
    import { BaseMyopLoader } from "@myop/sdk/host/loaders/IMyopLoader";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    import { IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    export class WebcomponentLoader extends BaseMyopLoader {
        type: "WebComponentLoader";
        load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<MyopWebComponent>;
    }
}
declare module "@myop/sdk/consts" {
    export const myopAttributes: {
        id: string;
    };
}
declare module "@myop/sdk/Iframe/messageHandlers/DetectMyopRefsMessageHandler" {
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { DetectMyopRefsMessage } from "@myop/sdk/messages";
    export class DetectMyopRefsMessageHandler extends BaseMessageHandler<DetectMyopRefsMessage> {
        messageType: string;
        executor: (message: DetectMyopRefsMessage) => void;
    }
}
declare module "@myop/sdk/common/messageHandlers/helpers" {
    import { Ref } from "@myop/sdk/messages";
    export const getElementsByRef: (ref: Ref, el: ParentNode) => NodeListOf<Element>;
    export const getFirstElementByRef: (ref: Ref, el: ParentNode) => Element;
}
declare module "@myop/sdk/Iframe/messageHandlers/bindOnClickHandler" {
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { BindClickMessage } from "@myop/sdk/messages";
    export class BindOnClickHandler extends BaseMessageHandler<BindClickMessage> {
        messageType: string;
        executor: (event: BindClickMessage) => () => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/changeTextHandler" {
    import { ChangeTextMessage } from "@myop/sdk/messages";
    import { BaseMessageHandler } from "@myop/sdk/common";
    export class ChangeTextHandler extends BaseMessageHandler<ChangeTextMessage> {
        messageType: string;
        executor: (event: ChangeTextMessage) => void;
    }
}
declare module "@myop/sdk/common/messageHandlers/executeScriptHandler" {
    import { ExecuteScriptMessage } from "@myop/sdk/messages";
    import { RootRef } from "@myop/sdk/common";
    export const ExecuteScriptHandlerExecutor: (event: ExecuteScriptMessage, replier: (data: any) => void, rootRef: RootRef) => void;
}
declare module "@myop/sdk/Iframe/messageHandlers/executeScriptHandler" {
    import { ExecuteScriptMessage } from "@myop/sdk/messages";
    import { BaseMessageHandler } from "@myop/sdk/common";
    export class ExecuteScriptHandler extends BaseMessageHandler<ExecuteScriptMessage> {
        messageType: string;
        executor: (event: ExecuteScriptMessage) => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/addEventListenerHandler" {
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { AddEventListenerMessage } from "@myop/sdk/messages";
    export class AddEventListenerHandler extends BaseMessageHandler<AddEventListenerMessage> {
        messageType: string;
        executor: (message: AddEventListenerMessage) => () => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/setAttributeHandler" {
    import { SetAttributeMessage } from "@myop/sdk/messages";
    import { BaseMessageHandler } from "@myop/sdk/common";
    export class setAttributeHandler extends BaseMessageHandler<SetAttributeMessage> {
        messageType: string;
        executor: (event: SetAttributeMessage) => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/CreateRefComponentMessageHandler" {
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { CreateRefComponentMessage } from "@myop/sdk/messages/CreateRefComponentMessage";
    export class CreateRefComponentMessageHandler extends BaseMessageHandler<CreateRefComponentMessage> {
        messageType: string;
        executor: (event: CreateRefComponentMessage) => void;
    }
}
declare module "@myop/sdk/common/utils/domObserver" {
    export const observeDOM: (obj: HTMLElement | null, callback: (mutationRecords?: MutationRecord[]) => void) => any;
}
declare module "@myop/sdk/Iframe/messageHandlers/SetMutationObserverHandler" {
    import { ExecuteScriptMessage } from "@myop/sdk/messages";
    import { BaseMessageHandler } from "@myop/sdk/common";
    export class SetMutationObserverHandler extends BaseMessageHandler<ExecuteScriptMessage> {
        messageType: string;
        executor: (event: ExecuteScriptMessage) => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/GetElementValueHandler" {
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { GetElementValueMessage } from "@myop/sdk/messages";
    export class GetElementValueHandler extends BaseMessageHandler<GetElementValueMessage> {
        messageType: string;
        executor: (event: GetElementValueMessage) => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/getAttributeHandler" {
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { GetAttributeMessage } from "@myop/sdk/messages";
    export class GetAttributeHandler extends BaseMessageHandler<GetAttributeMessage> {
        messageType: string;
        executor: (event: GetAttributeMessage) => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/SetResizeObserverHandler" {
    import { SetResizeObserverMessage } from "@myop/sdk/messages";
    import { BaseMessageHandler } from "@myop/sdk/common";
    export class SetResizeObserverHandler extends BaseMessageHandler<SetResizeObserverMessage> {
        messageType: string;
        executor: (event: SetResizeObserverMessage) => () => void;
    }
}
declare module "@myop/sdk/Iframe/messageHandlers/setInnerHtmlHandler" {
    import { SetInnerHtml } from "@myop/sdk/messages";
    import { BaseMessageHandler } from "@myop/sdk/common";
    export class SetInnerHtmlHandler extends BaseMessageHandler<SetInnerHtml> {
        messageType: string;
        executor: (event: SetInnerHtml) => void;
    }
}
declare module "@myop/sdk/Iframe/IframeSDK" {
    /**
     * @packageDocumentation
     * The Iframe SDK is intended for scenarios where developers wish to implement Myop components as separate web applications hosted within iframes.<br/><br/>
     * By importing the Iframe SDK, developers gain access to tools and utilities necessary for handling communication between the host application and the embedded iframe-based Myop components<br/><br/>
     * This SDK facilitates secure isolation, allowing components to function independently while still benefiting from the overall structure and management capabilities provided by the host application.<br/><br/>
     *
     Once loaded the `RootSDK`, you can load the `IframeSDK`
     ```js
     const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());
     ```
     or
     ```ts
     import {getIframeModule} from '@myop/sdk';
     const {IframeSDK} = (await getIframeModule());
     ```
     or
     ```ts
     import {IframeSDK} from '@myop/sdk/iframe';
     ```
     *
     */
    import { BaseMyopSDK } from "@myop/sdk/common";
    import { BaseMessageHandler } from "@myop/sdk/common";
    import { MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages";
    /**
     The Iframe SDK is intended for scenarios where developers wish to implement Myop components as separate web applications hosted within iframes.<br/><br/>
     By importing the Iframe SDK, developers gain access to tools and utilities necessary for handling communication between the host application and the embedded iframe-based Myop components<br/><br/>
     This SDK facilitates secure isolation, allowing components to function independently while still benefiting from the overall structure and management capabilities provided by the host application.<br/><br/>
    
     Once loaded the `RootSDK`, you can load the `IframeSDK`
     ```js
     const {IframeSDK} = (await window.myop.rootSDK.getIframeModule());
     ```
     or
     ```ts
     import {getIframeModule} from '@myop/sdk';
     const {IframeSDK} = (await getIframeModule());
     ```
     */
    export class IframeSDK extends BaseMyopSDK {
        version: any;
        constructor();
        messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
        supportedHandlers: BaseMessageHandler[];
        init: () => void;
    }
}
declare module "@myop/sdk/Iframe" {
    export * from "@myop/sdk/Iframe/IframeSDK";
}
declare module "@myop/sdk/webcomponent/shadowRootRef" {
    import { RootRef } from "@myop/sdk/common";
    export class ShadowRootRef extends RootRef {
        container: HTMLElement;
        shadowRoot: ShadowRoot;
        constructor(container: HTMLElement, shadowRoot: ShadowRoot);
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler" {
    import { BaseContextMessageHandler, HostedComponent } from "@myop/sdk/common";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    import { BaseMyopMessage } from "@myop/sdk/messages";
    export type MessageToHost = (message: BaseMyopMessage) => void;
    export abstract class BaseWebComponentMessageHandler<T extends BaseMyopMessage = any> extends BaseContextMessageHandler<T, Record<string, HostedComponent<ShadowRootRef>>> {
        context: Record<string, HostedComponent<ShadowRootRef>>;
        abstract messageType: string;
        constructor(messageToHost: any, context: Record<string, HostedComponent<ShadowRootRef>>);
        abstract innerExecutor: (event: T, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;
        executor: (event: T) => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/bindOnClickHandler" {
    import { BindClickMessage } from "@myop/sdk/messages";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    import { BaseWebComponentMessageHandler, MessageToHost } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    export class BindOnClickHandler extends BaseWebComponentMessageHandler<BindClickMessage> {
        messageType: string;
        innerExecutor: (event: BindClickMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => () => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/changeTextHandler" {
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    import { BaseWebComponentMessageHandler } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { MyopElementMessage } from "@myop/sdk/messages";
    export class ChangeTextHandler extends BaseWebComponentMessageHandler<MyopElementMessage> {
        messageType: string;
        innerExecutor: (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/DetectMyopRefsMessageHandler" {
    import { BaseWebComponentMessageHandler } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    import { DetectMyopRefsMessage } from "@myop/sdk/messages";
    export class DetectMyopRefsMessageHandler extends BaseWebComponentMessageHandler<DetectMyopRefsMessage> {
        innerExecutor: (event: DetectMyopRefsMessage, shadowRootRef: ShadowRootRef) => void;
        messageType: string;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/setAttributeHandler" {
    import { SetAttributeMessage } from "@myop/sdk/messages";
    import { BaseWebComponentMessageHandler } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    export class setAttributeHandler extends BaseWebComponentMessageHandler<SetAttributeMessage> {
        messageType: string;
        innerExecutor: (event: SetAttributeMessage, shadowRootRef: ShadowRootRef) => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/addEventListenerHandler" {
    import { AddEventListenerMessage } from "@myop/sdk/messages";
    import { BaseWebComponentMessageHandler, MessageToHost } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    export class AddEventListenerHandler extends BaseWebComponentMessageHandler<AddEventListenerMessage> {
        messageType: string;
        innerExecutor: (event: AddEventListenerMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => () => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/CreateRefComponentMessageHandler" {
    import { CreateRefComponentMessage } from "@myop/sdk/messages/CreateRefComponentMessage";
    import { BaseWebComponentMessageHandler, MessageToHost } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    export class CreateRefComponentMessageHandler extends BaseWebComponentMessageHandler<CreateRefComponentMessage> {
        messageType: string;
        innerExecutor: (event: CreateRefComponentMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/executeScriptHandler" {
    import { ExecuteScriptMessage } from "@myop/sdk/messages";
    import { BaseWebComponentMessageHandler, MessageToHost } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    export class ExecuteScriptHandler extends BaseWebComponentMessageHandler<ExecuteScriptMessage> {
        messageType: string;
        innerExecutor: (event: ExecuteScriptMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/GetElementValueHandler" {
    import { GetElementValueMessage } from "@myop/sdk/messages";
    import { BaseWebComponentMessageHandler, MessageToHost } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    export class GetElementValueHandler extends BaseWebComponentMessageHandler<GetElementValueMessage> {
        messageType: string;
        innerExecutor: (event: GetElementValueMessage, shadowRootRef: ShadowRootRef, messageToHost: MessageToHost) => void;
    }
}
declare module "@myop/sdk/webcomponent/messageHandlers/setInnerHtmlHandler" {
    import { SetInnerHtml } from "@myop/sdk/messages";
    import { ShadowRootRef } from "@myop/sdk/webcomponent/shadowRootRef";
    import { BaseWebComponentMessageHandler } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { MyopElementMessage } from "@myop/sdk/messages";
    export class SetInnerHtmlHandler extends BaseWebComponentMessageHandler<SetInnerHtml> {
        messageType: string;
        innerExecutor: (event: MyopElementMessage, shadowRootRef: ShadowRootRef) => void;
    }
}
declare module "@myop/sdk/webcomponent/WebComponentSDK" {
    /**
     * @packageDocumentation
     * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>
     * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>
     * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.
     *
     *
     * Once loaded the `RootSDK`, you can load the `IframeSDK`
     * ```js
     * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());
     * ```
     * or
     * ```ts
     * import {getWebcomponentModule} from '@myop/sdk';
     * const {WebComponentSDK} = (await getWebcomponentModule());
     * ```
     * or
     * ```ts
     * import {WebComponentSDK} from '@myop/sdk/webcomponent';
     * ```
     *
     */
    import { BaseMyopSDK } from "@myop/sdk/common";
    import { BaseWebComponentMessageHandler } from "@myop/sdk/webcomponent/messageHandlers/BaseWebComponentMessageHandler";
    import { MyopBindMessage, MyopBindReplayMessage } from "@myop/sdk/messages";
    /**
     * The Webcomponent SDK is tailored for using Myop components packaged as separate bundles and exposed as web components.<br/>
     * Developers importing this SDK can leverage APIs and utilities specifically crafted to support the lifecycle management and communication patterns required for web components within the Myop architecture.<br/>
     * This SDK promotes reusability and encapsulation, enabling developers to build modular, self-contained components that can be seamlessly integrated into the host application's DOM structure.
     *
     *
     * Once loaded the `Root SDK`, you can load the `IframeSDK`
     * ```js
     * const {WebComponentSDK} = (await window.myop.rootSDK.getWebcomponentModule());
     * ```
     * or
     * ```ts
     * import {getWebcomponentModule} from '@myop/sdk';
     * const {WebComponentSDK} = (await getWebcomponentModule());
     * ```
     *
     */
    export class WebComponentSDK extends BaseMyopSDK {
        alwaysPassEnvelopesToHost: boolean;
        connectedCallback: (container: HTMLElement, shadow: ShadowRoot) => void;
        messageToHost: (message: MyopBindReplayMessage, replayTo?: MyopBindMessage) => void;
        supportedHandlers: BaseWebComponentMessageHandler[];
        init: () => void;
    }
}
declare module "@myop/sdk/webcomponent" {
    export * from "@myop/sdk/webcomponent/WebComponentSDK";
}
declare module "@myop/sdk/host/embeddedSDK" {
    /**
     * Embedded SDK Content Module
     *
     * This module provides the embedded SDK content for npm package users.
     * The actual content is generated at build time by scripts/build-embedded-sdk.js
     *
     * For development, this file exports placeholders.
     * After build, the dist/module/embeddedSDK.js will contain the actual SDK content.
     *
     * Usage in HTMLComponentLoader:
     * - If HAS_EMBEDDED_SDK is true, inject SDK inline: <script>${EMBEDDED_SDK_CONTENT}</script>
     * - If HAS_EMBEDDED_SDK is false, fall back to CDN: <script src="${url}"></script>
     */
    /**
     * The embedded SDK content as a minified JavaScript string.
     * This placeholder will be replaced with actual content in the build output.
     */
    export const EMBEDDED_SDK_CONTENT: string;
    /**
     * Flag indicating whether embedded SDK content is available.
     * This is false in development, true in the built module.
     */
    export const HAS_EMBEDDED_SDK: boolean;
}
declare module "@myop/sdk/host/loaders/HTMLComponentLoader" {
    import { MyopWebComponent } from "@myop/sdk/host/components/myopWebcomponent";
    import { MyopExtractedWebComponent } from "@myop/sdk/host/components/myopExtractedWebComponent";
    import { BaseMyopLoader } from "@myop/sdk/host/loaders/IMyopLoader";
    import { loaderOptions } from "@myop/sdk/host/hostSDK";
    import { IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    import { MyopIframeComponent } from "@myop/sdk/host/components/myopIframeComponent";
    export class HTMLComponentLoader extends BaseMyopLoader {
        type: "HTMLLoader";
        /**
         * Detect if HTML is a Myop Web Component (starts with marker comment)
         */
        private isMyopWebComponent;
        /**
         * Extract the web component script content from HTML
         */
        private extractWebComponentScript;
        /**
         * Execute the web component script on the host document
         */
        private executeWebComponentScript;
        /**
         * Load a Myop Web Component (extracted and run on host document)
         */
        private loadExtractedWebComponent;
        load: (componentDefinition: IComponentDefinitionConfig, skin: ISkinConfig, container: HTMLElement, options?: loaderOptions) => Promise<MyopExtractedWebComponent | MyopIframeComponent | MyopWebComponent>;
    }
}
declare module "@myop/sdk/helpers/applyStylesheet" {
    import type * as CSS from "@myop/sdk/csstype";
    import { IMyopComponent } from "@myop/sdk/host";
    /** @ignore */
    export interface CSSProperties extends CSS.Properties<string | number> {
    }
    export type StylesheetDefinition = {
        [key: string]: CSSProperties;
    };
    export const applyStylesheet: (component: IMyopComponent, stylesheet: StylesheetDefinition, css?: string) => () => void;
    export const applyStylesheetLink: (component: IMyopComponent, link: string) => () => void;
}
declare module "@myop/sdk/helpers/iframeSkinUrlTokenizer" {
    import { ISkinConfig } from "@myop/sdk/common";
    export type TokenMap = Record<string, string | number>;
    export const createIframeSkinByTokenizer: (selectedSkin: ISkinConfig, tokenMap: TokenMap) => ISkinConfig;
    export const changeSkinUrlByTokenizer: (tokenMap: TokenMap) => (selectedSkin: ISkinConfig) => Promise<ISkinConfig>;
}
declare module "@myop/sdk/helpers/classList" {
    import { IMyopComponent } from "@myop/sdk/host";
    export const addClass: (component: IMyopComponent, className: string, myopId: string) => void;
    export const removeClass: (component: IMyopComponent, className: string, myopId: string) => void;
}
declare module "@myop/sdk/helpers/configBuilder" {
    import { IComponentConfig, IComponentDefinitionConfig, IComponentInstanceConfig, IHTMLLoaderConfig, IRefConfig, ISkinLoaderConfig, ISkinConfig } from "@myop/sdk/common";
    export class SkinConfig implements ISkinConfig {
        _runTimeInstanceId: string;
        _runTimeId: string;
        _runTimeName: string;
        static create: () => SkinConfig;
        id: string;
        name: string;
        description: string;
        loader: ISkinLoaderConfig;
        withLoader: (loader: ISkinLoaderConfig) => this;
        withHTMLLoader: (loader: Omit<IHTMLLoaderConfig, "type">) => this;
        build: () => this;
    }
    export class ComponentConfig implements IComponentConfig {
        _runTimeInstanceId: string;
        _runTimeId: string;
        _runTimeName: string;
        static create: () => ComponentConfig;
        instance: IComponentInstanceConfig;
        name: string;
        type: IComponentDefinitionConfig;
        withInstance: (instance: IComponentInstanceConfig) => this;
        withType: (type: IComponentDefinitionConfig) => this;
        withName: (name: string) => this;
        withDefaultSkin: (defaultSkin: ISkinConfig) => this;
        withRef: (ref: IRefConfig) => this;
        withBasicRef: (refSelector: string) => this;
        build: () => any;
    }
}
declare module "@myop/sdk/helpers/CloudRepository" {
    import { IComponentConfig, IUserFlow } from "@myop/sdk/common";
    export class CloudRepository {
        private _baseUrl;
        private static _main;
        static get Main(): CloudRepository;
        private variants;
        private preloadedComponents;
        private userFlows;
        private _defaultEnv;
        private _envExplicitlySet;
        private _staticMode;
        private _queryParams;
        constructor(_baseUrl?: string);
        /**
         * Enable static mode for self-hosted component registries.
         * In static mode, URLs are constructed as file paths instead of query params:
         *   ${baseUrl}/components/${componentId}/${env}.json
         */
        enableStaticMode(): void;
        /**
         * Set query parameters to append to all fetch URLs (e.g. for CDN cache busting).
         * Example: `setQueryParams({ lastupdate: '11112026' })`
         */
        setQueryParams(params: Record<string, string>): void;
        /**
         * Set the default environment for this CloudRepository instance
         */
        setEnvironment(env: string): void;
        /**
         * Get the current default environment
         */
        getDefaultEnvironment(): string;
        /**
         * Check if a component is already cached/preloaded (v2)
         * If env and preview are not provided, checks if ANY version is preloaded
         */
        isPreloaded(componentId: string, env?: string, preview?: boolean): boolean;
        /**
         * Get the preloaded params for a component (if preloaded)
         * Returns undefined if not preloaded
         */
        getPreloadedParams(componentId: string): {
            env: string;
            preview: boolean;
        } | undefined;
        /**
         * Fetch a v2 component config
         * If env/preview not specified and component was preloaded, uses preloaded params
         */
        fetchComponentV2(componentId: string, environmentIdentifier?: string, preview?: boolean): Promise<IComponentConfig>;
        /**
         * Synchronous version of fetchComponentV2 — returns the config only if
         * the fetch already completed, null otherwise.
         *
         * Uses the same `this.variants` cache that fetchComponentV2/preloadComponents
         * populate. Each cached Promise is tagged with a `.resolved` property when
         * it settles — this method just reads that property. No separate cache.
         *
         * Why this exists: React Native needs the config at render time to embed it
         * in the WebView HTML (can't await in useState). If preloadComponents ran
         * earlier and the fetch completed, this returns the result synchronously,
         * skipping the WEBVIEW_READY → fetch → inject round trip entirely.
         */
        getResolvedConfig(componentId: string, env?: string, preview?: boolean): IComponentConfig | null;
        /**
         * Fetch a v1 component from a flow
         */
        fetchComponentV1(componentId: string, flowId?: string): Promise<IComponentConfig>;
        fetchAutoFlow(componentId: string): Promise<IUserFlow>;
        fetchFlow(flowId: string): Promise<IUserFlow>;
        /**
         * @deprecated Use fetchComponentV2 or fetchComponentV1 explicitly
         * Defaults to v1 behavior for backward compatibility with existing code
         */
        fetchComponent(componentId: string, flowId?: string): Promise<IComponentConfig>;
    }
    /**
     * @deprecated Use CloudRepository instead
     */
    export const v2_CloudRepository: typeof CloudRepository;
}
declare module "@myop/sdk/helpers/exec" {
    export const exec: (getter: any) => Promise<any>;
}
declare module "@myop/sdk/helpers/cloudRepositoryHelpers" {
    import { CloudRepository } from "@myop/sdk/helpers/CloudRepository";
    export const getCloudRepository: () => CloudRepository;
    export const isPreloaded: (componentId: string, env?: string, preview?: boolean) => boolean;
    export const getPreloadedParams: (componentId: string) => {
        env: string;
        preview: boolean;
    };
    export const enableLocalDev: () => void;
    export const setCloudRepositoryUrl: (url: string) => void;
    /**
     * Configure the SDK to fetch components from a self-hosted static registry (S3, CDN, etc.)
     * instead of the Myop cloud. Components are served as static JSON files:
     *   `${cdnUrl}/components/${componentId}/${environment}.json`
     */
    export const enableSelfHosted: (cdnUrl: string, queryParams?: Record<string, string>) => void;
    export const setCloudRepository: (repository: CloudRepository) => void;
    export const setEnvironment: (env: string) => void;
    export const getResolvedConfig: (componentId: string, env?: string, preview?: boolean) => import("common").IComponentConfig;
    export const preloadComponents: (ids: string[], env?: string, preview?: boolean) => Promise<PromiseSettledResult<import("common").IComponentConfig>[]>;
}
declare module "@myop/sdk/helpers" {
    export * from "@myop/sdk/helpers/applyStylesheet";
    export * from "@myop/sdk/helpers/iframeSkinUrlTokenizer";
    export * from "@myop/sdk/helpers/classList";
    export * from "@myop/sdk/helpers/configBuilder";
    export * from "@myop/sdk/helpers/CloudRepository";
    export * from "@myop/sdk/helpers/exec";
    export * from "@myop/sdk/helpers/cloudRepositoryHelpers";
}
declare module "@myop/sdk/host/myopOverride" {
    import { IComponentConfig } from "@myop/sdk/common";
    export const checkMyopOverride: (componentConfig: IComponentConfig) => Promise<IComponentConfig | null>;
}
declare module "@myop/sdk/host/hostSDK" {
    import { IMyopLoader } from "@myop/sdk/host/loaders/IMyopLoader";
    import { IMyopComponent } from "@myop/sdk/host/components/IMyopComponent";
    import { BaseMyopMessage, Ref } from "@myop/sdk/messages";
    import type { IframeSDK } from "@myop/sdk/Iframe";
    import { IComponentConfig, IComponentDefinitionConfig, ISkinConfig } from "@myop/sdk/common";
    interface componentLoaderCreator {
        new (loaders: IMyopLoader[]): any;
    }
    /**
     * The Host SDK is designed for integration within the host application that serves as the container for Myop  components.<br/><br/>
     * It provides essential functionalities and APIs for registering, managing, and communicating with Myop components.<br/><br/>
     * This SDK enables seamless embedding of independently developed components into the host application, ensuring smooth interoperability and consistent user experience across various Myop component implementations.
     */
    export class HostSDK {
        static Instance: () => HostSDK;
        components2init: IMyopComponent[];
        components: IMyopComponent[];
        componentsLoaders: IMyopLoader[];
        initiated: boolean;
        version: any;
        type2InstanceCount: Record<string, number>;
        assignId: (componentDefinition: IComponentDefinitionConfig) => string;
        private inspected;
        inspect: () => void;
        private incomingMessageHandler;
        send: (message: BaseMyopMessage) => void;
        init: (customComponentLoaderCreators?: componentLoaderCreator[]) => void;
        private _getSkinIdBySkinSelector;
        private runSkinSelector;
        loaderHooks?: loaderHooks;
        loadComponent: <T extends IMyopComponent = IMyopComponent>(componentConfig: IComponentConfig, container?: HTMLElement | Ref, options?: loaderOptions) => Promise<T>;
        navigate: <T extends IMyopComponent = IMyopComponent>(component: IMyopComponent, newComponentConfig: IComponentConfig, options?: navigationOptions) => Promise<T>;
    }
    export type navigationOptions = {
        staged?: boolean;
        init?: (component: IMyopComponent) => Promise<void>;
        skipInit?: boolean;
    } & loaderOptions;
    type relativeLoadConfigDirection = 'before' | 'after';
    export type loaderHooks = {
        afterSkinSelected?: (selectedSkin: ISkinConfig) => Promise<ISkinConfig>;
    } & ({
        [key: string]: () => Promise<boolean> | boolean;
    } | {});
    export interface relativeLoadConfig {
        child: ChildNode | null;
        direction: relativeLoadConfigDirection;
    }
    export interface IEnvironment {
        [key: string]: any;
    }
    type ElementAttributes = {
        [key: string]: string | number | boolean | undefined | null;
    };
    export interface loaderOptions {
        id?: string;
        hidden?: boolean;
        connectProps?: boolean;
        timeout?: number;
        skipInit?: boolean;
        relative?: relativeLoadConfig;
        hooks?: loaderHooks;
        elementAttributes?: ElementAttributes;
        _environment?: IEnvironment;
        _hasParent?: boolean;
        _inspection?: boolean;
        data?: any;
        /**
         * Raw CSS injected into the component's iframe <head> before first paint.
         * Appended last so it overrides the component's own styles via cascade order.
         * Useful for theming v2 (HTML) components — colors, fonts, spacing, etc.
         */
        injectCss?: string;
        /**
         * Control iframe auto-sizing behavior.
         * - true (default): iframe auto-sizes to content height, width fills parent.
         * - false: no sizing logic runs. No observers, no measurements, no style changes.
         *   The iframe stays at position:absolute filling the container.
         *   The host is fully responsible for container dimensions.
         */
        autoSize?: boolean;
    }
    export const hostSDK: HostSDK;
    global {
        interface Window {
            myop: {
                __ROOT_SDK_PUBLIC_URL__: string;
                hostSDK: HostSDK;
                IframeSDK: InstanceType<typeof IframeSDK>;
            };
        }
    }
}
declare module "@myop/sdk/messages/MyopMessages" { }
declare module "@myop/sdk/helpers/MyopHelpers" {
    export * from "@myop/sdk/helpers";
}
declare module "@myop/sdk/SDK" {
    import "dynamicImport/load__federation__";
    const getHostModule: () => Promise<typeof import("@myop/sdk/host/hostSDK")>;
    const getIframeModule: () => Promise<typeof import("@myop/sdk/Iframe/IframeSDK")>;
    const getWebcomponentModule: () => Promise<typeof import("@myop/sdk/webcomponent/WebComponentSDK")>;
    const sdkModule: {
        getHostModule: () => Promise<typeof import("@myop/sdk/host/hostSDK")>;
        getIframeModule: () => Promise<typeof import("@myop/sdk/Iframe/IframeSDK")>;
        getWebcomponentModule: () => Promise<typeof import("@myop/sdk/webcomponent/WebComponentSDK")>;
    };
    export type rootSDKType = typeof sdkModule;
    export { getHostModule, getIframeModule, getWebcomponentModule };
}