@wippy-fe/types-global-proxy 0.0.1

package/index.d.ts

@@ -0,0 +1,826 @@
+import * as nanoevents from 'nanoevents';
+import { AxiosDefaults, AxiosInstance } from 'axios';
+import { ConfirmationOptions } from 'primevue/confirmationoptions';
+import { ToastMessageOptions } from 'primevue/toast';
+
+declare namespace PageApi {
+    interface Page {
+        icon: string;
+        id: string;
+        name: string;
+        title: string;
+        internal?: string;
+        order: number;
+        placement?: 'default' | 'bottom';
+        hidden?: boolean;
+        badge?: string | number;
+        badge_icon?: string;
+        group?: string;
+        group_order?: number;
+        group_icon?: string;
+        group_placement?: 'default' | 'bottom';
+        content_version?: string;
+        /** The content of the page artifact, which can be HTML, Markdown, or JSON with wippy specific package.json info */
+        content_type?: 'text/html' | 'text/markdown' | 'application/json';
+    }
+    interface PagesResponse {
+        count: number;
+        pages: Page[];
+        success: boolean;
+    }
+    interface PageContentResponse {
+        content: string;
+        success: boolean;
+    }
+}
+
+declare namespace UploadApi {
+    interface Meta {
+        filename: string;
+        content_sample?: string;
+    }
+    interface Upload {
+        uuid: string;
+        created_at: string;
+        updated_at: string;
+        mime_type: string;
+        size: number;
+        /**
+         * Note `@@local` is not part of the API response, it's a local state when file is still only on user PC
+         */
+        status: '@@local' | 'uploaded' | 'completed' | 'error' | 'processing';
+        meta: Meta;
+        error?: string;
+    }
+    interface ListResponse {
+        success: boolean;
+        meta: {
+            limit: number;
+            offset: number;
+            total: number;
+        };
+        uploads: Upload[];
+    }
+    interface GetResponse {
+        success: boolean;
+        upload: Upload;
+    }
+    interface UploadResponse {
+        success: boolean;
+        uuid: string;
+    }
+}
+
+declare enum ArtifactStatus {
+    /**
+     * The artifact is still being generated or processed.
+     * UI should display a loading indicator or show partial code/content.
+     * User interactions with the artifact may be limited during this state.
+     */
+    PROCESSING = "processing",
+    /**
+     * The artifact rendering is complete and it's in an active state.
+     * For interactive artifacts (forms, calculators, etc.), this indicates
+     * the artifact is ready and waiting for user input or interaction.
+     * UI should show the artifact as fully interactive.
+     */
+    RUNNING = "running",
+    /**
+     * The artifact rendering is complete but it's in an inactive state.
+     * For interactive artifacts, this indicates the artifact is not expecting
+     * any further input from the user.
+     * UI should show the artifact as read-only or with limited interactivity.
+     */
+    IDLE = "idle",
+    /**
+     * The artifact is being built by the system.
+     */
+    BUILDING = "building",
+    /**
+     * The artifact is being unit tested by the system.
+     */
+    TESTING = "testing",
+    /**
+     * The artifact failed to generate
+     */
+    ERROR = "error"
+}
+declare enum ArtifactType {
+    /**
+     * The artifact is embedded within chat message, html is sanitized to very basic tags.
+     * Applies only to text/html and text/markdown content types.
+     */
+    INLINE = "inline",
+    /**
+     * The artifact is embedded within chat message, in an iframe with support of iframe-proxy API
+     */
+    INLINE_INTERACTIVE = "inline-interactive",
+    /**
+     * The artifact is rendered as a button that opens artifact in an iframe with support of iframe-proxy API
+     * @see iframe-proxy.md
+     */
+    STANDALONE = "standalone"
+}
+interface Artifact {
+    uuid: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    type: ArtifactType;
+    /** The content of the artifact, which can be HTML, Markdown, or JSON with wippy specific package.json info */
+    content_type: 'text/html' | 'text/markdown' | 'application/json';
+    content_version?: string;
+    status: ArtifactStatus;
+}
+
+type ArtifactUUID = string;
+type PageUUID = string;
+type SessionUUID = string;
+type EntryUUID = string;
+type MessageUUID = string;
+type ActionCommand = 'navigate' | 'sidebar';
+declare const WsTopicPrefixes: {
+    readonly Pages: "pages";
+    readonly Page: "page";
+    readonly Artifact: "artifact";
+    readonly Welcome: "welcome";
+    readonly Update: "update";
+    readonly Session: "session";
+    readonly SessionOpen: "session.opened";
+    readonly SessionClosed: "session.closed";
+    readonly Error: "error";
+    readonly Upload: "upload";
+    readonly Action: "action";
+    readonly Registry: "registry";
+    readonly RegistryEntry: "entry";
+};
+interface WsTopicTypes {
+    /**
+     * Welcome info with active sessions
+     */
+    Welcome: typeof WsTopicPrefixes.Welcome;
+    /**
+     * Artifact are updated
+     */
+    Artifact: `${typeof WsTopicPrefixes.Artifact}:${ArtifactUUID}`;
+    /**
+     * Dynamic page list is updated
+     */
+    Pages: typeof WsTopicPrefixes.Pages;
+    /**
+     * Single page is updated and needs reload
+     */
+    Page: `${typeof WsTopicPrefixes.Page}:${PageUUID}`;
+    /**
+     * Session was opened event
+     */
+    SessionOpened: typeof WsTopicPrefixes.SessionOpen;
+    /**
+     * Session was closed event
+     */
+    SessionClosed: typeof WsTopicPrefixes.SessionClosed;
+    /**
+     * Session operation
+     */
+    Session: `${typeof WsTopicPrefixes.Session}:${SessionUUID}`;
+    /**
+     * Registry operation
+     */
+    Registry: `${typeof WsTopicPrefixes.Registry}:${string}`;
+    /**
+     * Registry entry updates
+     */
+    RegistryEntry: `${typeof WsTopicPrefixes.RegistryEntry}:${EntryUUID}`;
+    /**
+     * Registry entry updates
+     */
+    Action: `${typeof WsTopicPrefixes.Action}:${ActionCommand}`;
+    /**
+     * Session message
+     */
+    SessionMessage: `${typeof WsTopicPrefixes.Session}:${SessionUUID}:message:${MessageUUID}`;
+    /**
+     * Error message
+     */
+    Error: typeof WsTopicPrefixes.Error;
+    /**
+     * Upload was created or updated
+     */
+    Upload: `${typeof WsTopicPrefixes.Upload}:${string}`;
+}
+type WsTopic = WsTopicTypes[keyof WsTopicTypes];
+declare enum WsMessageType {
+    /** Contains the actual content of the message */
+    CONTENT = "content",
+    /** Contains content of the message to append to current one */
+    CHUNK = "chunk",
+    /** User message with contents */
+    USER = "received",
+    /** Response started, can create a message placeholder */
+    RESPONSE_STARTED = "response_started",
+    /** Kill the message */
+    INVALIDATE = "invalidate",
+    /** from to agent, get agent names */
+    DELEGATION = "delegation",
+    /** Tool/fn was called */
+    TOOL_CALL = "tool_call",
+    FUNCTION_CALL = "function_call",
+    /** Tool/fn was succesfull */
+    TOOL_SUCCESS = "tool_success",
+    FUNCTION_SUCCESS = "function_success",
+    /** Tool/fn failed */
+    TOOL_ERROR = "tool_error",
+    FUNCTION_ERROR = "function_error",
+    /** Error */
+    ERROR = "error",
+    /** Error */
+    ARTIFACT = "artifact"
+}
+interface WsMessageBase {
+    topic: WsTopic;
+    data?: {
+        request_id?: string;
+    };
+}
+interface WsMessage_Welcome extends WsMessageBase {
+    topic: WsTopicTypes['Welcome'];
+    data: {
+        request_id?: string;
+        active_session_ids: Array<string>;
+        active_sessions: number;
+        client_count: number;
+        user_id: string;
+    };
+}
+interface WsMessage_Action extends WsMessageBase {
+    topic: WsTopicTypes['Action'];
+    data: {
+        request_id?: string;
+        artifact_uuid?: string;
+        artifact_content_type?: string;
+        session_uuid?: string;
+        path?: string;
+    };
+}
+interface WsMessage_Registry extends WsMessageBase {
+    topic: WsTopicTypes['Registry'];
+    data: {
+        request_id?: string;
+    };
+}
+interface WsMessage_RegistryEntry extends WsMessageBase {
+    topic: WsTopicTypes['RegistryEntry'];
+    data: {
+        request_id?: string;
+        content_version?: string;
+    };
+}
+interface WsMessage_Pages extends WsMessageBase {
+    topic: WsTopicTypes['Pages'];
+}
+interface WsMessage_Page extends WsMessageBase {
+    topic: WsTopicTypes['Page'];
+    data: PageApi.Page & {
+        request_id?: string;
+    };
+}
+interface WsMessage_SessionOpen extends WsMessageBase {
+    topic: WsTopicTypes['SessionOpened'];
+    data: {
+        request_id?: string;
+        active_session_ids: Array<string>;
+        session_id: string;
+    };
+}
+interface WsMessage_Error extends WsMessageBase {
+    topic: WsTopicTypes['Error'];
+    data: {
+        request_id?: string;
+        error: string;
+        message: string;
+    };
+}
+interface WsMessage_SessionClosed extends WsMessageBase {
+    topic: WsTopicTypes['SessionClosed'];
+    data: {
+        request_id?: string;
+        active_session_ids: Array<string>;
+        session_id: string;
+    };
+}
+interface WsMessageDataBase {
+    type: WsMessageType;
+}
+interface WsMessageDataChunk extends WsMessageDataBase {
+    type: WsMessageType.CHUNK;
+    content: string;
+}
+interface WsMessageDataContent extends WsMessageDataBase {
+    type: WsMessageType.CONTENT;
+    content: string;
+    message_id: MessageUUID;
+    file_uuids?: string[];
+}
+interface WsMessageDataUser extends WsMessageDataBase {
+    type: WsMessageType.USER;
+    text: string;
+    message_id: MessageUUID;
+    file_uuids?: string[];
+}
+interface WsMessageDataDelegation extends WsMessageDataBase {
+    type: WsMessageType.DELEGATION;
+    from: string;
+    to: string;
+}
+interface WsMessageDataInvalidate extends WsMessageDataBase {
+    type: WsMessageType.INVALIDATE;
+}
+interface WsMessageDataStarted extends WsMessageDataBase {
+    type: WsMessageType.RESPONSE_STARTED;
+    message_id: MessageUUID;
+}
+interface WsMessageDataToolCall extends WsMessageDataBase {
+    type: WsMessageType.TOOL_CALL | WsMessageType.FUNCTION_CALL;
+    function_name: string;
+    artifact_id?: string;
+}
+interface WsMessageDataArtifact extends WsMessageDataBase {
+    type: WsMessageType.ARTIFACT;
+    artifact_id?: string;
+}
+interface WsMessageDataToolSuccess extends WsMessageDataBase {
+    type: WsMessageType.TOOL_SUCCESS | WsMessageType.FUNCTION_SUCCESS;
+    function_name: string;
+    artifact_id?: string;
+}
+interface WsMessageDataToolError extends WsMessageDataBase {
+    type: WsMessageType.TOOL_ERROR | WsMessageType.FUNCTION_ERROR;
+    function_name: string;
+    artifact_id?: string;
+}
+interface WsMessageDataError extends WsMessageDataBase {
+    type: WsMessageType.ERROR;
+    message: string;
+    code: string;
+}
+interface WsMessage_SessionMessage extends WsMessageBase {
+    topic: WsTopicTypes['SessionMessage'];
+    data: (WsMessageDataUser | WsMessageDataContent | WsMessageDataChunk | WsMessageDataDelegation | WsMessageDataToolCall | WsMessageDataError | WsMessageDataInvalidate | WsMessageDataStarted | WsMessageDataToolSuccess | WsMessageDataArtifact | WsMessageDataToolError) & {
+        request_id?: string;
+    };
+}
+interface WsMessage_Session extends WsMessageBase {
+    topic: WsTopicTypes['Session'];
+    data: {
+        request_id?: string;
+        agent?: string;
+        last_message_date?: number;
+        model?: string;
+        status?: string;
+        title?: string;
+        type: 'update';
+        public_meta?: Array<{
+            icon?: string;
+            id: string;
+            title: string;
+            url?: string;
+        }>;
+    };
+}
+interface WsMessage_Artifact extends WsMessageBase {
+    topic: WsTopicTypes['Artifact'];
+    data: Partial<Artifact> & {
+        request_id?: string;
+    };
+}
+interface WsMessage_Upload extends WsMessageBase {
+    topic: WsTopicTypes['Upload'];
+    data: UploadApi.Upload & {
+        request_id?: string;
+    };
+}
+type WsMessage = WsMessage_Welcome | WsMessage_Pages | WsMessage_Page | WsMessage_SessionMessage | WsMessage_Session | WsMessage_SessionClosed | WsMessage_Error | WsMessage_Artifact | WsMessage_SessionOpen | WsMessage_Action | WsMessage_Registry | WsMessage_RegistryEntry | WsMessage_Upload;
+
+type KnownTopics = '@history' | '@visibility' | '@message';
+type Events = {
+    /** Emitted when pages are updated */
+    '@history': (data: {
+        path: string;
+    }) => void;
+    '@visibility': (visible: boolean) => void;
+    '@message': (data: WsMessage) => void;
+} & {
+    [K in string as K extends KnownTopics ? never : K]: (data: WsMessage) => void;
+};
+declare function createEvents(): <T extends string>(topicPattern: T, callback: T extends KnownTopics ? Events[T] : Events["@message"]) => nanoevents.Unsubscribe;
+
+var cssRS = {
+	
+};
+
+var session = {
+	type: "non-persistent"
+};
+var history = "browser";
+var env = {
+	APP_API_URL: "",
+	APP_AUTH_API_URL: "",
+	APP_WEBSOCKET_URL: ""
+};
+var featureRS = {
+	session: session,
+	history: history,
+	env: env
+};
+
+var chat = {
+	emptyState: {
+		title: "No chat session selected",
+		description: "Please select a session from the dropdown above or start a new conversation.",
+		goToHome: "Go to Home Page",
+		loadingAgents: "Loading agents...",
+		selectAgent: "Select Agent",
+		startChat: "Start Chat",
+		startChatError: "Failed to start chat",
+		noAgents: "No agents available. Please contact your administrator.",
+		dropFiles: "Drop files here to upload"
+	}
+};
+var customPage = {
+	loading: {
+		title: "Loading page content..."
+	},
+	error: {
+		title: "Failed to load page content"
+	}
+};
+var home = {
+	loading: "Application is Loading",
+	error: {
+		title: "Error Loading Application"
+	},
+	noHomePage: {
+		title: "No Home Page Detected",
+		message: "Probably backend configuration is malformed"
+	}
+};
+var app = {
+	title: "Wippy App",
+	appName: "Wippy",
+	icon: "wippy:logo"
+};
+var login = {
+	error: {
+		title: "Session Token Expired",
+		description: "Your session has expired or is no longer valid. Please close this window and log in again to continue."
+	}
+};
+var logout = {
+	title: "Logout",
+	description: "Logging out..."
+};
+var keeper = {
+	controls: {
+		newChat: "New Chat",
+		searchAgents: "Search agents...",
+		undo: "Undo",
+		redo: "Redo",
+		download: "Registry To File System",
+		upload: "File System To Registry",
+		codeAssistant: "Wippy Code Assistant",
+		syncControls: "Sync Controls",
+		confirmUpload: {
+			title: "Confirm Upload",
+			message: "Do you wish to upload file system changes to registry? This will overwrite current state",
+			cancel: "Cancel",
+			upload: "Upload",
+			cancelled: {
+				title: "Upload cancelled",
+				message: "The upload operation was cancelled"
+			}
+		}
+	},
+	version: {
+		label: "Version:",
+		tooltip: "Version {{version}}"
+	}
+};
+var textRS = {
+	chat: chat,
+	customPage: customPage,
+	home: home,
+	app: app,
+	login: login,
+	logout: logout,
+	keeper: keeper
+};
+
+type I18NFeatureTypes = typeof featureRS;
+type I18NTextTypes = typeof textRS;
+type I18NCssTypes = typeof cssRS;
+
+/**
+ * All API route templates, grouped by domain.
+ * Dynamic path segments use `{paramName}` placeholders (OpenAPI-style).
+ * Each leaf value is a flat, fully-formed route — no concatenation needed at call site.
+ *
+ * Internally, routes use `@/…` shorthand that resolves against the group's `@prefix`.
+ * Resolution happens once inside `getApiRoutes()`, so consumers always receive clean strings.
+ *
+ * Base URL resolution:
+ * - HTTP routes: `getEnv().APP_API_URL` + route  (handled by axios baseURL)
+ * - WebSocket:   `getEnv().APP_WEBSOCKET_URL` + `getApiRoutes().ws.join`  (composed in ws/client.ts)
+ */
+interface ApiRoutes {
+    agents: {
+        list: string;
+        details: string;
+        byName: string;
+    };
+    sessions: {
+        list: string;
+        get: string;
+        messages: string;
+    };
+    models: {
+        list: string;
+        byName: string;
+    };
+    uploads: {
+        list: string;
+        get: string;
+        create: string;
+    };
+    artifacts: {
+        get: string;
+        content: string;
+        state: string;
+        baseUrl: string;
+    };
+    pages: {
+        list: string;
+        get: string;
+        content: string;
+        baseUrl: string;
+    };
+    registry: {
+        namespaces: string;
+        entries: string;
+        entry: string;
+        entryCreate: string;
+        entryEditors: string;
+        versions: string;
+        versionApply: string;
+    };
+    keeperSync: {
+        state: string;
+        download: string;
+        upload: string;
+        undo: string;
+        redo: string;
+    };
+    npm: {
+        globalAutoload: string;
+    };
+    tools: {
+        byName: string;
+    };
+    ws: {
+        join: string;
+    };
+}
+/**
+ * Override type for `AppConfig.feature.apiRoutes`.
+ *
+ * Each group is optional and partially overridable.
+ * Set `@prefix` to rebase all `@/…` routes in that group at once,
+ * or override individual routes with absolute paths.
+ */
+type ApiRoutesOverride = {
+    [K in keyof ApiRoutes]?: Partial<ApiRoutes[K]> & {
+        '@prefix'?: string;
+    };
+};
+
+interface AppFeatures extends I18NFeatureTypes {
+    /**
+     * If to remember auth details or not
+     */
+    session: {
+        type: 'non-persistent' | 'cookie';
+    };
+    history: 'browser' | 'hash';
+    env: {
+        APP_API_URL: string;
+        APP_AUTH_API_URL: string;
+        APP_WEBSOCKET_URL: string;
+    };
+    axiosDefaults?: Partial<AxiosDefaults>;
+    routePrefix?: string;
+    showAdmin?: boolean;
+    allowSelectModel?: boolean;
+    startNavOpen?: boolean;
+    hideNavBar?: boolean;
+    disableRightPanel?: boolean;
+    /**
+     * Hide the session selector dropdown in chat views
+     * @default false
+     */
+    hideSessionSelector?: boolean;
+    additionalNavItems?: Array<PageApi.Page>;
+    chat?: {
+        convertPasteToFile?: {
+            enabled: boolean;
+            minFileSize: number;
+            allowHtml: boolean;
+        };
+    };
+    apiRoutes?: ApiRoutesOverride;
+}
+interface AppAuthConfig {
+    token: string;
+    expiresAt: string;
+}
+interface AppCustomization {
+    customCSS?: string;
+    cssVariables?: I18NCssTypes;
+    i18n?: Partial<I18NTextTypes>;
+    icons?: Record<string, {
+        body: string;
+        width: number;
+        height: number;
+    }>;
+}
+interface AppConfig {
+    artifactId?: string;
+    /**
+     * Starting app or artifact/page path
+     */
+    path?: string;
+    /**
+     * App features like history mode, session type, etc.
+     */
+    feature?: AppFeatures;
+    /**
+     * Auth configuration
+     */
+    auth: AppAuthConfig;
+    /**
+     * App customization like i18n texts, css variables, custom css, etc.
+     */
+    customization?: AppCustomization;
+    externalEvents?: {
+        enabled: boolean;
+        wsType: string;
+        allowedOrigins: string[];
+        allowedTypes: string[];
+    };
+}
+
+interface FormState {
+    data?: Record<string, unknown>;
+    status: 'active' | 'inactive';
+}
+interface FormResult {
+    success: boolean;
+    message?: string;
+    errors?: Record<string, string>;
+}
+type LimitedConfirmationOptions = Omit<ConfirmationOptions, 'target' | 'appendTo' | 'onShow' | 'onHide'>;
+interface ProxyApiInstance {
+    config: AppConfig;
+    /** @deprecated, use `host` instead */
+    iframe: {
+        toast: (message: ToastMessageOptions) => void;
+        confirm: (options: LimitedConfirmationOptions) => Promise<boolean>;
+        startChat: (start_token: string, sidebar?: boolean) => void;
+        openSession: (sessionUUID: string, sidebar?: boolean) => void;
+        openArtifact: (artifactUUID: string, target: 'modal' | 'sidebar') => void;
+        navigate: (url: string) => void;
+        handleError: (code: ('auth-expired' | 'other'), error: Record<string, unknown>) => void;
+        setContext: (context: Record<string, unknown>, source?: {
+            type: 'page' | 'artifact';
+            uuid: string;
+        }) => void;
+        formatUrl: (relativeUrl: string) => string;
+        logout: () => void;
+    };
+    host: {
+        toast: (message: ToastMessageOptions) => void;
+        confirm: (options: LimitedConfirmationOptions) => Promise<boolean>;
+        startChat: (start_token: string, options?: {
+            sidebar?: boolean;
+        }) => void;
+        openSession: (sessionUUID: string, options?: {
+            sidebar?: boolean;
+        }) => void;
+        openArtifact: (artifactUUID: string, options?: {
+            target: 'modal' | 'sidebar';
+        }) => void;
+        navigate: (url: string) => void;
+        onRouteChanged: (internalRoute: string) => void;
+        handleError: (code: ('auth-expired' | 'other'), error: Record<string, unknown>) => void;
+        setContext: (context: Record<string, unknown>, sessionUUID?: string, source?: {
+            type: 'page' | 'artifact';
+            uuid: string;
+            instanceUUID?: string;
+        }) => void;
+        formatUrl: (relativeUrl: string) => string;
+        logout: () => void;
+    };
+    api: AxiosInstance;
+    /** @deprecated, use api calls instead */
+    form: {
+        get: () => Promise<FormState>;
+        submit: (data: FormData | Record<string, unknown>) => Promise<FormResult>;
+    };
+    on: ReturnType<typeof createEvents>;
+    loadWebComponent: (componentId: string, tagName?: string) => Promise<void>;
+}
+
+interface ProxyConfig {
+    enabled: boolean;
+    injections: {
+        css: {
+            fonts: boolean;
+            themeConfig: boolean;
+            iframe: boolean;
+            primevue: boolean;
+            markdown: boolean;
+            customCss: boolean;
+            customVariabled: boolean;
+        };
+        tailwindConfig: boolean;
+        resizeObserver: boolean;
+        preventLinkClicks: boolean;
+        iconifyIcons: boolean;
+        refreshWhenVisible: boolean;
+        historyPolyfill: boolean;
+    };
+}
+
+declare const GLOBAL_CONFIG_VAR: "__WIPPY_APP_CONFIG__";
+declare const GLOBAL_PROXY_CONFIG_VAR: "__WIPPY_PROXY_CONFIG__";
+declare const GLOBAL_API_PROVIDER: "__WIPPY_APP_API__";
+declare const GLOBAL_WEB_COMPONENT_CACHE: "__WIPPY_WEB_COMPONENT_CACHE__";
+declare global {
+    interface Window {
+        [GLOBAL_CONFIG_VAR]: AppConfig;
+        [GLOBAL_API_PROVIDER]: ProxyApiInstance;
+        [GLOBAL_PROXY_CONFIG_VAR]?: ProxyConfig;
+        [GLOBAL_WEB_COMPONENT_CACHE]: Record<string, {
+            usedAt: number;
+            data: string;
+            clearable: boolean;
+        }>;
+    }
+}
+
+/** @type {import('tailwindcss').Config} */
+declare const _default: {
+    content: string[];
+    theme: {
+        extend: {
+            colors: {
+                secondary: {
+                    50: string;
+                    100: string;
+                    200: string;
+                    300: string;
+                    400: string;
+                    500: string;
+                    600: string;
+                    700: string;
+                    800: string;
+                    900: string;
+                    950: string;
+                };
+            };
+        };
+    };
+    plugins: any[];
+};
+
+declare global {
+    interface Window {
+        getWippyApi: () => Promise<ProxyApiInstance>;
+        /**
+         * @deprecated
+         */
+        initWippyApi: () => Promise<ProxyApiInstance>;
+        $W: {
+            config: () => Promise<AppConfig>;
+            instance: () => Promise<ProxyApiInstance>;
+            api: () => Promise<ProxyApiInstance['api']>;
+            form: () => Promise<ProxyApiInstance['form']>;
+            host: () => Promise<ProxyApiInstance['host']>;
+            iframe: () => Promise<ProxyApiInstance['iframe']>;
+            on: () => Promise<ProxyApiInstance['on']>;
+            loadWebComponent: () => Promise<ProxyApiInstance['loadWebComponent']>;
+        };
+        tailwind?: {
+            config: Partial<typeof _default>;
+        };
+        [GLOBAL_PROXY_CONFIG_VAR]?: ProxyConfig;
+    }
+}

package/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@wippy-fe/types-global-proxy",
+  "version": "0.0.1",
+  "description": "Global type declarations for Wippy iframe proxy (window.getWippyApi, $W, etc.)",
+  "types": "index.d.ts"
+}