ngx-markdown

readonly copied$: any;

readonly copiedText$: any;

static ɵcmp: i0.ɵɵComponentDeclaration<
    ClipboardButtonComponent,
    'markdown-clipboard',
    never,
    {},
    {},
    never,
    never,
    true,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardButtonComponent, never>;

onCopyToClipboardClick: () => void;

ɵNgxMarkdownRendererExtendedForExtensions: boolean;

ɵNgxMarkdownRendererExtendedForMermaid: boolean;

allowedProtocols?: string[];

colorIsTextColor?: boolean;

displayMode?: boolean;

errorColor?: string;

macros?: any;

maxExpand?: number;

maxSize?: number;

strict?: string | boolean | Function;

throwOnError?: boolean;

static ɵfac: i0.ɵɵFactoryDeclaration<LanguagePipe, never>;

static ɵpipe: i0.ɵɵPipeDeclaration<LanguagePipe, 'language', true>;

transform: (value: string | null, language: string) => string;

constructor(
    element: ElementRef<HTMLElement>,
    markdownService: MarkdownService,
    viewContainerRef: ViewContainerRef
);

clipboard: boolean;

clipboardButtonComponent: any;

clipboardButtonTemplate: any;

commandLine: boolean;

data: string;

disableSanitizer: boolean;

element: ElementRef<HTMLElement>;

emoji: boolean;

error: EventEmitter<string | Error>;

filterOutput: string;

host: string;

inline: boolean;

katex: boolean;

katexOptions: KatexSpecificOptions & RenderMathInElementSpecificOptions;

line: string | string[];

lineHighlight: boolean;

lineNumbers: boolean;

lineOffset: number;

load: EventEmitter<string>;

markdownService: MarkdownService;

mermaid: boolean;

mermaidOptions: MermaidAPI.MermaidConfig;

protected static ngAcceptInputType_clipboard: boolean | '';

protected static ngAcceptInputType_commandLine: boolean | '';

protected static ngAcceptInputType_emoji: boolean | '';

protected static ngAcceptInputType_katex: boolean | '';

protected static ngAcceptInputType_lineHighlight: boolean | '';

protected static ngAcceptInputType_lineNumbers: boolean | '';

protected static ngAcceptInputType_mermaid: boolean | '';

output: string;

static ɵcmp: i0.ɵɵComponentDeclaration<
    MarkdownComponent,
    'markdown, [markdown]',
    never,
    {
        data: { alias: 'data'; required: false };
        src: { alias: 'src'; required: false };
        disableSanitizer: { alias: 'disableSanitizer'; required: false };
        inline: { alias: 'inline'; required: false };
        clipboard: { alias: 'clipboard'; required: false };
        clipboardButtonComponent: {
            alias: 'clipboardButtonComponent';
            required: false;
        };
        clipboardButtonTemplate: {
            alias: 'clipboardButtonTemplate';
            required: false;
        };
        emoji: { alias: 'emoji'; required: false };
        katex: { alias: 'katex'; required: false };
        katexOptions: { alias: 'katexOptions'; required: false };
        mermaid: { alias: 'mermaid'; required: false };
        mermaidOptions: { alias: 'mermaidOptions'; required: false };
        lineHighlight: { alias: 'lineHighlight'; required: false };
        line: { alias: 'line'; required: false };
        lineOffset: { alias: 'lineOffset'; required: false };
        lineNumbers: { alias: 'lineNumbers'; required: false };
        start: { alias: 'start'; required: false };
        commandLine: { alias: 'commandLine'; required: false };
        filterOutput: { alias: 'filterOutput'; required: false };
        host: { alias: 'host'; required: false };
        prompt: { alias: 'prompt'; required: false };
        output: { alias: 'output'; required: false };
        user: { alias: 'user'; required: false };
    },
    { error: 'error'; load: 'load'; ready: 'ready' },
    never,
    ['*'],
    true,
    never
>;

static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownComponent, never>;

prompt: string;

ready: EventEmitter<void>;

src: string;

start: number;

user: string;

viewContainerRef: ViewContainerRef;

loadContent: () => void;

ngAfterViewInit: () => void;

ngOnChanges: () => void;

ngOnDestroy: () => void;

render: (markdown: string, decodeHtml?: boolean) => Promise<void>;

static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownModule, never>;

static ɵinj: i0.ɵɵInjectorDeclaration<MarkdownModule>;

static ɵmod: i0.ɵɵNgModuleDeclaration<
    MarkdownModule,
    never,
    [
        any,
        typeof i2.ClipboardButtonComponent,
        typeof i3.LanguagePipe,
        typeof i4.MarkdownComponent,
        typeof i5.MarkdownPipe
    ],
    [
        typeof i2.ClipboardButtonComponent,
        typeof i3.LanguagePipe,
        typeof i4.MarkdownComponent,
        typeof i5.MarkdownPipe
    ]
>;

static forChild: () => ModuleWithProviders<MarkdownModule>;

static forRoot: (
    markdownModuleConfig?: MarkdownModuleConfig
) => ModuleWithProviders<MarkdownModule>;

constructor(
    domSanitizer: DomSanitizer,
    elementRef: ElementRef<HTMLElement>,
    markdownService: MarkdownService,
    viewContainerRef: ViewContainerRef,
    zone: NgZone
);

static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownPipe, never>;

static ɵpipe: i0.ɵɵPipeDeclaration<MarkdownPipe, 'markdown', true>;

transform: (value: string, options?: MarkdownPipeOptions) => Promise<SafeHtml>;

constructor(
    clipboardOptions: ClipboardOptions,
    extensions: MarkedExtension[],
    options: MarkedOptions,
    mermaidOptions: MermaidAPI.MermaidConfig,
    platform: Object,
    securityContext: SecurityContext,
    http: HttpClient,
    sanitizer: DomSanitizer
);

options: MarkedOptions;

static ɵfac: i0.ɵɵFactoryDeclaration<
    MarkdownService,
    [
        { optional: true },
        { optional: true },
        { optional: true },
        { optional: true },
        null,
        null,
        { optional: true },
        null
    ]
>;

static ɵprov: i0.ɵɵInjectableDeclaration<MarkdownService>;

readonly reload$: Observable<void>;

renderer: MarkedRenderer;

getSource: (src: string) => Observable<string>;

highlight: (element?: Element | Document) => void;

parse: (
    markdown: string,
    parseOptions?: ParseOptions
) => string | Promise<string>;

reload: () => void;

render: (
    element: HTMLElement,
    options?: RenderOptions,
    viewContainerRef?: ViewContainerRef
) => void;

buttonComponent?: Type<unknown>;

buttonTemplate?: TemplateRef<unknown>;

clipboardOptions?: TypedProvider<typeof CLIPBOARD_OPTIONS>;

loader?: Provider;

markedExtensions?: MarkedExtension[];

markedOptions?: TypedProvider<typeof MARKED_OPTIONS>;

mermaidOptions?: TypedProvider<typeof MERMAID_OPTIONS>;

sanitize?: SecurityContext;

decodeHtml?: boolean;

disableSanitizer?: boolean;

emoji?: boolean;

inline?: boolean;

markedOptions?: MarkedOptions;

mermaid?: boolean;

delimiters?:
    | ReadonlyArray<RenderMathInElementSpecificOptionsDelimiters>
    | undefined;

ignoredClasses?: string[] | undefined;

ignoredTags?: ReadonlyArray<keyof HTMLElementTagNameMap> | undefined;

errorCallback: (msg: string, err: Error) => void;

display: boolean;

left: string;

right: string;

clipboard?: boolean;

clipboardOptions?: ClipboardRenderOptions;

katex?: boolean;

katexOptions?: KatexOptions;

mermaid?: boolean;

mermaidOptions?: MermaidAPI.MermaidConfig;

CommandLine = 'command-line'

LineHighlight = 'line-highlight'

LineNumbers = 'line-numbers'