@purposeinplay/payload-ai-translate 0.1.0

package/dist/providers/ai-sdk-adapter.d.ts

@@ -0,0 +1,35 @@
+import type { LanguageModel } from 'ai';
+import type { TranslationProvider } from '../types.js';
+/**
+ * Pricing entry used to compute `estimatedCostUsd`. Per-token cost in USD.
+ * Provider-specific tables are passed in by each wrapper factory; pass
+ * `undefined` to opt out of cost estimation.
+ */
+export type PricingPerToken = {
+    input: number;
+    output: number;
+};
+export type AISDKProviderInput = {
+    /** Pre-built `LanguageModel` from `@ai-sdk/<vendor>`'s factory. */
+    model: LanguageModel;
+    /** Model id for analytics + pricing lookup; mirrored on the provider object. */
+    modelId: string;
+    /** Optional. Skip to disable cost estimation. */
+    pricing?: PricingPerToken;
+    temperature?: number;
+    /** AI SDK's `maxOutputTokens`. Optional. */
+    maxOutputTokens?: number;
+};
+/**
+ * The shared core that all four built-in providers (openai, anthropic,
+ * gemini, custom) call into. Replaces ~1000 lines of per-provider parser
+ * + prompt + JSON-mode plumbing with a single `generateObject` call.
+ *
+ * Why this exists:
+ * - Each vendor's hand-rolled JSON parser had its own quirks (the
+ *   Anthropic prefill bug that broke single-item requests is one of N).
+ * - `generateObject` enforces the response shape via tool-calling /
+ *   structured-output, so the model literally cannot emit a malformed
+ *   array. Schema validation happens before we see the data.
+ */
+export declare function createAISDKProvider(input: AISDKProviderInput): TranslationProvider;

package/dist/providers/ai-sdk-adapter.js

@@ -0,0 +1,100 @@
+import { generateObject, NoObjectGeneratedError } from 'ai';
+import { buildSystemPrompt, buildUserMessage, estimateUsage, TranslateResponseSchema } from '../lib/translate-prompt.js';
+const DEFAULT_TEMPERATURE = 0.3;
+/**
+ * The shared core that all four built-in providers (openai, anthropic,
+ * gemini, custom) call into. Replaces ~1000 lines of per-provider parser
+ * + prompt + JSON-mode plumbing with a single `generateObject` call.
+ *
+ * Why this exists:
+ * - Each vendor's hand-rolled JSON parser had its own quirks (the
+ *   Anthropic prefill bug that broke single-item requests is one of N).
+ * - `generateObject` enforces the response shape via tool-calling /
+ *   structured-output, so the model literally cannot emit a malformed
+ *   array. Schema validation happens before we see the data.
+ */ export function createAISDKProvider(input) {
+    const temperature = input.temperature ?? DEFAULT_TEMPERATURE;
+    return {
+        model: input.modelId,
+        async translate (request) {
+            const start = Date.now();
+            const system = buildSystemPrompt(request);
+            const userMessage = buildUserMessage(request);
+            try {
+                const result = await generateObject({
+                    model: input.model,
+                    schema: TranslateResponseSchema,
+                    system,
+                    messages: [
+                        {
+                            role: 'user',
+                            content: userMessage
+                        }
+                    ],
+                    temperature,
+                    ...input.maxOutputTokens ? {
+                        maxOutputTokens: input.maxOutputTokens
+                    } : {},
+                    abortSignal: request.signal ?? undefined
+                });
+                const latencyMs = Date.now() - start;
+                const inputTokens = result.usage?.inputTokens ?? 0;
+                const outputTokens = result.usage?.outputTokens ?? 0;
+                return {
+                    items: result.object.items,
+                    usage: {
+                        inputTokens,
+                        outputTokens,
+                        estimatedCostUsd: input.pricing ? inputTokens * input.pricing.input + outputTokens * input.pricing.output : undefined
+                    },
+                    model: input.modelId,
+                    latencyMs
+                };
+            } catch (error) {
+                // `NoObjectGeneratedError` carries partial usage data when the
+                // model spent tokens but emitted output that failed schema
+                // validation. Surface that so the per-locale failure persists
+                // accurate cost data, and include a snippet of the raw model
+                // output so operators can diagnose oversize inputs vs garbage
+                // output. The previous error message just bubbled the AI SDK's
+                // generic "could not parse" string with no clue about the cause.
+                if (NoObjectGeneratedError.isInstance(error)) {
+                    const usage = error.usage;
+                    const rawText = typeof error.text === 'string' ? error.text : '';
+                    const headSnippet = rawText ? ` (model output head: ${JSON.stringify(rawText.slice(0, 200))}${rawText.length > 200 ? '…' : ''})` : '';
+                    // Output-budget exhaustion is the dominant cause of schema-validation
+                    // failures on Anthropic + AI SDK `generateObject` for translation
+                    // batches: the model produces JSON until it hits `maxOutputTokens`,
+                    // gets cut off mid-string, and the partial response fails Zod parse.
+                    // Detect this by comparing observed outputTokens to the configured
+                    // cap — outputs sitting at (or within ~5% of) the cap are truncation,
+                    // not malformed output. Naming `maxTokens` and the concrete observed
+                    // value collapses minutes of debugging down to "raise the knob".
+                    const outputTokens = usage?.outputTokens ?? 0;
+                    const cap = input.maxOutputTokens;
+                    const lookedTruncated = !!cap && outputTokens > 0 && outputTokens >= cap * 0.95;
+                    let hint = '';
+                    if (lookedTruncated) {
+                        hint = ` — output truncated at ${outputTokens} tokens` + (cap ? ` (maxOutputTokens=${cap})` : '') + `. Raise \`maxTokens\` on the provider config, or lower \`perCallCharLimit\` so each batch fits within the model's output budget.`;
+                    } else {
+                        const totalChars = request.items.reduce((sum, item)=>sum + item.text.length, 0);
+                        if (totalChars > 10_000) {
+                            hint = ` — input was ${totalChars} chars across ${request.items.length} items; if the model output got truncated, raise \`maxTokens\` or lower \`perCallCharLimit\`.`;
+                        }
+                    }
+                    throw Object.assign(new Error(`[ai-translate] Schema validation failed for ${input.modelId}: model returned non-JSON output${headSnippet}${hint}`), {
+                        cause: error,
+                        usage: {
+                            inputTokens: usage?.inputTokens ?? 0,
+                            outputTokens
+                        }
+                    });
+                }
+                throw error;
+            }
+        },
+        async estimate (request) {
+            return estimateUsage(request, input.pricing);
+        }
+    };
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,31 @@
+import type { TranslationProvider } from '../types.js';
+import { type PricingPerToken } from './ai-sdk-adapter.js';
+export type AnthropicProviderOptions = {
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+    temperature?: number;
+    /** Maps to the AI SDK `maxOutputTokens` setting. */
+    maxTokens?: number;
+};
+/**
+ * Per-token pricing in USD. Updated as of April 2026.
+ * Unknown models return undefined for cost estimates — not an error.
+ */
+export declare const MODEL_PRICING: Record<string, PricingPerToken>;
+/**
+ * Anthropic resolves an alias like `claude-haiku-4-5` to a dated id
+ * (`claude-haiku-4-5-20251001`). The pricing table is keyed by the alias,
+ * so strip a trailing `-YYYYMMDD` before lookup.
+ */
+export declare function lookupPricing(model: string): PricingPerToken | undefined;
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to Anthropic.
+ *
+ * The previous implementation used a "JSON prefill" hack (`{"items":` as
+ * the assistant's pre-filled message) and concatenated the model's
+ * continuation. That broke for single-item requests on Haiku 4.5, which
+ * emitted an extra closing brace. `generateObject` enforces the response
+ * shape via tool-calling — the model literally cannot emit a stray brace.
+ */
+export declare function createAnthropicProvider(options: AnthropicProviderOptions): TranslationProvider;

package/dist/providers/anthropic.js

@@ -0,0 +1,66 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createAISDKProvider } from './ai-sdk-adapter.js';
+const DEFAULT_MODEL = 'claude-sonnet-4-6';
+// Default output budget per translate call. History: 4096 truncated
+// Haiku mid-response, 16384 was the 1.1.12 fix and held until a
+// consumer using perCallCharLimit=50_000 hit it on Spanish/French
+// (output expansion of 20-30% pushed legitimate outputs past 16k).
+// 64_000 gives ~4x headroom over the largest output we have observed
+// in production translations and sits within Claude 4.x per-request
+// output ceilings via every upstream we route to. The cap is billed
+// per actual output token used, so the unused headroom is free unless
+// the model fills it. Consumers can still override via `maxTokens`.
+const DEFAULT_MAX_TOKENS = 64_000;
+/**
+ * Per-token pricing in USD. Updated as of April 2026.
+ * Unknown models return undefined for cost estimates — not an error.
+ */ export const MODEL_PRICING = {
+    'claude-opus-4-6': {
+        input: 15.0 / 1_000_000,
+        output: 75.0 / 1_000_000
+    },
+    'claude-sonnet-4-6': {
+        input: 3.0 / 1_000_000,
+        output: 15.0 / 1_000_000
+    },
+    'claude-haiku-4-5': {
+        input: 0.8 / 1_000_000,
+        output: 4.0 / 1_000_000
+    }
+};
+/**
+ * Anthropic resolves an alias like `claude-haiku-4-5` to a dated id
+ * (`claude-haiku-4-5-20251001`). The pricing table is keyed by the alias,
+ * so strip a trailing `-YYYYMMDD` before lookup.
+ */ export function lookupPricing(model) {
+    if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+    const stripped = model.replace(/-\d{8}$/, '');
+    return MODEL_PRICING[stripped];
+}
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to Anthropic.
+ *
+ * The previous implementation used a "JSON prefill" hack (`{"items":` as
+ * the assistant's pre-filled message) and concatenated the model's
+ * continuation. That broke for single-item requests on Haiku 4.5, which
+ * emitted an extra closing brace. `generateObject` enforces the response
+ * shape via tool-calling — the model literally cannot emit a stray brace.
+ */ export function createAnthropicProvider(options) {
+    const modelId = options.model ?? DEFAULT_MODEL;
+    const anthropic = createAnthropic({
+        apiKey: options.apiKey,
+        ...options.baseURL ? {
+            baseURL: options.baseURL
+        } : {}
+    });
+    return createAISDKProvider({
+        model: anthropic(modelId),
+        modelId,
+        pricing: lookupPricing(modelId),
+        temperature: options.temperature,
+        maxOutputTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS
+    });
+}

package/dist/providers/custom.d.ts

@@ -0,0 +1,36 @@
+import type { TranslationProvider } from '../types.js';
+export type CustomProviderPricing = {
+    /** Cost per input token in USD. */
+    input: number;
+    /** Cost per output token in USD. */
+    output: number;
+};
+export type CustomProviderOptions = {
+    apiKey: string;
+    /**
+     * Base URL of the OpenAI-compatible endpoint
+     * (Together AI, Groq, vLLM, OpenRouter, etc).
+     */
+    baseURL: string;
+    model: string;
+    /**
+     * Optional pricing override. The custom endpoint's vendor/model pair
+     * isn't known to the plugin, so consumers supply their own table when
+     * they want cost tracking.
+     */
+    pricing?: CustomProviderPricing;
+    temperature?: number;
+    /** Maps to the AI SDK `maxOutputTokens` setting. */
+    maxTokens?: number;
+    /**
+     * Friendly name for the endpoint (default: "custom"). Surfaces in
+     * AI SDK error messages when something goes wrong upstream.
+     */
+    name?: string;
+};
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to any
+ * OpenAI-compatible endpoint via `@ai-sdk/openai-compatible`. Drop-in
+ * replacement for the previous custom-provider implementation.
+ */
+export declare function createCustomProvider(options: CustomProviderOptions): TranslationProvider;

package/dist/providers/custom.js

@@ -0,0 +1,24 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { createAISDKProvider } from './ai-sdk-adapter.js';
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to any
+ * OpenAI-compatible endpoint via `@ai-sdk/openai-compatible`. Drop-in
+ * replacement for the previous custom-provider implementation.
+ */ export function createCustomProvider(options) {
+    const { model: modelId, pricing } = options;
+    const provider = createOpenAICompatible({
+        name: options.name ?? 'custom',
+        apiKey: options.apiKey,
+        baseURL: options.baseURL
+    });
+    return createAISDKProvider({
+        model: provider(modelId),
+        modelId,
+        pricing,
+        temperature: options.temperature,
+        maxOutputTokens: options.maxTokens
+    });
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,20 @@
+import type { TranslationProvider } from '../types.js';
+import { type PricingPerToken } from './ai-sdk-adapter.js';
+export type GeminiProviderOptions = {
+    apiKey: string;
+    model?: string;
+    temperature?: number;
+    /** Maps to the AI SDK `maxOutputTokens` setting. */
+    maxOutputTokens?: number;
+};
+/**
+ * Per-token pricing in USD. Updated as of April 2026.
+ * Unknown models return undefined for cost estimates — not an error.
+ */
+export declare const MODEL_PRICING: Record<string, PricingPerToken>;
+export declare function lookupPricing(model: string): PricingPerToken | undefined;
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to Google's
+ * Gemini API. Uses `@ai-sdk/google`'s `createGoogleGenerativeAI`.
+ */
+export declare function createGeminiProvider(options: GeminiProviderOptions): TranslationProvider;

package/dist/providers/gemini.js

@@ -0,0 +1,48 @@
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createAISDKProvider } from './ai-sdk-adapter.js';
+const DEFAULT_MODEL = 'gemini-2.5-flash';
+// Default output budget per translate call. Without this the AI SDK
+// inherits Google's per-request default (which has bitten consumers
+// on long-form blog posts). 64_000 sits within Gemini 2.5 Flash and
+// Pro output ceilings and is billed per actual use, so headroom is
+// free. Consumers can override via `maxOutputTokens`.
+const DEFAULT_MAX_OUTPUT_TOKENS = 64_000;
+/**
+ * Per-token pricing in USD. Updated as of April 2026.
+ * Unknown models return undefined for cost estimates — not an error.
+ */ export const MODEL_PRICING = {
+    'gemini-2.5-pro': {
+        input: 1.25 / 1_000_000,
+        output: 10.0 / 1_000_000
+    },
+    'gemini-2.5-flash': {
+        input: 0.15 / 1_000_000,
+        output: 0.6 / 1_000_000
+    },
+    'gemini-2.0-flash': {
+        input: 0.1 / 1_000_000,
+        output: 0.4 / 1_000_000
+    }
+};
+export function lookupPricing(model) {
+    return MODEL_PRICING[model];
+}
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to Google's
+ * Gemini API. Uses `@ai-sdk/google`'s `createGoogleGenerativeAI`.
+ */ export function createGeminiProvider(options) {
+    const modelId = options.model ?? DEFAULT_MODEL;
+    const google = createGoogleGenerativeAI({
+        apiKey: options.apiKey
+    });
+    return createAISDKProvider({
+        model: google(modelId),
+        modelId,
+        pricing: lookupPricing(modelId),
+        temperature: options.temperature,
+        maxOutputTokens: options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS
+    });
+}

package/dist/providers/mock.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationProvider } from '../types.js';
+export declare function createMockProvider(): TranslationProvider;

package/dist/providers/mock.js

@@ -0,0 +1,29 @@
+export function createMockProvider() {
+    return {
+        model: 'mock',
+        async translate (request) {
+            const start = Date.now();
+            const items = request.items.map((item)=>({
+                    id: item.id,
+                    text: `[${request.targetLocale}] ${item.text}`
+                }));
+            const totalChars = request.items.reduce((sum, item)=>sum + item.text.length, 0);
+            return {
+                items,
+                usage: {
+                    inputTokens: totalChars,
+                    outputTokens: totalChars
+                },
+                model: 'mock',
+                latencyMs: Date.now() - start
+            };
+        },
+        async estimate (request) {
+            const totalChars = request.items.reduce((sum, item)=>sum + item.text.length, 0);
+            return {
+                inputTokens: totalChars,
+                estimatedCostUsd: 0
+            };
+        }
+    };
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,28 @@
+import type { TranslationProvider } from '../types.js';
+import { type PricingPerToken } from './ai-sdk-adapter.js';
+export type OpenAIProviderOptions = {
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+    temperature?: number;
+    /** Maps to the AI SDK `maxOutputTokens` setting. */
+    maxTokens?: number;
+};
+/**
+ * Per-token pricing in USD. Updated as of April 2026.
+ * Unknown models return undefined for cost estimates — not an error.
+ */
+export declare const MODEL_PRICING: Record<string, PricingPerToken>;
+/**
+ * OpenAI returns dated model ids (`gpt-4o-mini-2024-07-18`). Strip a
+ * trailing `-YYYY-MM-DD` suffix before pricing lookup.
+ */
+export declare function lookupPricing(model: string): PricingPerToken | undefined;
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to OpenAI.
+ * Public API is unchanged from the pre-AI-SDK implementation — consumers
+ * pass `{ apiKey, model }` and get back a `TranslationProvider`. Internals
+ * delegate to `createAISDKProvider`, which uses `generateObject` and
+ * eliminates manual JSON parsing.
+ */
+export declare function createOpenAIProvider(options: OpenAIProviderOptions): TranslationProvider;

package/dist/providers/openai.js

@@ -0,0 +1,69 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAISDKProvider } from './ai-sdk-adapter.js';
+const DEFAULT_MODEL = 'gpt-4o';
+// Default output budget per translate call. The AI SDK's
+// `generateObject` has no built-in cap, so without this the upstream's
+// own default applies (commonly 4096 on GPT-4o) and large batches
+// truncate mid-JSON, producing the misleading "non-JSON output"
+// error. 64_000 sits within GPT-4o / GPT-4.1 family output ceilings
+// and is billed per actual use, so headroom is free. Consumers can
+// override via `maxTokens`.
+const DEFAULT_MAX_TOKENS = 64_000;
+/**
+ * Per-token pricing in USD. Updated as of April 2026.
+ * Unknown models return undefined for cost estimates — not an error.
+ */ export const MODEL_PRICING = {
+    'gpt-4o': {
+        input: 2.5 / 1_000_000,
+        output: 10.0 / 1_000_000
+    },
+    'gpt-4o-mini': {
+        input: 0.15 / 1_000_000,
+        output: 0.6 / 1_000_000
+    },
+    'gpt-4.1': {
+        input: 2.0 / 1_000_000,
+        output: 8.0 / 1_000_000
+    },
+    'gpt-4.1-mini': {
+        input: 0.4 / 1_000_000,
+        output: 1.6 / 1_000_000
+    },
+    'gpt-4.1-nano': {
+        input: 0.1 / 1_000_000,
+        output: 0.4 / 1_000_000
+    }
+};
+/**
+ * OpenAI returns dated model ids (`gpt-4o-mini-2024-07-18`). Strip a
+ * trailing `-YYYY-MM-DD` suffix before pricing lookup.
+ */ export function lookupPricing(model) {
+    if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+    const stripped = model.replace(/-\d{4}-\d{2}-\d{2}$/, '');
+    return MODEL_PRICING[stripped];
+}
+// ---------------------------------------------------------------------------
+// Provider factory
+// ---------------------------------------------------------------------------
+/**
+ * Builds an AI-SDK-backed `TranslationProvider` that talks to OpenAI.
+ * Public API is unchanged from the pre-AI-SDK implementation — consumers
+ * pass `{ apiKey, model }` and get back a `TranslationProvider`. Internals
+ * delegate to `createAISDKProvider`, which uses `generateObject` and
+ * eliminates manual JSON parsing.
+ */ export function createOpenAIProvider(options) {
+    const modelId = options.model ?? DEFAULT_MODEL;
+    const openai = createOpenAI({
+        apiKey: options.apiKey,
+        ...options.baseURL ? {
+            baseURL: options.baseURL
+        } : {}
+    });
+    return createAISDKProvider({
+        model: openai(modelId),
+        modelId,
+        pricing: lookupPricing(modelId),
+        temperature: options.temperature,
+        maxOutputTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS
+    });
+}

package/dist/settings-global.d.ts

@@ -0,0 +1,74 @@
+import type { Access, GlobalConfig } from 'payload';
+export declare const DEFAULT_SETTINGS_GLOBAL_SLUG = "translation-settings";
+/**
+ * Per-collection (or global) settings row stored under
+ * `translation-settings.perCollection`. Lets admins configure each
+ * translatable surface independently. **AUTOMATION ONLY** — none of
+ * these fields gate the manual Translate… dialog or per-field button.
+ * Editors retain full manual access to every tracked surface; this
+ * layer narrows what `after-change` fan-out does.
+ *
+ * - `enabled` — when `false`, the auto-translate after-change hook
+ *   skips this surface entirely. Manual Translate still works.
+ * - `autoOnPublish` — when `false`, the on-publish trigger skips this
+ *   surface. Manual Translate still works. Effectively a synonym for
+ *   `enabled: false` today; both surface as `skipAutoOnPublish: true`
+ *   in `effective-locales`. Kept distinct in the field schema so
+ *   admins can express intent (collection-disabled vs auto-disabled).
+ * - `targetLocalesOverride` — restrict which target locales auto-
+ *   translate. Empty / unset = inherit from site-wide
+ *   `enabledTargetLocales`. A locale must be in BOTH lists to fan out.
+ * - `excludedFieldPaths` — field paths excluded from translation for
+ *   this surface. **Applies to BOTH manual and automation paths** —
+ *   distinct from the automation-only `enabled` / `autoOnPublish`
+ *   flags above. The admin decision "never translate `meta.description`
+ *   on posts" is global; it would be surprising if Manual Translate…
+ *   silently ignored it. Empty / unset = translate every auto-resolved
+ *   field (back-compat with pre-D6 deployments).
+ * - `translateSlug` — opt-in for slug translation. Defaults to false
+ *   because the plugin's `excludeFields` config typically lists
+ *   `'slug'` to prevent accidental per-locale URL churn. When `true`
+ *   AND the consumer's slug field is `localized: true` on the
+ *   collection schema, the slug becomes translatable for this
+ *   surface. Applies to BOTH manual and automation paths.
+ */
+export type PerCollectionSettings = {
+    slug: string;
+    enabled?: boolean | null;
+    autoOnPublish?: boolean | null;
+    targetLocalesOverride?: string[] | null;
+    excludedFieldPaths?: string[] | null;
+    translateSlug?: boolean | null;
+};
+/**
+ * Auto-registered global that lets admins manage translation runtime
+ * settings without editing `payload.config.ts` and restarting the
+ * server. Carries two responsibilities:
+ *
+ * 1. **Active provider selection** — when the consumer configured a
+ *    `providers` map, each entry becomes a select option here. The
+ *    translate path resolves the active provider at request time (see
+ *    `resolveProvider` in `api.ts`). Hidden when no `providers` map is
+ *    configured (single-provider consumer).
+ *
+ * 2. **Per-locale auto-translate toggle** — admins can opt locales out
+ *    of the on-publish auto-translate hook without losing the ability
+ *    to manually translate to those locales via the Translate button.
+ *    Empty / unset = "all enabled" (back-compat).
+ *
+ * Read/write access defaults to admin-only: these settings affect
+ * operational cost and translation coverage, so editors shouldn't
+ * silently change them. Override via `settings.access`.
+ */
+export type TranslationSettingsConfig = {
+    /** Master switch. Defaults to `true` when targetLocales is configured. */
+    enabled?: boolean;
+    /** Override the auto-registered global slug. */
+    globalSlug?: string;
+    /** Override the default admin-only read/update access. */
+    access?: {
+        read?: Access;
+        update?: Access;
+    };
+};
+export declare function createSettingsGlobal(providerKeys: string[], targetLocales: string[], options?: TranslationSettingsConfig, trackedSurfaces?: string[]): GlobalConfig;