g-comments 0.0.0-stage → 0.2.0

package/dist/messages-C9bMljl3.d.ts

@@ -0,0 +1,699 @@
+/** Public sort names (`DiscourseComments::Sort`). */
+type Sort = "best" | "hot" | "newest" | "oldest";
+/** Report reasons accepted by `POST …/comments/:id/flag` (`Comment::Flag::FLAG_TYPES`). */
+type FlagType = "off_topic" | "inappropriate" | "spam" | "illegal" | "notify_moderators";
+/** `discourse_comments_thread_creation` setting values. */
+type ThreadCreation = "first_view" | "first_comment";
+/** `CommenterSerializer`: the signed-in reader, mention results, exchange/me responses. */
+interface Commenter {
+    id: number;
+    username: string;
+    name: string | null;
+    avatar_url: string;
+    title: string | null;
+    staff: boolean;
+}
+/** `ClientConfig#auth_providers` entry. */
+interface AuthProvider {
+    name: string;
+    title: string;
+}
+interface ForumInfo {
+    name: string;
+    base_url: string;
+    locale: string;
+}
+interface Features {
+    nested: boolean;
+    hot_sort: boolean;
+    mentions: boolean;
+    uploads: boolean;
+    /** `null` when the reactions plugin is not installed. */
+    reactions: boolean | null;
+}
+interface Limits {
+    min_post_length: number;
+    max_post_length: number;
+    roots_per_page: number;
+    children_per_page: number;
+    max_image_size_kb: number;
+    /** Pipe-separated list, as stored in the `authorized_extensions` site setting. */
+    authorized_extensions: string;
+}
+/** `ConfigSerializer` (`GET /comments/config`). */
+interface Config {
+    forum: ForumInfo;
+    features: Features;
+    limits: Limits;
+    auth_providers: AuthProvider[];
+    sorts: Sort[];
+    default_sort: Sort;
+    thread_creation: ThreadCreation;
+    guidelines_url: string | null;
+    scope_version: number;
+    /** Present only when the request carried a valid user API key. */
+    current_user?: Commenter;
+    /** Set when the forum served the request anonymously under load; the key is still valid. */
+    degraded?: true;
+}
+/** `ThreadSerializer`: a page's thread once its topic exists. */
+interface Thread {
+    /** Opaque handle; the topic id as a string. */
+    id: string;
+    topic_id: number;
+    key: string;
+    url: string;
+    title: string | null;
+    count: number;
+    closed: boolean;
+    listed: boolean;
+    can_comment: boolean;
+    nested: boolean;
+    sorts: Sort[];
+    sort: Sort;
+    pinned_ids: number[];
+    realtime: "live" | "poll";
+    message_bus_last_id: number;
+    forum_url: string;
+}
+/** `VirtualThreadSerializer`: a page whose topic does not exist yet. */
+interface VirtualThread {
+    id: `v:${string}`;
+    topic_id: null;
+    key: string;
+    url: string;
+    title: string;
+    count: 0;
+    closed: false;
+    listed: false;
+    can_comment: boolean;
+    nested: boolean;
+    sorts: Sort[];
+    sort: Sort;
+    pinned_ids: [];
+    realtime: "pending";
+    /** MessageBus channel where the forum announces `{ topic_id }` on creation. */
+    pending_channel: string;
+    message_bus_last_id: null;
+    forum_url: null;
+}
+type AnyThread = Thread | VirtualThread;
+declare function isVirtualThread(thread: AnyThread): thread is VirtualThread;
+/** `CommentSerializer#author`; `null` on deleted placeholders. */
+interface CommentAuthor {
+    id: number | null;
+    username: string | null;
+    name: string | null;
+    avatar_url: string | null;
+    title: string | null;
+    staff: boolean;
+}
+interface CommentReplyTo {
+    number: number;
+    username: string | null;
+}
+interface CommentLikes {
+    count: number;
+    liked: boolean;
+    can_like: boolean;
+}
+interface CommentPermissions {
+    edit: boolean;
+    delete: boolean;
+    flag: boolean;
+    pin: boolean;
+}
+/** `CommentSerializer`. Treat as immutable: the SDK replaces nodes instead of mutating them. */
+interface Comment {
+    id: number;
+    number: number;
+    author: CommentAuthor | null;
+    /** Server-sanitized cooked HTML with absolute links; `""` for deleted placeholders. */
+    html: string;
+    created_at: string;
+    updated_at: string;
+    edited: boolean;
+    /** `null` for top-level comments. Carries the parent's post number, not its id. */
+    reply_to: CommentReplyTo | null;
+    children: Comment[];
+    direct_reply_count: number;
+    total_descendant_count: number;
+    pinned: boolean;
+    likes: CommentLikes;
+    can: CommentPermissions;
+    pending: boolean;
+    deleted: boolean;
+    hidden: boolean;
+    url: string | null;
+}
+/** `{ pending }` from `POST …/comments` when the comment went to the review queue. */
+interface Pending {
+    reviewable_id: number | null;
+    message: string | null;
+    pending_count: number | null;
+}
+/** `UploadSerializer` as returned by `POST …/attachments`. */
+interface Upload {
+    id: number;
+    url: string;
+    original_filename: string;
+    filesize: number;
+    width: number | null;
+    height: number | null;
+    thumbnail_width: number | null;
+    thumbnail_height: number | null;
+    extension: string;
+    short_url: string;
+    short_path: string;
+    retain_hours: number | null;
+    human_filesize: string;
+    dominant_color: string | null;
+}
+/** Comment counts keyed by encoded ref (`url:…`, `id:<host>/<identifier>`, `t:<topic_id>`). */
+type Counts = Record<string, number>;
+type CountRef = {
+    url: string;
+} | {
+    identifier: string;
+    host?: string;
+} | {
+    topicId: number;
+};
+interface ThreadResponse {
+    thread: AnyThread;
+}
+interface RootsPageResponse {
+    thread: Thread;
+    comments: Comment[];
+    has_more: boolean;
+    page: number;
+    sort: Sort;
+}
+interface CommentsByIdsResponse {
+    thread: Thread;
+    comments: Comment[];
+}
+interface ChildrenPageResponse {
+    comments: Comment[];
+    has_more: boolean;
+    page: number;
+}
+interface CommentContextResponse {
+    ancestors: Comment[];
+    ancestors_truncated: boolean;
+    comment: Comment;
+}
+type CreateCommentResponse = {
+    comment: Comment;
+    thread: Thread;
+} | {
+    pending: Pending;
+};
+interface CommentResponse {
+    comment: Comment;
+}
+interface PinsResponse {
+    pinned_ids: number[];
+}
+interface RawResponse {
+    id: number;
+    raw: string;
+}
+interface CountsResponse {
+    counts: Counts;
+}
+interface MentionsResponse {
+    users: Commenter[];
+}
+interface PreviewResponse {
+    html: string;
+}
+interface ExchangeResponse {
+    key: string;
+    client_id: string;
+    expires_at: string | null;
+    user: Commenter;
+}
+/** Server error body (`create_errors_json`). */
+interface ErrorResponse {
+    errors?: string[];
+    error_type?: string;
+    extras?: Record<string, unknown>;
+    degraded?: boolean;
+}
+/** One palette of a theme (`ForumTheme#scheme_payload`). */
+interface ForumColorScheme {
+    id: number;
+    name: string;
+    type: "light" | "dark";
+    /**
+     * Every custom property the forum's colour definitions emit, without the
+     * `--` prefix and with references already resolved: `primary`, `secondary`,
+     * `tertiary`, `primary-low`, `primary-medium`, `danger`, …
+     */
+    colors: Record<string, string>;
+}
+/** A `@font-face` source the forum serves. */
+interface ForumFontFace {
+    family: string;
+    /** A CSS `src` value, e.g. `url("https://forum/fonts/x.woff2") format("woff2")`. */
+    src: string;
+    weight: number | string;
+}
+interface ForumFont {
+    key: string;
+    name: string;
+    /** A CSS `font-family` value. */
+    stack: string;
+    /** Empty for fonts the forum expects to be installed. */
+    faces: ForumFontFace[];
+}
+/** `GET /comments/theme`: the forum's look as data. */
+interface ForumTheme {
+    theme: {
+        id: number;
+        name: string;
+    } | null;
+    schemes: {
+        light: ForumColorScheme;
+        /** Present when the theme has a dark palette. */
+        dark: ForumColorScheme | null;
+    };
+    fonts: {
+        body: ForumFont | null;
+        heading: ForumFont | null;
+        monospace: ForumFont | null;
+    };
+    /** The theme's "Embedded CSS" stylesheets, absolute URLs. */
+    stylesheets: string[];
+    /** Changes whenever any of the above changes. */
+    version: string;
+}
+
+type CommentsErrorType = "invalid_key" | "not_logged_in" | "invalid_access" | "invalid_parameters" | "not_found" | "rate_limit" | "thread_conflict" | "page_not_allowed" | "invalid_url" | "no_category" | "thread_not_created" | "invalid_grant" | "user_not_allowed" | "submission_rejected" | "not_a_root_comment" | "pin_limit_reached" | "cancelled" | "storage_unavailable" | "unreachable" | "unknown";
+interface CommentsErrorOptions {
+    status?: number;
+    errors?: string[];
+    extras?: Record<string, unknown>;
+    waitSeconds?: number;
+    hint?: string;
+    serverType?: string;
+    cause?: unknown;
+}
+declare class CommentsError extends Error {
+    readonly name = "CommentsError";
+    readonly type: CommentsErrorType;
+    /** HTTP status, or 0 when no response was received. */
+    readonly status: number;
+    /** Human-readable messages from the server, safe to show inline. */
+    readonly errors: string[];
+    readonly extras: Record<string, unknown> | undefined;
+    /** Seconds until a rate-limited action may be retried. */
+    readonly waitSeconds: number | undefined;
+    /** Developer-facing explanation of the probable cause (setup problems). */
+    readonly hint: string | undefined;
+    /** The raw `error_type` from the server, if it sent one. */
+    readonly serverType: string | undefined;
+    constructor(type: CommentsErrorType, message: string, options?: CommentsErrorOptions);
+}
+declare function isCommentsError(error: unknown): error is CommentsError;
+
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+
+/** The subset of the Web Storage API the client needs. */
+interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    /**
+     * `false` when values do not survive a page navigation (memory). Redirect
+     * sign-in needs storage that does; anything else is assumed durable.
+     */
+    readonly durable?: boolean;
+}
+declare function memoryStorage(): StorageLike;
+
+type AuthStatus = "anonymous" | "signing-in" | "signed-in";
+interface AuthState {
+    readonly status: AuthStatus;
+    readonly user: Commenter | null;
+    /** The forum served a request anonymously under load. The key is kept; treat the UI as read-only. */
+    readonly degraded: boolean;
+    /** Why the last sign-in failed or the session ended (`invalid_key` means it expired). */
+    readonly error: CommentsError | null;
+}
+/** What is persisted under `gc:<forum>:auth`. */
+interface StoredAuth {
+    key: string;
+    client_id: string;
+    expires_at: string | null;
+    user: Commenter;
+}
+interface SignInOptions {
+    /** An `auth_providers[].name` to go straight to that provider. */
+    provider?: string;
+    /** Defaults to `popup`; a blocked popup falls back to `redirect`. */
+    mode?: "popup" | "redirect";
+}
+interface CommentsAuth {
+    readonly status: AuthStatus;
+    readonly user: Commenter | null;
+    /** From `config().auth_providers`; empty until the config has loaded. */
+    readonly providers: readonly AuthProvider[];
+    /** Per-browser id the forum's user API key is bound to. */
+    readonly clientId: string;
+    /** Immutable, referentially stable while nothing changes. */
+    state(): AuthState;
+    onChange(listener: (state: AuthState) => void): () => void;
+    /** Resolves with the user (popup) or `null` once a redirect has started. */
+    signIn(options?: SignInOptions): Promise<Commenter | null>;
+    /** Abandons a pending popup sign-in. */
+    cancelSignIn(): void;
+    signOut(): Promise<void>;
+    /** Completes a redirect sign-in from `#gc_code=…&gc_nonce=…`; runs once per page load. */
+    handleRedirect(): Promise<Commenter | null>;
+}
+
+interface ComposerTiming {
+    typingDurationMsecs: number;
+    composerOpenDurationMsecs: number;
+}
+/**
+ * Measures what the forum's fast-typer check needs (`typing_duration_msecs`,
+ * `composer_open_duration_msecs`). Without it, a new account's first comments
+ * land in the review queue.
+ */
+interface ComposerTimer {
+    readonly started: boolean;
+    /** Call when the composer opens or gains focus; repeated calls are no-ops. */
+    start(): void;
+    /** Call on every input event. */
+    typing(): void;
+    measure(): ComposerTiming;
+    /** Returns the measurement and resets the timer. */
+    stop(): ComposerTiming;
+}
+declare function createComposerTimer(now?: () => number): ComposerTimer;
+
+type ThreadStatus = "idle" | "loading" | "ready" | "error";
+/** How updates arrive: MessageBus, the interval fallback, or not at all. */
+type ConnectionMode = "live" | "interval" | "off";
+interface BranchState {
+    /** Last children page loaded for this comment (-1 = only the preloaded ones). */
+    readonly page: number;
+    readonly loading: boolean;
+    readonly hasMore: boolean;
+}
+interface ThreadSnapshot {
+    readonly thread: AnyThread;
+    /** True until the page's topic exists (`thread.id` starts with `v:`). */
+    readonly virtual: boolean;
+    /** Top-level comments with their loaded replies nested in `children`. */
+    readonly comments: readonly Comment[];
+    readonly sort: Sort;
+    readonly status: ThreadStatus;
+    readonly error: CommentsError | null;
+    readonly page: number;
+    readonly hasMore: boolean;
+    readonly loadingMore: boolean;
+    /** Top-level comments that arrived live and wait for `showPending()`. */
+    readonly pendingNew: number;
+    readonly branches: Readonly<Record<number, BranchState>>;
+    /** The reader's own comments that went to the review queue. */
+    readonly awaitingApproval: readonly Pending[];
+    readonly connection: ConnectionMode;
+}
+type ThreadEvent = {
+    type: "change";
+    snapshot: ThreadSnapshot;
+} | {
+    type: "comment.posted";
+    comment: Comment;
+} | {
+    type: "comment.pending";
+    pending: Pending;
+} | {
+    type: "comment.edited";
+    comment: Comment;
+} | {
+    type: "comment.removed";
+    id: number;
+} | {
+    type: "comment.received";
+    comment: Comment;
+    buffered: boolean;
+} | {
+    type: "thread.created";
+    thread: Thread;
+};
+interface PostOptions {
+    body: string;
+    /** Id of the comment being replied to (never a post number). */
+    replyTo?: number;
+    typingDurationMsecs?: number;
+    composerOpenDurationMsecs?: number;
+    /** Timer to read when the durations are not passed; defaults to `thread.composer`. */
+    composer?: ComposerTimer;
+}
+type PostResult = {
+    type: "created";
+    comment: Comment;
+} | {
+    type: "pending";
+    pending: Pending;
+};
+interface FlagOptions {
+    type: FlagType;
+    message?: string;
+}
+interface CommentContext {
+    ancestors: Comment[];
+    ancestorsTruncated: boolean;
+    comment: Comment;
+}
+interface ThreadHandle {
+    /** Current handle; changes from `v:…` to the topic id once the thread is created. */
+    readonly id: string;
+    /** Default timer for the thread's main composer. */
+    readonly composer: ComposerTimer;
+    /** Immutable; the same object is returned until something changes. */
+    snapshot(): ThreadSnapshot;
+    subscribe(listener: (event: ThreadEvent) => void): () => void;
+    load(): Promise<void>;
+    loadMore(): Promise<void>;
+    loadReplies(commentId: number): Promise<void>;
+    setSort(sort: Sort): Promise<void>;
+    post(options: PostOptions): Promise<PostResult>;
+    edit(commentId: number, body: string): Promise<Comment>;
+    remove(commentId: number): Promise<void>;
+    like(commentId: number): Promise<Comment>;
+    unlike(commentId: number): Promise<Comment>;
+    flag(commentId: number, options: FlagOptions): Promise<void>;
+    pin(commentId: number): Promise<void>;
+    unpin(commentId: number): Promise<void>;
+    /** Markdown source, for editing. */
+    raw(commentId: number): Promise<string>;
+    /** Moves live-arrived top-level comments into `comments`. */
+    showPending(): void;
+    /** Loads a comment with its ancestors into the tree (deep links). */
+    context(commentId: number): Promise<CommentContext>;
+    dispose(): void;
+}
+
+interface CreateClientOptions {
+    /** The forum's base URL, e.g. `https://forum.example.com` (a trailing slash is fine). */
+    forum: string;
+    /** Custom fetch (SSR, tests, proxies). Defaults to the global fetch. */
+    fetch?: FetchLike;
+    /** Extra headers for comments API requests, e.g. `Authorization` for a forum behind basic auth. */
+    headers?: Record<string, string>;
+    /** Where the key and client id are kept. Defaults to `localStorage` (memory if unavailable). */
+    storage?: StorageLike;
+    /** Fixed client id (`[\w-]{8,64}`) instead of a generated per-browser one. */
+    clientId?: string;
+    /** Sent as `Accept-Language` so server messages match the widget. */
+    locale?: string;
+    /** Logs requests and realtime activity to the console. */
+    debug?: boolean;
+}
+interface OpenThreadOptions {
+    /** Defaults to `<link rel="canonical">`, else `location.href`. */
+    url?: string;
+    /** Defaults to `document.title`. */
+    title?: string;
+    /** Optional stable key, namespaced by the page's canonical host on the forum. */
+    identifier?: string;
+    /** Initial sort; defaults to the forum's default. */
+    sort?: Sort;
+}
+interface UploadOptions {
+    filename?: string;
+    /** Marks the file as pasted from the clipboard. */
+    pasted?: boolean;
+}
+interface CommentsClient {
+    /** Normalized forum base URL. */
+    readonly forum: string;
+    readonly forumOrigin: string;
+    readonly locale: string | undefined;
+    readonly auth: CommentsAuth;
+    readonly threads: {
+        /** Resolves (or creates) the page's thread and loads its first page of comments. */
+        open(options?: OpenThreadOptions): Promise<ThreadHandle>;
+    };
+    readonly attachments: {
+        upload(threadId: string, file: Blob, options?: UploadOptions): Promise<Upload>;
+    };
+    /** Cached; refetched after sign-in and sign-out. */
+    config(): Promise<Config>;
+    /** The forum's palettes, fonts and theme stylesheets; cached for the client's lifetime. */
+    theme(): Promise<ForumTheme>;
+    /** Batched per tick, at most 50 refs per request. Keys are encoded refs (see `encodeRef`). */
+    counts(refs: readonly CountRef[]): Promise<Counts>;
+    count(ref: CountRef): Promise<number>;
+    /** Cooks markdown into sanitized HTML (signed-in only). */
+    preview(body: string): Promise<string>;
+    /** User search for @mentions (signed-in only). */
+    mentions(query: string, threadId?: string): Promise<Commenter[]>;
+    /** Stops realtime, timers and listeners for every thread of this client. */
+    dispose(): void;
+}
+declare function createClient(options: CreateClientOptions): CommentsClient;
+
+interface PluralMessage {
+    /** Used for a count of exactly 0 when present. */
+    zero?: string;
+    one: string;
+    two?: string;
+    few?: string;
+    many?: string;
+    other: string;
+}
+type MessageValue = string | PluralMessage;
+declare const en: {
+    readonly signIn: "Sign in";
+    readonly signInWith: "Continue with {provider}";
+    readonly signOut: "Sign out";
+    readonly signingIn: "Finish signing in in the window that opened.";
+    readonly signInCancel: "Cancel";
+    readonly sessionExpired: "Your session expired. Sign in again to comment.";
+    readonly joinConversation: "Join the conversation";
+    readonly joinConversationBody: "Sign in with your {forum} account to comment.";
+    readonly composerPlaceholder: "Add a comment…";
+    readonly post: "Post";
+    readonly posting: "Posting…";
+    readonly reply: "Reply";
+    readonly replyingTo: "Replying to @{username}";
+    readonly cancel: "Cancel";
+    readonly save: "Save";
+    readonly edit: "Edit";
+    readonly edited: "Edited";
+    readonly delete: "Delete";
+    readonly deleteConfirm: "Delete this comment?";
+    readonly deleted: "This comment was deleted.";
+    readonly hidden: "This comment was hidden after reports from the community.";
+    readonly like: "Like";
+    readonly unlike: "Remove like";
+    readonly likeCount: {
+        readonly zero: "No likes";
+        readonly one: "{count} like";
+        readonly other: "{count} likes";
+    };
+    readonly report: "Report";
+    readonly reportTitle: "Why are you reporting this comment?";
+    readonly "report.off_topic": "Off-topic";
+    readonly "report.inappropriate": "Inappropriate";
+    readonly "report.spam": "Spam";
+    readonly "report.illegal": "Illegal";
+    readonly "report.notify_moderators": "Something else";
+    readonly reportMessagePlaceholder: "Tell the moderators more (optional)";
+    readonly reportSent: "Thanks, the moderators will take a look.";
+    readonly pin: "Feature";
+    readonly unpin: "Unfeature";
+    readonly pinned: "Featured";
+    readonly pending: "Your comment was submitted and is awaiting approval.";
+    readonly loadMore: "Load more comments";
+    readonly loadReplies: {
+        readonly one: "View {count} reply";
+        readonly other: "View {count} replies";
+    };
+    readonly continueThread: "Continue this thread";
+    readonly newComments: {
+        readonly one: "{count} new comment";
+        readonly other: "{count} new comments";
+    };
+    readonly commentCount: {
+        readonly zero: "No comments yet";
+        readonly one: "{count} comment";
+        readonly other: "{count} comments";
+    };
+    readonly sortBy: "Sort by";
+    readonly "sort.best": "Best";
+    readonly "sort.hot": "Hot";
+    readonly "sort.newest": "Newest";
+    readonly "sort.oldest": "Oldest";
+    readonly closed: "Comments are closed.";
+    readonly readOnly: "Comments are read-only right now.";
+    readonly guidelines: "Community guidelines";
+    readonly preview: "Preview";
+    readonly write: "Write";
+    readonly unavailable: "Comments are unavailable right now.";
+    readonly retry: "Try again";
+    readonly rateLimited: {
+        readonly one: "You're doing that too often. Try again in {count} second.";
+        readonly other: "You're doing that too often. Try again in {count} seconds.";
+    };
+    readonly genericError: "Something went wrong. Please try again.";
+    readonly copyLink: "Copy link";
+    readonly linkCopied: "Link copied";
+    readonly viewOnForum: "View on {forum}";
+    readonly staff: "Staff";
+    readonly upload: "Attach image";
+    readonly uploading: "Uploading…";
+    readonly comments: "Comments";
+    readonly signedInAs: "Signed in as {username}";
+    readonly loadMoreReplies: {
+        readonly one: "View {count} more reply";
+        readonly other: "View {count} more replies";
+    };
+    readonly backToAll: "Back to all comments";
+    readonly ancestorsTruncated: "Some earlier replies are not shown.";
+    readonly moreActions: "More actions";
+    readonly commentBy: "Comment by {name}";
+    readonly deletedComment: "Deleted comment";
+    readonly repliesTo: "Replies to {name}";
+    readonly replyPlaceholder: "Write a reply…";
+    readonly editing: "Editing your comment";
+    readonly tooShort: "Comments need at least {min} characters.";
+    readonly tooLong: "Comments can have at most {max} characters.";
+    readonly formatting: "Formatting";
+    readonly bold: "Bold";
+    readonly italic: "Italic";
+    readonly insertLink: "Insert link";
+    readonly code: "Code";
+    readonly quote: "Quote";
+    readonly mentionSuggestions: "Mention suggestions";
+    readonly previewEmpty: "Nothing to preview yet.";
+    readonly loading: "Loading…";
+    readonly cannotComment: "You can't comment on this page.";
+    readonly reportMessageRequired: "Tell the moderators what's wrong";
+    readonly close: "Close";
+};
+type MessageKey = keyof typeof en;
+/** A full table: plural entries stay plural in every locale. */
+type Messages = {
+    [K in MessageKey]: (typeof en)[K] extends string ? string : PluralMessage;
+};
+declare const ptBR: Messages;
+declare const locales: {
+    readonly en: Messages;
+    readonly "pt-BR": Messages;
+};
+type SupportedLocale = keyof typeof locales;
+type MessageVars = Record<string, string | number>;
+type Translator = (key: MessageKey, vars?: MessageVars) => string;
+/** Closest bundled locale: any `pt*` maps to `pt-BR`, everything else to `en`. */
+declare function resolveLocale(locale: string | undefined): SupportedLocale;
+declare function createTranslator(locale?: string, overrides?: Partial<Messages>): Translator;
+
+export { type RawResponse as $, type AnyThread as A, type BranchState as B, type CreateClientOptions as C, type ExchangeResponse as D, type ErrorResponse as E, type Features as F, type FetchLike as G, type FlagOptions as H, type FlagType as I, type ForumColorScheme as J, type ForumFont as K, type ForumFontFace as L, type ForumInfo as M, type ForumTheme as N, type Limits as O, type MentionsResponse as P, type MessageKey as Q, type MessageValue as R, type MessageVars as S, type Messages as T, type OpenThreadOptions as U, type Pending as V, type PinsResponse as W, type PluralMessage as X, type PostOptions as Y, type PostResult as Z, type PreviewResponse as _, type CommentsClient as a, type RootsPageResponse as a0, type SignInOptions as a1, type Sort as a2, type StorageLike as a3, type StoredAuth as a4, type SupportedLocale as a5, type Thread as a6, type ThreadCreation as a7, type ThreadEvent as a8, type ThreadHandle as a9, type ThreadResponse as aa, type ThreadSnapshot as ab, type ThreadStatus as ac, type Translator as ad, type Upload as ae, type UploadOptions as af, type VirtualThread as ag, createClient as ah, createComposerTimer as ai, createTranslator as aj, en as ak, isCommentsError as al, isVirtualThread as am, locales as an, memoryStorage as ao, ptBR as ap, resolveLocale as aq, type CountRef as b, type AuthProvider as c, type AuthState as d, type AuthStatus as e, type ChildrenPageResponse as f, type Comment as g, type CommentAuthor as h, type CommentContext as i, type CommentContextResponse as j, type CommentLikes as k, type CommentPermissions as l, type CommentReplyTo as m, type CommentResponse as n, type Commenter as o, type CommentsAuth as p, type CommentsByIdsResponse as q, CommentsError as r, type CommentsErrorType as s, type ComposerTimer as t, type ComposerTiming as u, type Config as v, type ConnectionMode as w, type Counts as x, type CountsResponse as y, type CreateCommentResponse as z };