@myop/sdk 0.3.34 → 0.4.0-beta.0

package/dist/bundled-declarations.d.ts

@@ -645,6 +645,12 @@ declare module "@myop/sdk/host/components/myopIframeComponent" {
          * @returns Cleanup function to stop observing
          */
         observeAutoSize: (options?: AutoSizeOptions) => CleanupHandler;
+        private _bridgeSizeCleanup?;
+        /**
+         * Auto-height for a frame the host can't read (cross-origin). Runs after the IframeSDK
+         * handshake: the frame reports body resizes and the host re-reads the scroll height.
+         */
+        observeHeightViaBridge: () => CleanupHandler;
         setSizeBasedOnDocumentElement: () => void;
         setHeightBasedOnScrollHeight: () => void;
         send: (message: BaseMyopMessage) => CleanupHandler;
@@ -1482,6 +1488,399 @@ declare module "@myop/sdk/Iframe/IframeSDK" {
 declare module "@myop/sdk/Iframe" {
     export * from "@myop/sdk/Iframe/IframeSDK";
 }
+declare module "@myop/sdk/helpers/deliveryStore" {
+    export interface StoredEntry {
+        key: string;
+        /** the resolved component config, exactly as the network path produces it */
+        config: any;
+        /** the server's version token for these bytes: `<rev>~<opt>` */
+        tag: string | null;
+        /** when this browser stored it */
+        storedAt: number;
+        /** how long it may be used without asking, in ms (already Age-adjusted) */
+        windowMs: number;
+        /** which host produced it — a key from another host is never reused */
+        host: string;
+        /** wire size of the response it came from, so stats can say what the window saved */
+        bytes?: number;
+    }
+    export const deliveryStore: {
+        key(host: string, componentId: string, env: string, preview: boolean, opt: string): string;
+        get(key: string): Promise<StoredEntry | null>;
+        put(entry: StoredEntry): Promise<void>;
+        drop(key: string): Promise<void>;
+        /** Still usable without asking the server? */
+        fresh(e: StoredEntry | null): boolean;
+        /**
+         * The window this response licenses: the server's freshness minus what a CDN already
+         * spent. Returns 0 when the server said nothing about caching, which means "do not
+         * hold this" — the safe reading, and what production sends today.
+         */
+        windowFrom(headers: Headers): number;
+        /** For tests and for `refresh()`: forget everything this browser holds. */
+        clear(): Promise<void>;
+    };
+}
+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);
+        /**
+         * How big the component we are NOT re-downloading is. Deliberately measured from what
+         * we hold rather than from Content-Length: once a response is compressed the header is
+         * not readable cross-origin, so reading it there reported 0 every single time.
+         */
+        private static sizeOfHeld;
+        /** The host every request goes to unless delivery() moved it. Never changes. */
+        private static readonly DEFAULT_HOST;
+        /**
+         * Opt-in delivery settings, set by myop.delivery(). Off means: this file behaves
+         * EXACTLY as it did before — same host, same URL, same everything.
+         */
+        private _delivery;
+        /**
+         * What actually happened, for myop.delivery.stats(). `fellBack` is the number that
+         * matters: it is how you find out the lane is unhealthy without waiting for a
+         * bug report, because a fallback is INVISIBLE to the page (it still renders).
+         */
+        private _deliveryStats;
+        /**
+         * Turn on the opt-in delivery path.
+         *
+         * Opting in IS choosing the delivery stack: this points /consume at `host` (a second,
+         * complete stack reading the same data) and asks for the minified artifact. Leave this
+         * uncalled and nothing about the SDK changes.
+         *
+         * Deliberately mutates THIS instance rather than constructing a new repository:
+         * CloudRepository.Main is a global singleton shared across bundles (see getGlobalMain),
+         * so a second instance would be ignored by every component already using the first.
+         */
+        setDelivery(opts?: {
+            minify?: boolean;
+            host?: string | null;
+            cache?: boolean;
+        }): void;
+        deliveryStats(): {
+            host: string;
+            minify: boolean;
+            cache: boolean;
+            requests: number;
+            viaDelivery: number;
+            fellBack: number;
+            lastError: string | null;
+            /** where the last loads were answered from — the number the client window exists to move */
+            fromMemory: number;
+            fromStorage: number;
+            fromNetwork: number;
+            /** re-checks after the window ended, and how many were answered "nothing changed" */
+            revalidations: number;
+            unchanged: number;
+            bytesSaved: number;
+        };
+        /**
+         * Forget what this browser holds, so the next load asks the server.
+         * `refresh()` with no ids drops everything; the counterpart to the window for the case
+         * where a change has to be visible on THIS load — right after someone publishes.
+         */
+        refreshDelivery(): Promise<void>;
+        /**
+         * Local serves waiting to be reported: componentId -> {env, count}.
+         *
+         * THE MEASUREMENT PROBLEM THIS SOLVES. The better this cache works, the more usage
+         * vanishes: a visitor inside their freshness window renders the page with no request,
+         * so neither the server nor the CDN can see them. Left alone, a successful rollout
+         * looks in the ledger exactly like customers leaving.
+         *
+         * So local serves are counted here and reported afterwards, batched, on a path that
+         * never blocks rendering: flushed when the page is hidden (keepalive, so it survives
+         * the tab closing) and opportunistically whenever the SDK is talking to the server
+         * anyway. Nothing is sent while the page is loading, which is the point of the window.
+         */
+        private _localServes;
+        private _flushBound;
+        private noteLocalServe;
+        /** Report on page-hide, which is the only event that reliably fires on mobile. */
+        private bindFlush;
+        /**
+         * Send what we have. `keepalive` is what makes this work at page-hide: the request
+         * outlives the document. Failure is ignored — a lost usage report must never be
+         * visible to a visitor, and the next page load will report its own.
+         */
+        flushLocalServes(): void;
+        /** Where /consume should be fetched from right now. */
+        private deliveryHost;
+        /**
+         * Fetch a delivery URL with ONE fallback to the default host.
+         *
+         * The fallback is the kill switch: break or disable the lane and every client drifts
+         * back to cloud.myop.dev on its own, with no customer deploy. It must therefore be
+         * genuinely silent to the page and genuinely LOUD in stats() — a fallback that nobody
+         * counts is an outage nobody notices.
+         *
+         * Only transport failures and 5xx fall back. A 404 is an answer: the component really
+         * is missing, and retrying elsewhere would only hide it.
+         */
+        private deliveryFetch;
+        /**
+         * 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;
+        /**
+         * Resolve a component config: fetch it once, then serve it from this
+         * repository's cache.
+         *
+         * This is the name to use. `fetchComponentV2` is the same method under its
+         * versioned name and stays for backward compatibility — note that the
+         * unversioned `fetchComponent` is a *deprecated v1* API and is NOT this.
+         *
+         * Completes the trio with {@link getResolvedConfig} (synchronous read of an
+         * already-resolved config) and {@link hydrateComponent} (seed one you
+         * already hold).
+         *
+         * Prefer the module-level `preloadComponents([id])` in app code; reach for
+         * this when you need an isolated repository instance whose cache lifetime
+         * you control — a server with its own TTL, for example.
+         */
+        resolveComponent(componentId: string, env?: string, preview?: boolean): Promise<IComponentConfig>;
+        /**
+         * Fetch a v2 component config
+         * If env/preview not specified and component was preloaded, uses preloaded params
+         *
+         * @see resolveComponent — the unversioned name for this method
+         */
+        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;
+        /**
+         * Resolve which (env, preview) pair — and therefore which cache key — a call
+         * for `componentId` refers to.
+         *
+         * Single source of truth for fetchComponentV2, getResolvedConfig and
+         * hydrateComponent, so a hydrated config always lands on the key a later
+         * fetch will look under.
+         */
+        private resolveParams;
+        /**
+         * Seed an already-resolved component config into the cache, without any
+         * network request.
+         *
+         * The counterpart to {@link fetchComponentV2}: use it when the config was
+         * resolved somewhere else — most often on a server, then embedded in the
+         * page — so the browser can render the component with no round trip.
+         *
+         * After hydrating, `fetchComponentV2`, `getResolvedConfig` and `isPreloaded`
+         * all answer for this component from memory.
+         *
+         * Pass the same `env` / `preview` the config was resolved with; the defaults
+         * match what a plain `fetchComponentV2(componentId)` would have used.
+         */
+        hydrateComponent(componentId: string, config: IComponentConfig, env?: string, preview?: boolean): void;
+        /**
+         * 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/cloudRepositoryHelpers" {
+    import { CloudRepository } from "@myop/sdk/helpers/CloudRepository";
+    import { IComponentConfig } from "@myop/sdk/common";
+    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;
+    /**
+     * THE OPT-IN. One call, and nothing changes for anyone who does not make it.
+     *
+     *   myop.delivery({ minify: true });
+     *
+     * Opting in IS choosing the delivery lane: a second, complete Myop stack (its own server
+     * and CDN) reading the same component data. So this call does two things at once — it
+     * points `/consume` at that stack and asks it for the minified artifact — which is why
+     * turning the feature off is a config value on our side or one line on yours, and never
+     * a DNS change.
+     *
+     * Safety properties, all deliberate:
+     *   - If the lane fails (transport error or 5xx), the SDK retries ONCE against
+     *     cloud.myop.dev and the page renders anyway. `delivery.stats().fellBack` counts it.
+     *   - `cache: true` adds the client window: a component this browser already holds, still
+     *     inside the freshness the server promised, is rendered with NO request. Once the
+     *     window ends the browser sends back the version it holds instead of re-downloading.
+     *   - A preview is never minified and never cached.
+     *   - Only /consume moves. Everything else keeps the host it has today.
+     *   - Asking for `minify` does not force it: the server decides per component, and a
+     *     component that is not enabled is served raw, which is not an error.
+     *
+     * `host` is for us (a staging lane, a local server); leave it out.
+     */
+    export const DELIVERY_HOST = "https://delivery.myop.dev";
+    export const delivery: (opts?: {
+        minify?: boolean;
+        cache?: boolean;
+        host?: string | null;
+    }) => {
+        host: string;
+        minify: boolean;
+        cache: boolean;
+        requests: number;
+        viaDelivery: number;
+        fellBack: number;
+        lastError: string | null;
+        fromMemory: number;
+        fromStorage: number;
+        fromNetwork: number;
+        revalidations: number;
+        unchanged: number;
+        bytesSaved: number;
+    };
+    /**
+     * Forget what this browser holds, so the next load asks the server. Use it when a change
+     * has to be visible on THIS load — right after someone publishes — rather than within the
+     * freshness window.
+     */
+    export const deliveryRefresh: () => Promise<{
+        host: string;
+        minify: boolean;
+        cache: boolean;
+        requests: number;
+        viaDelivery: number;
+        fellBack: number;
+        lastError: string | null;
+        fromMemory: number;
+        fromStorage: number;
+        fromNetwork: number;
+        revalidations: number;
+        unchanged: number;
+        bytesSaved: number;
+    }>;
+    /**
+     * What answered the last requests, and — the number worth watching — how many times the
+     * SDK had to fall back to the default host because the lane did not answer.
+     */
+    export const deliveryStats: () => {
+        host: string;
+        minify: boolean;
+        cache: boolean;
+        requests: number;
+        viaDelivery: number;
+        fellBack: number;
+        lastError: string | null;
+        fromMemory: number;
+        fromStorage: number;
+        fromNetwork: number;
+        revalidations: number;
+        unchanged: number;
+        bytesSaved: number;
+    };
+    /** Undo delivery(): back to the default host and raw bytes, with no reload. */
+    export const deliveryOff: () => {
+        host: string;
+        minify: boolean;
+        cache: boolean;
+        requests: number;
+        viaDelivery: number;
+        fellBack: number;
+        lastError: string | null;
+        fromMemory: number;
+        fromStorage: number;
+        fromNetwork: number;
+        revalidations: number;
+        unchanged: number;
+        bytesSaved: number;
+    };
+    export const setCloudRepository: (repository: CloudRepository) => void;
+    export const setEnvironment: (env: string) => void;
+    export const getResolvedConfig: (componentId: string, env?: string, preview?: boolean) => IComponentConfig;
+    export const preloadComponents: (ids: string[], env?: string, preview?: boolean) => Promise<PromiseSettledResult<IComponentConfig>[]>;
+    /**
+     * Seed already-resolved component configs into the SDK cache, with no network
+     * request. The counterpart to {@link preloadComponents}.
+     *
+     * Use it when the configs were resolved somewhere else — typically on a server
+     * and embedded in the page — so the component renders with zero round trips:
+     *
+     * ```ts
+     * // server: const configs = { [id]: await new CloudRepository().fetchComponentV2(id) }
+     * // client:
+     * hydrateComponents(configs);
+     * // <MyopComponent componentId={id} /> now renders without fetching
+     * ```
+     *
+     * Pass the same `env` / `preview` the configs were resolved with; the defaults
+     * match what a plain `preloadComponents([id])` would have used.
+     */
+    export const hydrateComponents: (configs: Record<string, IComponentConfig>, env?: string, preview?: boolean) => void;
+}
 declare module "@myop/sdk/webcomponent/shadowRootRef" {
     import { RootRef } from "@myop/sdk/common";
     export class ShadowRootRef extends RootRef {
@@ -1710,7 +2109,8 @@ declare module "@myop/sdk/host/loaders/HTMLComponentLoader" {
          */
         private extractWebComponentScript;
         /**
-         * Execute the web component script on the host document
+         * Execute the web component script on the host document.
+         * Returns the custom element tag name this script registered.
          */
         private executeWebComponentScript;
         /**
@@ -1775,174 +2175,9 @@ declare module "@myop/sdk/helpers/configBuilder" {
         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;
-        /**
-         * Resolve a component config: fetch it once, then serve it from this
-         * repository's cache.
-         *
-         * This is the name to use. `fetchComponentV2` is the same method under its
-         * versioned name and stays for backward compatibility — note that the
-         * unversioned `fetchComponent` is a *deprecated v1* API and is NOT this.
-         *
-         * Completes the trio with {@link getResolvedConfig} (synchronous read of an
-         * already-resolved config) and {@link hydrateComponent} (seed one you
-         * already hold).
-         *
-         * Prefer the module-level `preloadComponents([id])` in app code; reach for
-         * this when you need an isolated repository instance whose cache lifetime
-         * you control — a server with its own TTL, for example.
-         */
-        resolveComponent(componentId: string, env?: string, preview?: boolean): Promise<IComponentConfig>;
-        /**
-         * Fetch a v2 component config
-         * If env/preview not specified and component was preloaded, uses preloaded params
-         *
-         * @see resolveComponent — the unversioned name for this method
-         */
-        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;
-        /**
-         * Resolve which (env, preview) pair — and therefore which cache key — a call
-         * for `componentId` refers to.
-         *
-         * Single source of truth for fetchComponentV2, getResolvedConfig and
-         * hydrateComponent, so a hydrated config always lands on the key a later
-         * fetch will look under.
-         */
-        private resolveParams;
-        /**
-         * Seed an already-resolved component config into the cache, without any
-         * network request.
-         *
-         * The counterpart to {@link fetchComponentV2}: use it when the config was
-         * resolved somewhere else — most often on a server, then embedded in the
-         * page — so the browser can render the component with no round trip.
-         *
-         * After hydrating, `fetchComponentV2`, `getResolvedConfig` and `isPreloaded`
-         * all answer for this component from memory.
-         *
-         * Pass the same `env` / `preview` the config was resolved with; the defaults
-         * match what a plain `fetchComponentV2(componentId)` would have used.
-         */
-        hydrateComponent(componentId: string, config: IComponentConfig, env?: string, preview?: boolean): void;
-        /**
-         * 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";
-    import { IComponentConfig } from "@myop/sdk/common";
-    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) => IComponentConfig;
-    export const preloadComponents: (ids: string[], env?: string, preview?: boolean) => Promise<PromiseSettledResult<IComponentConfig>[]>;
-    /**
-     * Seed already-resolved component configs into the SDK cache, with no network
-     * request. The counterpart to {@link preloadComponents}.
-     *
-     * Use it when the configs were resolved somewhere else — typically on a server
-     * and embedded in the page — so the component renders with zero round trips:
-     *
-     * ```ts
-     * // server: const configs = { [id]: await new CloudRepository().fetchComponentV2(id) }
-     * // client:
-     * hydrateComponents(configs);
-     * // <MyopComponent componentId={id} /> now renders without fetching
-     * ```
-     *
-     * Pass the same `env` / `preview` the configs were resolved with; the defaults
-     * match what a plain `preloadComponents([id])` would have used.
-     */
-    export const hydrateComponents: (configs: Record<string, IComponentConfig>, env?: string, preview?: boolean) => void;
-}
 declare module "@myop/sdk/helpers" {
     export * from "@myop/sdk/helpers/applyStylesheet";
     export * from "@myop/sdk/helpers/iframeSkinUrlTokenizer";
@@ -1985,9 +2220,11 @@ declare module "@myop/sdk/host/hostSDK" {
         assignId: (componentDefinition: IComponentDefinitionConfig) => string;
         private inspected;
         inspect: () => void;
+        private isTrustedSource;
         private incomingMessageHandler;
         send: (message: BaseMyopMessage) => void;
         init: (customComponentLoaderCreators?: componentLoaderCreator[]) => void;
+        private _registerLoaders;
         private _getSkinIdBySkinSelector;
         private runSkinSelector;
         loaderHooks?: loaderHooks;
@@ -2074,11 +2311,15 @@ declare module "@myop/sdk/SDK" {
     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 getMyopMessages: () => Promise<typeof import("messages/MyopMessages")>;
+    const getMyopHelpers: () => Promise<typeof import("helpers/MyopHelpers")>;
     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")>;
+        getMyopMessages: () => Promise<typeof import("messages/MyopMessages")>;
+        getMyopHelpers: () => Promise<typeof import("helpers/MyopHelpers")>;
     };
     export type rootSDKType = typeof sdkModule;
-    export { getHostModule, getIframeModule, getWebcomponentModule };
+    export { getHostModule, getIframeModule, getWebcomponentModule, getMyopMessages, getMyopHelpers };
 }