import * as magic_string0 from "magic-string";
import { Logger } from "vite";

//#region src/core/types/comment.d.ts
interface Comment {
  type: string;
  start: string;
  end: string;
  regex: RegExp;
}
//#endregion
//#region src/core/context/generator/generator.d.ts
type UnhandledPolicy = 'throw' | 'keep' | 'remove';
interface GeneratorOptions {
  unhandled?: UnhandledPolicy;
}
/**
 * 生成器基类
 * 提供通用的 AST 遍历和节点处理逻辑
 */
declare abstract class Generator {
  readonly node: SimpleNode;
  readonly generates: (Generate | undefined)[];
  protected readonly options: GeneratorOptions;
  constructor(node: SimpleNode, generates?: (Generate | undefined)[], options?: GeneratorOptions);
  /**
   * 遍历 AST 节点
   */
  walk(node: SimpleNode): void;
  /**
   * 处理 CodeStatement 节点
   * 子类需要实现此方法
   */
  protected abstract handleCodeStatement(node: SimpleNode): void;
  /**
   * 处理自定义生成器的结果
   * 子类需要实现此方法
   */
  protected abstract handleGeneratorResult(node: SimpleNode, result: string): void;
  /**
   * 使用自定义生成器处理节点
   * 生成器返回值约定：
   * - string: 处理该节点
   * - null: 已手动处理
   * - undefined: 不处理，交给下一个生成器
   */
  private processWithCustomGenerators;
  /**
   * 处理未被任何生成器处理的节点
   */
  protected handleUnprocessedNode(node: SimpleNode): void;
  /**
   * 保留节点（用于 unhandled: 'keep' 策略）
   * 子类需要实现此方法
   */
  protected abstract handleKeepNode(node: SimpleNode): void;
}
//#endregion
//#region src/core/context/lexer.d.ts
declare class Lexer {
  code: string;
  lexers: Lex[];
  current: number;
  tokens: SimpleToken[];
  constructor(code: string, lexers?: Lex[]);
  private lex;
  static lex(code: string, lexers?: Lex[]): SimpleToken[];
}
//#endregion
//#region src/core/context/parser.d.ts
declare class Parser {
  tokens: SimpleToken[];
  parsers: Parse[];
  ast: ProgramNode;
  current: number;
  constructor(tokens: SimpleToken[], parsers?: Parse[]);
  walk(): CodeStatement | {
    comment: string;
    type: string;
    start: number;
    end: number;
  };
  private parse;
  static parse(tokens: SimpleToken[], parsers?: Parse[]): ProgramNode;
}
//#endregion
//#region src/core/context/index.d.ts
declare function resolveOptions(options?: UserOptions): Required<UserOptions>;
declare function sortUserDirectives(directives: ObjectDirective[]): [ObjectDirective[], ObjectDirective[], ObjectDirective[]];
declare class Context {
  options: Required<UserOptions>;
  directives: ObjectDirective[];
  lexers: Lex[];
  parsers: Parse[];
  transforms: Transform[];
  generates: (Generate | undefined)[];
  filter: (id: string) => boolean;
  env: Record<string, any>;
  logger: Logger;
  constructor(options?: UserOptions);
  loadEnv(mode?: string): Record<string, string>;
  private _transform;
  transform(code: string, id: string): string | undefined;
  transformWithMap(code: string, id: string): {
    map: magic_string0.SourceMap;
    code: string;
  } | undefined;
}
//#endregion
//#region src/core/context/transformer.d.ts
declare class Transformer {
  program: ProgramNode;
  transforms: Transform[];
  constructor(program: ProgramNode, transforms?: Transform[]);
  walk(node: SimpleNode): SimpleNode | void;
  private transform;
  static transform(program: ProgramNode, transforms?: Transform[]): void | SimpleNode;
}
//#endregion
//#region src/core/types/directive.d.ts
interface SimpleToken {
  comment?: string;
  type: string;
  value: string;
  start?: number;
  end?: number;
  [x: string]: any;
}
interface SimpleNode {
  comment?: string;
  type: string;
  start?: number;
  end?: number;
  [x: string]: any;
}
type Lex<T = SimpleToken> = (this: Lexer, currentLine: string) => (T | void);
type Parse<T = SimpleToken, N = SimpleNode> = (this: Parser, currentToken: T) => (N | void);
type Transform<N = SimpleNode, ResultN = SimpleNode> = (this: Transformer, currentNode: N) => (ResultN | void);
type Generate = (this: Generator, ast: SimpleNode, comment?: Comment) => (string | void);
/**
 * Represents an object-based directive configuration for preprocessing.
 *
 * @template T - The type of token produced by the lexer, defaults to SimpleToken
 * @template N - The type of AST node produced by the parser, defaults to SimpleNode
 *
 * @property {('pre' | 'post')} [enforce] - Optional enforcement phase for when the directive should be applied
 * @property {Lex<T>} lex - Lexical analyzer function that tokenizes the input
 * @property {Parse<T, N>} parse - Parser function that converts tokens into AST nodes
 * @property {Transform<N>} transform - Transformation function that modifies AST nodes
 * @property {Generate} generate - Code generation function that produces the final output
 */
interface ObjectDirective<T = SimpleToken, N = SimpleNode> {
  enforce?: 'pre' | 'post';
  lex: Lex<T>;
  parse: Parse<T, N>;
  transform: Transform<N>;
  generate?: Generate;
}
interface FunctionDirective<T = SimpleToken, N = SimpleNode> {
  (context: Context): ObjectDirective<T, N>;
}
type Directive<T = SimpleToken, N = SimpleNode> = ObjectDirective<T, N> | FunctionDirective<T, N>;
//#endregion
//#region src/core/types/node.d.ts
interface ProgramNode extends SimpleNode {
  type: 'Program';
  body: SimpleNode[];
}
interface CodeStatement extends SimpleNode {
  type: 'CodeStatement';
  value: string;
}
interface IfStatement extends SimpleNode {
  type: 'IfStatement';
  test: string;
  consequent: SimpleNode[];
  alternate: SimpleNode[];
  kind: IfToken['type'];
}
interface DefineStatement extends SimpleNode {
  type: 'DefineStatement';
  kind: 'define' | 'undef';
  value: string;
}
interface MessageStatement extends SimpleNode {
  type: 'MessageStatement';
  kind: 'error' | 'warning' | 'info';
  value: string;
}
interface IncludeStatement extends SimpleNode {
  type: 'IncludeStatement';
  value: string;
  sourceFile?: string;
}
//#endregion
//#region src/core/types/token.d.ts
interface CodeToken extends SimpleToken {
  type: 'code';
  value: string;
}
interface IfToken extends SimpleToken {
  type: 'if' | 'else' | 'elif' | 'endif';
  value: string;
}
interface DefineToken extends SimpleToken {
  type: 'define' | 'undef';
  value: string;
}
interface MessageToken extends SimpleToken {
  type: 'error' | 'warning' | 'info';
  value: string;
}
interface IncludeToken extends SimpleToken {
  type: 'include';
  value: string;
}
//#endregion
//#region src/types.d.ts
type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
interface Options {
  cwd: string;
  directives: Directive[];
  include: FilterPattern;
  exclude: FilterPattern;
}
interface UserOptions extends Partial<Options> {}
//#endregion
export { Comment as A, Context as C, Lexer as D, Parser as E, Generator as O, Transform as S, sortUserDirectives as T, Lex as _, IfToken as a, SimpleNode as b, CodeStatement as c, IncludeStatement as d, MessageStatement as f, Generate as g, FunctionDirective as h, DefineToken as i, GeneratorOptions as k, DefineStatement as l, Directive as m, UserOptions as n, IncludeToken as o, ProgramNode as p, CodeToken as r, MessageToken as s, Options as t, IfStatement as u, ObjectDirective as v, resolveOptions as w, SimpleToken as x, Parse as y };