@cliff-format/i18n 0.0.0-stage → 0.2.0

package/dist/types-CtbwKSot.d.cts

@@ -0,0 +1,462 @@
+import { CliffDocument, CliffGroup, ValidationIssue, Correction, CliffEntry, ParseOptions } from '@cliff-format/core';
+
+interface EntryIdCatalogContext {
+    readonly knownNamespaces: ReadonlySet<string>;
+    readonly knownClans: ReadonlySet<string>;
+    readonly defaultGroup: string;
+    readonly aliases: Readonly<Record<string, string>>;
+    hasCanonical(canonical: string): boolean;
+    recordForCanonical(canonical: string): MessageRecord | undefined;
+    suffixMatches(suffix: string): readonly string[];
+}
+declare function joinCanonical(namespace: string, clan: string, group: string, id: string): string;
+declare function assertScope(scope: TranslationScope): void;
+declare function resolveEntryId(input: EntryIdInput, scope: TranslationScope, context: EntryIdCatalogContext, strictEntryIds?: boolean): ResolvedEntryId;
+
+interface CatalogOptions {
+    aliases?: Readonly<Record<string, string>>;
+    defaultGroup?: string;
+}
+declare class Catalog implements EntryIdCatalogContext {
+    readonly defaultGroup: string;
+    readonly aliases: Readonly<Record<string, string>>;
+    private readonly documentsList;
+    private readonly byLocale;
+    private readonly byCanonical;
+    private readonly suffixMap;
+    private readonly namespaceSet;
+    private readonly clanSet;
+    private readonly groupSet;
+    private readonly localeSet;
+    private readonly sourceLanguageSet;
+    constructor(options?: CatalogOptions);
+    get knownNamespaces(): ReadonlySet<string>;
+    get knownClans(): ReadonlySet<string>;
+    get documents(): readonly CliffDocument[];
+    get sourceLanguages(): readonly string[];
+    addDocument(document: CliffDocument): MessageRecord[];
+    addDraft(parts: {
+        namespace: string;
+        clan: string;
+        group: string;
+        id: string;
+        sourceLanguage: string;
+        targetLanguage: string;
+    }, draft: TranslatedDraft): MessageRecord;
+    private ensureDocument;
+    private indexRecord;
+    hasCanonical(canonical: string): boolean;
+    recordForCanonical(canonical: string): MessageRecord | undefined;
+    recordsForCanonical(canonical: string): readonly MessageRecord[];
+    suffixMatches(suffix: string): readonly string[];
+    record(canonical: string, locale: string): MessageRecord | undefined;
+    selectRecord(canonical: string, localeChain: readonly string[], sourceLanguage?: string): MessageRecord | undefined;
+    localeChain(locale: string, fallbacks?: readonly string[], sourceLanguage?: string): string[];
+    namespaces(): string[];
+    clans(namespace?: string): string[];
+    groups(scope?: Partial<TranslationScope>): string[];
+    entryIds(scope?: Partial<TranslationScope>): string[];
+    allRecords(): MessageRecord[];
+    query(options?: EntryQuery): MessageRecord[];
+    untranslated(options?: Omit<EntryQuery, "status" | "target">): MessageRecord[];
+    byStatus(status: StatusTag, options?: Omit<EntryQuery, "status">): MessageRecord[];
+    statusCounts(options?: Omit<EntryQuery, "status">): StatusCounts;
+    locales(): string[];
+    findGroup(namespace: string, clan: string, groupPath: string): CliffGroup | undefined;
+    files(options?: FileOptions): CliffFile[];
+    toCliff(options?: FileOptions): string;
+    validate(): ValidationIssue[];
+}
+declare function assertCatalogParts(parts: {
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+}): void;
+
+type IcuDialect = "plain" | "mf1" | "mf2";
+interface IcuError {
+    type: string;
+    message: string;
+    source?: string;
+}
+type MessagePart = {
+    type: "literal";
+    value: string;
+} | {
+    type: "expression";
+    source: string;
+    value: string;
+    locale?: string;
+} | {
+    type: "markup";
+    kind: "open" | "close" | "standalone";
+    name: string;
+    source: string;
+};
+interface IcuFormatResult {
+    text: string;
+    errors: IcuError[];
+}
+interface IcuPartsResult {
+    parts: MessagePart[];
+    errors: IcuError[];
+}
+interface IcuAnalysis {
+    dialect: IcuDialect;
+    arguments: string[];
+    errors: IcuError[];
+}
+interface IcuFormatOptions {
+    currency?: string;
+    timeZone?: string;
+}
+interface IcuRuntime {
+    format(message: string, locale: string, values: Record<string, unknown>, options?: IcuFormatOptions): IcuFormatResult;
+    formatToParts(message: string, locale: string, values: Record<string, unknown>, options?: IcuFormatOptions): IcuPartsResult;
+    analyze(message: string): IcuAnalysis;
+}
+
+declare const TYPE: {
+    readonly noun: "noun";
+    readonly verb: "verb";
+    readonly adjective: "adjective";
+    readonly adverb: "adverb";
+    readonly pronoun: "pronoun";
+    readonly numeral: "numeral";
+    readonly preposition: "preposition";
+    readonly conjunction: "conjunction";
+    readonly particle: "particle";
+    readonly interjection: "interjection";
+    readonly "proper-noun": "proper-noun";
+    readonly "noun-phrase": "noun-phrase";
+    readonly "verb-phrase": "verb-phrase";
+    readonly "adjective-phrase": "adjective-phrase";
+    readonly "adverb-phrase": "adverb-phrase";
+    readonly "fixed-phrase": "fixed-phrase";
+    readonly idiom: "idiom";
+    readonly sentence: "sentence";
+    readonly description: "description";
+    readonly narration: "narration";
+    readonly dialogue: "dialogue";
+    readonly monologue: "monologue";
+    readonly prompt: "prompt";
+    readonly label: "label";
+    readonly subtitle: "subtitle";
+    readonly "accessibility-cue": "accessibility-cue";
+};
+type TypeTag = (typeof TYPE)[keyof typeof TYPE];
+declare const EMOTION: {
+    readonly neutral: "neutral";
+    readonly objective: "objective";
+    readonly mechanical: "mechanical";
+    readonly joyful: "joyful";
+    readonly sad: "sad";
+    readonly angry: "angry";
+    readonly fearful: "fearful";
+    readonly surprised: "surprised";
+    readonly curious: "curious";
+    readonly disgusted: "disgusted";
+    readonly anxious: "anxious";
+    readonly calm: "calm";
+    readonly playful: "playful";
+    readonly serious: "serious";
+    readonly urgent: "urgent";
+    readonly romantic: "romantic";
+    readonly hopeful: "hopeful";
+    readonly grateful: "grateful";
+    readonly formal: "formal";
+    readonly informal: "informal";
+    readonly polite: "polite";
+    readonly rude: "rude";
+    readonly nostalgic: "nostalgic";
+};
+type EmotionTag = (typeof EMOTION)[keyof typeof EMOTION];
+declare const STATUS: {
+    readonly initial: "initial";
+    readonly translated: "translated";
+    readonly reviewed: "reviewed";
+    readonly final: "final";
+};
+type StatusTag = (typeof STATUS)[keyof typeof STATUS];
+declare const VARIANT: {
+    readonly standard: "standard";
+    readonly glossary: "glossary";
+};
+type VariantTag = (typeof VARIANT)[keyof typeof VARIANT];
+declare const STATUS_ORDER: readonly ["initial", "translated", "reviewed", "final"];
+type Params = Record<string, unknown>;
+type EntryIdOf<EntryIds extends string> = string extends EntryIds ? string : EntryIds | (string & {});
+type CliffResource = string | Uint8Array | CliffDocument;
+interface TranslationScope {
+    namespace: string;
+    clan: string;
+    group?: string;
+}
+type EntryIdInput = string | {
+    namespace?: string;
+    clan?: string;
+    group?: string;
+    id: string;
+};
+interface EntryQuery {
+    namespace?: string;
+    clan?: string;
+    group?: string;
+    locale?: string | "all";
+    status?: StatusTag | readonly StatusTag[];
+    target?: "any" | "present" | "missing";
+}
+type StatusCounts = Record<StatusTag, number>;
+interface ResolvedEntryId {
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+    canonical: string;
+    exists: boolean;
+    ambiguous?: boolean;
+    candidates?: readonly string[];
+}
+interface MessageRecord {
+    canonical: string;
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+    locale: string;
+    sourceLanguage: string;
+    document: CliffDocument;
+    groupRef: CliffGroup;
+    entry: CliffEntry;
+    variant: string;
+    source: string;
+    target?: string;
+    type?: string;
+    emotion: string[];
+    status?: string;
+    context?: string;
+    maxWidth?: number;
+    reference: string[];
+    reviewer?: string;
+    extensions: Record<string, string>;
+    filePath?: string;
+}
+interface MessageMetadata {
+    entryId: string;
+    namespace: string;
+    clan: string;
+    group: string;
+    id: string;
+    locale: string;
+    sourceLanguage: string;
+    targetLanguage: string;
+    variant: string;
+    source: string;
+    target?: string;
+    type?: string;
+    emotion: string[];
+    status?: string;
+    context?: string;
+    maxWidth?: number;
+    reference: string[];
+    reviewer?: string;
+    extensions: Record<string, string>;
+}
+interface MessageState {
+    source: boolean;
+    type: boolean;
+}
+type RenderMethod<S extends MessageState> = S["source"] extends true ? S["type"] extends true ? (params?: Params) => string : never : (params?: Params) => string;
+type RenderPartsMethod<S extends MessageState> = S["source"] extends true ? S["type"] extends true ? (params?: Params) => MessagePart[] : never : (params?: Params) => MessagePart[];
+interface CommitOptions {
+    overwrite?: boolean;
+    validate?: boolean;
+}
+interface MessageBuilder<S extends MessageState = {
+    source: false;
+    type: false;
+}> {
+    source(text: string, params?: Params): MessageBuilder<{
+        source: true;
+        type: S["type"];
+    }>;
+    type(tag: TypeTag): MessageBuilder<{
+        source: S["source"];
+        type: true;
+    }>;
+    typeFromGroup: S extends {
+        source: true;
+        type: false;
+    } ? () => MessageBuilder<{
+        source: true;
+        type: true;
+    }> : never;
+    emotion(...tags: readonly (EmotionTag | readonly EmotionTag[])[]): MessageBuilder<S>;
+    context(text: string): MessageBuilder<S>;
+    maxWidth(cells: number): MessageBuilder<S>;
+    reference(...paths: string[]): MessageBuilder<S>;
+    reviewer(name: string): MessageBuilder<S>;
+    extension(name: string, value: string): MessageBuilder<S>;
+    target(text: string, params?: Params): MessageBuilder<S>;
+    status(tag: StatusTag): MessageBuilder<S>;
+    locale(tag: string): MessageBuilder<S>;
+    params(params: Params): MessageBuilder<S>;
+    count(value: number): MessageBuilder<S>;
+    render: RenderMethod<S>;
+    renderToParts: RenderPartsMethod<S>;
+    commit: S extends {
+        source: true;
+        type: true;
+    } ? (options?: CommitOptions) => MessageBuilder<S> : never;
+    meta(): MessageMetadata;
+    entry(): CliffEntry | undefined;
+    width(params?: Params): number;
+    fits(params?: Params): boolean;
+    toString(): string;
+}
+interface TFunction<EntryIds extends string = string> {
+    (entryId: EntryIdOf<EntryIds>): MessageBuilder<{
+        source: false;
+        type: false;
+    }>;
+    (entryId: EntryIdOf<EntryIds>, params: Params): string;
+    render(entryId: EntryIdOf<EntryIds>, params?: Params): string;
+    renderToParts(entryId: EntryIdOf<EntryIds>, params?: Params): MessagePart[];
+    has(entryId: EntryIdOf<EntryIds>): boolean;
+    entry(entryId: EntryIdOf<EntryIds>): CliffEntry | undefined;
+    meta(entryId: EntryIdOf<EntryIds>): MessageMetadata | undefined;
+    entryIds(): string[];
+}
+interface ScopedI18n<EntryIds extends string = string> {
+    readonly t: TFunction<EntryIds>;
+    readonly scope: TranslationScope;
+}
+type MissingBehavior = "entryId" | "empty" | "throw" | "source";
+type WidthPolicy = "off" | "warn" | "error";
+type DiagnosticSeverity = "error" | "warning" | "info";
+interface I18nDiagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    entryId?: string;
+    locale?: string;
+    namespace?: string;
+    clan?: string;
+    group?: string;
+    line?: number;
+    details?: Record<string, unknown>;
+}
+interface I18nOptions {
+    locale: string;
+    fallbackLocale?: string | readonly string[];
+    resources?: readonly CliffResource[];
+    sourceLanguage?: string;
+    defaultGroup?: string;
+    params?: Params;
+    aliases?: Readonly<Record<string, string>>;
+    missing?: MissingBehavior;
+    strictEntryIds?: boolean;
+    requireEmotion?: boolean | readonly TypeTag[];
+    enforceMaxWidth?: WidthPolicy;
+    icu?: IcuRuntime;
+    parse?: ParseOptions;
+    onDiagnostic?: (diagnostic: I18nDiagnostic) => void;
+    maxDiagnostics?: number;
+}
+interface TranslatedDraft {
+    source?: string;
+    target?: string;
+    type?: string;
+    emotion?: readonly string[];
+    status?: string;
+    context?: string;
+    maxWidth?: number;
+    reference?: readonly string[];
+    reviewer?: string;
+    extensions?: Record<string, string>;
+}
+interface AddOptions {
+    sourcePath?: string;
+    tolerant?: boolean;
+    validate?: boolean;
+}
+interface AddResult {
+    documents: readonly CliffDocument[];
+    issues: readonly ValidationIssue[];
+    corrections: readonly Correction[];
+}
+interface FileOptions {
+    layout?: "folder" | "flat";
+}
+interface CliffFile {
+    filePath: string;
+    namespace: string;
+    clan: string;
+    locale: string;
+    text: string;
+    document: CliffDocument;
+}
+interface I18n<EntryIds extends string = string> {
+    readonly locale: string;
+    readonly language: string;
+    readonly sourceLanguage: string | undefined;
+    getLocale(): string;
+    setLocale(locale: string): void;
+    changeLanguage(locale: string): void;
+    getVersion(): number;
+    subscribe(listener: () => void): () => void;
+    scope(scope: TranslationScope): ScopedI18n<EntryIds>;
+    add(resource: CliffResource, options?: AddOptions): AddResult;
+    addDocument(document: CliffDocument, options?: AddOptions): AddResult;
+    has(entryId: EntryIdOf<EntryIds> | Exclude<EntryIdInput, string>, scope: TranslationScope): boolean;
+    resolve(entryId: EntryIdOf<EntryIds> | Exclude<EntryIdInput, string>, scope: TranslationScope): ResolvedEntryId;
+    entryIds(scope?: Partial<TranslationScope>): string[];
+    query(options?: EntryQuery): MessageRecord[];
+    untranslated(options?: Omit<EntryQuery, "status" | "target">): MessageRecord[];
+    byStatus(status: StatusTag, options?: Omit<EntryQuery, "status">): MessageRecord[];
+    statusCounts(options?: Omit<EntryQuery, "status">): StatusCounts;
+    namespaces(): string[];
+    clans(namespace?: string): string[];
+    groups(scope?: Partial<TranslationScope>): string[];
+    locales(): string[];
+    files(options?: FileOptions): CliffFile[];
+    toCliff(options?: FileOptions): string;
+    validate(): ValidationIssue[];
+    diagnostics(): readonly I18nDiagnostic[];
+    clearDiagnostics(): void;
+    format(message: string, params?: Params, options?: {
+        locale?: string;
+        currency?: string;
+        timeZone?: string;
+    }): string;
+    formatToParts(message: string, params?: Params, options?: {
+        locale?: string;
+        currency?: string;
+        timeZone?: string;
+    }): MessagePart[];
+}
+interface I18nRuntime {
+    resolve(entryId: EntryIdInput, scope: TranslationScope): ResolvedEntryId;
+    recordFor(canonical: string, locale: string): MessageRecord | undefined;
+    format(message: string, params: Params, options: {
+        locale: string;
+        currency?: string;
+        timeZone?: string;
+    }): string;
+    formatToParts(message: string, params: Params, options: {
+        locale: string;
+        currency?: string;
+        timeZone?: string;
+    }): MessagePart[];
+    diagnose(diagnostic: I18nDiagnostic): void;
+    getSourceLanguage(): string;
+    getLocale(): string;
+    getCatalog(): Catalog;
+    readonly defaultParams: Params;
+    readonly missing: MissingBehavior;
+    readonly requireEmotion: boolean | readonly TypeTag[];
+    readonly enforceMaxWidth: WidthPolicy;
+}
+
+export { type AddOptions as A, type ResolvedEntryId as B, Catalog as C, type DiagnosticSeverity as D, EMOTION as E, type FileOptions as F, STATUS_ORDER as G, type ScopedI18n as H, type I18nOptions as I, type StatusCounts as J, type StatusTag as K, TYPE as L, type MessageBuilder as M, type TranslatedDraft as N, type TranslationScope as O, type Params as P, type TypeTag as Q, type RenderMethod as R, STATUS as S, type TFunction as T, type VariantTag as U, VARIANT as V, type WidthPolicy as W, assertCatalogParts as X, assertScope as Y, joinCanonical as Z, resolveEntryId as _, type I18n as a, type IcuRuntime as b, type AddResult as c, type CatalogOptions as d, type CliffFile as e, type CliffResource as f, type CommitOptions as g, type EmotionTag as h, type EntryIdCatalogContext as i, type EntryIdInput as j, type EntryIdOf as k, type EntryQuery as l, type I18nDiagnostic as m, type I18nRuntime as n, type IcuAnalysis as o, type IcuDialect as p, type IcuError as q, type IcuFormatOptions as r, type IcuFormatResult as s, type IcuPartsResult as t, type MessageMetadata as u, type MessagePart as v, type MessageRecord as w, type MessageState as x, type MissingBehavior as y, type RenderPartsMethod as z };