import { T as ToolKey } from './tool-DA175Utm.js';

declare const refBrand: unique symbol;
/**
 * The callback both markers expose: given the config's `default` locale, it
 * returns the sibling locale to forward to. {@link ref} ignores the default and
 * returns its fixed target; {@link todo} returns the default itself. Resolving a
 * marker means calling it — the translator passes in `config.default`.
 */
type RefCallback = (defaultLocale: string) => string;
/**
 * A branded callback produced by {@link ref}. Forwards a locale entry to a
 * sibling locale's value within the same translation key, resolved lazily on
 * property access by invoking the callback.
 */
type Ref<Target extends string = string> = RefCallback & {
    [refBrand]: true;
    target: Target;
    wasTodo: false;
};
/**
 * A branded callback produced by {@link todo} — a {@link Ref} that defers its
 * target to the config's `default` (which it can't know up front), so it shares
 * the brand and every `ref` rule applies to it automatically. `wasTodo` only
 * sharpens the runtime guard's message and never participates in validation.
 */
type TodoRef = RefCallback & {
    [refBrand]: true;
    wasTodo: true;
};
type AnyRef = Ref | TodoRef;
/**
 * Forwards this locale's entry to another locale's value within the same
 * translation key — as if the target field were copied and pasted into place.
 * For deliberate, character-for-character identical translations.
 *
 * The target must be another locale key in the same key's object, and must not
 * itself be a `ref(...)`/`todo()` — both are enforced at compile time and
 * guarded at runtime.
 *
 * @example ```ts
 * define({
 *   submit: {
 *     en: "Submit",
 *     "en-gb": ref("en"), // identical to English
 *   },
 * });
 * ```
 *
 * @param target The sibling locale whose value to forward to
 */
declare function ref<const Target extends string>(target: Target): Ref<Target>;
/**
 * Stubs an untranslated entry. A thin wrapper over {@link ref}: at resolve time
 * it forwards to `ref(<default>)`, deferring the target to the config's
 * `default`. Resolves to the default locale's value for that key, and because it
 * carries the same brand, every `ref` rule applies to it automatically.
 *
 * Enables gap-free incremental localization: add a locale, stub each missing
 * entry with `todo()` (the app compiles and ships on the default-locale
 * fallback), then replace each with a real template at your own pace.
 * `grep -rn 'todo()' src/` is your exact backlog.
 *
 * @example ```ts
 * define({ welcome: { en: msg`Hi`, fr: todo() } }); // fr falls back to the default
 * ```
 */
declare function todo(): TodoRef;

type TranslationValue = string | ((dict: never, locale?: string) => string) | AnyRef;
type TranslationDict<Language extends string = string> = Record<string, Record<Language, TranslationValue>>;
/**
 * The function returned by `define(...)`. Give it the active locale and it
 * resolves every key to that locale's value.
 *
 * Use it to type a value that holds a translator: a prop, a context value, or a
 * `useTranslation` wrapper. Pin your locale union and infer the resolved
 * translations to keep the keys without a type assertion.
 *
 * @example ```ts
 * type Locale = "en" | "ja";
 *
 * function useTranslation<T>(translator: (locale: Locale) => T): T {
 *   return translator(getUserLocale()); // your locale source
 * }
 * ```
 */
type Translator<T extends TranslationDict = TranslationDict, Language extends string = string, Default extends string = string> = <Locale extends Language>(locale: Locale) => {
    [K in keyof T]: ResolveValue<T[K], T[K][Locale], Default>;
};
type ResolveValue<Entry, V, Default extends string> = V extends TodoRef ? Default extends keyof Entry ? Entry[Default] : never : V extends Ref<infer Target> ? Target extends keyof Entry ? Entry[Target] : never : V;
type ValidateDict<T extends TranslationDict, Default extends string> = {
    [K in keyof T]: {
        [L in keyof T[K]]: ValidateValue<T[K], T[K][L], Default>;
    };
};
type ValidateValue<Entry, V, Default extends string> = V extends TodoRef ? Default extends keyof Entry ? Entry[Default] extends AnyRef ? `❌ todo() used on the default locale "${Default & string}" — there's nothing to fall back to` : V : V : V extends Ref<infer Target> ? Target extends keyof Entry ? Entry[Target] extends AnyRef ? `❌ ref("${Target & string}") points at another ref() — point at a real value` : V : `❌ ref("${Target & string}") target does not exist` : V;
/**
 * The resolved translations a {@link Translator} produces: every key mapped to
 * its value across the supported locales.
 *
 * @example ```ts
 * const translator = define({ submit: { en: "Submit", ja: "Submitto" } });
 *
 * type T = Translation<typeof translator>; // { submit: "Submit" | "Submitto" }
 * ```
 */
type Translation<T extends Translator> = ReturnType<T>;

declare const msgBrand: unique symbol;
/**
 * The branded template function produced by {@link msg}. You rarely name this
 * directly. It's what a `msg` interpolation resolves to inside a translation.
 */
type Msg = ((dict: never, locale?: string) => string) & {
    [msgBrand]: true;
};
type TemplateKey = string | ToolKey;
type UnionToIntersection<U> = (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never;
type NamedParam<Key extends string> = {
    [P in Key]: string | number;
};
type NoParams = Record<never, never>;
type FinalTemplateDict<Keys> = [Keys] extends [never] ? NoParams : UnionToIntersection<Keys extends ToolKey<infer Name, infer V> ? unknown extends V ? {
    [P in Name]?: V;
} : {
    [P in Name]: V;
} : Keys extends string ? NamedParam<Keys> : NoParams>;
type IsWidenedName<Name extends string> = NoParams extends Record<Name, unknown> ? true : false;
type LiteralName<Key> = Key extends ToolKey<infer Name, infer V> ? IsWidenedName<Name> extends true ? ToolKey<"❌ tool name must be a string literal, declare recipes as <const Name extends string>(name: Name)", V> : Key : IsWidenedName<Key & string> extends true ? "❌ msg parameter name must be a string literal" : Key;
type ValidateKeys<Keys extends readonly TemplateKey[]> = {
    [I in keyof Keys]: LiteralName<Keys[I]>;
};
type MsgReturn<Keys extends readonly TemplateKey[]> = (dict: {
    [K in keyof FinalTemplateDict<Keys[number]>]: FinalTemplateDict<Keys[number]>[K];
}) => string;
/**
 * A tagged template for translations with named, type-inferred parameters.
 *
 * Interpolate a string literal for a plain named parameter, or a formatter key
 * from a recipe like {@link plural}/{@link num}/{@link tool}. The parameter names
 * and types are inferred from what you interpolate and become the argument to the
 * resolved template function.
 *
 * The argument is an exact object literal: every name must be a string literal
 * type (a name widened to `string` is a compile error), and a recipe that never
 * types its value makes its parameter optional.
 *
 * @example ```ts
 * const greet = msg`Hey ${"name"}`;
 * greet({ name: "Ada" }); // "Hey Ada", infers { name: string | number }
 * ```
 */
declare function msg<const Keys extends readonly TemplateKey[]>(strings: TemplateStringsArray, ...keys: Keys & ValidateKeys<Keys>): MsgReturn<Keys>;

type LanguageOf<Languages> = keyof Languages & string;
type TranslationConfig<Languages extends Record<string, unknown>, Default extends keyof Languages & string> = {
    languages: Languages;
    default: Default;
};
/**
 * Creates a translator factory bound to your languages and their per-language
 * config. Keep this in a central `i18n.ts` and import `define`/`tool` from there.
 *
 * Each key of `languages` is a supported language; its value is that language's
 * config: arbitrary data your {@link tool} recipes can read (use `{}` when a
 * language needs none). `default` must be one of those languages and is the
 * locale {@link todo} falls back to.
 *
 * @returns `{ define, tool }`, both bound to this config.
 *
 * @example ```ts
 * // i18n.ts
 * export const { define, tool } = createTranslationConfig({
 *   languages: { en: {}, ja: {} },
 *   default: "en",
 * });
 * ```
 */
declare function createTranslationConfig<const Languages extends Record<string, unknown>, const Default extends keyof Languages & string>(config: TranslationConfig<Languages, Default>): {
    define: <const T extends TranslationDict<LanguageOf<Languages>>>(translations: T & ValidateDict<T, Default>) => Translator<T, LanguageOf<Languages>, Default>;
    tool: <const Name extends string, V>(name: Name, format: (value: V, locale: LanguageOf<Languages>, config: Languages[LanguageOf<Languages>]) => string) => ToolKey<Name, V>;
};

export { type Msg, type Ref, type TodoRef, ToolKey, type Translation, type Translator, createTranslationConfig, msg, ref, todo };