@keymanapp/common-types 17.0.256-alpha → 17.0.258-alpha

package/build/src/util/compiler-interfaces.d.ts

@@ -1,369 +1,367 @@
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="efd73433-f1ea-5b91-9e57-c90d1baad20c")}catch(e){}}();
-/**
- * Abstract interface for compiler error and warning messages
- */
-export interface CompilerEvent {
-    filename?: string;
-    line?: number;
-    code: number;
-    message: string;
-    /**
-     * an internal error occurred that should be captured with a stack trace
-     * e.g. to the Keyman sentry instance by kmc
-     */
-    exceptionVar?: any;
-}
-export declare enum CompilerErrorSeverity {
-    Info = 0,
-    Hint = 1048576,
-    Warn = 2097152,
-    Error = 3145728,
-    Fatal = 4194304
-}
-export declare const CompilerErrorSeverityValues: CompilerErrorSeverity[];
-/**
- * Mask values for mapping compiler errors
- */
-export declare enum CompilerErrorMask {
-    Severity = 15728640,
-    Error = 1048575,
-    Namespace = 1044480,
-    BaseError = 4095,
-    Reserved = 4278190080
-}
-export declare class CompilerError {
-    static severity(code: number): CompilerErrorSeverity;
-    static error(code: number): number;
-    static baseError(code: number): number;
-    static namespace(code: number): CompilerErrorNamespace;
-    static formatSeverity(code: number): string;
-    /** true if events has at least one message of the atLeast severity */
-    static hasSeverity(events: CompilerEvent[], atLeast: CompilerErrorSeverity): boolean;
-    /** true if events has at least one Error or worse */
-    static hasError(events: CompilerEvent[]): boolean;
-    /**
-     * Format an error code number. The error code number does not include
-     * the severity mask, as this is reported in text form separately; see
-     * `severityName`.
-     * @example
-     *
-     * The following call returns `KM03004`
-     * ```
-     *   formatCode(CompilerMessage.ERROR_InvalidDisplayMapFile)
-     * ```
-     */
-    static formatCode(code: number): string;
-    /**
-     * Formats an event filename for an error report,
-     * stripping off path component
-     * @param filename
-     * @returns
-     */
-    static formatFilename(filename: string, options?: {
-        fullPath?: boolean;
-        forwardSlashes?: boolean;
-    }): string;
-    /**
-     * Formats an event line for an error report
-     * @param line
-     * @returns
-     */
-    static formatLine(line: number): string;
-    /**
-     * Formats an event message for an error report
-     * @param message
-     * @returns
-     */
-    static formatMessage(message: string): string;
-    /**
-     * Formats a compiler message, without coloring; an ANSI color version is
-     * implemented in NodeCompilerCallbacks.
-     * @param event event or array of events
-     */
-    static formatEvent(event: CompilerEvent | CompilerEvent[]): string;
-    /**
-     * @param e Error-like
-     */
-    static exceptionToString(e?: any): string;
-    /**
-     * Returns the corresponding error severity value from a partial name match,
-     * e.g. 'inf' returns CompilerErrorSeverity.Info, or returns null if not found
-     * @param name
-     * @returns
-     */
-    static severityNameToValue(name: string): CompilerErrorSeverity;
-}
-/** @deprecated use `CompilerError.severity` instead */
-export declare function compilerErrorSeverity(code: number): CompilerErrorSeverity;
-/** @deprecated use `CompilerError.formatSeverity` instead */
-export declare function compilerErrorSeverityName(code: number): string;
-/** @deprecated use `CompilerError.formatCode` instead */
-export declare function compilerErrorFormatCode(code: number): string;
-/** @deprecated use `CompilerError.formatEvent` instead */
-export declare function compilerEventFormat(e: CompilerEvent | CompilerEvent[]): string;
-/**
- * Defines the error code ranges for various compilers. Once defined, these
- * ranges must not be changed as external modules may depend on specific error
- * codes. Individual errors are defined at a compiler level, for example,
- * kmc-ldml/src/compiler/messages.ts.
- *
- * kmc defines a mapping between each namespace and the corresponding compiler's
- * error reporting class in kmc/src/messages/messageNamespaces.ts
- */
-export declare enum CompilerErrorNamespace {
-    /**
-     * kmc-ldml errors between 0x0000…0x0FFF
-     */
-    LdmlKeyboardCompiler = 0,
-    /**
-     * common/web/types errors between 0x1000…0x1FFF
-     */
-    CommonTypes = 4096,
-    /**
-     * kmc-kmn errors between 0x2000…0x2FFF; these map to
-     * the base codes found in kmn_compiler_errors.h, exclusive severity flags
-     */
-    KmnCompiler = 8192,
-    /**
-     * kmc-model errors between 0x3000…0x3FFF
-     */
-    ModelCompiler = 12288,
-    /**
-     * kmc-package errors between 0x4000…0x4FFF
-     */
-    PackageCompiler = 16384,
-    /**
-     * kmc and related infrastructure errors between 0x5000…0x5FFF
-     */
-    Infrastructure = 20480,
-    /**
-     * kmc-analyze 0x6000…0x6FFF
-     */
-    Analyzer = 24576,
-    /**
-     * kmc-kmn/kmw-compiler errors between 0x7000…0x7FFF; note that some errors
-     * generated by kmc-kmn/kmw-compiler are from kmc-kmn namespace for legacy
-     * reasons
-     */
-    KmwCompiler = 28672,
-    /**
-     * kmc-model-info 0x8000…0x8FFF
-     */
-    ModelInfoCompiler = 32768,
-    /**
-     * kmc-keyboard-info 0x9000…0x9FFF
-     */
-    KeyboardInfoCompiler = 36864
-}
-/**
- * A mapping for common path operations, maps to Node path module. This only
- * defines the functions we are actually using, so that we can port more easily
- * between different systems.
- */
-export interface CompilerPathCallbacks {
-    dirname(name: string): string;
-    extname(name: string): string;
-    basename(name: string, ext?: string): string;
-    isAbsolute(name: string): boolean;
-    join(...paths: string[]): string;
-    normalize(p: string): string;
-}
-/**
- * A mapping for common filesystem operations, maps to Node fs module. This only
- * defines the functions we are actually using, so that we can port more easily
- * between different systems.
- */
-export interface CompilerFileSystemCallbacks {
-    readdirSync(name: string): string[];
-    readFileSync(path: string, options?: {
-        encoding?: null;
-        flag?: string;
-    } | null): Uint8Array;
-    readFileSync(path: string, options: {
-        encoding: string;
-        flag?: string;
-    } | string): string;
-    readFileSync(path: string, options?: {
-        encoding?: string | null;
-        flag?: string;
-    } | string | null): string | Uint8Array;
-    writeFileSync(path: string, data: Uint8Array): void;
-    existsSync(name: string): boolean;
-}
-type CompilerErrorSeverityOverride = CompilerErrorSeverity | 'disable';
-export interface CompilerMessageOverrideMap {
-    [code: number]: CompilerErrorSeverityOverride;
-}
-export interface CompilerMessageOverride {
-    code: number;
-    level: CompilerErrorSeverityOverride;
-}
-export interface CompilerCallbackOptions {
-    logLevel?: CompilerLogLevel;
-    logFormat?: CompilerLogFormat;
-    color?: boolean;
-    compilerWarningsAsErrors?: boolean;
-    messageOverrides?: CompilerMessageOverrideMap;
-}
-export interface KeymanCompilerArtifact {
-    data: Uint8Array;
-    filename: string;
-}
-export type KeymanCompilerArtifactOptional = KeymanCompilerArtifact | undefined;
-export interface KeymanCompilerArtifacts {
-    readonly [type: string]: KeymanCompilerArtifactOptional;
-}
-export interface KeymanCompilerResult {
-    artifacts: KeymanCompilerArtifacts;
-}
-export interface KeymanCompiler {
-    init(callbacks: CompilerCallbacks, options: CompilerOptions): Promise<boolean>;
-    /**
-     * Run the compiler, and save the result in memory arrays. Note that while
-     * `outputFilename` is provided here, the output file is not written to in
-     * this function.
-     * @param inputFilename
-     * @param outputFilename The intended output filename, optional, if missing,
-     *                       calculated from inputFilename
-     * @param data
-     */
-    run(inputFilename: string, outputFilename?: string): Promise<KeymanCompilerResult>;
-    /**
-     * Writes the compiled output files to disk
-     * @param artifacts
-     */
-    write(artifacts: KeymanCompilerArtifacts): Promise<boolean>;
-}
-/**
- * Abstract interface for callbacks, to abstract out file i/o
- */
-export interface CompilerCallbacks {
-    /**
-     * Attempt to load a file. Return falsy if not found.
-     * TODO: never return falsy, just throw if not found?
-     * @param filename
-     */
-    loadFile(filename: string): Uint8Array;
-    /**
-     * Get file size, returns undefined if not found
-     */
-    fileSize(filename: string): number;
-    get path(): CompilerPathCallbacks;
-    get fs(): CompilerFileSystemCallbacks;
-    /**
-     * Resolves a file path relative to the baseFilename
-     * @param baseFilename
-     * @param filename
-     */
-    resolveFilename(baseFilename: string, filename: string): string;
-    reportMessage(event: CompilerEvent): void;
-    debug(msg: string): void;
-}
-/**
- * Wrapper class for CompilerCallbacks for a given input file
- */
-export declare class CompilerFileCallbacks implements CompilerCallbacks {
-    private filename;
-    private options;
-    private parent;
-    messages: CompilerEvent[];
-    constructor(filename: string, options: CompilerCallbackOptions, parent: CompilerCallbacks);
-    /**
-     * Returns `true` if any message in the `messages` array is a Fatal or Error
-     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
-     * `true` if any message is a Warning.
-     */
-    static hasFailureMessage(messages: CompilerEvent[], compilerWarningsAsErrors: boolean): boolean;
-    /**
-     *
-     * @param event
-     * @param overrides
-     * @returns true if event has been suppressed
-     */
-    static applyMessageOverridesToEvent(event: CompilerEvent, overrides: CompilerMessageOverrideMap): boolean;
-    /**
-     * Returns `true` if any message in the `messages` array is a Fatal or Error
-     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
-     * `true` if any message is a Warning.
-     *
-     * If passed a defined `compilerWarningsAsErrors` value, then uses that,
-     * otherwise uses `options.compilerWarningsAsErrors`, or `false` if that is
-     * also `undefined`.
-     */
-    hasFailureMessage(compilerWarningsAsErrors?: boolean): boolean;
-    clear(): void;
-    loadFile(filename: string): Uint8Array;
-    fileSize(filename: string): number;
-    get path(): CompilerPathCallbacks;
-    get fs(): CompilerFileSystemCallbacks;
-    resolveFilename(baseFilename: string, filename: string): string;
-    reportMessage(event: CompilerEvent): void;
-    debug(msg: string): void;
-}
-/**
- * Abstract interface for compiler options
- */
-export interface CompilerBaseOptions {
-    /**
-     * Reporting level to console, used by NodeCompilerCallbacks (not used in compiler modules;
-     * all messages are still reported to the internal log)
-     */
-    logLevel?: CompilerLogLevel;
-    /**
-     * Format of output for log to console
-     */
-    logFormat?: CompilerLogFormat;
-    /**
-     * Colorize log output, default is detected from console
-     */
-    color?: boolean;
-}
-export interface CompilerOptions extends CompilerBaseOptions {
-    /**
-     * Add metadata about the compiler version to .kmx file when compiling
-     */
-    shouldAddCompilerVersion?: boolean;
-    /**
-     * Add debug information to the .kmx file when compiling
-     */
-    saveDebug?: boolean;
-    /**
-     * Upgrade any warnings produced in the compile to errors
-     */
-    compilerWarningsAsErrors?: boolean;
-    /**
-     * Emit warnings if deprecated code is encountered
-     */
-    warnDeprecatedCode?: boolean;
-    /**
-     * Check filename conventions in packages
-     */
-    checkFilenameConventions?: boolean;
-}
-export declare const defaultCompilerOptions: CompilerOptions;
-/**
- * Convenience function for constructing CompilerEvents
- * @param code
- * @param message
- * @returns
- */
-export declare const CompilerMessageSpec: (code: number, message: string, exceptionVar?: any) => CompilerEvent;
-/**
- * @deprecated use `CompilerError.exceptionToString` instead
- */
-export declare function compilerExceptionToString(e?: any): string;
-/**
- * Compiler logging level and correspondence to severity
- */
-export declare const ALL_COMPILER_LOG_LEVELS: readonly ["silent", "error", "warn", "hint", "info", "debug"];
-type CompilerLogLevelTuple = typeof ALL_COMPILER_LOG_LEVELS;
-export type CompilerLogLevel = CompilerLogLevelTuple[number];
-export declare const compilerLogLevelToSeverity: {
-    [index in CompilerLogLevel]: number;
-};
-export declare const ALL_COMPILER_LOG_FORMATS: readonly ["tsv", "formatted"];
-type CompilerLogFormatTuple = typeof ALL_COMPILER_LOG_FORMATS;
-export type CompilerLogFormat = CompilerLogFormatTuple[number];
-export {};
-//# debugId=efd73433-f1ea-5b91-9e57-c90d1baad20c
-//# sourceMappingURL=compiler-interfaces.d.ts.map
+/**
+ * Abstract interface for compiler error and warning messages
+ */
+export interface CompilerEvent {
+    filename?: string;
+    line?: number;
+    code: number;
+    message: string;
+    /**
+     * an internal error occurred that should be captured with a stack trace
+     * e.g. to the Keyman sentry instance by kmc
+     */
+    exceptionVar?: any;
+}
+export declare enum CompilerErrorSeverity {
+    Info = 0,
+    Hint = 1048576,
+    Warn = 2097152,
+    Error = 3145728,
+    Fatal = 4194304
+}
+export declare const CompilerErrorSeverityValues: CompilerErrorSeverity[];
+/**
+ * Mask values for mapping compiler errors
+ */
+export declare enum CompilerErrorMask {
+    Severity = 15728640,
+    Error = 1048575,
+    Namespace = 1044480,
+    BaseError = 4095,
+    Reserved = 4278190080
+}
+export declare class CompilerError {
+    static severity(code: number): CompilerErrorSeverity;
+    static error(code: number): number;
+    static baseError(code: number): number;
+    static namespace(code: number): CompilerErrorNamespace;
+    static formatSeverity(code: number): string;
+    /** true if events has at least one message of the atLeast severity */
+    static hasSeverity(events: CompilerEvent[], atLeast: CompilerErrorSeverity): boolean;
+    /** true if events has at least one Error or worse */
+    static hasError(events: CompilerEvent[]): boolean;
+    /**
+     * Format an error code number. The error code number does not include
+     * the severity mask, as this is reported in text form separately; see
+     * `severityName`.
+     * @example
+     *
+     * The following call returns `KM03004`
+     * ```
+     *   formatCode(CompilerMessage.ERROR_InvalidDisplayMapFile)
+     * ```
+     */
+    static formatCode(code: number): string;
+    /**
+     * Formats an event filename for an error report,
+     * stripping off path component
+     * @param filename
+     * @returns
+     */
+    static formatFilename(filename: string, options?: {
+        fullPath?: boolean;
+        forwardSlashes?: boolean;
+    }): string;
+    /**
+     * Formats an event line for an error report
+     * @param line
+     * @returns
+     */
+    static formatLine(line: number): string;
+    /**
+     * Formats an event message for an error report
+     * @param message
+     * @returns
+     */
+    static formatMessage(message: string): string;
+    /**
+     * Formats a compiler message, without coloring; an ANSI color version is
+     * implemented in NodeCompilerCallbacks.
+     * @param event event or array of events
+     */
+    static formatEvent(event: CompilerEvent | CompilerEvent[]): string;
+    /**
+     * @param e Error-like
+     */
+    static exceptionToString(e?: any): string;
+    /**
+     * Returns the corresponding error severity value from a partial name match,
+     * e.g. 'inf' returns CompilerErrorSeverity.Info, or returns null if not found
+     * @param name
+     * @returns
+     */
+    static severityNameToValue(name: string): CompilerErrorSeverity;
+}
+/** @deprecated use `CompilerError.severity` instead */
+export declare function compilerErrorSeverity(code: number): CompilerErrorSeverity;
+/** @deprecated use `CompilerError.formatSeverity` instead */
+export declare function compilerErrorSeverityName(code: number): string;
+/** @deprecated use `CompilerError.formatCode` instead */
+export declare function compilerErrorFormatCode(code: number): string;
+/** @deprecated use `CompilerError.formatEvent` instead */
+export declare function compilerEventFormat(e: CompilerEvent | CompilerEvent[]): string;
+/**
+ * Defines the error code ranges for various compilers. Once defined, these
+ * ranges must not be changed as external modules may depend on specific error
+ * codes. Individual errors are defined at a compiler level, for example,
+ * kmc-ldml/src/compiler/messages.ts.
+ *
+ * kmc defines a mapping between each namespace and the corresponding compiler's
+ * error reporting class in kmc/src/messages/messageNamespaces.ts
+ */
+export declare enum CompilerErrorNamespace {
+    /**
+     * kmc-ldml errors between 0x0000…0x0FFF
+     */
+    LdmlKeyboardCompiler = 0,
+    /**
+     * common/web/types errors between 0x1000…0x1FFF
+     */
+    CommonTypes = 4096,
+    /**
+     * kmc-kmn errors between 0x2000…0x2FFF; these map to
+     * the base codes found in kmn_compiler_errors.h, exclusive severity flags
+     */
+    KmnCompiler = 8192,
+    /**
+     * kmc-model errors between 0x3000…0x3FFF
+     */
+    ModelCompiler = 12288,
+    /**
+     * kmc-package errors between 0x4000…0x4FFF
+     */
+    PackageCompiler = 16384,
+    /**
+     * kmc and related infrastructure errors between 0x5000…0x5FFF
+     */
+    Infrastructure = 20480,
+    /**
+     * kmc-analyze 0x6000…0x6FFF
+     */
+    Analyzer = 24576,
+    /**
+     * kmc-kmn/kmw-compiler errors between 0x7000…0x7FFF; note that some errors
+     * generated by kmc-kmn/kmw-compiler are from kmc-kmn namespace for legacy
+     * reasons
+     */
+    KmwCompiler = 28672,
+    /**
+     * kmc-model-info 0x8000…0x8FFF
+     */
+    ModelInfoCompiler = 32768,
+    /**
+     * kmc-keyboard-info 0x9000…0x9FFF
+     */
+    KeyboardInfoCompiler = 36864
+}
+/**
+ * A mapping for common path operations, maps to Node path module. This only
+ * defines the functions we are actually using, so that we can port more easily
+ * between different systems.
+ */
+export interface CompilerPathCallbacks {
+    dirname(name: string): string;
+    extname(name: string): string;
+    basename(name: string, ext?: string): string;
+    isAbsolute(name: string): boolean;
+    join(...paths: string[]): string;
+    normalize(p: string): string;
+}
+/**
+ * A mapping for common filesystem operations, maps to Node fs module. This only
+ * defines the functions we are actually using, so that we can port more easily
+ * between different systems.
+ */
+export interface CompilerFileSystemCallbacks {
+    readdirSync(name: string): string[];
+    readFileSync(path: string, options?: {
+        encoding?: null;
+        flag?: string;
+    } | null): Uint8Array;
+    readFileSync(path: string, options: {
+        encoding: string;
+        flag?: string;
+    } | string): string;
+    readFileSync(path: string, options?: {
+        encoding?: string | null;
+        flag?: string;
+    } | string | null): string | Uint8Array;
+    writeFileSync(path: string, data: Uint8Array): void;
+    existsSync(name: string): boolean;
+}
+type CompilerErrorSeverityOverride = CompilerErrorSeverity | 'disable';
+export interface CompilerMessageOverrideMap {
+    [code: number]: CompilerErrorSeverityOverride;
+}
+export interface CompilerMessageOverride {
+    code: number;
+    level: CompilerErrorSeverityOverride;
+}
+export interface CompilerCallbackOptions {
+    logLevel?: CompilerLogLevel;
+    logFormat?: CompilerLogFormat;
+    color?: boolean;
+    compilerWarningsAsErrors?: boolean;
+    messageOverrides?: CompilerMessageOverrideMap;
+}
+export interface KeymanCompilerArtifact {
+    data: Uint8Array;
+    filename: string;
+}
+export type KeymanCompilerArtifactOptional = KeymanCompilerArtifact | undefined;
+export interface KeymanCompilerArtifacts {
+    readonly [type: string]: KeymanCompilerArtifactOptional;
+}
+export interface KeymanCompilerResult {
+    artifacts: KeymanCompilerArtifacts;
+}
+export interface KeymanCompiler {
+    init(callbacks: CompilerCallbacks, options: CompilerOptions): Promise<boolean>;
+    /**
+     * Run the compiler, and save the result in memory arrays. Note that while
+     * `outputFilename` is provided here, the output file is not written to in
+     * this function.
+     * @param inputFilename
+     * @param outputFilename The intended output filename, optional, if missing,
+     *                       calculated from inputFilename
+     * @param data
+     */
+    run(inputFilename: string, outputFilename?: string): Promise<KeymanCompilerResult>;
+    /**
+     * Writes the compiled output files to disk
+     * @param artifacts
+     */
+    write(artifacts: KeymanCompilerArtifacts): Promise<boolean>;
+}
+/**
+ * Abstract interface for callbacks, to abstract out file i/o
+ */
+export interface CompilerCallbacks {
+    /**
+     * Attempt to load a file. Return falsy if not found.
+     * TODO: never return falsy, just throw if not found?
+     * @param filename
+     */
+    loadFile(filename: string): Uint8Array;
+    /**
+     * Get file size, returns undefined if not found
+     */
+    fileSize(filename: string): number;
+    get path(): CompilerPathCallbacks;
+    get fs(): CompilerFileSystemCallbacks;
+    /**
+     * Resolves a file path relative to the baseFilename
+     * @param baseFilename
+     * @param filename
+     */
+    resolveFilename(baseFilename: string, filename: string): string;
+    reportMessage(event: CompilerEvent): void;
+    debug(msg: string): void;
+}
+/**
+ * Wrapper class for CompilerCallbacks for a given input file
+ */
+export declare class CompilerFileCallbacks implements CompilerCallbacks {
+    private filename;
+    private options;
+    private parent;
+    messages: CompilerEvent[];
+    constructor(filename: string, options: CompilerCallbackOptions, parent: CompilerCallbacks);
+    /**
+     * Returns `true` if any message in the `messages` array is a Fatal or Error
+     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
+     * `true` if any message is a Warning.
+     */
+    static hasFailureMessage(messages: CompilerEvent[], compilerWarningsAsErrors: boolean): boolean;
+    /**
+     *
+     * @param event
+     * @param overrides
+     * @returns true if event has been suppressed
+     */
+    static applyMessageOverridesToEvent(event: CompilerEvent, overrides: CompilerMessageOverrideMap): boolean;
+    /**
+     * Returns `true` if any message in the `messages` array is a Fatal or Error
+     * message, and if `compilerWarningsAsErrors` is `true`, then also returns
+     * `true` if any message is a Warning.
+     *
+     * If passed a defined `compilerWarningsAsErrors` value, then uses that,
+     * otherwise uses `options.compilerWarningsAsErrors`, or `false` if that is
+     * also `undefined`.
+     */
+    hasFailureMessage(compilerWarningsAsErrors?: boolean): boolean;
+    clear(): void;
+    loadFile(filename: string): Uint8Array;
+    fileSize(filename: string): number;
+    get path(): CompilerPathCallbacks;
+    get fs(): CompilerFileSystemCallbacks;
+    resolveFilename(baseFilename: string, filename: string): string;
+    reportMessage(event: CompilerEvent): void;
+    debug(msg: string): void;
+}
+/**
+ * Abstract interface for compiler options
+ */
+export interface CompilerBaseOptions {
+    /**
+     * Reporting level to console, used by NodeCompilerCallbacks (not used in compiler modules;
+     * all messages are still reported to the internal log)
+     */
+    logLevel?: CompilerLogLevel;
+    /**
+     * Format of output for log to console
+     */
+    logFormat?: CompilerLogFormat;
+    /**
+     * Colorize log output, default is detected from console
+     */
+    color?: boolean;
+}
+export interface CompilerOptions extends CompilerBaseOptions {
+    /**
+     * Add metadata about the compiler version to .kmx file when compiling
+     */
+    shouldAddCompilerVersion?: boolean;
+    /**
+     * Add debug information to the .kmx file when compiling
+     */
+    saveDebug?: boolean;
+    /**
+     * Upgrade any warnings produced in the compile to errors
+     */
+    compilerWarningsAsErrors?: boolean;
+    /**
+     * Emit warnings if deprecated code is encountered
+     */
+    warnDeprecatedCode?: boolean;
+    /**
+     * Check filename conventions in packages
+     */
+    checkFilenameConventions?: boolean;
+}
+export declare const defaultCompilerOptions: CompilerOptions;
+/**
+ * Convenience function for constructing CompilerEvents
+ * @param code
+ * @param message
+ * @returns
+ */
+export declare const CompilerMessageSpec: (code: number, message: string, exceptionVar?: any) => CompilerEvent;
+/**
+ * @deprecated use `CompilerError.exceptionToString` instead
+ */
+export declare function compilerExceptionToString(e?: any): string;
+/**
+ * Compiler logging level and correspondence to severity
+ */
+export declare const ALL_COMPILER_LOG_LEVELS: readonly ["silent", "error", "warn", "hint", "info", "debug"];
+type CompilerLogLevelTuple = typeof ALL_COMPILER_LOG_LEVELS;
+export type CompilerLogLevel = CompilerLogLevelTuple[number];
+export declare const compilerLogLevelToSeverity: {
+    [index in CompilerLogLevel]: number;
+};
+export declare const ALL_COMPILER_LOG_FORMATS: readonly ["tsv", "formatted"];
+type CompilerLogFormatTuple = typeof ALL_COMPILER_LOG_FORMATS;
+export type CompilerLogFormat = CompilerLogFormatTuple[number];
+export {};
+//# sourceMappingURL=compiler-interfaces.d.ts.map