import { RichLink, Routing } from "verbaly";
import MagicString from "magic-string";
//#region src/catalog.d.ts
type Catalog = Record<string, string>;
type Catalogs = Record<string, Catalog>;
export declare function readCatalog(cfg: ResolvedConfig, locale: string): Catalog;
export declare function parseCatalog(content: string): Catalog | undefined;
export declare function loadCatalogs(cfg: ResolvedConfig): Catalogs;
export declare function writeCatalog(cfg: ResolvedConfig, locale: string, catalog: Catalog): string;
export declare function needsIcu(catalogs: Catalogs): boolean;
export declare function needsRelative(catalogs: Catalogs): boolean;
//#endregion
//#region src/analyze.d.ts
interface TaggedParam {
  name: string;
  start: number;
  end: number;
}
interface TransComponent {
  name: string;
  source: string;
}
interface TaggedMessage {
  key: string;
  message: string;
  params: TaggedParam[];
  start: number;
  end: number;
  line: number;
  tagStart: number;
  tagEnd: number;
  file: string;
  jsx?: {
    name: string;
    components: TransComponent[];
  };
  singleQuote?: boolean;
}
interface UsedKey {
  key: string;
  file: string;
  loose?: true;
}
interface StrayImport {
  name: string;
  source: string;
  file: string;
}
interface MissedCall {
  name: string;
  file: string;
  start: number;
  line: number;
}
interface Analysis {
  tagged: TaggedMessage[];
  usedKeys: UsedKey[];
  strayImports: StrayImport[];
  missed: MissedCall[];
  parseError?: string;
}
//#endregion
//#region src/registry.d.ts
interface Collision {
  key: string;
  kept: TaggedMessage;
  dropped: TaggedMessage[];
}
export declare class MessageRegistry {
  private files;
  update(file: string, analysis: Analysis): void;
  remove(file: string): void;
  messages(): Map<string, TaggedMessage>;
  collisions(): Collision[];
  usedKeys(strict?: boolean): Map<string, string[]>;
  strayImports(): StrayImport[];
  missed(): MissedCall[];
  parseErrors(): {
    file: string;
    message: string;
  }[];
  origins(): Map<string, string[]>;
  private inOrder;
}
//#endregion
//#region src/translate.d.ts
interface TranslateRequest {
  sourceLocale: string;
  targetLocale: string;
  messages: Record<string, string>;
  origins?: Record<string, string[]>;
  instructions?: string;
  glossary?: Record<string, string>;
}
type TranslateProvider = (request: TranslateRequest) => Promise<Record<string, string>>;
interface TranslateProgress {
  locale: string;
  batch: number;
  batches: number;
  keys: number;
  error?: string;
}
interface TranslateOptions {
  locales?: string[];
  batchSize?: number;
  concurrency?: number;
  retries?: number;
  retryDelay?: number;
  dryRun?: boolean;
  origins?: Record<string, string[]>;
  onProgress?: (progress: TranslateProgress) => void;
}
interface TranslateFailure {
  locale: string;
  keys: string[];
  error: string;
}
interface TranslateResult {
  translated: Record<string, string[]>;
  invalid: Record<string, string[]>;
  pending: Record<string, string[]>;
  failed: TranslateFailure[];
}
export declare function translateCatalogs(cfg: ResolvedConfig, catalogs: Catalogs, provider: TranslateProvider, options?: TranslateOptions): Promise<TranslateResult>;
export declare function mergeTranslations(cfg: ResolvedConfig, locale: string, translated: Catalog, keys: string[]): string[];
interface DraftEntry {
  key: string;
  text: string;
}
interface WriteDraftsResult {
  written: string[];
  kept: string[];
  invalid: string[];
  unknown: string[];
}
interface WriteDraftsOptions {
  overwrite?: boolean;
  registry?: MessageRegistry;
}
export declare function writeDrafts(cfg: ResolvedConfig, locale: string, entries: DraftEntry[], options?: WriteDraftsOptions): WriteDraftsResult;
export declare function formatTranslateFailures(failed: TranslateFailure[]): string[];
export declare function resolveProvider(cfg: ResolvedConfig, model?: string): Promise<TranslateProvider>;
//#endregion
//#region src/config.d.ts
type GlossaryEntry = string | Record<string, string>;
interface TranslateConfig {
  provider?: 'claude' | TranslateProvider;
  model?: string;
  batchSize?: number;
  concurrency?: number;
  retries?: number;
  instructions?: string;
  glossary?: Record<string, GlossaryEntry>;
}
interface RedirectConfig {
  on?: 'root' | 'all';
  storageKey?: string | false;
}
interface BundleConfig {
  exclude?: string[];
}
interface RenderConfig {
  links?: Record<string, RichLink>;
  exclude?: string[];
  site?: string;
  attribute?: string;
  base?: string;
  baseUrl?: string;
  hreflang?: boolean;
  sitemap?: boolean | string;
  redirect?: boolean | RedirectConfig;
  clean?: boolean;
  inlineCatalog?: boolean;
}
interface VerbalyConfig {
  root?: string;
  dir?: string;
  sourceLocale?: string;
  locales?: string[];
  routing?: Routing;
  icu?: boolean;
  relative?: boolean;
  include?: string[];
  exclude?: string[];
  dts?: string | false;
  translate?: TranslateConfig;
  render?: RenderConfig;
  bundle?: BundleConfig;
}
interface ResolvedConfig {
  root: string;
  dir: string;
  sourceLocale: string;
  locales: string[];
  localesDeclared: boolean;
  routing: Routing;
  icu: boolean | undefined;
  relative: boolean | undefined;
  include: string[];
  exclude: string[];
  dts: string | false;
  translate: TranslateConfig;
  render: RenderConfig;
  bundle: BundleConfig;
}
export declare function resolveConfig(config?: VerbalyConfig): ResolvedConfig;
export declare function targetLocales(cfg: ResolvedConfig, override?: string[]): string[];
export declare function loadConfig(root: string, overrides?: VerbalyConfig, from?: {
  plugin?: boolean;
}): Promise<ResolvedConfig>;
//#endregion
//#region src/bundle.d.ts
export declare function clientCatalogs(cfg: ResolvedConfig, catalogs: Catalogs): Catalogs;
//#endregion
//#region src/extract.d.ts
export declare function extractProject(cfg: ResolvedConfig, options?: {
  keepSource?: boolean;
}): Promise<MessageRegistry>;
export declare function collectOrigins(cfg: ResolvedConfig, reuse?: MessageRegistry): Promise<Record<string, string[]>>;
interface ReplacedText {
  key: string;
  before: string;
}
interface SyncResult {
  added: Record<string, string[]>;
  replaced: ReplacedText[];
}
export declare function syncCatalogs(cfg: ResolvedConfig, catalogs: Catalogs, registry: MessageRegistry): SyncResult;
export declare function shippedCatalogs(cfg: ResolvedConfig, catalogs: Catalogs, registry: MessageRegistry, options?: {
  newKeys?: boolean;
}): Catalogs;
export declare function pruneCatalogs(cfg: ResolvedConfig, catalogs: Catalogs, registry: MessageRegistry): Record<string, string[]>;
//#endregion
//#region src/state.d.ts
export declare const STATE_FILE = "verbaly.lock";
type Drafts = Record<string, string[]>;
type Fingerprints = Record<string, Record<string, string>>;
interface State {
  drafts: Drafts;
  fingerprints: Fingerprints;
  migrated?: string[];
}
interface OutdatedEntry {
  locale: string;
  key: string;
}
interface StateRead {
  state: State;
  problem?: string;
  conflict?: true;
}
interface WrittenTranslation {
  key: string;
  text: string;
  source?: string;
}
interface TranslationWrite {
  locale: string;
  entries: WrittenTranslation[];
  draft?: boolean;
}
interface LockEntry {
  file: string;
  from?: string;
  merged?: true;
}
export declare function loadState(cfg: ResolvedConfig): State;
export declare function readState(cfg: ResolvedConfig): StateRead;
export declare function updateState(cfg: ResolvedConfig, catalogs: Catalogs): State;
export declare function recordTranslations(cfg: ResolvedConfig, source: Catalog, writes: TranslationWrite[]): State;
export declare function effectiveDrafts(drafts: Drafts, catalogs: Catalogs): Drafts;
export declare function markDrafts(drafts: Drafts, locale: string, keys: string[]): void;
export declare function clearDrafts(drafts: Drafts, locale: string, keys?: string[]): void;
export declare function outdatedTranslations(cfg: ResolvedConfig, catalogs: Catalogs, fingerprints: Fingerprints): OutdatedEntry[];
//#endregion
//#region src/findings.d.ts
interface SourceSite {
  file: string;
  line?: number;
  message: string;
}
interface CollisionEntry {
  key: string;
  sites: SourceSite[];
}
interface ReplacedEntry {
  locale: string;
  key: string;
  before: string;
  site: SourceSite;
  edited?: boolean;
}
interface RenamedEntry {
  name: string;
  file: string;
  line?: number;
}
interface PositionalEntry {
  params: string[];
  site: SourceSite;
}
interface EscapedEntry {
  slice: string;
  site: SourceSite;
}
interface UnparsedEntry {
  file: string;
  message: string;
}
type Finding = ({
  kind: 'replaced';
} & ReplacedEntry) | ({
  kind: 'collision';
} & CollisionEntry) | ({
  kind: 'renamed';
} & RenamedEntry) | ({
  kind: 'positional';
} & PositionalEntry) | ({
  kind: 'escaped';
} & EscapedEntry) | ({
  kind: 'unparsed';
} & UnparsedEntry) | ({
  kind: 'outdated';
} & OutdatedEntry) | ({
  kind: 'lock';
} & LockEntry);
export declare function collisionEntries(registry: MessageRegistry): CollisionEntry[];
export declare function formatCollision({ key, sites }: CollisionEntry, root?: string): string;
export declare function formatFinding(finding: Finding, root?: string): string;
interface DevReporter {
  report(channel: string, findings: Finding[]): void;
}
export declare function createDevReporter(root: string, print?: (line: string) => void, cap?: number): DevReporter;
//#endregion
//#region src/project.d.ts
interface SyncProjectOptions {
  prune?: boolean;
  dryRun?: boolean;
  registry?: MessageRegistry;
  catalogs?: Catalogs;
  confirm?: boolean;
  write?: 'all' | 'changed';
}
interface SyncProjectResult {
  registry: MessageRegistry;
  catalogs: Catalogs;
  added: Record<string, string[]>;
  replaced: ReplacedText[];
  pruned: Record<string, string[]>;
  pruneBlocked: boolean;
  findings: Finding[];
  written: Record<string, string>;
  state?: State;
  stateProblem?: string;
}
export declare function syncProject(cfg: ResolvedConfig, options?: SyncProjectOptions): Promise<SyncProjectResult>;
//#endregion
//#region src/key.d.ts
export declare function stableKey(message: string): string;
//#endregion
//#region src/codegen.d.ts
interface RuntimeModuleOptions {
  localeImport?: (locale: string) => string;
  extraExports?: string;
  icu?: boolean;
  relative?: boolean;
  inlineCatalog?: boolean;
}
export declare function generateRuntimeModule(cfg: ResolvedConfig, options?: RuntimeModuleOptions): string;
export declare function generateLocaleModule(catalog: Catalog): string;
interface DtsOptions {
  inlineCatalog?: boolean;
  locales?: string[];
}
export declare function generateDts(catalog: Catalog, options?: DtsOptions): string;
interface DtsWrite {
  file: string;
  changed: boolean;
}
export declare function writeDts(cfg: ResolvedConfig, catalog: Catalog, file?: string | false): DtsWrite | undefined;
//#endregion
//#region src/transform.d.ts
interface TransformResult {
  code: string;
  map: ReturnType<MagicString['generateMap']>;
}
export declare function transformCode(code: string, file: string, analysis?: Analysis): TransformResult | null;
//#endregion
//#region src/plugin.d.ts
interface PluginOptions extends VerbalyConfig {
  failOnMissing?: boolean;
}
export declare const RESOLVED_VIRTUAL_ID: string;
export declare const LOCALE_MODULE_PREFIX = "\0virtual:verbaly/locale/";
export declare const SOURCE_FILE_RE: RegExp;
export declare function resolveVirtualId(id: string): string | undefined;
export declare function loadVirtualModule(id: string, cfg: ResolvedConfig, catalogs: Catalogs): string | undefined;
export declare function isTransformTarget(id: string): boolean;
export declare function createSourceFilter(cfg: ResolvedConfig): (id: string) => boolean;
export declare function transformSource(code: string, id: string, registry: MessageRegistry, scan?: MessageRegistry): {
  messages: Catalog;
  result: TransformResult | null;
};
export declare function runBuildGate(cfg: ResolvedConfig, registry: MessageRegistry, failOnMissing?: boolean): void;
//#endregion
//#region src/scope.d.ts
export declare function reportOutsideInclude(cfg: ResolvedConfig): Promise<void>;
//#endregion
//#region src/validate.d.ts
type IssueSeverity = 'error' | 'warning';
interface StructureIssue {
  severity: IssueSeverity;
  message: string;
}
export declare function validateMessage(message: string, locale?: string): StructureIssue[];
export declare function validatePair(source: string, translated: string): StructureIssue[];
//#endregion
//#region src/check.d.ts
interface MissingEntry {
  locale: string;
  key: string;
  source?: string;
}
interface UnknownEntry {
  key: string;
  files: string[];
}
interface BrokenEntry {
  locale: string;
  key: string;
  severity: IssueSeverity;
  issue: string;
}
interface ExtraEntry {
  locale: string;
  key: string;
  files: string[];
}
interface DivergentEntry {
  key: string;
  catalog: string;
  code: SourceSite;
}
interface CheckResult {
  ok: boolean;
  missing: MissingEntry[];
  unknown: UnknownEntry[];
  broken: BrokenEntry[];
  extra: ExtraEntry[];
  collisions: CollisionEntry[];
  divergent: DivergentEntry[];
  outdated: OutdatedEntry[];
}
export declare function check(cfg: ResolvedConfig, catalogs: Catalogs, registry: MessageRegistry, fingerprints?: Fingerprints): CheckResult;
export declare function formatCheckResult(result: CheckResult, root?: string): string;
interface CheckReportOptions {
  outdatedFails?: boolean;
}
export declare function formatCheckWarnings(result: CheckResult, root?: string, options?: CheckReportOptions): string;
//#endregion
//#region src/drafts.d.ts
export declare function loadDrafts(cfg: ResolvedConfig): Drafts;
export declare function saveDrafts(cfg: ResolvedConfig, drafts: Drafts): void;
//#endregion
//#region src/status.d.ts
interface LocaleStatus {
  locale: string;
  translated: number;
  total: number;
  drafts: number;
  broken: number;
  outdated: number;
}
interface StatusResult {
  messages: number;
  source: string;
  locales: LocaleStatus[];
}
export declare function status(cfg: ResolvedConfig, catalogs: Catalogs, registry: MessageRegistry, drafts?: Drafts, fingerprints?: Fingerprints): StatusResult;
export declare function formatStatusResult(result: StatusResult): string;
//#endregion
//#region src/text.d.ts
export declare function counted(count: number, noun: string, many?: string): string;
//#endregion
//#region src/run.d.ts
export declare function formatCliError(error: unknown): string;
//#endregion
//#region src/watch.d.ts
interface TreeOptions {
  keep?: string;
  native?: boolean;
  persistent?: boolean;
}
export declare function watchTree(root: string, options: TreeOptions, onFile: (file: string) => void): () => void;
//#endregion
//#region src/doctor.d.ts
interface DoctorEntry {
  level: 'ok' | 'warn' | 'error';
  check: string;
  message: string;
  fix?: string;
}
interface DoctorResult {
  ok: boolean;
  entries: DoctorEntry[];
}
export declare function formatDoctorEntry(entry: DoctorEntry): string;
export declare function formatDoctorHealth(result: DoctorResult): string;
export declare function doctor(cfg: ResolvedConfig): Promise<DoctorResult>;
//#endregion
//#region src/host.d.ts
type Host = 'nuxt' | 'next' | 'sveltekit' | 'astro' | 'vite' | 'webpack' | 'rspack' | 'rollup' | 'esbuild';
//#endregion
//#region src/init.d.ts
interface InitOptions {
  root?: string;
  dir?: string;
  sourceLocale?: string;
  locales?: string[];
}
interface InitResult {
  created: string[];
  skipped: string[];
  host: Host | undefined;
  configFile: string;
  next: string[];
  renamed: {
    from: string;
    to: string;
  }[];
  refused: string[];
  found?: string;
}
export declare function init(input?: InitOptions): Promise<InitResult>;
//#endregion
//#region src/wrap.d.ts
interface WrapEntry {
  file: string;
  line: number;
  text: string;
  kind: 'text' | 'attribute';
  attribute?: string;
}
interface WrapSkip {
  file: string;
  line: number;
  text: string;
  reason: string;
}
interface WrapBlocked {
  file: string;
  texts: number;
  client: boolean;
}
interface WrapResult {
  files: number;
  changed: string[];
  wrapped: WrapEntry[];
  skipped: WrapSkip[];
  blocked: WrapBlocked[];
}
interface WrapOptions {
  write?: boolean;
}
export declare function wrapProject(cfg: ResolvedConfig, options?: WrapOptions): Promise<WrapResult>;
//#endregion
//#region src/render.d.ts
interface RenderSiteOptions {
  site?: string;
  locales?: string[];
  attribute?: string;
  richTags?: string[];
  richLinks?: Record<string, RichLink>;
  base?: string;
  baseUrl?: string;
  hreflang?: boolean;
  exclude?: string[];
  sitemap?: boolean | string;
  redirect?: boolean | RedirectConfig;
  clean?: boolean;
}
interface RenderSiteResult {
  files: number;
  locales: string[];
  missing: Record<string, string[]>;
  untranslatedHead: string[];
}
export declare function renderSite(cfg: ResolvedConfig, options?: RenderSiteOptions): Promise<RenderSiteResult>;
export declare function formatRenderWarnings(result: RenderSiteResult, sourceLocale: string): string[];
//#endregion
export type { BrokenEntry, BundleConfig, Catalog, Catalogs, CheckResult, CollisionEntry, DevReporter, DivergentEntry, DoctorEntry, DoctorResult, DraftEntry, Drafts, DtsOptions, ExtraEntry, Finding, Fingerprints, GlossaryEntry, Host, InitOptions, InitResult, IssueSeverity, LocaleStatus, MissingEntry, OutdatedEntry, PluginOptions, RedirectConfig, RenderConfig, RenderSiteOptions, RenderSiteResult, ResolvedConfig, RuntimeModuleOptions, SourceSite, State, StatusResult, StructureIssue, SyncProjectResult, SyncResult, TransformResult, TranslateConfig, TranslateFailure, TranslateOptions, TranslateProgress, TranslateProvider, TranslateRequest, TranslateResult, TranslationWrite, TreeOptions, UnknownEntry, VerbalyConfig, WrapBlocked, WrapEntry, WrapOptions, WrapResult, WrapSkip, WriteDraftsResult };
//# sourceMappingURL=index.d.ts.map