//github.com/ <reference types="node" />

import { BaseError } from 'make-error';
import type * as _ts from 'typescript';

// @public
export function create(rawOptions?: CreateOptions): Service;

// Warning: (ae-forgotten-export) The symbol "createEsmHooks" needs to be exported by the entry point index.d.ts
//
// @public
export const createEsmHooks: typeof createEsmHooks_2;

// @public
export interface CreateOptions {
    compiler?: string;
    compilerHost?: boolean;
    compilerOptions?: object;
    cwd?: string;
    // @deprecated
    dir?: string;
    emit?: boolean;
    esm?: boolean;
    experimentalReplAwait?: boolean;
    experimentalSpecifierResolution?: 'node' | 'explicit';
    experimentalTsImportSpecifiers?: boolean;
    // (undocumented)
    fileExists?: (path: string) => boolean;
    files?: boolean;
    ignore?: string[];
    ignoreDiagnostics?: Array<number | string>;
    logError?: boolean;
    moduleTypes?: ModuleTypes;
    preferTsExts?: boolean;
    pretty?: boolean;
    project?: string;
    projectSearchDir?: string;
    // (undocumented)
    readFile?: (path: string) => string | undefined;
    require?: Array<string>;
    scope?: boolean;
    // (undocumented)
    scopeDir?: string;
    skipIgnore?: boolean;
    skipProject?: boolean;
    swc?: boolean;
    // (undocumented)
    transformers?: _ts.CustomTransformers | ((p: _ts.Program) => _ts.CustomTransformers);
    transpileOnly?: boolean;
    transpiler?: string | [string, object];
    tsTrace?: (str: string) => void;
    typeCheck?: boolean;
}

// @public
export function createRepl(options?: CreateReplOptions): ReplService;

// @public
export interface CreateReplOptions {
    // (undocumented)
    service?: Service;
    // Warning: (ae-forgotten-export) The symbol "EvalState" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    state?: EvalState;
    // (undocumented)
    stderr?: NodeJS.WritableStream;
    // (undocumented)
    stdin?: NodeJS.ReadableStream;
    // (undocumented)
    stdout?: NodeJS.WritableStream;
}

// @public
export interface CreateTranspilerOptions {
    // (undocumented)
    service: Pick<Service, Extract<'config' | 'options' | 'projectLocalResolveHelper', keyof Service>>;
}

// @public
export type EvalAwarePartialHost = Pick<CreateOptions, 'readFile' | 'fileExists'>;

// @public (undocumented)
export type ExperimentalSpecifierResolution = 'node' | 'explicit';

// @public (undocumented)
export type ModuleTypeOverride = 'cjs' | 'esm' | 'package';

// @public (undocumented)
export type ModuleTypes = Record<string, ModuleTypeOverride>;

// @public (undocumented)
export interface NodeLoaderHooksAPI1 {
    // (undocumented)
    getFormat: NodeLoaderHooksAPI1.GetFormatHook;
    // (undocumented)
    resolve: NodeLoaderHooksAPI1.ResolveHook;
    // (undocumented)
    transformSource: NodeLoaderHooksAPI1.TransformSourceHook;
}

// @public (undocumented)
export namespace NodeLoaderHooksAPI1 {
    // (undocumented)
    export type GetFormatHook = (url: string, context: {}, defaultGetFormat: GetFormatHook) => Promise<{
        format: NodeLoaderHooksFormat;
    }>;
    // (undocumented)
    export type ResolveHook = NodeLoaderHooksAPI2.ResolveHook;
    // (undocumented)
    export type TransformSourceHook = (source: string | Buffer, context: {
        url: string;
        format: NodeLoaderHooksFormat;
    }, defaultTransformSource: NodeLoaderHooksAPI1.TransformSourceHook) => Promise<{
        source: string | Buffer;
    }>;
}

// @public (undocumented)
export interface NodeLoaderHooksAPI2 {
    // (undocumented)
    load: NodeLoaderHooksAPI2.LoadHook;
    // (undocumented)
    resolve: NodeLoaderHooksAPI2.ResolveHook;
}

// @public (undocumented)
export namespace NodeLoaderHooksAPI2 {
    // (undocumented)
    export type LoadHook = (url: string, context: {
        format: NodeLoaderHooksFormat | null | undefined;
        importAssertions?: NodeImportAssertions;
    }, defaultLoad: NodeLoaderHooksAPI2['load']) => Promise<{
        format: NodeLoaderHooksFormat;
        source: string | Buffer | undefined;
        shortCircuit?: boolean;
    }>;
    // (undocumented)
    export interface NodeImportAssertions {
        // (undocumented)
        type?: 'json';
    }
    // (undocumented)
    export type NodeImportConditions = unknown;
    // (undocumented)
    export type ResolveHook = (specifier: string, context: {
        conditions?: NodeImportConditions;
        importAssertions?: NodeImportAssertions;
        parentURL: string;
    }, defaultResolve: ResolveHook) => Promise<{
        url: string;
        format?: NodeLoaderHooksFormat;
        shortCircuit?: boolean;
    }>;
}

// @public (undocumented)
export type NodeLoaderHooksFormat = 'builtin' | 'commonjs' | 'dynamic' | 'json' | 'module' | 'wasm';

// @public
export type NodeModuleEmitKind = 'nodeesm' | 'nodecjs';

// @public @deprecated
export type Register = Service;

// @public
export function register(opts?: RegisterOptions): Service;

// @public
export function register(service: Service): Service;

// @public
export const REGISTER_INSTANCE: unique symbol;

// @public
export interface RegisterOptions extends CreateOptions {
    experimentalResolver?: boolean;
}

// @public (undocumented)
export interface ReplService {
    // (undocumented)
    evalAwarePartialHost: EvalAwarePartialHost;
    evalCode(code: string): any;
    nodeEval(code: string, context: any, _filename: string, callback: (err: Error | null, result?: any) => any): void;
    setService(service: Service): void;
    start(): void;
    // @deprecated
    start(code: string): void;
    // (undocumented)
    readonly state: EvalState;
}

// @public
export interface Service {
    // (undocumented)
    compile(code: string, fileName: string, lineOffset?: number): string;
    // (undocumented)
    config: _ts.ParsedCommandLine;
    // (undocumented)
    enabled(enabled?: boolean): boolean;
    // (undocumented)
    getTypeInfo(code: string, fileName: string, position: number): TypeInfo;
    // (undocumented)
    ignored(fileName: string): boolean;
    // (undocumented)
    options: RegisterOptions;
    // (undocumented)
    ts: TSCommon;
}

// @public
export interface TranspileOptions {
    // (undocumented)
    fileName: string;
}

// @public
export interface TranspileOutput {
    // (undocumented)
    diagnostics?: _ts.Diagnostic[];
    // (undocumented)
    outputText: string;
    // (undocumented)
    sourceMapText?: string;
}

// @public
export interface Transpiler {
    // (undocumented)
    transpile(input: string, options: TranspileOptions): TranspileOutput;
}

// @public
export type TranspilerFactory = (options: CreateTranspilerOptions) => Transpiler;

// @public
export interface TranspilerModule {
    // (undocumented)
    create: TranspilerFactory;
}

// @public
export interface TSCommon {
    // (undocumented)
    createDocumentRegistry: typeof _ts.createDocumentRegistry;
    // (undocumented)
    createEmitAndSemanticDiagnosticsBuilderProgram: typeof _ts.createEmitAndSemanticDiagnosticsBuilderProgram;
    // (undocumented)
    createIncrementalCompilerHost: typeof _ts.createIncrementalCompilerHost;
    // (undocumented)
    createIncrementalProgram: typeof _ts.createIncrementalProgram;
    // (undocumented)
    createLanguageService: typeof _ts.createLanguageService;
    // (undocumented)
    createModuleResolutionCache: typeof _ts.createModuleResolutionCache;
    // (undocumented)
    createSourceFile: typeof _ts.createSourceFile;
    // (undocumented)
    displayPartsToString: typeof _ts.displayPartsToString;
    // (undocumented)
    Extension: typeof _ts.Extension;
    // (undocumented)
    findConfigFile: typeof _ts.findConfigFile;
    // (undocumented)
    flattenDiagnosticMessageText: typeof _ts.flattenDiagnosticMessageText;
    // (undocumented)
    formatDiagnostics: typeof _ts.formatDiagnostics;
    // (undocumented)
    formatDiagnosticsWithColorAndContext: typeof _ts.formatDiagnosticsWithColorAndContext;
    // (undocumented)
    getDefaultLibFileName: typeof _ts.getDefaultLibFileName;
    // (undocumented)
    getDefaultLibFilePath: typeof _ts.getDefaultLibFilePath;
    // (undocumented)
    getPreEmitDiagnostics: typeof _ts.getPreEmitDiagnostics;
    // (undocumented)
    JsxEmit: typeof _ts.JsxEmit;
    // (undocumented)
    ModuleKind: TSCommon.ModuleKindEnum;
    // (undocumented)
    ModuleResolutionKind: typeof _ts.ModuleResolutionKind;
    // (undocumented)
    parseJsonConfigFileContent: typeof _ts.parseJsonConfigFileContent;
    // (undocumented)
    readConfigFile: typeof _ts.readConfigFile;
    // (undocumented)
    resolveModuleName: typeof _ts.resolveModuleName;
    // (undocumented)
    resolveModuleNameFromCache: typeof _ts.resolveModuleNameFromCache;
    // (undocumented)
    resolveTypeReferenceDirective: typeof _ts.resolveTypeReferenceDirective;
    // (undocumented)
    ScriptSnapshot: typeof _ts.ScriptSnapshot;
    // (undocumented)
    ScriptTarget: typeof _ts.ScriptTarget;
    // (undocumented)
    sys: typeof _ts.sys;
    // (undocumented)
    transpileModule: typeof _ts.transpileModule;
    // (undocumented)
    version: typeof _ts.version;
}

// @public (undocumented)
export namespace TSCommon {
    // (undocumented)
    export type CompilerOptions = _ts.CompilerOptions;
    // (undocumented)
    export type FileReference = _ts.FileReference;
    // (undocumented)
    export interface LanguageServiceHost extends _ts.LanguageServiceHost {
    }
    // (undocumented)
    export namespace ModuleKind {
        // (undocumented)
        export type CommonJS = _ts.ModuleKind.CommonJS;
        // (undocumented)
        export type ESNext = _ts.ModuleKind.ESNext;
    }
    // (undocumented)
    export type ModuleKindEnum = typeof _ts.ModuleKind & {
        Node16: typeof _ts.ModuleKind extends {
            Node16: any;
        } ? typeof _ts.ModuleKind['Node16'] : 100;
    };
    // (undocumented)
    export type ModuleResolutionHost = _ts.ModuleResolutionHost;
    // (undocumented)
    export type ParsedCommandLine = _ts.ParsedCommandLine;
    // (undocumented)
    export type ResolvedModule = _ts.ResolvedModule;
    // (undocumented)
    export type ResolvedModuleWithFailedLookupLocations = _ts.ResolvedModuleWithFailedLookupLocations;
    // (undocumented)
    export type ResolvedProjectReference = _ts.ResolvedProjectReference;
    // (undocumented)
    export type ResolvedTypeReferenceDirective = _ts.ResolvedTypeReferenceDirective;
    // (undocumented)
    export type SourceFile = _ts.SourceFile;
}

// @public
export interface TsConfigOptions extends Omit<RegisterOptions, 'transformers' | 'readFile' | 'fileExists' | 'skipProject' | 'project' | 'dir' | 'cwd' | 'projectSearchDir' | 'optionBasePaths' | 'tsTrace'> {
}

// @public
export class TSError extends BaseError {
    constructor(diagnosticText: string, diagnosticCodes: number[], diagnostics?: ReadonlyArray<_ts.Diagnostic>);
    // (undocumented)
    diagnosticCodes: number[];
    // (undocumented)
    diagnostics: ReadonlyArray<_ts.Diagnostic>;
    // (undocumented)
    diagnosticText: string;
    // (undocumented)
    name: string;
}

// @public
export interface TypeInfo {
    // (undocumented)
    comment: string;
    // (undocumented)
    name: string;
}

// @public
export const VERSION: any;

// (No @packageDocumentation comment for this package)