@toototech/webbuilder-plugins 0.1.0

package/dist/global-settings/components/FontFamilySelect.vue.d.ts

@@ -0,0 +1,29 @@
+interface FontSelectPayload {
+    value: string;
+    source: 'installed' | 'system' | 'google';
+    family?: string;
+    googleName?: string;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    modelValue: string;
+    grapes?: any;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => void;
+    select: (payload: FontSelectPayload) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    modelValue: string;
+    grapes?: any;
+}>>> & Readonly<{
+    onSelect?: ((payload: FontSelectPayload) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/global-settings/components/FontManagerPanel.vue.d.ts

@@ -0,0 +1,37 @@
+import type { HostUi } from '@toototech/webbuilder/core';
+type FontDelivery = 'remote' | 'local';
+interface FontSelectPayload {
+    value: string;
+    source: 'installed' | 'system' | 'google';
+    family?: string;
+    googleName?: string;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    grapes?: any;
+    hostUi?: Pick<HostUi, "confirm"> | undefined;
+    globalFontFamily: string;
+    fontDelivery: FontDelivery;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "select-global-font": (payload: FontSelectPayload) => void;
+    "reset-global-font": () => void;
+    "update:font-delivery": (value: FontDelivery) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    grapes?: any;
+    hostUi?: Pick<HostUi, "confirm"> | undefined;
+    globalFontFamily: string;
+    fontDelivery: FontDelivery;
+}>>> & Readonly<{
+    "onSelect-global-font"?: ((payload: FontSelectPayload) => any) | undefined;
+    "onReset-global-font"?: (() => any) | undefined;
+    "onUpdate:font-delivery"?: ((value: FontDelivery) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/global-settings/index.d.ts

@@ -0,0 +1,8 @@
+export * from './plugin.js';
+export { createGlobalSettingsPlugin as globalSettings } from './plugin.js';
+export * from './publisher.js';
+export * from './runtime/canvasInjection.js';
+export * from './runtime/panelDraftSave.js';
+export * from './runtime/settingsSource.js';
+export * from './useFontManager.js';
+export * from './useGoogleFonts.js';

package/dist/global-settings/plugin.d.ts

@@ -0,0 +1,3 @@
+import { type WebBuilderFeaturePlugin } from '@toototech/webbuilder/core';
+export declare const GLOBAL_SETTINGS_PLUGIN_ID = "global-settings";
+export declare const createGlobalSettingsPlugin: () => WebBuilderFeaturePlugin;

package/dist/global-settings/publisher.d.ts

@@ -0,0 +1,15 @@
+import type { GlobalSettingsSnapshot } from '@toototech/webbuilder/core';
+export interface GlobalSettingsPublishedAssets {
+    css: string;
+    headHtml: string;
+    bodyStartHtml: string;
+    bodyEndHtml: string;
+    metadata: {
+        globalSettings: {
+            version?: string;
+            hash?: string;
+            updatedAt?: string;
+        };
+    };
+}
+export declare const renderGlobalSettingsPublishedAssets: (snapshot: GlobalSettingsSnapshot) => GlobalSettingsPublishedAssets;

package/dist/global-settings/runtime/canvasInjection.d.ts

@@ -0,0 +1,13 @@
+import type { GlobalSettingsSnapshot } from '@toototech/webbuilder/core';
+export declare const GLOBAL_SETTINGS_STYLE_IDS: {
+    readonly colors: "wb-global-colors";
+    readonly typography: "wb-global-font-family";
+    readonly customCss: "wb-global-custom-css";
+};
+declare const CUSTOM_CODE_POSITIONS: readonly ["head", "body-start", "body-end"];
+export type GlobalSettingsCustomCodePosition = (typeof CUSTOM_CODE_POSITIONS)[number];
+export declare const buildGlobalSettingsCss: (snapshot: GlobalSettingsSnapshot) => string;
+export declare const getGlobalSettingsGoogleFontName: (snapshot: GlobalSettingsSnapshot) => string;
+export declare const getEnabledGlobalCustomCode: (snapshot: GlobalSettingsSnapshot, position: GlobalSettingsCustomCodePosition) => string;
+export declare const injectGlobalSettingsIntoDocument: (doc: Document, snapshot: GlobalSettingsSnapshot) => () => void;
+export {};

package/dist/global-settings/runtime/panelDraftSave.d.ts

@@ -0,0 +1,17 @@
+import type { GlobalSettingsService, GlobalSettingsSnapshot, PageResourceIdentity, SettingsSource } from '@toototech/webbuilder/core';
+export interface GlobalSettingsPanelCacheSnapshot {
+    colors: unknown[];
+    typography: unknown;
+    customCss: string;
+    customCode: unknown[];
+}
+export interface SaveGlobalSettingsPanelDraftOptions {
+    settings: SettingsSource;
+    service: GlobalSettingsService;
+    resource: PageResourceIdentity;
+    tenantId?: string | number | null;
+    sessionKey?: string;
+    cacheSnapshot: GlobalSettingsPanelCacheSnapshot;
+}
+export declare const buildGlobalSettingsPanelDraftSnapshot: (currentSnapshot: GlobalSettingsSnapshot | null, cacheSnapshot: GlobalSettingsPanelCacheSnapshot) => GlobalSettingsSnapshot;
+export declare const saveGlobalSettingsPanelDraft: (options: SaveGlobalSettingsPanelDraftOptions) => Promise<GlobalSettingsSnapshot>;

package/dist/global-settings/runtime/settingsSource.d.ts

@@ -0,0 +1,4 @@
+import type { GlobalSettingsSnapshot, SettingsSource } from '@toototech/webbuilder/core';
+export type { GlobalSettingsSnapshot, SettingsSource };
+export declare const createMemoryGlobalSettingsSource: () => SettingsSource;
+export declare const createGlobalSettingsSource: () => SettingsSource;

package/dist/global-settings/useFontManager.d.ts

@@ -0,0 +1,38 @@
+import { type GoogleFontItem } from './useGoogleFonts.js';
+export interface InstalledFont {
+    family: string;
+    category: string;
+    cssFamily: string;
+    googleName: string;
+    variants: string[];
+}
+export declare function useFontManager(): {
+    installedFonts: import("vue").ComputedRef<{
+        family: string;
+        category: string;
+        cssFamily: string;
+        googleName: string;
+        variants: string[];
+    }[]>;
+    googleFonts: {
+        allFonts: import("vue").ComputedRef<{
+            family: string;
+            category: string;
+            cssFamily: string;
+            googleName: string;
+        }[]>;
+        loading: import("vue").Ref<boolean, boolean>;
+        hasApiKey: boolean;
+        load: () => Promise<void>;
+        search: (query: string) => GoogleFontItem[];
+    };
+    installFont: (fontItem: GoogleFontItem, variants?: string[] | undefined) => void;
+    removeFont: (family: string) => void;
+    updateVariants: (family: string, variants: string[]) => void;
+    isInstalled: (family: string) => boolean;
+    restoreFromSaved: (saved: any[] | null | undefined) => void;
+    getFontLinks: () => string[];
+    getFontLinksHtml: () => string;
+    setupEditor: (editor: any) => void;
+    ALL_VARIANTS: string[];
+};

package/dist/global-settings/useGoogleFonts.d.ts

@@ -0,0 +1,20 @@
+export interface GoogleFontItem {
+    family: string;
+    category: string;
+    cssFamily: string;
+    googleName: string;
+}
+export declare function injectGoogleFontCss(googleName: string, canvasDoc?: Document | null): void;
+export declare function useGoogleFonts(): {
+    allFonts: import("vue").ComputedRef<{
+        family: string;
+        category: string;
+        cssFamily: string;
+        googleName: string;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    hasApiKey: boolean;
+    load: () => Promise<void>;
+    search: (query: string) => GoogleFontItem[];
+};
+export declare function extractGoogleFontLinks(cssOrHtml: string): string[];

package/dist/global-settings/vue.d.ts

@@ -0,0 +1 @@
+export { default as FontManagerPanel } from './components/FontManagerPanel.vue';

package/dist/global-settings.js

@@ -0,0 +1,66 @@
+import { G, a, b, c, g, d, c as c2, i, r } from "./plugin-DQshk1sY.js";
+import { e, i as i2, u, a as a2 } from "./useFontManager-CdrLq1eG.js";
+const createEmptyBaseSnapshot = () => ({
+  colors: [],
+  typography: {},
+  customCss: "",
+  customCode: []
+});
+const buildGlobalSettingsPanelDraftSnapshot = (currentSnapshot, cacheSnapshot) => ({
+  ...currentSnapshot ?? createEmptyBaseSnapshot(),
+  colors: cacheSnapshot.colors,
+  typography: cacheSnapshot.typography,
+  customCss: cacheSnapshot.customCss,
+  customCode: cacheSnapshot.customCode
+});
+const saveGlobalSettingsPanelDraft = async (options) => {
+  const nextSnapshot = buildGlobalSettingsPanelDraftSnapshot(
+    options.settings.getSnapshot(),
+    options.cacheSnapshot
+  );
+  const context = {
+    resource: options.resource,
+    tenantId: options.tenantId ?? void 0,
+    sessionKey: options.sessionKey
+  };
+  const savedSnapshot = await options.service.saveDraft(nextSnapshot, context);
+  options.settings.hydrate(savedSnapshot);
+  return savedSnapshot;
+};
+const createMemoryGlobalSettingsSource = () => {
+  let snapshot = null;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getSnapshot: () => snapshot,
+    hydrate(nextSnapshot) {
+      snapshot = nextSnapshot;
+      listeners.forEach((listener) => listener(snapshot));
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+const createGlobalSettingsSource = createMemoryGlobalSettingsSource;
+export {
+  G as GLOBAL_SETTINGS_PLUGIN_ID,
+  a as GLOBAL_SETTINGS_STYLE_IDS,
+  b as buildGlobalSettingsCss,
+  buildGlobalSettingsPanelDraftSnapshot,
+  c as createGlobalSettingsPlugin,
+  createGlobalSettingsSource,
+  createMemoryGlobalSettingsSource,
+  e as extractGoogleFontLinks,
+  g as getEnabledGlobalCustomCode,
+  d as getGlobalSettingsGoogleFontName,
+  c2 as globalSettings,
+  i as injectGlobalSettingsIntoDocument,
+  i2 as injectGoogleFontCss,
+  r as renderGlobalSettingsPublishedAssets,
+  saveGlobalSettingsPanelDraft,
+  u as useFontManager,
+  a2 as useGoogleFonts
+};

package/dist/i18n/I18nPanel.vue.d.ts

@@ -0,0 +1,23 @@
+import { type Ref } from 'vue';
+import type useWebBuilderI18n from './useWebBuilderI18n.js';
+type WebBuilderI18nManager = ReturnType<typeof useWebBuilderI18n>;
+type MaybeRef<T> = T | Ref<T>;
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    manager: WebBuilderI18nManager;
+    selectedComponent?: MaybeRef<any>;
+    selectedRevision?: MaybeRef<number> | undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    manager: WebBuilderI18nManager;
+    selectedComponent?: MaybeRef<any>;
+    selectedRevision?: MaybeRef<number> | undefined;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/i18n/i18n.d.ts

@@ -0,0 +1,25 @@
+import type { WebBuilderI18nEntry, WebBuilderI18nReviewStatus, WebBuilderI18nEntryStatus } from './types.js';
+export declare const WB_I18N_KEY_ATTR = "data-wb-i18n-key";
+export declare const WB_I18N_SKIP_ATTR = "data-wb-i18n-skip";
+export declare const isIdentityTranslationAllowed: (source: unknown) => boolean;
+export declare const isUnchangedNonIdentityTranslation: (source: unknown, translation: unknown) => boolean;
+export declare const getWebBuilderI18nEntryId: (entry: Pick<WebBuilderI18nEntry, 'key' | 'field'>) => string;
+export interface ExtractI18nEntriesOptions {
+    includeLayoutPages?: boolean;
+}
+export interface EnsureModelI18nKeysOptions {
+    includeLayoutPages?: boolean;
+}
+export declare const hashI18nSource: (source: string) => string;
+export declare const isModelI18nSkipped: (component: any) => boolean;
+export declare const setModelI18nSkipped: (component: any, skipped: boolean) => boolean;
+export declare const collectI18nKeysFromModel: (component: any, options?: {
+    includeAncestors?: boolean;
+}) => Set<string>;
+export declare const ensureModelI18nKeys: (editor: any, options?: EnsureModelI18nKeysOptions) => string[];
+export declare const extractI18nEntriesFromProjectData: (projectData: Record<string, any> | null, options?: ExtractI18nEntriesOptions) => WebBuilderI18nEntry[];
+export declare const stripI18nTranslationsFromProjectData: <T extends Record<string, any> | null>(projectData: T) => T;
+export declare const applyI18nTranslationsToProjectData: (projectData: Record<string, any> | null, entries: WebBuilderI18nEntry[]) => Record<string, any> | null;
+export declare const resolveI18nEntryStatus: (source: Pick<WebBuilderI18nEntry, 'sourceHash'> & Partial<Pick<WebBuilderI18nEntry, 'source'>>, saved?: Pick<WebBuilderI18nEntry, 'sourceHash' | 'translation' | 'status'> | null) => WebBuilderI18nEntryStatus;
+export declare const resolveI18nReviewStatus: (source: Pick<WebBuilderI18nEntry, 'sourceHash'>, saved?: Pick<WebBuilderI18nEntry, 'sourceHash' | 'translation' | 'status' | 'reviewStatus'> | null) => WebBuilderI18nReviewStatus | undefined;
+export declare const mergeI18nEntries: (sourceEntries: WebBuilderI18nEntry[], savedEntries: WebBuilderI18nEntry[]) => WebBuilderI18nEntry[];

package/dist/i18n/index.d.ts

@@ -0,0 +1,7 @@
+export * from './plugin.js';
+export { createI18nPlugin as webBuilderI18n } from './plugin.js';
+export * from './types.js';
+export * from './i18n.js';
+export * from './languageOrder.js';
+export { default as useWebBuilderI18n } from './useWebBuilderI18n.js';
+export type { UseWebBuilderI18nOptions, WebBuilderI18nLanguage } from './useWebBuilderI18n.js';

package/dist/i18n/languageOrder.d.ts

@@ -0,0 +1,9 @@
+export type OrderedLanguage = {
+    id?: number | string | null;
+    sortOrder?: number | string | null;
+    code?: string | null;
+    slug?: string | null;
+    name?: string | null;
+};
+export declare const compareLanguagesByOrder: <T extends OrderedLanguage>(left: T, right: T) => number;
+export declare const sortLanguagesByOrder: <T extends OrderedLanguage>(languages?: readonly T[] | null | undefined) => T[];

package/dist/i18n/plugin.d.ts

@@ -0,0 +1,21 @@
+import { type WebBuilderFeaturePlugin, type WebBuilderPanelContribution, type WebBuilderPluginAction } from '@toototech/webbuilder/core';
+export declare const I18N_PLUGIN_ID = "i18n";
+export declare const I18N_PLUGIN_CAPABILITY = "webbuilder:i18n";
+export interface WebBuilderI18nRuntime {
+    panelComponent?: unknown;
+    panelProps?: WebBuilderPanelContribution['props'];
+    isDirty?: () => boolean;
+    ensureReadyOrConfirm?: (action: WebBuilderPluginAction) => Promise<boolean> | boolean;
+    refreshSourceEntries?: () => void;
+    autoTranslateMissing?: (options: {
+        publishReady: boolean;
+        reloadCurrentLocale: boolean;
+        silent: boolean;
+    }) => Promise<unknown> | unknown;
+    reloadBundle?: () => Promise<unknown> | unknown;
+    canLoadPreview?: () => boolean;
+    hasPreview?: () => boolean;
+    restorePreview?: () => Promise<void> | void;
+    getPreviewProjectData?: () => Record<string, unknown> | null;
+}
+export declare const createI18nPlugin: (runtime?: WebBuilderI18nRuntime) => WebBuilderFeaturePlugin;

package/dist/i18n/types.d.ts

@@ -0,0 +1,101 @@
+import type { PageResourceIdentity } from '@toototech/webbuilder/core';
+export type WebBuilderI18nField = 'text' | 'html' | 'alt' | 'title' | 'placeholder' | 'aria-label' | 'seo.title' | 'seo.description' | 'seo.keywords' | `attr:${string}` | `prop:${string}`;
+export type WebBuilderI18nEntryStatus = 'translated' | 'missing' | 'stale' | 'pending' | 'source_changed' | 'draft' | 'empty' | 'error';
+export type WebBuilderI18nTranslationOrigin = 'machine' | 'manual';
+export type WebBuilderI18nReviewStatus = 'pending_review' | 'reviewed';
+export interface WebBuilderI18nEntry {
+    key: string;
+    field: WebBuilderI18nField;
+    source: string;
+    sourceHash: string;
+    translation?: string;
+    status?: WebBuilderI18nEntryStatus;
+    translationOrigin?: WebBuilderI18nTranslationOrigin;
+    reviewStatus?: WebBuilderI18nReviewStatus;
+    translatedAt?: Date | string;
+    reviewedAt?: Date | string;
+    pageId?: string;
+    componentType?: string;
+    label?: string;
+}
+export interface WebBuilderI18nBundleReq extends PageResourceIdentity {
+    locale: string;
+    sourceLocale?: string;
+}
+export interface WebBuilderI18nBundleResp extends PageResourceIdentity {
+    locale: string;
+    sourceLocale?: string;
+    entries: WebBuilderI18nEntry[];
+    updateTime?: Date | string;
+}
+export interface WebBuilderI18nSaveBundleReq extends WebBuilderI18nBundleReq {
+    entries: WebBuilderI18nEntry[];
+    partial?: boolean;
+}
+export interface WebBuilderI18nTranslateReq extends WebBuilderI18nBundleReq {
+    entries: WebBuilderI18nEntry[];
+    provider?: string;
+    engine?: string;
+}
+export interface WebBuilderI18nTranslateResp {
+    success?: boolean;
+    errorMessage?: string;
+    entries?: WebBuilderI18nEntry[];
+}
+export interface WebBuilderI18nAutoTranslateReq extends WebBuilderI18nBundleReq {
+    entries: WebBuilderI18nEntry[];
+    locales?: string[];
+    provider?: string;
+    engine?: string;
+    publishReady?: boolean;
+}
+export interface WebBuilderI18nAutoTranslateResp extends PageResourceIdentity {
+    success?: boolean;
+    errorMessage?: string;
+    translatedCount?: number;
+    skippedCount?: number;
+    failedCount?: number;
+    locales?: Array<{
+        locale: string;
+        languageId?: number;
+        total?: number;
+        translated?: number;
+        skipped?: number;
+        failed?: number;
+        errorMessage?: string;
+    }>;
+}
+export interface WebBuilderI18nLanguageRecord {
+    id?: number;
+    name?: string;
+    code?: string;
+    slug?: string;
+    sortOrder?: number;
+    status?: number;
+    defaultLang?: number;
+    createTime?: Date | string;
+}
+export interface WebBuilderTranslationProviderConfig {
+    id?: number;
+    engineType?: string;
+    model?: string;
+    endpoint?: string;
+    apiKey?: string;
+    apiType?: string;
+    apiEndpoint?: string;
+    status?: number;
+    config?: Record<string, unknown> | string;
+    usageCount?: number;
+    characterCount?: number;
+    createTime?: string;
+    updateTime?: string;
+}
+export interface WebBuilderI18nHostService {
+    loadBundle?: (context: WebBuilderI18nBundleReq) => Promise<WebBuilderI18nBundleResp | null> | WebBuilderI18nBundleResp | null;
+    saveBundle?: (context: WebBuilderI18nSaveBundleReq) => Promise<WebBuilderI18nBundleResp | null> | WebBuilderI18nBundleResp | null;
+    translateEntries?: (context: WebBuilderI18nTranslateReq) => Promise<WebBuilderI18nTranslateResp | null> | WebBuilderI18nTranslateResp | null;
+    autoTranslateEntries?: (context: WebBuilderI18nAutoTranslateReq) => Promise<WebBuilderI18nAutoTranslateResp | null> | WebBuilderI18nAutoTranslateResp | null;
+    getEnabledLanguages?: () => Promise<WebBuilderI18nLanguageRecord[]> | WebBuilderI18nLanguageRecord[];
+    getTranslationConfig?: () => Promise<unknown> | unknown;
+    getEnabledProviderConfigs?: () => Promise<WebBuilderTranslationProviderConfig[]> | WebBuilderTranslationProviderConfig[];
+}

package/dist/i18n/useWebBuilderI18n.d.ts

@@ -0,0 +1,164 @@
+import { type Ref } from 'vue';
+import type { HostServices, HostUi, PageResourceIdentity, WebBuilderPluginAction } from '@toototech/webbuilder/core';
+import type { WebBuilderI18nEntry, WebBuilderI18nEntryStatus, WebBuilderI18nReviewStatus, WebBuilderI18nTranslationOrigin, WebBuilderTranslationProviderConfig } from './types.js';
+type MaybeRef<T> = T | Ref<T>;
+type BlockingProcessAction = WebBuilderPluginAction;
+type BlockingProcessMessage = string | string[];
+type RefreshSourceEntriesOptions = {
+    ensureKeys?: boolean;
+};
+type AutoTranslateOptions = {
+    publishReady?: boolean;
+    reloadCurrentLocale?: boolean;
+    silent?: boolean;
+};
+export interface WebBuilderI18nLanguage {
+    label: string;
+    value: string;
+    id?: number;
+    code?: string;
+    slug?: string;
+    sortOrder?: number;
+    defaultLang?: number;
+}
+export interface UseWebBuilderI18nOptions {
+    grapes: any;
+    resource: MaybeRef<PageResourceIdentity>;
+    hostServices?: HostServices;
+    hostUi?: HostUi;
+    sourceLocale?: string;
+    defaultLocale?: string;
+    languages?: WebBuilderI18nLanguage[];
+    blockingProcess?: {
+        start: (action: BlockingProcessAction, message?: BlockingProcessMessage) => void;
+        stop: () => void;
+        setMessage: (message: BlockingProcessMessage) => void;
+    };
+}
+export default function useWebBuilderI18n(options: UseWebBuilderI18nOptions): {
+    locale: Ref<string, string>;
+    sourceLocale: Ref<string, string>;
+    provider: Ref<string, string>;
+    languages: Ref<{
+        label: string;
+        value: string;
+        id?: number | undefined;
+        code?: string | undefined;
+        slug?: string | undefined;
+        sortOrder?: number | undefined;
+        defaultLang?: number | undefined;
+    }[], WebBuilderI18nLanguage[] | {
+        label: string;
+        value: string;
+        id?: number | undefined;
+        code?: string | undefined;
+        slug?: string | undefined;
+        sortOrder?: number | undefined;
+        defaultLang?: number | undefined;
+    }[]>;
+    entries: import("vue").ComputedRef<WebBuilderI18nEntry[]>;
+    sourceEntries: Ref<{
+        key: string;
+        field: import("./types.js").WebBuilderI18nField;
+        source: string;
+        sourceHash: string;
+        translation?: string | undefined;
+        status?: WebBuilderI18nEntryStatus | undefined;
+        translationOrigin?: WebBuilderI18nTranslationOrigin | undefined;
+        reviewStatus?: WebBuilderI18nReviewStatus | undefined;
+        translatedAt?: string | Date | undefined;
+        reviewedAt?: string | Date | undefined;
+        pageId?: string | undefined;
+        componentType?: string | undefined;
+        label?: string | undefined;
+    }[], WebBuilderI18nEntry[] | {
+        key: string;
+        field: import("./types.js").WebBuilderI18nField;
+        source: string;
+        sourceHash: string;
+        translation?: string | undefined;
+        status?: WebBuilderI18nEntryStatus | undefined;
+        translationOrigin?: WebBuilderI18nTranslationOrigin | undefined;
+        reviewStatus?: WebBuilderI18nReviewStatus | undefined;
+        translatedAt?: string | Date | undefined;
+        reviewedAt?: string | Date | undefined;
+        pageId?: string | undefined;
+        componentType?: string | undefined;
+        label?: string | undefined;
+    }[]>;
+    sourceRevision: Ref<number, number>;
+    savedEntries: Ref<{
+        key: string;
+        field: import("./types.js").WebBuilderI18nField;
+        source: string;
+        sourceHash: string;
+        translation?: string | undefined;
+        status?: WebBuilderI18nEntryStatus | undefined;
+        translationOrigin?: WebBuilderI18nTranslationOrigin | undefined;
+        reviewStatus?: WebBuilderI18nReviewStatus | undefined;
+        translatedAt?: string | Date | undefined;
+        reviewedAt?: string | Date | undefined;
+        pageId?: string | undefined;
+        componentType?: string | undefined;
+        label?: string | undefined;
+    }[], WebBuilderI18nEntry[] | {
+        key: string;
+        field: import("./types.js").WebBuilderI18nField;
+        source: string;
+        sourceHash: string;
+        translation?: string | undefined;
+        status?: WebBuilderI18nEntryStatus | undefined;
+        translationOrigin?: WebBuilderI18nTranslationOrigin | undefined;
+        reviewStatus?: WebBuilderI18nReviewStatus | undefined;
+        translatedAt?: string | Date | undefined;
+        reviewedAt?: string | Date | undefined;
+        pageId?: string | undefined;
+        componentType?: string | undefined;
+        label?: string | undefined;
+    }[]>;
+    loading: Ref<boolean, boolean>;
+    saving: Ref<boolean, boolean>;
+    translating: Ref<boolean, boolean>;
+    autoTranslating: Ref<boolean, boolean>;
+    dirty: import("vue").ComputedRef<boolean>;
+    dirtyEntryIds: import("vue").ComputedRef<string[]>;
+    actionableEntries: import("vue").ComputedRef<WebBuilderI18nEntry[]>;
+    missingCount: import("vue").ComputedRef<number>;
+    staleCount: import("vue").ComputedRef<number>;
+    translatedCount: import("vue").ComputedRef<number>;
+    pendingReviewCount: import("vue").ComputedRef<number>;
+    reviewedCount: import("vue").ComputedRef<number>;
+    targetLanguages: import("vue").ComputedRef<{
+        label: string;
+        value: string;
+        id?: number | undefined;
+        code?: string | undefined;
+        slug?: string | undefined;
+        sortOrder?: number | undefined;
+        defaultLang?: number | undefined;
+    }[]>;
+    lastError: Ref<string, string>;
+    lastSavedAt: Ref<string | Date | null, string | Date | null>;
+    hostUi: HostUi;
+    setLocale: (nextLocale: string) => void;
+    setProvider: (nextProvider: string) => void;
+    refreshSourceEntries: (refreshOptions?: RefreshSourceEntriesOptions) => void;
+    loadBundle: () => Promise<void>;
+    setTranslation: (entry: WebBuilderI18nEntry, translation: string, options?: {
+        origin?: WebBuilderI18nTranslationOrigin;
+        reviewStatus?: WebBuilderI18nReviewStatus;
+        status?: WebBuilderI18nEntryStatus;
+    }) => void;
+    confirmTranslation: (entry: WebBuilderI18nEntry) => void;
+    saveTranslations: () => Promise<boolean>;
+    flushDirtyTranslations: () => Promise<boolean>;
+    ensureReadyOrConfirm: (action: BlockingProcessAction) => Promise<boolean>;
+    machineTranslate: (mode?: 'missing' | 'stale' | 'all') => Promise<void>;
+    machineTranslateEntries: (targetEntries: WebBuilderI18nEntry[]) => Promise<void>;
+    autoTranslateMissing: (autoOptions?: AutoTranslateOptions) => Promise<boolean>;
+    getPreviewProjectData: () => Record<string, any> | null;
+    selectEntryComponent: (entry: Pick<WebBuilderI18nEntry, 'key'> | null | undefined) => boolean;
+    loadLanguages: () => Promise<void>;
+    loadProviderConfigs: () => Promise<WebBuilderTranslationProviderConfig[]>;
+};
+export {};

package/dist/i18n/vue.d.ts

@@ -0,0 +1 @@
+export { default as I18nPanel } from './I18nPanel.vue';