@banta/sdk 6.0.2 → 7.0.0

package/index.d.ts

@@ -1,5 +1,1474 @@
+import * as rxjs from 'rxjs';
+import { Subject, Observable } from 'rxjs';
+import * as i0 from '@angular/core';
+import { ElementRef, PipeTransform, ModuleWithProviders, OnInit, TemplateRef, QueryList, NgZone, Type, InjectionToken } from '@angular/core';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as marked from 'marked';
+import { ChatMessageMention, ChatMessageAttachment, ChatMessage, User, Topic, CommentsOrder, FilterMode, Notification, UrlCard, SocketRPC, ChatPermissions, DurableSocket, ServerInfo, NewMessageForm, UpvoteNotification, NoticeNotification, MentionNotification, ReplyNotification, CDNProvider } from '@banta/common';
+import * as i8 from '@angular/common';
+import * as i9 from '@angular/material/icon';
+import * as i10 from '@angular/material/progress-spinner';
+import * as i11 from '@angular/material/button';
+import { EmojiCategory, Emoji } from '@astronautlabs/emoji';
+import * as i9$1 from '@angular/cdk/overlay';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import * as i10$1 from '@angular/cdk/portal';
+import { TemplatePortal } from '@angular/cdk/portal';
+import * as i4 from '@angular/forms';
+import * as i15 from '@angular/material/form-field';
+import * as i16 from '@angular/material/input';
+import * as i14 from '@angular/material/dialog';
+import { MatDialog } from '@angular/material/dialog';
+import { ActivatedRoute } from '@angular/router';
+import * as i18$1 from '@angular/material/snack-bar';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import * as i12 from '@angular/cdk/text-field';
+import * as i18 from '@angular/material/menu';
+import * as i19 from '@angular/material/divider';
+import * as i23 from '@angular/material/tooltip';
+import * as i24 from '@angular/material/datepicker';
+import * as i25 from '@angular/material/select';
+import * as i26 from '@angular/material/badge';
+import * as i27 from '@angular/material/radio';
+
+interface LazyConnectionOptions<T> {
+    start: (subject: Subject<T>) => void;
+    stop: () => void;
+}
+declare function lazyConnection<T>(options: LazyConnectionOptions<T>): Observable<T>;
+
 /**
- * Generated bundle index. Do not edit.
+ * Provides a way to hook in to a shared set of timers, instead of creating a timer per instance.
+ * This is very useful for cases where the update is not extremely time-sensitive, but happens at scale.
+ * The principal use case is the TimestampComponent. When several hundred (or several thousand) comments are
+ * being displayed, we do not want to trigger thousands of independent relative timestamp updates, because over
+ * time the updates will saturate the CPU since they don't perfectly align.
  */
-/// <amd-module name="@banta/sdk" />
-export * from './public-api';
+declare class TimerPool {
+    private subscriptions;
+    private newSubscriptionsNotice;
+    private newSubscriptions;
+    private removedSubscriptionsNotice;
+    private removedSubscriptions;
+    addTimer(interval: number, callback: () => void): () => void;
+}
+
+declare class TimestampComponent {
+    private timerPool;
+    constructor(timerPool: TimerPool);
+    private _value;
+    relative: string;
+    tooltip: string;
+    private timerUnsubscribe;
+    private timerInterval;
+    private _destroyed;
+    ngOnDestroy(): void;
+    get value(): number;
+    showAbsolute: boolean;
+    update(): void;
+    set value(v: number);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimestampComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimestampComponent, "banta-timestamp", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class LightboxComponent {
+    containerElement: ElementRef<HTMLDivElement>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    images: string[];
+    currentImage: string;
+    isOpen: boolean;
+    close(): void;
+    open(currentImage: string, images: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LightboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LightboxComponent, "banta-lightbox", never, {}, {}, never, never, false, never>;
+}
+
+declare class BantaMarkdownToHtmlPipe implements PipeTransform {
+    private sanitizer;
+    private sdkOptions;
+    constructor();
+    private get emojiUrl();
+    renderer: marked.Renderer;
+    transform(value: string): _angular_platform_browser.SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaMarkdownToHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BantaMarkdownToHtmlPipe, "bantaMarkdownToHtml", false>;
+}
+
+declare class BantaTrustResourceUrlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(value: string): _angular_platform_browser.SafeResourceUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaTrustResourceUrlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BantaTrustResourceUrlPipe, "trustResourceUrl", false>;
+}
+
+declare class BantaMentionLinkerPipe implements PipeTransform {
+    transform(value: string, links?: ChatMessageMention[]): string;
+    formatLink(link: ChatMessageMention): string;
+    /**
+     * https://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
+     */
+    escapeRegExp(string: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaMentionLinkerPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BantaMentionLinkerPipe, "mentionLinker", false>;
+}
+
+declare class BantaAttachmentComponent {
+    private elementRef;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    private _attachment;
+    get attachment(): ChatMessageAttachment;
+    set attachment(value: ChatMessageAttachment);
+    loading: boolean;
+    editing: boolean;
+    loadingMessage: string;
+    error: boolean;
+    errorMessage: string;
+    removed: Subject<void>;
+    activated: Subject<void>;
+    loaded: Subject<void>;
+    private _viewLoaded;
+    ngAfterViewInit(): void;
+    private loadTwitterWidgets;
+    private loadPlatformSpecific;
+    private checkLoad;
+    activate(): void;
+    remove(): void;
+    get isError(): any;
+    get theErrorMessage(): any;
+    get isLoading(): any;
+    get isImageAttachment(): boolean;
+    get hasFrame(): string | boolean;
+    get frameUrl(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaAttachmentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BantaAttachmentComponent, "banta-attachment", never, { "attachment": { "alias": "attachment"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "editing": { "alias": "editing"; "required": false; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; }; "error": { "alias": "error"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; }, { "removed": "removed"; "activated": "activated"; "loaded": "loaded"; }, never, never, false, never>;
+}
+
+declare class BantaAttachmentsComponent {
+    attachments: ChatMessageAttachment[];
+    editing: boolean;
+    lightbox: LightboxComponent;
+    remove: Subject<ChatMessageAttachment>;
+    loaded: Subject<void>;
+    loadedAttachments: WeakMap<ChatMessageAttachment, boolean>;
+    ngAfterViewInit(): void;
+    markAttachmentLoaded(attachment: ChatMessageAttachment): void;
+    isAttachmentLoaded(attachment: ChatMessageAttachment): boolean;
+    get allAttachmentsLoaded(): boolean;
+    removeAttachment(attachment: ChatMessageAttachment): void;
+    isImageAttachment(attachment: ChatMessageAttachment): boolean;
+    isCardAttachment(attachment: ChatMessageAttachment): boolean;
+    showLightbox(image: ChatMessageAttachment): void;
+    get validAttachments(): ChatMessageAttachment[];
+    get inlineAttachments(): ChatMessageAttachment[];
+    get blockAttachments(): ChatMessageAttachment[];
+    attachmentId(index: number, attachment: ChatMessageAttachment): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaAttachmentsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BantaAttachmentsComponent, "banta-attachments", never, { "attachments": { "alias": "attachments"; "required": false; }; "editing": { "alias": "editing"; "required": false; }; }, { "remove": "remove"; "loaded": "loaded"; }, never, never, false, never>;
+}
+
+declare class BantaCommonModule {
+    static forRoot(): ModuleWithProviders<BantaCommonModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BantaCommonModule, [typeof TimestampComponent, typeof LightboxComponent, typeof BantaMarkdownToHtmlPipe, typeof BantaMentionLinkerPipe, typeof BantaTrustResourceUrlPipe, typeof BantaAttachmentComponent, typeof BantaAttachmentsComponent], [typeof i8.CommonModule, typeof i9.MatIconModule, typeof i10.MatProgressSpinnerModule, typeof i11.MatButtonModule], [typeof TimestampComponent, typeof LightboxComponent, typeof BantaMarkdownToHtmlPipe, typeof BantaMentionLinkerPipe, typeof BantaTrustResourceUrlPipe, typeof BantaAttachmentComponent, typeof BantaAttachmentsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BantaCommonModule>;
+}
+
+interface AugmentedCategory extends EmojiCategory {
+    icon: string;
+    items: AugmentedEmoji[];
+}
+interface AugmentedEmoji extends Emoji {
+    html: SafeHtml;
+}
+declare class EmojiSelectorPanelComponent implements OnInit {
+    private sanitizer;
+    private sdkOptions;
+    categories: AugmentedCategory[];
+    allEmoji: AugmentedEmoji[];
+    activeCategory: string;
+    searchResults: any[];
+    searchVisible: boolean;
+    private selected;
+    private _searchQuery;
+    get searchQuery(): string;
+    set searchQuery(value: string);
+    humanize(str: string): string;
+    select(char: string): void;
+    hideSearch(): void;
+    showSearch(): void;
+    private get emojiUrl();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmojiSelectorPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmojiSelectorPanelComponent, "emoji-selector-panel", never, {}, { "selected": "selected"; }, never, never, false, never>;
+}
+
+declare class EmojiSelectorButtonComponent {
+    private elementRef;
+    private overlay;
+    constructor(elementRef: ElementRef<HTMLElement>, overlay: Overlay);
+    selectorPanelTemplate: TemplatePortal<any>;
+    private _selected;
+    showEmojiPanel: boolean;
+    get selected(): Observable<string>;
+    private overlayRef;
+    get isOpen(): OverlayRef;
+    /**
+     * Insert the given emoji.
+     * @param str
+     */
+    insert(str: any): void;
+    close(): void;
+    disabled: boolean;
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    show(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmojiSelectorButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmojiSelectorButtonComponent, "emoji-selector-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "overlayX": { "alias": "overlayX"; "required": false; }; "overlayY": { "alias": "overlayY"; "required": false; }; "originX": { "alias": "originX"; "required": false; }; "originY": { "alias": "originY"; "required": false; }; }, { "selected": "selected"; }, never, never, false, never>;
+}
+
+declare class EmojiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmojiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EmojiModule, [typeof EmojiSelectorPanelComponent, typeof EmojiSelectorButtonComponent], [typeof i8.CommonModule, typeof i4.FormsModule, typeof i9.MatIconModule, typeof i11.MatButtonModule, typeof i15.MatFormFieldModule, typeof i16.MatInputModule, typeof i9$1.OverlayModule, typeof i10$1.PortalModule], [typeof EmojiSelectorPanelComponent, typeof EmojiSelectorButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EmojiModule>;
+}
+
+declare class ChatMessageComponent {
+    private _selected;
+    private _reported;
+    private _upvoted;
+    private _userSelected;
+    message: ChatMessage;
+    get userSelected(): Subject<User>;
+    get selected(): Subject<void>;
+    get reported(): Subject<void>;
+    get upvoted(): Subject<void>;
+    avatarForUser(user: User): string;
+    upvote(): void;
+    report(): void;
+    select(): void;
+    selectUser(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatMessageComponent, "banta-chat-message", never, { "message": { "alias": "message"; "required": false; }; }, { "userSelected": "userSelected"; "selected": "selected"; "reported": "reported"; "upvoted": "upvoted"; }, never, never, false, never>;
+}
+
+declare class ChatBackend extends ChatBackendBase {
+    private options;
+    private platformId;
+    runId: string;
+    get serviceUrl(): string;
+    private connectToService;
+    private isServer;
+    /**
+     * Check if we are currently running inside a Googlebot user agent or via the Google inspection tool in Search Console.
+     * We'll use this to avoid WebSockets so that comments can be indexable.
+     * @returns
+     */
+    private isGooglebot;
+    getSourceForTopic(topicId: string, options?: ChatSourceOptions): Promise<ChatSourceBase>;
+    getSourceForThread(topicId: string, messageId: string, options?: ChatSourceOptions): Promise<ChatSourceBase>;
+    /**
+     * Get the count of the given topic
+     * @param topicId
+     * @returns
+     */
+    getSourceCountForTopic(topicId: string): Promise<number>;
+    /**
+     * Get the count of the given topics.
+     * @param topicId Topics to count messages on. Maximum of 1000.
+     * @returns
+     */
+    getSourceCountForTopics(topicIds: string[]): Promise<Record<string, number>>;
+    /**
+     * Get information about the given topic.
+     * @param topicId
+     * @returns The topic object, or undefined if no such topic was found.
+     */
+    getTopic(topicId: string): Promise<Topic | undefined>;
+    /**
+     * Get information about the given topics
+     * @param topicIds The topic IDs to look up. Maximum of 1000.
+     * @returns An array of matching topic objects.
+     */
+    getTopicsById(topicIds: string[]): Promise<Topic[]>;
+    /**
+     * Get a set of messages from the given topic.
+     * @param topicId
+     * @returns
+     */
+    getMessages(topicId: string, sort?: CommentsOrder, filter?: FilterMode, offset?: number, limit?: number, pinned?: boolean): Promise<ChatMessage[]>;
+    /**
+     * Get a set of messages from the given topic.
+     * @param topicId
+     * @returns
+     */
+    getReplies(parentMessageId: string, sort?: CommentsOrder, filter?: FilterMode, offset?: number, limit?: number, pinned?: boolean): Promise<ChatMessage[]>;
+    refreshMessage(message: ChatMessage): Promise<ChatMessage>;
+    getMessage(topicId: string, messageId: string): Promise<ChatMessage>;
+    getSubMessage(topicId: string, parentMessageId: string, messageId: string): Promise<ChatMessage>;
+    watchMessage(message: ChatMessage, handler: (message: ChatMessage) => void): () => void;
+    notificationsChanged: Observable<Notification[]>;
+    newNotification: Observable<Notification>;
+    getCardForUrl(url: string): Promise<UrlCard>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatBackend, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatBackend>;
+}
+
+type SignInState = 'signed-out' | 'signed-in' | 'signing-in';
+interface PinOptions {
+    until?: number;
+}
+declare class ChatSource extends SocketRPC implements ChatSourceBase {
+    readonly backend: ChatBackend;
+    readonly identifier: string;
+    readonly parentIdentifier: string;
+    constructor(backend: ChatBackend, identifier: string, parentIdentifier: string, options: ChatSourceOptions);
+    private options;
+    private subscription;
+    private markReady;
+    readonly: boolean;
+    canLoadMore: boolean;
+    ready: Promise<void>;
+    permissions: ChatPermissions;
+    private _state;
+    get sortOrder(): "newest" | "oldest" | "likes";
+    get filterMode(): string;
+    get state(): "connected" | "connecting" | "lost" | "restored";
+    set state(value: "connected" | "connecting" | "lost" | "restored");
+    private _connectionStateChanged;
+    private _connectionStateChanged$;
+    get connectionStateChanged(): rxjs.Observable<"connected" | "connecting" | "lost" | "restored">;
+    private wasRestored;
+    bind(socket: DurableSocket): Promise<this>;
+    private mapOrUpdateMessages;
+    private mapOrUpdateMessage;
+    /**
+     * Ask server for messages that have occurred since the message with the given ID.
+     * This is used during brief reconnects to avoid dropping messages, while also not
+     * causing mobbing as everyone reconnects after an issue. The backend can choose to
+     * not service this request, instead returning undefined. In that case, the client
+     * is expected to fetch the existing messages and start state anew.
+     *
+     * TODO: this is not yet used
+     *
+     * @param id
+     * @returns
+     */
+    loadSince(id: string): Promise<ChatMessage[]>;
+    getExistingMessages(): Promise<ChatMessage[]>;
+    getPinnedMessages(): Promise<ChatMessage[]>;
+    private ensureConnection;
+    editMessage(messageId: string, text: string): Promise<void>;
+    private subscribeAttempt;
+    private _errorState;
+    get errorState(): string;
+    subscribeToTopic(): Promise<void>;
+    private _signInState;
+    private _signInStateChanged;
+    private _signInStateChanged$;
+    get signInState(): SignInState;
+    get signInStateChanged(): rxjs.Observable<SignInState>;
+    private setSignInState;
+    authenticate(): Promise<void>;
+    close(): void;
+    onPermissions(permissions: ChatPermissions): void;
+    onChatMessage(message: ChatMessage): void;
+    private messageMap;
+    private _messageReceived;
+    private _messageUpdated;
+    private _messageSent;
+    private _messageObserved;
+    get messageReceived(): rxjs.Observable<ChatMessage>;
+    get messageUpdated(): rxjs.Observable<ChatMessage>;
+    get messageSent(): rxjs.Observable<ChatMessage>;
+    get messageObserved(): rxjs.Observable<ChatMessage>;
+    messages: ChatMessage[];
+    getServerInfo(): Promise<ServerInfo>;
+    send(message: ChatMessage): Promise<ChatMessage>;
+    loadAfter(message: ChatMessage, count: number): Promise<ChatMessage[]>;
+    get(id: string): Promise<ChatMessage>;
+    getCount(): Promise<number>;
+    likeMessage(messageId: string): Promise<void>;
+    pinMessage(messageId: string, options?: PinOptions): Promise<void>;
+    unpinMessage(messageId: string): Promise<void>;
+    unlikeMessage(messageId: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+}
+
+interface ChatSourceBase {
+    /**
+     * The topic identifier for the current chat/comments
+     */
+    identifier: string;
+    permissions: ChatPermissions;
+    ready: Promise<void>;
+    /**
+     * The ID of the parent message that this thread chat source is for.
+     * When this is not set, the chat source is a top-level ("topic") source.
+     * When it is set, this chat source is a thread source (ie replies).
+     */
+    parentIdentifier?: string;
+    sortOrder?: CommentsOrder;
+    filterMode?: FilterMode;
+    messageReceived: Observable<ChatMessage>;
+    messageObserved: Observable<ChatMessage>;
+    messageUpdated: Observable<ChatMessage>;
+    signInState?: SignInState;
+    signInStateChanged?: Observable<SignInState>;
+    messageSent: Observable<ChatMessage>;
+    messages: ChatMessage[];
+    send(message: ChatMessage): Promise<ChatMessage>;
+    close(): any;
+    getCount(): Promise<number>;
+    loadSince(id: string): Promise<ChatMessage[]>;
+    getExistingMessages(): Promise<ChatMessage[]>;
+    getPinnedMessages(): Promise<ChatMessage[]>;
+    loadAfter(message: ChatMessage, count: number): Promise<ChatMessage[]>;
+    get(id: string): Promise<ChatMessage>;
+    getServerInfo(): Promise<ServerInfo>;
+    likeMessage(messageId: string): Promise<void>;
+    unlikeMessage(messageId: string): Promise<void>;
+    pinMessage(messageId: string, options?: {
+        until?: number;
+    }): Promise<void>;
+    unpinMessage(messageId: string): Promise<void>;
+    editMessage(messageId: string, text: string): Promise<void>;
+    deleteMessage(messageId: string): Promise<void>;
+    connectionStateChanged?: Observable<'connected' | 'connecting' | 'lost' | 'restored'>;
+    state?: 'connecting' | 'connected' | 'lost' | 'restored';
+    /**
+     * When true, this source is readonly, so messages cannot be sent/edited/deleted, nor liked/unliked.
+     */
+    readonly?: boolean;
+    /**
+     * When true/undefined, the source supports loading more messages. When false, it does not.
+     */
+    canLoadMore?: boolean;
+    get errorState(): any;
+}
+
+interface AttachmentFragment {
+    text: string;
+    offset: number;
+    type: string;
+}
+interface AttachmentScraper {
+    findFragments(message: ChatMessage): AttachmentFragment[];
+}
+interface AttachmentResolver {
+    resolveFragment(message: ChatMessage, fragment: AttachmentFragment): Promise<ChatMessageAttachment>;
+}
+interface AttachmentRenderer {
+    attachment: ChatMessageAttachment;
+}
+
+interface ChatSourceOptions {
+    sortOrder?: CommentsOrder;
+    filterMode?: FilterMode;
+    /**
+     * How many messages should be loaded initially?
+     */
+    initialMessageCount?: number;
+    metadata?: Record<string, any>;
+}
+declare abstract class ChatBackendBase {
+    constructor();
+    abstract getSourceForTopic(topicId: string, options?: ChatSourceOptions): Promise<ChatSourceBase>;
+    abstract getSourceForThread(topicId: string, messageId: string, options?: ChatSourceOptions): Promise<ChatSourceBase>;
+    /**
+     * Get the count of the given topic
+     * @param topicId
+     * @returns
+     */
+    abstract getSourceCountForTopic(topicId: string): Promise<number>;
+    /**
+     * Get the count of the given topics.
+     * @param topicId Topics to count messages on. Maximum of 1000.
+     * @returns
+     */
+    abstract getSourceCountForTopics(topicIds: string[]): Promise<Record<string, number>>;
+    /**
+     * Get information about the given topic.
+     * @param topicId
+     * @returns The topic object, or undefined if no such topic was found.
+     */
+    abstract getTopic(topicId: string): Promise<Topic | undefined>;
+    /**
+     * Get information about the given topics
+     * @param topicIds The topic IDs to look up. Maximum of 1000.
+     * @returns An array of matching topic objects.
+     */
+    abstract getTopicsById(topicIds: string[]): Promise<Topic[]>;
+    /**
+     * Get a set of messages from the given topic.
+     * @param topicId
+     * @returns
+     */
+    abstract getMessages(topicId: string, sort?: CommentsOrder, filter?: FilterMode, offset?: number, limit?: number, pinned?: boolean): Promise<ChatMessage[]>;
+    /**
+     * Get a set of messages from the given topic.
+     * @param topicId
+     * @returns
+     */
+    abstract getReplies(parentMessageId: string, sort?: CommentsOrder, filter?: FilterMode, offset?: number, limit?: number): Promise<ChatMessage[]>;
+    abstract refreshMessage(message: ChatMessage): Promise<ChatMessage>;
+    abstract getMessage(topicId: string, messageId: string): Promise<ChatMessage>;
+    abstract getSubMessage(topicId: string, parentMessageId: string, messageId: string): Promise<ChatMessage>;
+    abstract watchMessage(message: ChatMessage, handler: (message: ChatMessage) => void): () => void;
+    abstract getCardForUrl(url: string): Promise<UrlCard>;
+    readonly notificationsChanged: Observable<Notification[]>;
+    readonly newNotification: Observable<Notification>;
+    private _userChanged;
+    private _user;
+    get userChanged(): Observable<User>;
+    set user(user: User);
+    get user(): User;
+    private _attachmentScrapers;
+    private _attachmentResolvers;
+    registerAttachmentScraper(scraper: AttachmentScraper): void;
+    registerAttachmentResolver(resolver: AttachmentResolver): void;
+    get attachmentScrapers(): AttachmentScraper[];
+    get attachmentResolvers(): AttachmentResolver[];
+}
+
+declare class LiveChatMessageComponent {
+    private backend;
+    constructor(backend: ChatBackendBase);
+    private _message;
+    private _upvoted;
+    private _reported;
+    private _selected;
+    get upvoted(): Observable<void>;
+    get reported(): Observable<void>;
+    get selected(): Observable<void>;
+    get message(): ChatMessage;
+    private unsubscribe;
+    set message(value: ChatMessage);
+    report(): void;
+    upvote(): void;
+    select(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LiveChatMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LiveChatMessageComponent, "banta-live-chat-message", never, { "message": { "alias": "message"; "required": false; }; }, { "upvoted": "upvoted"; "reported": "reported"; "selected": "selected"; }, never, never, false, never>;
+}
+
+declare class ChatViewComponent {
+    private backend;
+    private elementRef;
+    constructor(backend: ChatBackendBase, elementRef: ElementRef<HTMLElement>);
+    private _sourceSubs;
+    private _source;
+    get source(): ChatSourceBase;
+    private _selected;
+    private _selected$;
+    private _reported;
+    private _reported$;
+    private _upvoted;
+    private _upvoted$;
+    private _userSelected;
+    private _userSelected$;
+    private _received;
+    private _received$;
+    get selected(): rxjs.Observable<ChatMessage>;
+    get userSelected(): rxjs.Observable<ChatMessage>;
+    get reported(): rxjs.Observable<ChatMessage>;
+    get upvoted(): rxjs.Observable<ChatMessage>;
+    get received(): rxjs.Observable<ChatMessage>;
+    set source(value: ChatSourceBase);
+    private getInitialMessages;
+    private sortMessages;
+    messages: ChatMessage[];
+    currentUser: User;
+    messageContainer: ElementRef<HTMLElement>;
+    maxMessages: number;
+    emptyLabel: string;
+    private addMessage;
+    private messageReceived;
+    isScrolledToLatest(): boolean;
+    private messageSent;
+    scrollToLatest(): void;
+    jumpTo(message: ChatMessage): void;
+    flashMessage(message: ChatMessage): void;
+    flashedMessageId: string;
+    mentionsMe(message: ChatMessage): boolean;
+    upvoteMessage(message: ChatMessage): void;
+    reportMessage(message: ChatMessage): void;
+    selectMessage(message: ChatMessage): void;
+    selectMessageUser(message: ChatMessage): void;
+    avatarForUser(user: User): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChatViewComponent, "banta-chat-view", never, { "source": { "alias": "source"; "required": false; }; "maxMessages": { "alias": "maxMessages"; "required": false; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; }; }, { "selected": "selected"; "userSelected": "userSelected"; "reported": "reported"; "upvoted": "upvoted"; "received": "received"; }, never, ["[data-before]", ":not([data-before])"], false, never>;
+}
+
+/**
+ * Chat component
+ */
+declare class BantaChatComponent {
+    private backend;
+    constructor(backend: ChatBackendBase);
+    private _source;
+    private _subs;
+    user: User;
+    shouldInterceptMessageSend?: (message: ChatMessage, source: ChatSourceBase) => boolean | Promise<boolean>;
+    url: string;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get source(): ChatSourceBase;
+    set source(value: ChatSourceBase);
+    get topicID(): string;
+    set topicID(value: string);
+    private _metadata;
+    /**
+     * Arbitrary metadata to send to the chat server. This can be used to provide context about the client to the server
+     * for things like validating authorization and other uses.
+     */
+    get metadata(): Record<string, any>;
+    set metadata(value: Record<string, any>);
+    private _reloadSourceTimeout;
+    private reloadSource;
+    private setSourceFromTopicID;
+    signInLabel: string;
+    sendLabel: string;
+    permissionDeniedLabel: string;
+    messageFieldPlaceholder: string;
+    emptyLabel: string;
+    private _selected;
+    private _selected$;
+    private _reported;
+    private _reported$;
+    private _upvoted;
+    private _upvoted$;
+    private _userSelected;
+    private _userSelected$;
+    private _permissionDeniedError;
+    private _permissionDeniedError$;
+    private _signInSelected;
+    private _signInSelected$;
+    private _received;
+    private _received$;
+    get selected(): Observable<ChatMessage>;
+    get reported(): Observable<ChatMessage>;
+    get upvoted(): Observable<ChatMessage>;
+    get userSelected(): Observable<ChatMessage>;
+    get permissionDeniedError(): Observable<string>;
+    get signInSelected(): Observable<void>;
+    get received(): Observable<ChatMessage>;
+    onReceived(message: ChatMessage): void;
+    showEmojiPanel: boolean;
+    showSignIn(): void;
+    sendPermissionError(message?: string): void;
+    insertEmoji(emoji: any): void;
+    onKeyDown(event: KeyboardEvent): void;
+    chatView: ChatViewComponent;
+    inputElementRef: ElementRef<HTMLInputElement>;
+    jumpToMessage(message: ChatMessage): void;
+    select(message: ChatMessage): void;
+    selectUser(message: ChatMessage): void;
+    report(message: ChatMessage): void;
+    upvote(message: ChatMessage): Promise<void>;
+    get canChat(): boolean;
+    newMessage: NewMessageForm;
+    sendMessage(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaChatComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BantaChatComponent, "banta-chat", never, { "shouldInterceptMessageSend": { "alias": "shouldInterceptMessageSend"; "required": false; }; "url": { "alias": "url"; "required": false; }; "source": { "alias": "source"; "required": false; }; "topicID": { "alias": "topicID"; "required": false; }; "metadata": { "alias": "metadata"; "required": false; }; "signInLabel": { "alias": "signInLabel"; "required": false; }; "sendLabel": { "alias": "sendLabel"; "required": false; }; "permissionDeniedLabel": { "alias": "permissionDeniedLabel"; "required": false; }; "messageFieldPlaceholder": { "alias": "messageFieldPlaceholder"; "required": false; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; }; }, { "selected": "selected"; "reported": "reported"; "upvoted": "upvoted"; "userSelected": "userSelected"; "permissionDeniedError": "permissionDeniedError"; "signInSelected": "signInSelected"; "received": "received"; }, never, never, false, never>;
+}
+
+declare class ChatModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ChatModule, [typeof ChatMessageComponent, typeof LiveChatMessageComponent, typeof ChatViewComponent, typeof BantaChatComponent], [typeof i8.CommonModule, typeof i4.FormsModule, typeof i9.MatIconModule, typeof i11.MatButtonModule, typeof EmojiModule], [typeof ChatMessageComponent, typeof LiveChatMessageComponent, typeof ChatViewComponent, typeof BantaChatComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ChatModule>;
+}
+
+/**
+ * Unified chat and comments component
+ */
+declare class BantaComponent {
+    private backend;
+    private matDialog;
+    constructor(backend: ChatBackendBase, matDialog: MatDialog);
+    firehoseSource: ChatSourceBase;
+    pointSource: ChatSourceBase;
+    private _topicID;
+    private _subs;
+    auxOpen: boolean;
+    auxTitle: string;
+    auxMode: string;
+    ngOnInit(): void;
+    mobileFocus: string;
+    sendPointSubMessage(): Promise<void>;
+    firehose: BantaChatComponent;
+    goToMessage(message: ChatMessage): Promise<void>;
+    notifications: Notification[];
+    newNotifications: boolean;
+    pointUnfocus(): void;
+    ngOnDestroy(): void;
+    showAux(title: string, mode: string): void;
+    showNotifications(): void;
+    get topicID(): string;
+    chatLabel: string;
+    commentsLabel: string;
+    allowServerInfoRequest: boolean;
+    set topicID(value: string);
+    private connectToTopic;
+    private _signInSelected;
+    get signInSelected(): Observable<void>;
+    showSignIn(): void;
+    close(): void;
+    get hasPoint(): boolean;
+    pointOpen: ChatMessage;
+    pointSubChat: ChatSourceBase;
+    closeAux(): void;
+    getViewType(message: ChatMessage): "chat" | "comment";
+    upvoteMessage(message: ChatMessage): Promise<void>;
+    showProfile(user: User): void;
+    profileUser: User;
+    reportedMessage: ChatMessage;
+    sendReport(message: ChatMessage): void;
+    reportMessage(message: ChatMessage): void;
+    currentUser: User;
+    newPointSubMessage: NewMessageForm;
+    genericAvatarUrl: string;
+    notifIsUpvote(notif: Notification): notif is UpvoteNotification;
+    notifIsNotice(notif: Notification): notif is NoticeNotification;
+    notifIsMention(notif: Notification): notif is MentionNotification;
+    notifIsReply(notif: Notification): notif is ReplyNotification;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BantaComponent, "banta", never, { "topicID": { "alias": "topicID"; "required": false; }; "chatLabel": { "alias": "chatLabel"; "required": false; }; "commentsLabel": { "alias": "commentsLabel"; "required": false; }; "allowServerInfoRequest": { "alias": "allowServerInfoRequest"; "required": false; }; }, { "signInSelected": "signInSelected"; }, never, never, false, never>;
+}
+
+declare class BantaLogoComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaLogoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BantaLogoComponent, "banta-logo", never, {}, {}, never, never, false, never>;
+}
+
+declare class LiveMessageComponent {
+    constructor();
+    private _message;
+    private _upvoted;
+    private _reported;
+    private _selected;
+    viewType: string;
+    get upvoted(): Observable<void>;
+    get reported(): Observable<void>;
+    get selected(): Observable<void>;
+    get message(): ChatMessage;
+    set message(value: ChatMessage);
+    private getViewType;
+    upvote(): void;
+    report(): void;
+    select(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LiveMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LiveMessageComponent, "banta-live-message", never, { "message": { "alias": "message"; "required": false; }; }, { "upvoted": "upvoted"; "reported": "reported"; "selected": "selected"; }, never, never, false, never>;
+}
+
+interface MessageMenuItem {
+    icon: string;
+    label: string;
+    action: (message: ChatMessage) => void;
+}
+
+declare class CommentComponent {
+    private elementRef;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    busy: boolean;
+    get message(): ChatMessage;
+    set message(value: ChatMessage);
+    private _message;
+    private isLoaded;
+    editedMessage: string;
+    pinFormVisible: boolean;
+    pinUntilDate: Date;
+    pinUntilTime: string;
+    pinMode: 'forever' | 'until';
+    today: Date;
+    customMenuItems: MessageMenuItem[];
+    showReplyAction: boolean;
+    maxLength: number;
+    permissions: ChatPermissions;
+    mine: boolean;
+    editing: boolean;
+    genericAvatarUrl: string;
+    readonly: boolean;
+    private _reported;
+    private _selected;
+    private _liked;
+    private _unliked;
+    private _shared;
+    private _userSelected;
+    private _avatarSelected;
+    private _usernameSelected;
+    private _editStarted;
+    private _deleted;
+    private _editEnded;
+    private _edited;
+    private _loaded;
+    private _pinned;
+    private _unpinned;
+    readonly liked: rxjs.Observable<void>;
+    readonly unliked: rxjs.Observable<void>;
+    readonly selected: rxjs.Observable<void>;
+    readonly edited: rxjs.Observable<string>;
+    readonly deleted: rxjs.Observable<void>;
+    readonly editStarted: rxjs.Observable<void>;
+    readonly editEnded: rxjs.Observable<void>;
+    readonly shared: rxjs.Observable<ChatMessage>;
+    readonly userSelected: rxjs.Observable<void>;
+    readonly usernameSelected: rxjs.Observable<User>;
+    readonly avatarSelected: rxjs.Observable<User>;
+    readonly reported: rxjs.Observable<void>;
+    readonly loaded: rxjs.Observable<void>;
+    readonly pinned: rxjs.Observable<{
+        message: ChatMessage;
+        options: PinOptions;
+    }>;
+    readonly unpinned: rxjs.Observable<ChatMessage>;
+    get commentId(): string;
+    isNew: boolean;
+    get isHighlighted(): any;
+    visible: boolean;
+    get replyCount(): number;
+    get element(): HTMLElement;
+    get isPinned(): boolean;
+    get pinFormValid(): boolean;
+    avatarForUser(user: User): string;
+    waitForLoad(): Promise<void>;
+    private setMessage;
+    markAttachmentsLoaded(): void;
+    saveEdit(): void;
+    endEditing(): void;
+    delete(): void;
+    report(): void;
+    like(): void;
+    unlike(): void;
+    share(): void;
+    unpin(): void;
+    select(): void;
+    selectUser(): void;
+    startEdit(): void;
+    selectUsername(user: User): void;
+    selectAvatar(user: User): void;
+    showPinForm(): void;
+    submitPin(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentComponent, "banta-comment", never, { "busy": { "alias": "busy"; "required": false; }; "message": { "alias": "message"; "required": false; }; "customMenuItems": { "alias": "customMenuItems"; "required": false; }; "showReplyAction": { "alias": "showReplyAction"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "permissions": { "alias": "permissions"; "required": false; }; "mine": { "alias": "mine"; "required": false; }; "editing": { "alias": "editing"; "required": false; }; "genericAvatarUrl": { "alias": "genericAvatarUrl"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "liked": "liked"; "unliked": "unliked"; "selected": "selected"; "edited": "edited"; "deleted": "deleted"; "editStarted": "editStarted"; "editEnded": "editEnded"; "shared": "shared"; "userSelected": "userSelected"; "usernameSelected": "usernameSelected"; "avatarSelected": "avatarSelected"; "reported": "reported"; "loaded": "loaded"; "pinned": "pinned"; "unpinned": "unpinned"; }, never, never, false, never>;
+}
+
+interface EditEvent {
+    message: ChatMessage;
+    newMessage: string;
+}
+declare class CommentViewComponent {
+    private backend;
+    private elementRef;
+    constructor(backend: ChatBackendBase, elementRef: ElementRef<HTMLElement>);
+    private _source;
+    get source(): ChatSourceBase;
+    set source(value: ChatSourceBase);
+    private _sourceSubs;
+    menuMessage: ChatMessage;
+    pinnedMessages: ChatMessage[];
+    messages: ChatMessage[];
+    currentUser: User;
+    customSortEnabled: boolean;
+    markSourceLoaded: () => void;
+    sourceLoaded: Promise<void>;
+    isViewingMore: boolean;
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    messageClicked: boolean;
+    get previousMessages(): ChatMessage[];
+    get nextMessages(): ChatMessage[];
+    /**
+     * While this is called "new" messages, it really represents the messages that would be visible *at the beginning
+     * of the sort order*, which can be flipped by the newestLast feature (used for replies mode).
+     *
+     * So, when newestLast is false (top-level comments), regardless of the current sortOrder, newMessages are conceptually
+     * *above* the visible set of messages.
+     *
+     * When newestLast is true (as in replies mode), regardless of the current sortOrder, newMessages are conceptually
+     * *below* the visible set of messages.
+     */
+    newMessages: ChatMessage[];
+    /**
+     * While this is called "older" messages, it really represents the messages that would be visible *at the end of the
+     * sort order*, which can be flipped by the newestLast feature (useds for replies mode).
+     *
+     * So, when newestLast is false, regardless of the current sortOrder, olderMessages are conceptually *below*
+     * the visible set of messages.
+     *
+     * When newestLast is true (as in replies mode), regardless of the current sortOrder, olderMessages are conceptually
+     * *above* the visible set of messages.
+     */
+    olderMessages: ChatMessage[];
+    private _maxMessages;
+    set maxMessages(value: number);
+    get maxMessages(): number;
+    private _maxVisibleMessages;
+    set maxVisibleMessages(value: number);
+    get maxVisibleMessages(): number;
+    collapsePins: boolean;
+    newestLast: boolean;
+    holdNewMessages: boolean;
+    showEmptyState: boolean;
+    emptyStateMessage: string;
+    allowReplies: boolean;
+    enableHoldOnClick: boolean;
+    enableHoldOnScroll: boolean;
+    customMenuItems: MessageMenuItem[];
+    fixedHeight: boolean;
+    selectedMessage: ChatMessage;
+    genericAvatarUrl: string;
+    inlineRepliesTemplate: TemplateRef<any>;
+    private _selected;
+    private _liked;
+    private _unliked;
+    private _pinned;
+    private _unpinned;
+    private _reported;
+    private _userSelected;
+    private _usernameSelected;
+    private _avatarSelected;
+    private _shared;
+    private _deleted;
+    private _messageEdited;
+    private _sortOrderChanged;
+    private _filterModeChanged;
+    readonly userSelected: rxjs.Observable<ChatMessage>;
+    readonly reported: rxjs.Observable<ChatMessage>;
+    readonly liked: rxjs.Observable<ChatMessage>;
+    readonly unliked: rxjs.Observable<ChatMessage>;
+    readonly pinned: rxjs.Observable<{
+        message: ChatMessage;
+        options: PinOptions;
+    }>;
+    readonly unpinned: rxjs.Observable<ChatMessage>;
+    readonly usernameSelected: rxjs.Observable<User>;
+    readonly avatarSelected: rxjs.Observable<User>;
+    readonly shared: rxjs.Observable<ChatMessage>;
+    readonly deleted: rxjs.Observable<ChatMessage>;
+    readonly selected: rxjs.Observable<ChatMessage>;
+    readonly messageEdited: rxjs.Observable<EditEvent>;
+    readonly sortOrderChanged: rxjs.Observable<"newest" | "oldest" | "likes">;
+    readonly filterModeChanged: rxjs.Observable<string>;
+    commentsQuery: QueryList<CommentComponent>;
+    messageContainer: ElementRef<HTMLElement>;
+    get comments(): CommentComponent[];
+    /**
+     * Returns true if this message can be found within one of the message buffers (older, current, newer)
+     * @param message
+     */
+    isMessageLoadedInContext(message: ChatMessage): ChatMessage;
+    loadMessageInContext(message: ChatMessage): Promise<boolean>;
+    get shouldShowNewMessageIndicator(): boolean;
+    get shouldHoldNewMessages(): boolean;
+    private isElementVisible;
+    /**
+     * Get the CommentComponent instantiated for the given ChatMessage,
+     * if it exists in the current view. Note that messages which are not
+     * currently shown to the user will not return a CommentComponent.
+     * @param message
+     * @returns
+     */
+    getCommentComponentForMessage(message: ChatMessage): CommentComponent;
+    saveEdit(message: ChatMessage, newMessage: string): void;
+    likeMessage(message: ChatMessage): void;
+    unlikeMessage(message: ChatMessage): void;
+    pinMessage(message: ChatMessage, options: PinOptions): void;
+    unpinMessage(message: ChatMessage): void;
+    reportMessage(message: ChatMessage): void;
+    selectMessage(message: ChatMessage): void;
+    selectMessageUser(message: ChatMessage): void;
+    selectUsername(user: User): void;
+    selectAvatar(user: User): void;
+    sharedMessage(message: ChatMessage): void;
+    startEditing(message: ChatMessage): void;
+    deleteMessage(message: ChatMessage): void;
+    private setSource;
+    private getInitialMessages;
+    debugMessages(): void;
+    zeroPad(number: number | string, count?: number): string;
+    leftPad(str: string, count?: number): string;
+    messageIdentity(index: number, chatMessage: ChatMessage): string;
+    get sourceSortOrder(): "newest" | "oldest" | "likes";
+    get sourceFilterMode(): string;
+    /**
+     * Show the newest content.
+     * - If an unnatural sort order is active (ie Oldest or Likes), it will be changed to Newest.
+     * - The new content will be placed where new content goes based on newestLast (replies mode), so if it is true, the content is
+     *   placed at the end, otherwise it is placed at the beginning.
+     *
+     * @param event
+     * @returns
+     */
+    showNewest(event: MouseEvent): Promise<void>;
+    get showDebug(): boolean;
+    get shouldShowNext(): boolean;
+    get shouldShowPrevious(): boolean;
+    get pageSize(): number;
+    showPrevious(): Promise<void>;
+    get sortNextLabel(): "Older" | "Newer" | "Less Likes" | "More";
+    get sortPreviousLabel(): "Older" | "Newer" | "More" | "More Likes";
+    get nextLabel(): "Older" | "Newer" | "Less Likes" | "More" | "More Likes";
+    get previousLabel(): "Older" | "Newer" | "Less Likes" | "More" | "More Likes";
+    /**
+     * Show more content
+     * - When in replies mode (newestLast), the content is added at the top
+     * - When in normal mode, the content is added at the bottom
+     * - The current sort order does *not* factor in here, which is why it is showMore() not showEarlier().
+     *
+     * @returns
+     */
+    showNext(): Promise<void>;
+    /**
+     * Show more content
+     * - When in replies mode (newestLast), the content is added at the top
+     * - When in normal mode, the content is added at the bottom
+     * - The current sort order does *not* factor in here, which is why it is showMore() not showEarlier().
+     *
+     * @returns
+     */
+    showMore(): Promise<void>;
+    heldMessages: ChatMessage[];
+    private addMessage;
+    private incrementPagingCursors;
+    /**
+     * Wait for all currently visible comments to be fully loaded, including all attachments.
+     * Doing this will prevent layout shift when scrolling to a specific comment.
+     */
+    waitForAllCommentsToLoad(): Promise<void>;
+    private sortMessages;
+    private messageReceived;
+    isScrolledToLatest(): boolean;
+    private messageSent;
+    private isPinned;
+    private messageUpdated;
+    scrollToLatest(): void;
+    get element(): HTMLElement;
+    scrollToComment(commentId: ChatMessage['id']): Promise<void>;
+    getElementForComment(commentId: string): Element;
+    mentionsMe(message: ChatMessage): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentViewComponent, "banta-comment-view", never, { "source": { "alias": "source"; "required": false; }; "maxMessages": { "alias": "maxMessages"; "required": false; }; "maxVisibleMessages": { "alias": "maxVisibleMessages"; "required": false; }; "collapsePins": { "alias": "collapsePins"; "required": false; }; "newestLast": { "alias": "newestLast"; "required": false; }; "holdNewMessages": { "alias": "holdNewMessages"; "required": false; }; "showEmptyState": { "alias": "showEmptyState"; "required": false; }; "emptyStateMessage": { "alias": "emptyStateMessage"; "required": false; }; "allowReplies": { "alias": "allowReplies"; "required": false; }; "enableHoldOnClick": { "alias": "enableHoldOnClick"; "required": false; }; "enableHoldOnScroll": { "alias": "enableHoldOnScroll"; "required": false; }; "customMenuItems": { "alias": "customMenuItems"; "required": false; }; "fixedHeight": { "alias": "fixedHeight"; "required": false; }; "selectedMessage": { "alias": "selectedMessage"; "required": false; }; "genericAvatarUrl": { "alias": "genericAvatarUrl"; "required": false; }; }, { "userSelected": "userSelected"; "reported": "reported"; "liked": "liked"; "unliked": "unliked"; "pinned": "pinned"; "unpinned": "unpinned"; "usernameSelected": "usernameSelected"; "avatarSelected": "avatarSelected"; "shared": "shared"; "deleted": "deleted"; "selected": "selected"; "messageEdited": "messageEdited"; "sortOrderChanged": "sortOrderChanged"; "filterModeChanged": "filterModeChanged"; }, ["inlineRepliesTemplate"], ["[data-before]", ":not([data-before]):not(.inline-replies)"], false, never>;
+}
+
+interface AutoCompleteOption {
+    label: string;
+    action?: () => void;
+}
+interface HashTag {
+    hashtag: string;
+    description: string;
+}
+declare class CommentFieldComponent {
+    ngAfterViewInit(): void;
+    private _source;
+    get source(): ChatSourceBase;
+    set source(value: ChatSourceBase);
+    private _permissionDeniedError;
+    private errorTimeout;
+    private _subs;
+    sending: boolean;
+    sendError: Error;
+    expandError: boolean;
+    autocompleteVisible: boolean;
+    autocompleteOptions: AutoCompleteOption[];
+    completionFunc: (str: string) => AutoCompleteOption[];
+    completionPrefix: string;
+    autoCompleteSelected: number;
+    text: string;
+    chatMessageAttachments: ChatMessageAttachment[];
+    user: User;
+    canComment: boolean;
+    signInState: SignInState;
+    allowAttachments: boolean;
+    transientMessage: string;
+    sendLabel: string;
+    signingInLabel: string;
+    sendingLabel: string;
+    label: string;
+    permissionDeniedLabel: string;
+    signInLabel: string;
+    maxLength: number;
+    placeholder: string;
+    shouldInterceptMessageSend?: (message: ChatMessage, source: ChatSourceBase) => boolean | Promise<boolean>;
+    hashtags: HashTag[];
+    participants: User[];
+    genericAvatarUrl: string;
+    url: string;
+    submit: (message: ChatMessage) => void;
+    readonly: boolean;
+    allowServerInfoRequest: boolean;
+    signInSelected: Subject<void>;
+    editAvatarSelected: Subject<void>;
+    focusChange: Subject<boolean>;
+    textChanged: Subject<void>;
+    serverInfoRequested: Subject<void>;
+    reconnectRequested: Subject<void>;
+    get permissionDeniedError(): Subject<string>;
+    autocompleteEl: ElementRef<HTMLElement>;
+    autocompleteContainerEl: ElementRef<HTMLElement>;
+    textareaEl: ElementRef<HTMLTextAreaElement>;
+    get indicatorState(): "error" | "transient" | "sending" | "none";
+    get buttonState(): "signing-in" | "sending" | "permission-denied" | "send";
+    get sendButtonEnabled(): boolean;
+    get userAvatarUrl(): string;
+    get isValidMessage(): string | boolean;
+    get hasPendingAttachments(): boolean;
+    private setSource;
+    sendPermissionDenied(message: string): void;
+    activateAutoComplete(option: AutoCompleteOption): void;
+    onFocus(): void;
+    onBlur(): void;
+    showSignIn(): void;
+    showEditAvatar(): void;
+    insertEmoji(text: string): void;
+    showAutoComplete(options: AutoCompleteOption[]): void;
+    dismissAutoComplete(): void;
+    indicateError(message: string): void;
+    autocomplete(replacement: string): Promise<void>;
+    insert(str: string): Promise<void>;
+    onKeyDown(event: KeyboardEvent): Promise<void>;
+    startAutoComplete(event: KeyboardEvent, completionFunc: (str: string) => AutoCompleteOption[]): void;
+    sendMessage(): Promise<void>;
+    addedAttachment(attachment: ChatMessageAttachment): void;
+    attachmentError(attachment: ChatMessageAttachment): void;
+    removeAttachment(attachment: ChatMessageAttachment): void;
+    alertError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentFieldComponent, "banta-comment-field", never, { "source": { "alias": "source"; "required": false; }; "user": { "alias": "user"; "required": false; }; "canComment": { "alias": "canComment"; "required": false; }; "signInState": { "alias": "signInState"; "required": false; }; "allowAttachments": { "alias": "allowAttachments"; "required": false; }; "transientMessage": { "alias": "transientMessage"; "required": false; }; "sendLabel": { "alias": "sendLabel"; "required": false; }; "signingInLabel": { "alias": "signingInLabel"; "required": false; }; "sendingLabel": { "alias": "sendingLabel"; "required": false; }; "label": { "alias": "label"; "required": false; }; "permissionDeniedLabel": { "alias": "permissionDeniedLabel"; "required": false; }; "signInLabel": { "alias": "signInLabel"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "shouldInterceptMessageSend": { "alias": "shouldInterceptMessageSend"; "required": false; }; "hashtags": { "alias": "hashtags"; "required": false; }; "participants": { "alias": "participants"; "required": false; }; "genericAvatarUrl": { "alias": "genericAvatarUrl"; "required": false; }; "url": { "alias": "url"; "required": false; }; "submit": { "alias": "submit"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "allowServerInfoRequest": { "alias": "allowServerInfoRequest"; "required": false; }; }, { "signInSelected": "signInSelected"; "editAvatarSelected": "editAvatarSelected"; "focusChange": "focusChange"; "textChanged": "textChanged"; "serverInfoRequested": "serverInfoRequested"; "reconnectRequested": "reconnectRequested"; "permissionDeniedError": "permissionDeniedError"; }, never, ["*"], false, never>;
+}
+
+/**
+ * Comments component
+ */
+declare class BantaCommentsComponent {
+    private backend;
+    private elementRef;
+    private activatedRoute;
+    private matSnackBar;
+    private ngZone;
+    constructor(backend: ChatBackendBase, elementRef: ElementRef<HTMLElement>, activatedRoute: ActivatedRoute, matSnackBar: MatSnackBar, ngZone: NgZone);
+    get element(): HTMLElement;
+    private handleBackendExceptionAsAlert;
+    private handleBackendExceptionAsSnack;
+    private handleBackendException;
+    ngOnInit(): void;
+    private resizeObserver;
+    private width;
+    private height;
+    isMobileSized: boolean;
+    sendReplyOptionsTemplate: any;
+    markViewReady: () => void;
+    viewReady: Promise<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setSourceFromTopicID;
+    loadingTitle: string;
+    private _loadingMessage;
+    loadingMessageVisible: boolean;
+    get loadingMessage(): string;
+    set loadingMessage(value: string);
+    loading: boolean;
+    showLoadingScreen: boolean;
+    loadingStartedAt: number;
+    messageChangedAt: number;
+    sharedCommentID: string;
+    lastSharedCommentID: string;
+    customMenuItems: MessageMenuItem[];
+    private startLoading;
+    private _loadingTimer;
+    private _loadingMessageIndex;
+    /**
+     * The canonical URL where this comment section can be found. If not specified, uses the current URL.
+     */
+    url: string;
+    maxCommentLength: number;
+    loadingMessages: string[];
+    useInlineReplies: boolean;
+    /**
+     * Access the CommentViewComponent for this BantaCommentsComponent.
+     * CommentViewComponent is responsible for interacting with the ChatSource
+     * object and rendering comments as CommentComponents. It is the source of
+     * truth for which CommentComponent corresponds to which ChatMessage.
+     *
+     * Note that this CommentViewComponent is only for the top level comments.
+     * Replies are handled by a separate CommentViewComponent which can be
+     * retrieved using the threadView property.
+     */
+    commentView: CommentViewComponent;
+    threadViewQuery: QueryList<CommentViewComponent>;
+    /**
+     * Attempts to find the CommentComponent that corresponds to the given ChatMessage.
+     * The ChatMessage could be a top-level message in this conversation, or a reply,
+     * but note that a CommentComponent will only exist for a reply if the user has
+     * the relevant reply thread open.
+     * @param message The message to look for
+     */
+    getCommentComponentForMessage(message: ChatMessage): CommentComponent;
+    /**
+     * Access the CommentViewComponent corresponding to the currently open reply thread.
+     * This is not the top level comments, but instead the reply thread that the user has
+     * opened (only one set of replies can be open at a time).
+     *
+     * For details about what CommentViewComponent affords you, see the commentView property.
+     */
+    get threadView(): CommentViewComponent;
+    waitForThreadView(): Promise<CommentViewComponent>;
+    markLoaded: () => void;
+    loaded: Promise<void>;
+    get sourceState(): "connected" | "connecting" | "lost" | "restored" | "no-source";
+    private updateLoading;
+    private _signInSelected;
+    private _permissionDeniedError;
+    private _editAvatarSelected;
+    private _upvoted;
+    private _reported;
+    private _selected;
+    private _userSelected;
+    private _shared;
+    private _usernameSelected;
+    private _avatarSelected;
+    private _reconnectRequested;
+    private _source;
+    /**
+     * Track whether we created this source. If we did not (ie it was passed in from the caller),
+     * then we are not responsible for calling close(). If we do own it though, we will call close()
+     * when we are done with it.
+     */
+    private _sourceIsOwned;
+    private _subs;
+    private _topicID;
+    user: User;
+    selectedMessage: ChatMessage;
+    selectedMessageThread: ChatSourceBase;
+    selectedMessageVisible: boolean;
+    connectionState: string;
+    signInLabel: string;
+    sendLabel: string;
+    signingInLabel: string;
+    replyLabel: string;
+    sendingLabel: string;
+    permissionDeniedLabel: string;
+    postCommentLabel: string;
+    postReplyLabel: string;
+    allowAttachments: boolean;
+    allowServerInfoRequest: boolean;
+    fixedHeight: boolean;
+    maxMessages: number;
+    maxVisibleMessages: number;
+    genericAvatarUrl: string;
+    shouldInterceptMessageSend?: (message: ChatMessage, source: ChatSourceBase) => boolean | Promise<boolean>;
+    participants: User[];
+    private _sourceSubscription;
+    reconnect(): void;
+    replyFieldFocused: boolean;
+    get source(): ChatSourceBase;
+    set source(value: ChatSourceBase);
+    hashtags: HashTag[];
+    get topicID(): string;
+    set topicID(value: string);
+    readonly signInSelected: Observable<void>;
+    readonly editAvatarSelected: Observable<void>;
+    readonly permissionDeniedError: Observable<string>;
+    readonly upvoted: Observable<ChatMessage>;
+    readonly reported: Observable<ChatMessage>;
+    readonly selected: Observable<ChatMessage>;
+    readonly userSelected: Observable<ChatMessage>;
+    readonly usernameSelected: Observable<User>;
+    readonly avatarSelected: Observable<User>;
+    readonly shared: Observable<ChatMessage>;
+    readonly reconnectRequested: Observable<void>;
+    private _reloadSourceTimeout;
+    private reloadSource;
+    private _sortOrder;
+    get sortOrder(): "newest" | "oldest" | "likes";
+    set sortOrder(value: "newest" | "oldest" | "likes");
+    private _filterMode;
+    get filterMode(): string;
+    set filterMode(value: string);
+    initialMessageCount: number;
+    private _metadata;
+    /**
+     * Arbitrary metadata to send to the chat server. This can be used to provide context about the client to the server
+     * for things like validating authorization and other uses.
+     */
+    get metadata(): Record<string, any>;
+    set metadata(value: Record<string, any>);
+    get filterModes(): string[];
+    get filterModeLabels(): {
+        all: string;
+        mine: string;
+        threads: string;
+        "my-likes": string;
+    };
+    get sortOrders(): readonly ["newest", "oldest", "likes"];
+    get sortOrderLabels(): {
+        newest: string;
+        oldest: string;
+        likes: string;
+    };
+    sendMessage: (message: ChatMessage) => void;
+    sendReply: (message: ChatMessage) => void;
+    scrollToComment(commentId: ChatMessage['id']): Promise<void>;
+    serverInfoVisible: boolean;
+    serverInfoLoading: boolean;
+    serverInfo: ServerInfo;
+    showServerInfo(): Promise<void>;
+    loadingSharedComment: boolean;
+    sharedCommentMissing: boolean;
+    navigateToSharedComment(id: string): Promise<void>;
+    handlePermissionDenied(errorMessage: string): void;
+    sendPermissionDenied(message: string): void;
+    scrollToMessage(message: ChatMessage): void;
+    private addParticipant;
+    likeMessage(source: ChatSourceBase, message: ChatMessage): Promise<void>;
+    pinMessage(source: ChatSourceBase, message: ChatMessage, options: PinOptions): Promise<void>;
+    unpinMessage(source: ChatSourceBase, message: ChatMessage): Promise<void>;
+    unlikeMessage(source: ChatSourceBase, message: ChatMessage): Promise<void>;
+    reportMessage(message: ChatMessage): Promise<void>;
+    unselectMessage(): Promise<void>;
+    toggleSelectedMessage(message: ChatMessage): Promise<void>;
+    selectMessage(message: ChatMessage): Promise<ChatSourceBase>;
+    showSignIn(): Promise<void>;
+    showEditAvatar(): Promise<void>;
+    selectMessageUser(message: ChatMessage): Promise<void>;
+    selectUsername(user: User): Promise<void>;
+    selectAvatar(user: User): Promise<void>;
+    shareMessage(message: ChatMessage): Promise<void>;
+    deleteMessage(message: ChatMessage): Promise<void>;
+    editMessage(source: ChatSourceBase, message: ChatMessage, newText: string): Promise<void>;
+    startEditing(message: ChatMessage): Promise<void>;
+    saveEdit(message: ChatMessage, text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaCommentsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BantaCommentsComponent, "banta-comments", never, { "customMenuItems": { "alias": "customMenuItems"; "required": false; }; "url": { "alias": "url"; "required": false; }; "maxCommentLength": { "alias": "maxCommentLength"; "required": false; }; "loadingMessages": { "alias": "loadingMessages"; "required": false; }; "useInlineReplies": { "alias": "useInlineReplies"; "required": false; }; "signInLabel": { "alias": "signInLabel"; "required": false; }; "sendLabel": { "alias": "sendLabel"; "required": false; }; "signingInLabel": { "alias": "signingInLabel"; "required": false; }; "replyLabel": { "alias": "replyLabel"; "required": false; }; "sendingLabel": { "alias": "sendingLabel"; "required": false; }; "permissionDeniedLabel": { "alias": "permissionDeniedLabel"; "required": false; }; "postCommentLabel": { "alias": "postCommentLabel"; "required": false; }; "postReplyLabel": { "alias": "postReplyLabel"; "required": false; }; "allowAttachments": { "alias": "allowAttachments"; "required": false; }; "allowServerInfoRequest": { "alias": "allowServerInfoRequest"; "required": false; }; "fixedHeight": { "alias": "fixedHeight"; "required": false; }; "maxMessages": { "alias": "maxMessages"; "required": false; }; "maxVisibleMessages": { "alias": "maxVisibleMessages"; "required": false; }; "genericAvatarUrl": { "alias": "genericAvatarUrl"; "required": false; }; "shouldInterceptMessageSend": { "alias": "shouldInterceptMessageSend"; "required": false; }; "participants": { "alias": "participants"; "required": false; }; "source": { "alias": "source"; "required": false; }; "hashtags": { "alias": "hashtags"; "required": false; }; "topicID": { "alias": "topicID"; "required": false; }; "sortOrder": { "alias": "sortOrder"; "required": false; }; "filterMode": { "alias": "filterMode"; "required": false; }; "initialMessageCount": { "alias": "initialMessageCount"; "required": false; }; "metadata": { "alias": "metadata"; "required": false; }; }, { "signInSelected": "signInSelected"; "editAvatarSelected": "editAvatarSelected"; "permissionDeniedError": "permissionDeniedError"; "upvoted": "upvoted"; "reported": "reported"; "selected": "selected"; "userSelected": "userSelected"; "usernameSelected": "usernameSelected"; "avatarSelected": "avatarSelected"; "shared": "shared"; "reconnectRequested": "reconnectRequested"; }, ["sendReplyOptionsTemplate"], never, false, never>;
+}
+
+declare class LiveCommentComponent {
+    private backend;
+    constructor(backend: ChatBackendBase);
+    private _message;
+    private _upvoted;
+    private _reported;
+    private _selected;
+    get upvoted(): Observable<void>;
+    get reported(): Observable<void>;
+    get selected(): Observable<void>;
+    get message(): ChatMessage;
+    private unsubscribe;
+    set message(value: ChatMessage);
+    report(): void;
+    upvote(): void;
+    select(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LiveCommentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LiveCommentComponent, "banta-live-comment", never, { "message": { "alias": "message"; "required": false; }; }, { "upvoted": "upvoted"; "reported": "reported"; "selected": "selected"; }, never, never, false, never>;
+}
+
+declare class CommentSortComponent {
+    commentsOrder: {
+        readonly NEWEST: "newest";
+        readonly OLDEST: "oldest";
+        readonly LIKES: "likes";
+        readonly options: readonly ["newest", "oldest", "likes"];
+    };
+    private _sortChange;
+    private _sort;
+    get sort(): "newest" | "oldest" | "likes";
+    set sort(value: "newest" | "oldest" | "likes");
+    get sortChange(): rxjs.Observable<"newest" | "oldest" | "likes">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentSortComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CommentSortComponent, "banta-comment-sort", never, { "sort": { "alias": "sort"; "required": false; }; }, { "sortChange": "sortChange"; }, never, never, false, never>;
+}
+
+declare class AttachmentButtonComponent {
+    private cdnProvider;
+    constructor(cdnProvider: CDNProvider);
+    private _addedAttachment;
+    private _attachmentError;
+    disabled: boolean;
+    get addedAttachment(): rxjs.Observable<ChatMessageAttachment>;
+    get attachmentError(): rxjs.Observable<ChatMessageAttachment>;
+    fileInput: ElementRef<HTMLInputElement>;
+    show(): void;
+    fileChange(event: Event): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachmentButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AttachmentButtonComponent, "banta-attachment-button", never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "addedAttachment": "addedAttachment"; "attachmentError": "attachmentError"; }, never, never, false, never>;
+}
+
+declare class BantaReplySendOptionsDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaReplySendOptionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BantaReplySendOptionsDirective, "[bantaReplySendOptions]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BantaInlineRepliesDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaInlineRepliesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BantaInlineRepliesDirective, "[bantaInlineReplies]", never, {}, {}, never, never, false, never>;
+}
+
+declare class AttachmentScraperDirective {
+    private elementRef;
+    private chatBackend;
+    constructor(elementRef: ElementRef<HTMLTextAreaElement>, chatBackend: ChatBackendBase);
+    attachments: ChatMessageAttachment[];
+    attachmentsChange: Subject<ChatMessageAttachment[]>;
+    ngOnInit(): void;
+    get element(): HTMLTextAreaElement;
+    get text(): string;
+    private scrapeTimeout;
+    private scrapeDebounce;
+    private fragments;
+    private scrape;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AttachmentScraperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AttachmentScraperDirective, "[attachmentScraper]", never, { "attachments": { "alias": "attachments"; "required": false; }; }, { "attachmentsChange": "attachmentsChange"; }, never, never, false, never>;
+}
+
+declare class CommentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CommentsModule, [typeof CommentComponent, typeof CommentViewComponent, typeof BantaCommentsComponent, typeof LiveCommentComponent, typeof CommentFieldComponent, typeof CommentSortComponent, typeof AttachmentButtonComponent, typeof BantaReplySendOptionsDirective, typeof BantaInlineRepliesDirective, typeof AttachmentScraperDirective], [typeof i8.CommonModule, typeof i12.TextFieldModule, typeof i4.FormsModule, typeof i9.MatIconModule, typeof i15.MatFormFieldModule, typeof i16.MatInputModule, typeof i11.MatButtonModule, typeof i18.MatMenuModule, typeof i19.MatDividerModule, typeof i10.MatProgressSpinnerModule, typeof BantaCommonModule, typeof EmojiModule, typeof i23.MatTooltipModule, typeof i24.MatDatepickerModule, typeof i25.MatSelectModule, typeof i26.MatBadgeModule, typeof i27.MatRadioModule, typeof i9$1.OverlayModule, typeof i10$1.PortalModule], [typeof CommentComponent, typeof CommentViewComponent, typeof BantaCommentsComponent, typeof LiveCommentComponent, typeof CommentFieldComponent, typeof CommentSortComponent, typeof AttachmentButtonComponent, typeof BantaReplySendOptionsDirective, typeof BantaInlineRepliesDirective, typeof AttachmentScraperDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CommentsModule>;
+}
+
+interface SdkOptions {
+    serviceUrl?: string;
+    emojiUrl?: string;
+    backendClass?: Type<ChatBackendBase>;
+}
+declare const BANTA_SDK_OPTIONS: InjectionToken<SdkOptions>;
+
+declare class UrlAttachmentScraper implements AttachmentScraper {
+    findFragments(message: ChatMessage): AttachmentFragment[];
+}
+declare class UrlAttachmentResolver implements AttachmentResolver {
+    private backend;
+    constructor(backend: ChatBackendBase);
+    resolveFragment(message: ChatMessage, fragment: AttachmentFragment): Promise<ChatMessageAttachment>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlAttachmentResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UrlAttachmentResolver>;
+}
+
+declare class YouTubeAttachmentResolver implements AttachmentResolver {
+    resolveFragment(message: ChatMessage, fragment: AttachmentFragment): Promise<ChatMessageAttachment>;
+}
+
+declare class GiphyAttachmentResolver implements AttachmentResolver {
+    resolveFragment(message: ChatMessage, fragment: AttachmentFragment): Promise<ChatMessageAttachment>;
+}
+
+declare class TweetAttachmentResolver implements AttachmentResolver {
+    resolveFragment(message: ChatMessage, fragment: AttachmentFragment): Promise<ChatMessageAttachment>;
+}
+
+declare class BantaSdkModule {
+    chatBackend: ChatBackendBase;
+    constructor();
+    static configure(options?: SdkOptions): ModuleWithProviders<BantaSdkModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BantaSdkModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BantaSdkModule, [typeof BantaComponent, typeof BantaLogoComponent, typeof LiveMessageComponent], [typeof i8.CommonModule, typeof i4.FormsModule, typeof BantaCommonModule, typeof CommentsModule, typeof ChatModule, typeof EmojiModule, typeof i9.MatIconModule, typeof i11.MatButtonModule, typeof i23.MatTooltipModule, typeof i18.MatMenuModule, typeof i14.MatDialogModule, typeof i15.MatFormFieldModule, typeof i16.MatInputModule, typeof i10.MatProgressSpinnerModule, typeof i18$1.MatSnackBarModule, typeof i9$1.OverlayModule, typeof i10$1.PortalModule], [typeof BantaComponent, typeof BantaLogoComponent, typeof LiveMessageComponent, typeof BantaCommonModule, typeof ChatModule, typeof CommentsModule, typeof EmojiModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BantaSdkModule>;
+}
+
+export { AttachmentButtonComponent, AttachmentScraperDirective, BANTA_SDK_OPTIONS, BantaAttachmentComponent, BantaAttachmentsComponent, BantaChatComponent, BantaCommentsComponent, BantaCommonModule, BantaComponent, BantaInlineRepliesDirective, BantaLogoComponent, BantaMarkdownToHtmlPipe, BantaMentionLinkerPipe, BantaReplySendOptionsDirective, BantaSdkModule, BantaTrustResourceUrlPipe, ChatBackend, ChatBackendBase, ChatMessageComponent, ChatModule, ChatSource, ChatViewComponent, CommentComponent, CommentFieldComponent, CommentSortComponent, CommentViewComponent, CommentsModule, EmojiModule, EmojiSelectorButtonComponent, EmojiSelectorPanelComponent, GiphyAttachmentResolver, LightboxComponent, LiveChatMessageComponent, LiveCommentComponent, LiveMessageComponent, TimerPool, TimestampComponent, TweetAttachmentResolver, UrlAttachmentResolver, UrlAttachmentScraper, YouTubeAttachmentResolver, lazyConnection };
+export type { AttachmentFragment, AttachmentRenderer, AttachmentResolver, AttachmentScraper, AugmentedCategory, AugmentedEmoji, AutoCompleteOption, ChatSourceBase, ChatSourceOptions, EditEvent, HashTag, LazyConnectionOptions, MessageMenuItem, PinOptions, SdkOptions, SignInState };