import { C as BuilderOptions, D as builderErrors, E as BuilderResult, O as GraphqlSystemIdentifyHelper, S as BuilderMode, T as BuilderErrorCode, _ as ModuleAnalysis, a as BuilderArtifactElement, b as BuilderFormat, c as BuilderArtifactMeta, d as __clearGqlCache, f as IntermediateArtifactElement, g as DiagnosticSeverity, h as DiagnosticLocation, i as BuilderArtifact, k as createGraphqlSystemIdentifyHelper, l as BuilderArtifactOperation, m as DiagnosticCode, n as BuilderServiceConfig, o as BuilderArtifactElementMetadata, p as createAstAnalyzer, r as createBuilderService, s as BuilderArtifactFragment, t as BuilderService, u as IntermediateElements, v as ModuleDiagnostic, w as BuilderError, x as BuilderInput, y as BuilderAnalyzer } from "./service-LY6CaxEG.cjs";
import * as neverthrow0 from "neverthrow";
import { Result } from "neverthrow";
import * as _soda_gql_common0 from "@soda-gql/common";
import { AliasResolver, CanonicalId, Effect, EffectGenerator } from "@soda-gql/common";
import { ResolvedSodaGqlConfig } from "@soda-gql/config";
import { AnyFieldsExtended, AnyFragment, AnyGqlDefine, AnyGraphqlSchema, AnyOperation, VariableDefinitions } from "@soda-gql/core";
import { VariableDefinitionNode } from "graphql";
import { ZodSchema, z } from "zod";

//#region packages/builder/src/artifact/loader.d.ts
/**
 * Error codes for artifact loading failures.
 */
type ArtifactLoadErrorCode = "ARTIFACT_NOT_FOUND" | "ARTIFACT_PARSE_ERROR" | "ARTIFACT_VALIDATION_ERROR";
/**
 * Error type for artifact loading operations.
 */
type ArtifactLoadError = {
  readonly code: ArtifactLoadErrorCode;
  readonly message: string;
  readonly filePath?: string;
};
/**
 * Load a pre-built artifact from a JSON file asynchronously.
 *
 * @param path - Absolute path to the artifact JSON file
 * @returns Result with the parsed artifact or an error
 *
 * @example
 * ```ts
 * const result = await loadArtifact("/path/to/artifact.json");
 * if (result.isOk()) {
 *   const artifact = result.value;
 *   // Use artifact...
 * }
 * ```
 */
declare const loadArtifact: (path: string) => Promise<Result<BuilderArtifact, ArtifactLoadError>>;
/**
 * Load a pre-built artifact from a JSON file synchronously.
 *
 * @param path - Absolute path to the artifact JSON file
 * @returns Result with the parsed artifact or an error
 *
 * @example
 * ```ts
 * const result = loadArtifactSync("/path/to/artifact.json");
 * if (result.isOk()) {
 *   const artifact = result.value;
 *   // Use artifact...
 * }
 * ```
 */
declare const loadArtifactSync: (path: string) => Result<BuilderArtifact, ArtifactLoadError>;
//#endregion
//#region packages/builder/src/ast/common/detection.d.ts
/**
 * Configuration for creating a diagnostic
 */
type DiagnosticConfig = {
  readonly code: DiagnosticCode;
  readonly message: string;
  readonly location: DiagnosticLocation;
  readonly context?: Readonly<Record<string, string>>;
};
/**
 * Create a diagnostic with appropriate severity
 */
declare const createDiagnostic: (config: DiagnosticConfig) => ModuleDiagnostic;
/**
 * Get severity for a diagnostic code.
 * - "error": Code will definitely not work
 * - "warning": Code might work but is unsupported/unreliable
 */
declare const getSeverity: (code: DiagnosticCode) => DiagnosticSeverity;
type MessageContext = Readonly<Record<string, string>>;
/**
 * Diagnostic message templates for each code
 */
declare const diagnosticMessages: Record<DiagnosticCode, (ctx?: MessageContext) => string>;
/**
 * Create a diagnostic with a standard message
 */
declare const createStandardDiagnostic: (code: DiagnosticCode, location: DiagnosticLocation, context?: MessageContext) => ModuleDiagnostic;
//#endregion
//#region packages/builder/src/discovery/entry-paths.d.ts
/**
 * Resolve entry file paths from glob patterns or direct paths.
 * Used by the discovery system to find entry points for module traversal.
 * All paths are normalized to POSIX format for consistent cache key matching.
 * Uses Node.js normalize() + backslash replacement to match normalizePath from @soda-gql/common.
 *
 * @param entries - Include patterns (glob or direct paths). Supports negation patterns (e.g., "!./path/to/exclude.ts")
 * @param exclude - Exclude patterns from config.exclude. Converted to negation globs for filtering.
 */
declare const resolveEntryPaths: (entries: readonly string[], exclude?: readonly string[]) => neverthrow0.Err<readonly string[], BuilderError> | neverthrow0.Ok<readonly string[], BuilderError>;
//#endregion
//#region packages/builder/src/discovery/fingerprint.d.ts
/**
 * File fingerprint containing hash, size, and modification time
 */
type FileFingerprint = {
  /** xxHash hash of file contents */
  hash: string;
  /** File size in bytes */
  sizeBytes: number;
  /** Last modification time in milliseconds since epoch */
  mtimeMs: number;
};
/**
 * Fingerprint computation error types
 */
type FingerprintError = {
  code: "FILE_NOT_FOUND";
  path: string;
  message: string;
} | {
  code: "NOT_A_FILE";
  path: string;
  message: string;
} | {
  code: "READ_ERROR";
  path: string;
  message: string;
};
/**
 * Compute file fingerprint with memoization.
 * Uses mtime to short-circuit re-hashing unchanged files.
 *
 * @param path - Absolute path to file
 * @returns Result containing FileFingerprint or FingerprintError
 */
declare function computeFingerprint(path: string): Result<FileFingerprint, FingerprintError>;
/**
 * Compute fingerprint from pre-read file content and stats.
 * This is used by the generator-based discoverer which already has the content.
 *
 * @param path - Absolute path to file (for caching)
 * @param stats - File stats (mtimeMs, size)
 * @param content - File content as string
 * @returns FileFingerprint
 */
declare function computeFingerprintFromContent(path: string, stats: {
  readonly mtimeMs: number;
  readonly size: number;
}, content: string): FileFingerprint;
/**
 * Invalidate cached fingerprint for a specific path
 *
 * @param path - Absolute path to invalidate
 */
declare function invalidateFingerprint(path: string): void;
/**
 * Clear all cached fingerprints
 */
declare function clearFingerprintCache(): void;
//#endregion
//#region packages/builder/src/discovery/types.d.ts
/**
 * Result of resolving a single import specifier encountered during discovery.
 */
type DiscoveredDependency = {
  /** Module specifier exactly as it appeared in source. */
  readonly specifier: string;
  /** Absolute, normalized path when the specifier points to a local file; null for bare package imports. */
  readonly resolvedPath: string | null;
  /** True when the specifier targets an external package (i.e. no local snapshot will exist). */
  readonly isExternal: boolean;
};
/**
 * Immutable cacheable record produced by the discovery phase for a single source file.
 * Captures analyzer output, dependency fan-out, and bookkeeping metadata.
 */
type DiscoverySnapshot = {
  /** Absolute path to the analyzed file (preserves original casing). */
  readonly filePath: string;
  /** Normalized path (POSIX separators) used as a stable cache key. */
  readonly normalizedFilePath: string;
  /** Signature of the source contents used to validate cache entries. */
  readonly signature: string;
  /** File fingerprint for fast cache invalidation. */
  readonly fingerprint: FileFingerprint;
  /** Analyzer type identifier for cache versioning. */
  readonly analyzer: string;
  /** Milliseconds since epoch when this snapshot was created. */
  readonly createdAtMs: number;
  /** Raw analyzer output (imports, exports, definitions, diagnostics). */
  readonly analysis: ModuleAnalysis;
  /** Resolved graph edges for relative imports encountered in the file. */
  readonly dependencies: readonly DiscoveredDependency[];
};
/**
 * Cache abstraction for storing and retrieving discovery snapshots.
 * Implementations can back onto disk, memory, or remote stores.
 */
interface DiscoveryCache {
  /**
   * Look up a snapshot by file path and signature.
   * Returns null when the cache entry is missing or stale.
   */
  load(filePath: string, signature: string): DiscoverySnapshot | null;
  /**
   * Peek at cached snapshot without signature validation.
   * Used for fingerprint-based cache invalidation.
   * Returns null when the cache entry is missing.
   */
  peek(filePath: string): DiscoverySnapshot | null;
  /**
   * Persist the provided snapshot.
   */
  store(snapshot: DiscoverySnapshot): void;
  /**
   * Remove a snapshot when a file is deleted or invalidated.
   */
  delete(filePath: string): void;
  /**
   * Enumerate all cached snapshots (used to seed incremental builds).
   */
  entries(): IterableIterator<DiscoverySnapshot>;
  /**
   * Drop every cached entry (useful when analyzer versions change).
   */
  clear(): void;
  /**
   * Total number of entries currently stored.
   */
  size(): number;
}
type ModuleLoadStats = {
  readonly hits: number;
  readonly misses: number;
  readonly skips: number;
};
//#endregion
//#region packages/builder/src/errors/formatter.d.ts
/**
 * Formatted error with structured information for display.
 */
type FormattedError = {
  readonly code: BuilderErrorCode;
  readonly message: string;
  readonly location?: {
    readonly modulePath: string;
    readonly astPath?: string;
  };
  readonly hint?: string;
  readonly relatedFiles?: readonly string[];
  readonly cause?: unknown;
};
/**
 * Format a BuilderError into a structured FormattedError object.
 */
declare const formatBuilderErrorStructured: (error: BuilderError) => FormattedError;
/**
 * Format a BuilderError for CLI/stderr output with human-readable formatting.
 * Includes location, hint, and related files when available.
 */
declare const formatBuilderErrorForCLI: (error: BuilderError) => string;
//#endregion
//#region packages/builder/src/prebuilt/extractor.d.ts
/**
 * Field selection data for a single element.
 */
type FieldSelectionData = {
  readonly type: "fragment";
  readonly schemaLabel: string;
  readonly key: string | undefined;
  readonly typename: string;
  readonly fields: AnyFieldsExtended;
  readonly variableDefinitions: VariableDefinitions;
} | {
  readonly type: "operation";
  readonly schemaLabel: string;
  readonly operationName: string;
  readonly operationType: string;
  readonly fields: AnyFieldsExtended;
  readonly variableDefinitions: readonly VariableDefinitionNode[];
};
/**
 * Map of canonical IDs to their field selection data.
 */
type FieldSelectionsMap = ReadonlyMap<CanonicalId, FieldSelectionData>;
/**
 * Result of field selection extraction including any warnings.
 */
type FieldSelectionsResult = {
  readonly selections: FieldSelectionsMap;
  readonly warnings: readonly string[];
};
/**
 * Extract field selections from evaluated intermediate elements.
 *
 * For fragments, calls `spread()` with empty/default variables to get field selections.
 * For operations, calls `documentSource()` to get field selections.
 *
 * @param elements - Record of canonical ID to intermediate artifact element
 * @returns Object containing selections map and any warnings encountered
 */
declare const extractFieldSelections: (elements: Record<CanonicalId, IntermediateArtifactElement>) => FieldSelectionsResult;
//#endregion
//#region packages/builder/src/scheduler/effects.d.ts
type AcceptableArtifact = AnyFragment | AnyOperation | AnyGqlDefine;
/**
 * File stats result type.
 */
type FileStats = {
  readonly mtimeMs: number;
  readonly size: number;
  readonly isFile: boolean;
};
/**
 * File read effect - reads a file from the filesystem.
 * Works in both sync and async schedulers.
 *
 * @example
 * const content = yield* new FileReadEffect("/path/to/file").run();
 */
declare class FileReadEffect extends Effect<string> {
  readonly path: string;
  constructor(path: string);
  protected _executeSync(): string;
  protected _executeAsync(): Promise<string>;
}
/**
 * File stat effect - gets file stats from the filesystem.
 * Works in both sync and async schedulers.
 *
 * @example
 * const stats = yield* new FileStatEffect("/path/to/file").run();
 */
declare class FileStatEffect extends Effect<FileStats> {
  readonly path: string;
  constructor(path: string);
  protected _executeSync(): FileStats;
  protected _executeAsync(): Promise<FileStats>;
}
/**
 * File read effect that returns null if file doesn't exist.
 * Useful for discovery where missing files are expected.
 */
declare class OptionalFileReadEffect extends Effect<string | null> {
  readonly path: string;
  constructor(path: string);
  protected _executeSync(): string | null;
  protected _executeAsync(): Promise<string | null>;
}
/**
 * File stat effect that returns null if file doesn't exist.
 * Useful for discovery where missing files are expected.
 */
declare class OptionalFileStatEffect extends Effect<FileStats | null> {
  readonly path: string;
  constructor(path: string);
  protected _executeSync(): FileStats | null;
  protected _executeAsync(): Promise<FileStats | null>;
}
/**
 * Element evaluation effect - evaluates a GqlElement using its generator.
 * Supports both sync and async schedulers, enabling parallel element evaluation
 * when using async scheduler.
 *
 * Wraps errors with module context for better debugging.
 *
 * @example
 * yield* new ElementEvaluationEffect(element).run();
 */
declare class ElementEvaluationEffect extends Effect<void> {
  readonly element: AcceptableArtifact;
  constructor(element: AcceptableArtifact);
  /**
   * Wrap an error with element context for better debugging.
   */
  private wrapError;
  protected _executeSync(): void;
  protected _executeAsync(): Promise<void>;
}
/**
 * Builder effect constructors.
 * Extends the base Effects with file I/O operations and element evaluation.
 */
declare const BuilderEffects: {
  /**
   * Create a file read effect.
   * @param path - The file path to read
   */
  readonly readFile: (path: string) => FileReadEffect;
  /**
   * Create a file stat effect.
   * @param path - The file path to stat
   */
  readonly stat: (path: string) => FileStatEffect;
  /**
   * Create an optional file read effect that returns null if file doesn't exist.
   * @param path - The file path to read
   */
  readonly readFileOptional: (path: string) => OptionalFileReadEffect;
  /**
   * Create an optional file stat effect that returns null if file doesn't exist.
   * @param path - The file path to stat
   */
  readonly statOptional: (path: string) => OptionalFileStatEffect;
  /**
   * Create an element evaluation effect.
   * @param element - The GqlElement to evaluate
   */
  readonly evaluateElement: (element: AcceptableArtifact) => ElementEvaluationEffect;
  readonly pure: <T>(value: T) => _soda_gql_common0.PureEffect<T>;
  readonly defer: <T>(promise: Promise<T>) => _soda_gql_common0.DeferEffect<T>;
  readonly parallel: (effects: readonly Effect<unknown>[]) => _soda_gql_common0.ParallelEffect;
  readonly yield: () => _soda_gql_common0.YieldEffect;
};
//#endregion
//#region packages/builder/src/schema-loader.d.ts
/**
 * Result of loading schemas from a CJS bundle.
 */
type LoadSchemasResult = Result<Record<string, AnyGraphqlSchema>, BuilderError>;
/**
 * Load AnyGraphqlSchema from a generated CJS bundle.
 *
 * The generated CJS bundle exports a `gql` object where each property
 * is a GQL element composer with a `$schema` property containing the
 * schema definition. This function executes the bundle in a VM context
 * and extracts those schemas.
 *
 * @param cjsPath - Absolute path to the CJS bundle file
 * @param schemaNames - Names of schemas to load (e.g., ["default", "admin"])
 * @returns Record mapping schema names to AnyGraphqlSchema objects
 *
 * @example
 * ```typescript
 * const result = loadSchemasFromBundle(
 *   "/path/to/generated/index.cjs",
 *   ["default"]
 * );
 *
 * if (result.isOk()) {
 *   const schemas = result.value;
 *   console.log(schemas.default); // AnyGraphqlSchema
 * }
 * ```
 */
declare const loadSchemasFromBundle: (cjsPath: string, schemaNames: readonly string[]) => LoadSchemasResult;
/**
 * Load AnyGraphqlSchema from a generated CJS bundle using `__fullSchema_*` exports.
 *
 * Unlike `loadSchemasFromBundle` which reads schemas from `gql.$schema`,
 * this function reads the `__fullSchema_*` named exports directly.
 * These contain the full AnyGraphqlSchema with complete scalar/enum/input
 * definitions needed for type generation.
 *
 * @param cjsPath - Absolute path to the CJS bundle file
 * @param schemaNames - Names of schemas to load (e.g., ["default", "admin"])
 * @returns Record mapping schema names to AnyGraphqlSchema objects
 *
 * @example
 * ```typescript
 * const result = loadFullSchemasFromBundle(
 *   "/path/to/generated/index.cjs",
 *   ["default"]
 * );
 *
 * if (result.isOk()) {
 *   const schemas = result.value;
 *   console.log(schemas.default); // AnyGraphqlSchema
 * }
 * ```
 */
declare const loadFullSchemasFromBundle: (cjsPath: string, schemaNames: readonly string[]) => LoadSchemasResult;
//#endregion
//#region packages/builder/src/schemas/artifact.d.ts
declare const BuilderArtifactElementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
  id: z.core.$ZodType<CanonicalId, CanonicalId, z.core.$ZodTypeInternals<CanonicalId, CanonicalId>>;
  type: z.ZodLiteral<"operation">;
  metadata: z.ZodObject<{
    sourcePath: z.ZodString;
    contentHash: z.ZodString;
  }, z.core.$strip>;
  prebuild: z.ZodObject<{
    operationType: z.ZodEnum<{
      query: "query";
      mutation: "mutation";
      subscription: "subscription";
    }>;
    operationName: z.ZodString;
    schemaLabel: z.ZodString;
    document: z.ZodUnknown;
    variableNames: z.ZodArray<z.ZodString>;
    metadata: z.ZodOptional<z.ZodUnknown>;
  }, z.core.$strip>;
}, z.core.$strip>, z.ZodObject<{
  id: z.core.$ZodType<CanonicalId, CanonicalId, z.core.$ZodTypeInternals<CanonicalId, CanonicalId>>;
  type: z.ZodLiteral<"fragment">;
  metadata: z.ZodObject<{
    sourcePath: z.ZodString;
    contentHash: z.ZodString;
  }, z.core.$strip>;
  prebuild: z.ZodObject<{
    typename: z.ZodString;
    key: z.ZodOptional<z.ZodString>;
    schemaLabel: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>], "type">;
declare const BuilderArtifactSchema: z.ZodObject<{
  meta: z.ZodOptional<z.ZodObject<{
    version: z.ZodString;
    createdAt: z.ZodString;
  }, z.core.$strip>>;
  elements: z.ZodRecord<z.core.$ZodType<CanonicalId, CanonicalId, z.core.$ZodTypeInternals<CanonicalId, CanonicalId>>, z.ZodDiscriminatedUnion<[z.ZodObject<{
    id: z.core.$ZodType<CanonicalId, CanonicalId, z.core.$ZodTypeInternals<CanonicalId, CanonicalId>>;
    type: z.ZodLiteral<"operation">;
    metadata: z.ZodObject<{
      sourcePath: z.ZodString;
      contentHash: z.ZodString;
    }, z.core.$strip>;
    prebuild: z.ZodObject<{
      operationType: z.ZodEnum<{
        query: "query";
        mutation: "mutation";
        subscription: "subscription";
      }>;
      operationName: z.ZodString;
      schemaLabel: z.ZodString;
      document: z.ZodUnknown;
      variableNames: z.ZodArray<z.ZodString>;
      metadata: z.ZodOptional<z.ZodUnknown>;
    }, z.core.$strip>;
  }, z.core.$strip>, z.ZodObject<{
    id: z.core.$ZodType<CanonicalId, CanonicalId, z.core.$ZodTypeInternals<CanonicalId, CanonicalId>>;
    type: z.ZodLiteral<"fragment">;
    metadata: z.ZodObject<{
      sourcePath: z.ZodString;
      contentHash: z.ZodString;
    }, z.core.$strip>;
    prebuild: z.ZodObject<{
      typename: z.ZodString;
      key: z.ZodOptional<z.ZodString>;
      schemaLabel: z.ZodString;
    }, z.core.$strip>;
  }, z.core.$strip>], "type">>;
  report: z.ZodObject<{
    durationMs: z.ZodNumber;
    warnings: z.ZodArray<z.ZodString>;
    stats: z.ZodObject<{
      hits: z.ZodNumber;
      misses: z.ZodNumber;
      skips: z.ZodNumber;
    }, z.core.$strip>;
  }, z.core.$strip>;
}, z.core.$strip>;
type BuilderArtifact$1 = z.infer<typeof BuilderArtifactSchema>;
type BuilderArtifactElement$1 = z.infer<typeof BuilderArtifactElementSchema>;
//#endregion
//#region packages/builder/src/cache/memory-cache.d.ts
type CacheNamespace = readonly string[];
type CacheFactoryOptions = {
  readonly prefix?: CacheNamespace;
  readonly persistence?: {
    readonly enabled: boolean;
    readonly filePath: string;
  };
};
type CacheStoreOptions<_K extends string, V> = {
  readonly namespace: CacheNamespace;
  readonly schema: z.ZodType<V>;
  readonly version?: string;
};
type CacheStore<K extends string, V> = {
  load(key: K): V | null;
  store(key: K, value: V): void;
  delete(key: K): void;
  entries(): IterableIterator<[K, V]>;
  clear(): void;
  size(): number;
};
type CacheFactory = {
  createStore<K extends string, V>(options: CacheStoreOptions<K, V>): CacheStore<K, V>;
  clearAll(): void;
  save(): void;
};
declare const createMemoryCache: ({
  prefix,
  persistence
}?: CacheFactoryOptions) => CacheFactory;
//#endregion
//#region packages/builder/src/cache/entity-cache.d.ts
type EntityCacheOptions<V> = {
  readonly factory: CacheFactory;
  readonly namespace: readonly string[];
  readonly schema: ZodSchema<V>;
  readonly version: string;
  readonly keyNormalizer?: (key: string) => string;
};
/**
 * Abstract base class for entity caches.
 * Provides common caching functionality with signature-based eviction.
 */
declare abstract class EntityCache<K extends string, V> {
  protected readonly cacheStore: CacheStore<K, V>;
  private readonly keyNormalizer;
  constructor(options: EntityCacheOptions<V>);
  /**
   * Normalize a key for consistent cache lookups.
   */
  protected normalizeKey(key: string): K;
  /**
   * Load raw value from cache without signature validation.
   */
  protected loadRaw(key: K): V | null;
  /**
   * Store raw value to cache.
   */
  protected storeRaw(key: K, value: V): void;
  /**
   * Delete an entry from the cache.
   */
  delete(key: string): void;
  /**
   * Get all cached entries.
   * Subclasses should override this to provide custom iteration.
   */
  protected baseEntries(): IterableIterator<V>;
  /**
   * Clear all entries from the cache.
   */
  clear(): void;
  /**
   * Get the number of entries in the cache.
   */
  size(): number;
}
//#endregion
//#region packages/builder/src/discovery/cache.d.ts
type DiscoveryCacheOptions = {
  readonly factory: CacheFactory;
  readonly analyzer: string;
  readonly evaluatorId: string;
  readonly namespacePrefix?: readonly string[];
  readonly version?: string;
};
declare class JsonDiscoveryCache extends EntityCache<string, DiscoverySnapshot> implements DiscoveryCache {
  constructor(options: DiscoveryCacheOptions);
  load(filePath: string, expectedSignature: string): DiscoverySnapshot | null;
  peek(filePath: string): DiscoverySnapshot | null;
  store(snapshot: DiscoverySnapshot): void;
  entries(): IterableIterator<DiscoverySnapshot>;
}
declare const createDiscoveryCache: (options: DiscoveryCacheOptions) => DiscoveryCache;
//#endregion
//#region packages/builder/src/discovery/discoverer.d.ts
type DiscoverModulesOptions = {
  readonly entryPaths: readonly string[];
  readonly astAnalyzer: ReturnType<typeof createAstAnalyzer>;
  /** Optional alias resolver for tsconfig paths */
  readonly aliasResolver?: AliasResolver;
  /** Set of file paths explicitly invalidated (from BuilderChangeSet) */
  readonly incremental?: {
    readonly cache: DiscoveryCache;
    readonly changedFiles: Set<string>;
    readonly removedFiles: Set<string>;
    readonly affectedFiles: Set<string>;
  };
};
type DiscoverModulesResult = {
  readonly snapshots: readonly DiscoverySnapshot[];
  readonly cacheHits: number;
  readonly cacheMisses: number;
  readonly cacheSkips: number;
};
/**
 * Generator-based module discovery that yields effects for file I/O.
 * This allows the discovery process to be executed with either sync or async schedulers.
 */
declare function discoverModulesGen({
  entryPaths,
  astAnalyzer,
  aliasResolver,
  incremental
}: DiscoverModulesOptions): EffectGenerator<DiscoverModulesResult>;
/**
 * Discover and analyze all modules starting from entry points.
 * Uses AST parsing instead of RegExp for reliable dependency extraction.
 * Supports caching with fingerprint-based invalidation to skip re-parsing unchanged files.
 *
 * This function uses the synchronous scheduler internally for backward compatibility.
 * For async execution with parallel file I/O, use discoverModulesGen with an async scheduler.
 */
declare const discoverModules: (options: DiscoverModulesOptions) => BuilderResult<DiscoverModulesResult>;
/**
 * Asynchronous version of discoverModules.
 * Uses async scheduler for parallel file I/O operations.
 *
 * This is useful for large codebases where parallel file operations can improve performance.
 */
declare const discoverModulesAsync: (options: DiscoverModulesOptions) => Promise<BuilderResult<DiscoverModulesResult>>;
//#endregion
//#region packages/builder/src/artifact/builder.d.ts
type BuildArtifactInput = {
  readonly elements: IntermediateElements;
  readonly analyses: ReadonlyMap<string, ModuleAnalysis>;
  readonly stats: ModuleLoadStats;
};
declare const buildArtifact: ({
  elements,
  analyses,
  stats: cache
}: BuildArtifactInput) => Result<BuilderArtifact, BuilderError>;
//#endregion
//#region packages/builder/src/session/builder-session.d.ts
/**
 * Optional callbacks for profiling build phases.
 * Called at phase boundaries when provided.
 */
interface BuildPhaseCallbacks {
  /** Called after discovery phase completes */
  afterDiscovery?: () => void;
  /** Called after intermediate module generation completes */
  afterIntermediateGen?: () => void;
  /** Called after evaluation phase completes */
  afterEvaluation?: () => void;
}
/**
 * Options for build methods.
 */
interface BuildOptions {
  /** Force full rebuild ignoring cache */
  force?: boolean;
  /** Optional callbacks for profiling (called at phase boundaries) */
  onPhase?: BuildPhaseCallbacks;
}
/**
 * Builder session interface for incremental builds.
 */
interface BuilderSession {
  /**
   * Perform build fully or incrementally (synchronous).
   * The session automatically detects file changes using the file tracker.
   * Throws if any element requires async operations (e.g., async metadata factory).
   */
  build(options?: BuildOptions): Result<BuilderArtifact, BuilderError>;
  /**
   * Perform build fully or incrementally (asynchronous).
   * The session automatically detects file changes using the file tracker.
   * Supports async metadata factories and parallel element evaluation.
   */
  buildAsync(options?: BuildOptions): Promise<Result<BuilderArtifact, BuilderError>>;
  /**
   * Get the current generation number.
   */
  getGeneration(): number;
  /**
   * Get the current artifact.
   */
  getCurrentArtifact(): BuilderArtifact | null;
  /**
   * Get the intermediate elements from the most recent build.
   * Returns null if no build has been performed yet.
   * Used by typegen to extract field selections for prebuilt type generation.
   */
  getIntermediateElements(): Record<string, IntermediateArtifactElement> | null;
  /**
   * Dispose the session and save cache to disk.
   */
  dispose(): void;
}
/**
 * Reset exit handler state for testing.
 * @internal
 */
declare const __resetExitHandlerForTests: () => void;
/**
 * Create a new builder session.
 *
 * The session maintains in-memory state across builds to enable incremental processing.
 */
declare const createBuilderSession: (options: {
  readonly evaluatorId?: string;
  readonly entrypointsOverride?: readonly string[] | ReadonlySet<string>;
  readonly config: ResolvedSodaGqlConfig;
}) => BuilderSession;
//#endregion
//#region packages/builder/src/session/dependency-validation.d.ts
type DependencyGraphError = {
  readonly code: "MISSING_IMPORT";
  readonly chain: readonly [importingFile: string, importSpecifier: string];
};
declare const validateModuleDependencies: ({
  analyses,
  graphqlSystemHelper,
  aliasResolver
}: {
  analyses: Map<string, ModuleAnalysis>;
  graphqlSystemHelper: GraphqlSystemIdentifyHelper;
  aliasResolver?: AliasResolver;
}) => Result<null, DependencyGraphError>;
//#endregion
//#region packages/builder/src/session/module-adjacency.d.ts
/**
 * Extract module-level adjacency from dependency graph.
 * Returns Map of file path -> set of files that import it.
 * All paths are normalized to POSIX format for consistent cache key matching.
 */
declare const extractModuleAdjacency: ({
  snapshots
}: {
  snapshots: Map<string, DiscoverySnapshot>;
}) => Map<string, Set<string>>;
/**
 * Collect all modules affected by changes, including transitive dependents.
 * Uses BFS to traverse module adjacency graph.
 * All paths are already normalized from extractModuleAdjacency.
 */
declare const collectAffectedFiles: (input: {
  changedFiles: Set<string>;
  removedFiles: Set<string>;
  previousModuleAdjacency: Map<string, Set<string>>;
}) => Set<string>;
//#endregion
export { type ArtifactLoadError, type ArtifactLoadErrorCode, type BuilderAnalyzer, type BuilderArtifact, type BuilderArtifactElement, type BuilderArtifactElementMetadata, type BuilderArtifactFragment, type BuilderArtifactMeta, type BuilderArtifactOperation, BuilderArtifactSchema, BuilderEffects, type BuilderError, type BuilderFormat, type BuilderInput, type BuilderMode, type BuilderOptions, type BuilderService, type BuilderServiceConfig, type BuilderSession, type DiagnosticCode, type DiagnosticLocation, type DiagnosticSeverity, type DiscoveredDependency, type DiscoveryCache, type DiscoverySnapshot, type FieldSelectionData, type FieldSelectionsMap, FileReadEffect, FileStatEffect, type FileStats, type FormattedError, type GraphqlSystemIdentifyHelper, type IntermediateArtifactElement, type LoadSchemasResult, type ModuleDiagnostic, __clearGqlCache, builderErrors, collectAffectedFiles, createBuilderService, createBuilderSession, createDiagnostic, createGraphqlSystemIdentifyHelper, createStandardDiagnostic, diagnosticMessages, extractFieldSelections, extractModuleAdjacency, formatBuilderErrorForCLI, formatBuilderErrorStructured, getSeverity, loadArtifact, loadArtifactSync, loadFullSchemasFromBundle, loadSchemasFromBundle, resolveEntryPaths };
//# sourceMappingURL=index.d.cts.map