@savvy-web/github-action-builder 0.1.0

package/index.d.ts

@@ -0,0 +1,1621 @@
+/**
+ * GitHub Action Builder
+ *
+ * A zero-config build tool for creating GitHub Actions from TypeScript source code.
+ * This package provides both a programmatic API and CLI for bundling TypeScript
+ * GitHub Actions into production-ready JavaScript bundles.
+ *
+ * @remarks
+ * The package uses vercel/ncc under the hood to create single-file bundles
+ * that include all dependencies. It automatically detects entry points
+ * (`main.ts`, `pre.ts`, `post.ts`) and validates `action.yml` configuration.
+ *
+ * @example Programmatic usage with GitHubAction class
+ * ```typescript
+ * import { GitHubAction } from "@savvy-web/github-action-builder";
+ *
+ * async function main(): Promise<void> {
+ *   const action = GitHubAction.create();
+ *   const result = await action.build();
+ *
+ *   if (result.success) {
+ *     console.log("Build completed successfully");
+ *   } else {
+ *     console.error(result.error);
+ *     process.exit(1);
+ *   }
+ * }
+ *
+ * main();
+ * ```
+ *
+ * @example Configuration file (action.config.ts)
+ * ```typescript
+ * import { defineConfig } from "@savvy-web/github-action-builder";
+ *
+ * export default defineConfig({
+ *   entries: {
+ *     main: "src/main.ts",
+ *     post: "src/cleanup.ts",
+ *   },
+ *   build: {
+ *     minify: true,
+ *     target: "es2022",
+ *   },
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+import { Context } from 'effect';
+import type { Effect } from 'effect';
+import { Equals } from 'effect/Types';
+import { Layer } from 'effect';
+import { Schema } from 'effect';
+import { URL as URL_2 } from 'node:url';
+import { YieldableError } from 'effect/Cause';
+
+/**
+ * Error when action.yml file is missing.
+ *
+ * @public
+ */
+export declare class ActionYmlMissing extends ActionYmlMissingBase<{
+    /**
+     * The working directory that was searched.
+     */
+    readonly cwd: string;
+}> {
+}
+
+/**
+ * Base class for ActionYmlMissing error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ActionYmlMissingBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ActionYmlMissing";
+} & Readonly<A>;
+
+/**
+ * Result of action.yml validation.
+ * @public
+ */
+export declare type ActionYmlResult = typeof ActionYmlResultSchema.Type;
+
+/**
+ * Result of action.yml validation.
+ * @internal
+ */
+export declare const ActionYmlResultSchema: Schema.Struct<{
+    /** Whether the action.yml is valid. */
+    valid: typeof Schema.Boolean;
+    /** Parsed action.yml content if valid. */
+    content: Schema.optional<typeof Schema.Any>;
+    /** Validation errors. */
+    errors: Schema.Array$<Schema.Struct<{
+        /** Error code for categorization. */
+        code: typeof Schema.String;
+        /** Human-readable error message. */
+        message: typeof Schema.String;
+        /** File path where error occurred. */
+        file: Schema.optional<typeof Schema.String>;
+        /** Suggestion for fixing the error. */
+        suggestion: Schema.optional<typeof Schema.String>;
+    }>>;
+    /** Validation warnings. */
+    warnings: Schema.Array$<Schema.Struct<{
+        /** Warning code for categorization. */
+        code: typeof Schema.String;
+        /** Human-readable warning message. */
+        message: typeof Schema.String;
+        /** File path where warning occurred. */
+        file: Schema.optional<typeof Schema.String>;
+        /** Suggestion for addressing the warning. */
+        suggestion: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+
+/**
+ * Error when action.yml fails schema validation.
+ *
+ * @public
+ */
+export declare class ActionYmlSchemaError extends ActionYmlSchemaErrorBase<{
+    /**
+     * The path to the action.yml file.
+     */
+    readonly path: string;
+    /**
+     * List of schema validation errors.
+     */
+    readonly errors: ReadonlyArray<{
+        readonly path: string;
+        readonly message: string;
+    }>;
+}> {
+}
+
+/**
+ * Base class for ActionYmlSchemaError error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ActionYmlSchemaErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ActionYmlSchemaError";
+} & Readonly<A>;
+
+/**
+ * Error when action.yml has invalid YAML syntax.
+ *
+ * @public
+ */
+export declare class ActionYmlSyntaxError extends ActionYmlSyntaxErrorBase<{
+    /**
+     * The path to the action.yml file.
+     */
+    readonly path: string;
+    /**
+     * The syntax error message.
+     */
+    readonly message: string;
+    /**
+     * Line number where the error occurred, if available.
+     */
+    readonly line?: number;
+    /**
+     * Column number where the error occurred, if available.
+     */
+    readonly column?: number;
+}> {
+}
+
+/**
+ * Base class for ActionYmlSyntaxError error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ActionYmlSyntaxErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ActionYmlSyntaxError";
+} & Readonly<A>;
+
+/**
+ * Union of all possible errors in the GitHub Action Builder.
+ *
+ * @public
+ */
+export declare type AppError = ConfigError | ValidationError | BuildError;
+
+/**
+ * Combined layer providing all services.
+ *
+ * @remarks
+ * This layer composes ConfigService, ValidationService, and BuildService.
+ * Use this when you need access to all services in your Effect program.
+ *
+ * @example Using AppLayer with Effect
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AppLayer, BuildService, ConfigService } from "@savvy-web/github-action-builder";
+ *
+ * const program = Effect.gen(function* () {
+ *   const configService = yield* ConfigService;
+ *   const buildService = yield* BuildService;
+ *
+ *   const { config } = yield* configService.load();
+ *   const result = yield* buildService.build(config);
+ *
+ *   return result;
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(AppLayer)));
+ * ```
+ *
+ * @public
+ */
+export declare const AppLayer: Layer.Layer<BuildService | ConfigService | ValidationService, never, never>;
+
+/**
+ * Union of all build-related errors.
+ *
+ * @public
+ */
+export declare type BuildError = BundleFailed | WriteError | CleanError | BuildFailed;
+
+/**
+ * Error when the build process fails overall.
+ *
+ * @public
+ */
+export declare class BuildFailed extends BuildFailedBase<{
+    /**
+     * Summary message of the build failure.
+     */
+    readonly message: string;
+    /**
+     * Number of entries that failed.
+     */
+    readonly failedEntries: number;
+}> {
+}
+
+/**
+ * Base class for BuildFailed error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const BuildFailedBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "BuildFailed";
+} & Readonly<A>;
+
+/**
+ * Layer providing BuildService (depends on ConfigService).
+ *
+ * @remarks
+ * Includes ConfigService automatically.
+ *
+ * @public
+ */
+export declare const BuildLayer: Layer.Layer<BuildService, never, never>;
+
+/**
+ * Build options for the bundler.
+ *
+ * @public
+ */
+export declare type BuildOptions = typeof BuildOptionsSchema.Type;
+
+/**
+ * Schema for build options.
+ *
+ * @remarks
+ * Build options control how the TypeScript source is bundled using `@vercel/ncc`.
+ * The bundler creates a single JavaScript file with all dependencies inlined.
+ *
+ * @internal
+ */
+export declare const BuildOptionsSchema: Schema.Struct<{
+    /** Enable minification to reduce bundle size. Defaults to true. */
+    minify: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    /** ECMAScript target version for the output. Defaults to "es2022". */
+    target: Schema.optionalWith<Schema.Literal<["es2020", "es2021", "es2022", "es2023", "es2024"]>, {
+        default: () => "es2022";
+    }>;
+    /** Generate source maps for debugging. Defaults to false. */
+    sourceMap: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    /** Packages to exclude from the bundle. Defaults to []. */
+    externals: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+        default: () => never[];
+    }>;
+    /** Suppress build output. Defaults to false. */
+    quiet: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+}>;
+
+/**
+ * Result of the complete build process.
+ * @public
+ */
+export declare type BuildResult = typeof BuildResultSchema.Type;
+
+/**
+ * Result of the complete build process.
+ * @internal
+ */
+export declare const BuildResultSchema: Schema.Struct<{
+    /** Whether the overall build succeeded. */
+    success: typeof Schema.Boolean;
+    /** Results for each entry that was built. */
+    entries: Schema.Array$<Schema.Struct<{
+        /** Whether bundling succeeded. */
+        success: typeof Schema.Boolean;
+        /** Bundle statistics if successful. */
+        stats: Schema.optional<Schema.Struct<{
+            /** Entry type (main, pre, or post). */
+            entry: typeof Schema.String;
+            /** Bundle size in bytes. */
+            size: typeof Schema.Number;
+            /** Build duration in milliseconds. */
+            duration: typeof Schema.Number;
+            /** Output path relative to working directory. */
+            outputPath: typeof Schema.String;
+        }>>;
+        /** Error message if failed. */
+        error: Schema.optional<typeof Schema.String>;
+    }>>;
+    /** Total build duration in milliseconds. */
+    duration: typeof Schema.Number;
+    /** Error message if build failed. */
+    error: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Options for the build process.
+ * @public
+ */
+export declare type BuildRunnerOptions = typeof BuildRunnerOptionsSchema.Type;
+
+/**
+ * Options for the build process.
+ * @internal
+ */
+export declare const BuildRunnerOptionsSchema: Schema.Struct<{
+    /** Working directory for the build. Accepts string, Buffer, or URL. */
+    cwd: Schema.optional<Schema.transform<Schema.Union<[typeof Schema.String, Schema.instanceOf<Buffer<ArrayBufferLike>>, Schema.instanceOf<URL_2>]>, typeof Schema.String>>;
+    /** Clean output directory before building. Defaults to true. */
+    clean: Schema.optional<typeof Schema.Boolean>;
+}>;
+
+/**
+ * BuildService interface for build and bundling capabilities.
+ *
+ * @remarks
+ * This service handles:
+ * - Bundling TypeScript entries with vercel/ncc
+ * - Managing output directory
+ * - Collecting build statistics
+ * - Formatting build results
+ *
+ * @example Using BuildService with Effect
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AppLayer, BuildService, ConfigService } from "@savvy-web/github-action-builder";
+ *
+ * const program = Effect.gen(function* () {
+ *   const configService = yield* ConfigService;
+ *   const buildService = yield* BuildService;
+ *
+ *   const { config } = yield* configService.load();
+ *   const result = yield* buildService.build(config);
+ *
+ *   if (result.success) {
+ *     console.log("Build complete:", result.entries.length, "entries");
+ *   }
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(AppLayer)));
+ * ```
+ *
+ * @public
+ */
+export declare interface BuildService {
+    /**
+     * Build all entries from the configuration.
+     *
+     * @param config - Configuration with entry points
+     * @param options - Build options
+     * @returns Effect that resolves to build result
+     */
+    readonly build: (config: Config, options?: BuildRunnerOptions) => Effect.Effect<BuildResult, BuildError | MainEntryMissing>;
+    /**
+     * Bundle a single entry point.
+     *
+     * @param entry - Entry to bundle
+     * @param config - Build configuration
+     * @returns Effect that resolves to bundle result
+     */
+    readonly bundle: (entry: DetectedEntry, config: Config) => Effect.Effect<BundleResult, BuildError>;
+    /**
+     * Clean the output directory.
+     *
+     * @param outputDir - Directory to clean
+     * @returns Effect that resolves when complete
+     */
+    readonly clean: (outputDir: string) => Effect.Effect<void, BuildError>;
+    /**
+     * Format build result for display.
+     *
+     * @param result - Build result to format
+     * @returns Formatted string for terminal output
+     */
+    readonly formatResult: (result: BuildResult) => string;
+    /**
+     * Format bytes as human-readable string.
+     *
+     * @param bytes - Number of bytes
+     * @returns Formatted string like "1.5 MB"
+     */
+    readonly formatBytes: (bytes: number) => string;
+}
+
+/**
+ * BuildService tag for dependency injection.
+ *
+ * @public
+ */
+export declare const BuildService: Context.Tag<BuildService, BuildService>;
+
+/**
+ * Error when bundling with ncc fails.
+ *
+ * @public
+ */
+export declare class BundleFailed extends BundleFailedBase<{
+    /**
+     * The entry file that failed to bundle.
+     */
+    readonly entry: string;
+    /**
+     * The underlying error message.
+     */
+    readonly cause: string;
+}> {
+}
+
+/**
+ * Base class for BundleFailed error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const BundleFailedBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "BundleFailed";
+} & Readonly<A>;
+
+/**
+ * Result of bundling a single entry.
+ * @public
+ */
+export declare type BundleResult = typeof BundleResultSchema.Type;
+
+/**
+ * Result of bundling a single entry.
+ * @internal
+ */
+export declare const BundleResultSchema: Schema.Struct<{
+    /** Whether bundling succeeded. */
+    success: typeof Schema.Boolean;
+    /** Bundle statistics if successful. */
+    stats: Schema.optional<Schema.Struct<{
+        /** Entry type (main, pre, or post). */
+        entry: typeof Schema.String;
+        /** Bundle size in bytes. */
+        size: typeof Schema.Number;
+        /** Build duration in milliseconds. */
+        duration: typeof Schema.Number;
+        /** Output path relative to working directory. */
+        outputPath: typeof Schema.String;
+    }>>;
+    /** Error message if failed. */
+    error: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Statistics for a single bundled entry.
+ * @public
+ */
+export declare type BundleStats = typeof BundleStatsSchema.Type;
+
+/**
+ * Statistics for a single bundled entry.
+ * @internal
+ */
+export declare const BundleStatsSchema: Schema.Struct<{
+    /** Entry type (main, pre, or post). */
+    entry: typeof Schema.String;
+    /** Bundle size in bytes. */
+    size: typeof Schema.Number;
+    /** Build duration in milliseconds. */
+    duration: typeof Schema.Number;
+    /** Output path relative to working directory. */
+    outputPath: typeof Schema.String;
+}>;
+
+/**
+ * Error when cleaning the output directory fails.
+ *
+ * @public
+ */
+export declare class CleanError extends CleanErrorBase<{
+    /**
+     * The directory that failed to clean.
+     */
+    readonly directory: string;
+    /**
+     * The underlying error message.
+     */
+    readonly cause: string;
+}> {
+}
+
+/**
+ * Base class for CleanError error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const CleanErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "CleanError";
+} & Readonly<A>;
+
+/**
+ * Fully resolved configuration with all defaults applied.
+ *
+ * @remarks
+ * This type represents the final configuration after all defaults
+ * have been applied. It is the result of calling {@link defineConfig}.
+ *
+ * @public
+ */
+export declare type Config = typeof ConfigSchema.Type;
+
+/**
+ * Union of all configuration-related errors.
+ *
+ * @public
+ */
+export declare type ConfigError = ConfigNotFound | ConfigInvalid | ConfigLoadFailed;
+
+/**
+ * User-provided configuration input (all fields optional).
+ *
+ * @remarks
+ * Use this type when accepting configuration from users.
+ * All fields are optional and will be merged with defaults.
+ *
+ * @public
+ */
+export declare type ConfigInput = typeof ConfigInputSchema.Type;
+
+/**
+ * User-provided configuration input (all fields optional).
+ *
+ * @remarks
+ * This schema is used for parsing user-provided configuration.
+ * All sections are optional; defaults are applied via {@link defineConfig}.
+ *
+ * @internal
+ */
+export declare const ConfigInputSchema: Schema.Struct<{
+    entries: Schema.optional<Schema.Struct<{
+        main: Schema.optional<typeof Schema.String>;
+        pre: Schema.optional<typeof Schema.String>;
+        post: Schema.optional<typeof Schema.String>;
+    }>>;
+    build: Schema.optional<Schema.Struct<{
+        minify: Schema.optional<typeof Schema.Boolean>;
+        target: Schema.optional<Schema.Literal<["es2020", "es2021", "es2022", "es2023", "es2024"]>>;
+        sourceMap: Schema.optional<typeof Schema.Boolean>;
+        externals: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        quiet: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    validation: Schema.optional<Schema.Struct<{
+        requireActionYml: Schema.optional<typeof Schema.Boolean>;
+        maxBundleSize: Schema.optional<typeof Schema.String>;
+        strict: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+}>;
+
+/**
+ * Error when configuration file exists but contains invalid content.
+ *
+ * @public
+ */
+export declare class ConfigInvalid extends ConfigInvalidBase<{
+    /**
+     * The path to the invalid config file.
+     */
+    readonly path: string;
+    /**
+     * List of validation errors.
+     */
+    readonly errors: ReadonlyArray<string>;
+}> {
+}
+
+/**
+ * Base class for ConfigInvalid error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ConfigInvalidBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ConfigInvalid";
+} & Readonly<A>;
+
+/**
+ * Layer providing ConfigService (no dependencies).
+ *
+ * @remarks
+ * Use this layer when you only need configuration management.
+ *
+ * @public
+ */
+export declare const ConfigLayer: Layer.Layer<ConfigService, never, never>;
+
+/**
+ * Error when configuration file fails to load (import error, syntax error, etc.).
+ *
+ * @public
+ */
+export declare class ConfigLoadFailed extends ConfigLoadFailedBase<{
+    /**
+     * The path to the config file that failed to load.
+     */
+    readonly path: string;
+    /**
+     * The underlying error message.
+     */
+    readonly cause: string;
+}> {
+}
+
+/**
+ * Base class for ConfigLoadFailed error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ConfigLoadFailedBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ConfigLoadFailed";
+} & Readonly<A>;
+
+/**
+ * Error when configuration file is not found.
+ *
+ * @public
+ */
+export declare class ConfigNotFound extends ConfigNotFoundBase<{
+    /**
+     * The path that was searched for the config file.
+     */
+    readonly path: string;
+    /**
+     * Additional context about the search.
+     */
+    readonly message?: string;
+}> {
+}
+
+/**
+ * Base class for ConfigNotFound error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ConfigNotFoundBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ConfigNotFound";
+} & Readonly<A>;
+
+/**
+ * Fully resolved configuration with all defaults applied.
+ *
+ * @internal
+ */
+export declare const ConfigSchema: Schema.Struct<{
+    entries: Schema.Struct<{
+        /** Path to the main action entry point. Defaults to "src/main.ts". */
+        main: Schema.optionalWith<typeof Schema.String, {
+            default: () => string;
+        }>;
+        /** Path to the pre-action hook entry point. */
+        pre: Schema.optional<typeof Schema.String>;
+        /** Path to the post-action hook entry point. */
+        post: Schema.optional<typeof Schema.String>;
+    }>;
+    build: Schema.Struct<{
+        /** Enable minification to reduce bundle size. Defaults to true. */
+        minify: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => true;
+        }>;
+        /** ECMAScript target version for the output. Defaults to "es2022". */
+        target: Schema.optionalWith<Schema.Literal<["es2020", "es2021", "es2022", "es2023", "es2024"]>, {
+            default: () => "es2022";
+        }>;
+        /** Generate source maps for debugging. Defaults to false. */
+        sourceMap: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => false;
+        }>;
+        /** Packages to exclude from the bundle. Defaults to []. */
+        externals: Schema.optionalWith<Schema.Array$<typeof Schema.String>, {
+            default: () => never[];
+        }>;
+        /** Suppress build output. Defaults to false. */
+        quiet: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => false;
+        }>;
+    }>;
+    validation: Schema.Struct<{
+        /** Require action.yml to exist and be valid. Defaults to true. */
+        requireActionYml: Schema.optionalWith<typeof Schema.Boolean, {
+            default: () => true;
+        }>;
+        /** Maximum bundle size before warning/error (e.g., "5mb", "500kb"). */
+        maxBundleSize: Schema.optional<typeof Schema.String>;
+        /** Treat warnings as errors. Auto-detects from CI when undefined. */
+        strict: Schema.optional<typeof Schema.Boolean>;
+    }>;
+}>;
+
+/**
+ * ConfigService interface for configuration management capabilities.
+ *
+ * @remarks
+ * This service handles:
+ * - Loading configuration from `action.config.ts` files
+ * - Resolving partial configuration with defaults
+ * - Detecting entry points in the project
+ *
+ * @example Using ConfigService with Effect
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AppLayer, ConfigService } from "@savvy-web/github-action-builder";
+ *
+ * const program = Effect.gen(function* () {
+ *   const configService = yield* ConfigService;
+ *   const result = yield* configService.load({ cwd: process.cwd() });
+ *   console.log("Loaded config:", result.config);
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(AppLayer)));
+ * ```
+ *
+ * @public
+ */
+export declare interface ConfigService {
+    /**
+     * Load configuration from file or use defaults.
+     *
+     * @param options - Loading options
+     * @returns Effect that resolves to the loaded configuration
+     */
+    readonly load: (options?: LoadConfigOptions) => Effect.Effect<LoadConfigResult, ConfigError>;
+    /**
+     * Resolve partial configuration input to full configuration.
+     *
+     * @param input - Partial configuration input
+     * @returns Effect that resolves to full configuration
+     */
+    readonly resolve: (input?: Partial<ConfigInput>) => Effect.Effect<Config, ConfigError>;
+    /**
+     * Detect entry points in the project.
+     *
+     * @param cwd - Working directory to search
+     * @param entries - Optional explicit entry configuration
+     * @returns Effect that resolves to detected entries
+     */
+    readonly detectEntries: (cwd: string, entries?: {
+        main?: string;
+        pre?: string;
+        post?: string;
+    }) => Effect.Effect<DetectEntriesResult, MainEntryMissing>;
+}
+
+/**
+ * ConfigService tag for dependency injection.
+ *
+ * @public
+ */
+export declare const ConfigService: Context.Tag<ConfigService, ConfigService>;
+
+/**
+ * Define a configuration with full TypeScript support.
+ *
+ * @remarks
+ * This function validates the configuration and applies all defaults.
+ * Use it in your `action.config.ts` file for autocomplete and type checking.
+ *
+ * @param config - Partial configuration object
+ * @returns Fully resolved configuration with defaults applied
+ *
+ * @example Basic configuration file
+ * ```typescript
+ * // action.config.ts
+ * import { defineConfig } from "@savvy-web/github-action-builder";
+ *
+ * export default defineConfig({
+ *   entries: {
+ *     main: "src/main.ts",
+ *   },
+ *   build: {
+ *     minify: true,
+ *   },
+ * });
+ * ```
+ *
+ * @example Full configuration with all options
+ * ```typescript
+ * // action.config.ts
+ * import { defineConfig } from "@savvy-web/github-action-builder";
+ *
+ * export default defineConfig({
+ *   entries: {
+ *     main: "src/action.ts",
+ *     pre: "src/setup.ts",
+ *     post: "src/cleanup.ts",
+ *   },
+ *   build: {
+ *     minify: true,
+ *     target: "es2022",
+ *     sourceMap: true,
+ *     externals: ["@aws-sdk/client-s3"],
+ *   },
+ *   validation: {
+ *     requireActionYml: true,
+ *     maxBundleSize: "10mb",
+ *     strict: true,
+ *   },
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare function defineConfig(config?: Partial<ConfigInput>): Config;
+
+/**
+ * Detected entry point information.
+ * @public
+ */
+export declare type DetectedEntry = typeof DetectedEntrySchema.Type;
+
+/**
+ * Detected entry point information.
+ * @internal
+ */
+export declare const DetectedEntrySchema: Schema.Struct<{
+    /** Entry type (main, pre, or post). */
+    type: Schema.Literal<["main", "pre", "post"]>;
+    /** Absolute path to the entry file. */
+    path: typeof Schema.String;
+    /** Output path for the bundled file. */
+    output: typeof Schema.String;
+}>;
+
+/**
+ * Result of entry detection.
+ * @public
+ */
+export declare type DetectEntriesResult = typeof DetectEntriesResultSchema.Type;
+
+/**
+ * Result of entry detection.
+ * @internal
+ */
+export declare const DetectEntriesResultSchema: Schema.Struct<{
+    /** Whether detection was successful. */
+    success: typeof Schema.Boolean;
+    /** Detected entries. */
+    entries: Schema.Array$<Schema.Struct<{
+        /** Entry type (main, pre, or post). */
+        type: Schema.Literal<["main", "pre", "post"]>;
+        /** Absolute path to the entry file. */
+        path: typeof Schema.String;
+        /** Output path for the bundled file. */
+        output: typeof Schema.String;
+    }>>;
+}>;
+
+/**
+ * Entry point paths configuration.
+ *
+ * @public
+ */
+export declare type Entries = typeof EntriesSchema.Type;
+
+/**
+ * Schema for entry point paths.
+ *
+ * @remarks
+ * GitHub Actions support three entry points:
+ * - `main`: The primary action entry point (required)
+ * - `pre`: Runs before the main action (optional)
+ * - `post`: Runs after the main action for cleanup (optional)
+ *
+ * @internal
+ */
+export declare const EntriesSchema: Schema.Struct<{
+    /** Path to the main action entry point. Defaults to "src/main.ts". */
+    main: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    /** Path to the pre-action hook entry point. */
+    pre: Schema.optional<typeof Schema.String>;
+    /** Path to the post-action hook entry point. */
+    post: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Error when an explicitly specified entry file is missing.
+ *
+ * @public
+ */
+export declare class EntryFileMissing extends EntryFileMissingBase<{
+    /**
+     * The type of entry (main, pre, post).
+     */
+    readonly entryType: "main" | "pre" | "post";
+    /**
+     * The path that was specified but not found.
+     */
+    readonly path: string;
+}> {
+}
+
+/**
+ * Base class for EntryFileMissing error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const EntryFileMissingBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "EntryFileMissing";
+} & Readonly<A>;
+
+/**
+ * ECMAScript target versions supported by the bundler.
+ *
+ * @internal
+ */
+export declare const EsTarget: Schema.Literal<["es2020", "es2021", "es2022", "es2023", "es2024"]>;
+
+/**
+ * Type for ECMAScript target.
+ *
+ * @public
+ */
+export declare type EsTarget = typeof EsTarget.Type;
+
+/**
+ * Main API class for building GitHub Actions.
+ *
+ * @remarks
+ * This class provides a Promise-based interface wrapping Effect services.
+ * It handles configuration loading, validation, and bundling in a single workflow.
+ *
+ * For Effect consumers, use the services directly:
+ * - {@link ConfigService} for configuration
+ * - {@link ValidationService} for validation
+ * - {@link BuildService} for building
+ *
+ * @example Complete build workflow
+ * ```typescript
+ * import { GitHubAction } from "@savvy-web/github-action-builder";
+ *
+ * async function buildAction(): Promise<void> {
+ *   const action = GitHubAction.create();
+ *   const result = await action.build();
+ *
+ *   if (result.success) {
+ *     console.log(`Built ${result.build?.entries.length} entry points`);
+ *   } else {
+ *     console.error(`Build failed: ${result.error}`);
+ *     process.exit(1);
+ *   }
+ * }
+ *
+ * buildAction();
+ * ```
+ *
+ * @example With custom configuration
+ * ```typescript
+ * import { GitHubAction } from "@savvy-web/github-action-builder";
+ *
+ * async function main(): Promise<void> {
+ *   const action = GitHubAction.create({
+ *     config: {
+ *       entries: { main: "src/action.ts" },
+ *       build: { minify: true, target: "es2022" },
+ *     },
+ *     cwd: "/path/to/project",
+ *   });
+ *
+ *   const result = await action.build();
+ *   console.log(result.success ? "Success" : result.error);
+ * }
+ *
+ * main();
+ * ```
+ *
+ * @public
+ */
+export declare class GitHubAction {
+    /**
+     * Managed runtime for running Effects.
+     * @internal
+     */
+    private readonly runtime;
+    /**
+     * Cached configuration after first load.
+     * @internal
+     */
+    private config;
+    /**
+     * Resolved options.
+     * @internal
+     */
+    private readonly cwd;
+    private readonly configSource;
+    private readonly skipValidation;
+    private readonly clean;
+    private constructor();
+    /**
+     * Create a new GitHubAction builder instance.
+     *
+     * @param options - Builder options
+     * @returns A new GitHubAction instance
+     *
+     * @example
+     * ```typescript
+     * import { GitHubAction } from "@savvy-web/github-action-builder";
+     *
+     * // Auto-detect configuration
+     * const action = GitHubAction.create();
+     *
+     * // With inline config
+     * const action2 = GitHubAction.create({
+     *   config: { build: { minify: false } },
+     * });
+     *
+     * // With config file path
+     * const action3 = GitHubAction.create({
+     *   config: "./custom.config.ts",
+     * });
+     * ```
+     */
+    static create(options?: GitHubActionOptions): GitHubAction;
+    /**
+     * Load and resolve configuration.
+     *
+     * @remarks
+     * Configuration is cached after the first load. Subsequent calls
+     * return the cached configuration.
+     *
+     * @returns Resolved configuration with all defaults applied
+     * @throws Error if configuration file cannot be loaded or is invalid
+     */
+    loadConfig(): Promise<Config>;
+    /**
+     * Validate the action configuration and action.yml.
+     *
+     * @remarks
+     * Validation checks:
+     * - Entry point files exist
+     * - Output directory is writable
+     * - action.yml exists and is valid (if required)
+     *
+     * In CI environments, warnings are treated as errors by default.
+     *
+     * @param options - Validation options
+     * @returns Validation result with errors and warnings
+     */
+    validate(options?: ValidateOptions): Promise<ValidationResult>;
+    /**
+     * Build the GitHub Action.
+     *
+     * @remarks
+     * The build process:
+     * 1. Loads configuration (if not already loaded)
+     * 2. Validates the project (unless `skipValidation` is set)
+     * 3. Bundles each entry point with vercel/ncc
+     * 4. Writes output to the `dist/` directory
+     *
+     * @returns Build result with success status and details
+     *
+     * @example
+     * ```typescript
+     * import { GitHubAction } from "@savvy-web/github-action-builder";
+     *
+     * async function main(): Promise<void> {
+     *   const action = GitHubAction.create();
+     *   const result = await action.build();
+     *
+     *   if (result.success && result.build) {
+     *     console.log(`Built ${result.build.entries.length} entries`);
+     *   } else {
+     *     console.error(result.error);
+     *   }
+     * }
+     *
+     * main();
+     * ```
+     */
+    build(): Promise<GitHubActionBuildResult>;
+    /**
+     * Dispose the runtime and release resources.
+     *
+     * @remarks
+     * Call this when you're done using the GitHubAction instance
+     * to clean up any resources held by the Effect runtime.
+     */
+    dispose(): Promise<void>;
+}
+
+/**
+ * Result of a GitHubAction build operation.
+ * @public
+ */
+export declare type GitHubActionBuildResult = typeof GitHubActionBuildResultSchema.Type;
+
+/**
+ * Result of a GitHubAction build operation.
+ *
+ * @remarks
+ * The result contains detailed information about both validation and build steps.
+ * Check the `success` property first, then examine `error`, `validation`, or `build`
+ * for details.
+ *
+ * @internal
+ */
+export declare const GitHubActionBuildResultSchema: Schema.Struct<{
+    /** Whether the build completed successfully. */
+    success: typeof Schema.Boolean;
+    /** Build result details if the build step ran. */
+    build: Schema.optional<Schema.Struct<{
+        success: typeof Schema.Boolean;
+        entries: Schema.Array$<Schema.Struct<{
+            success: typeof Schema.Boolean;
+            stats: Schema.optional<Schema.Struct<{
+                entry: typeof Schema.String;
+                size: typeof Schema.Number;
+                duration: typeof Schema.Number;
+                outputPath: typeof Schema.String;
+            }>>;
+            error: Schema.optional<typeof Schema.String>;
+        }>>;
+        duration: typeof Schema.Number;
+        error: Schema.optional<typeof Schema.String>;
+    }>>;
+    /** Validation result if validation was performed. */
+    validation: Schema.optional<Schema.Struct<{
+        valid: typeof Schema.Boolean;
+        errors: Schema.Array$<Schema.Struct<{
+            code: typeof Schema.String;
+            message: typeof Schema.String;
+            file: Schema.optional<typeof Schema.String>;
+            suggestion: Schema.optional<typeof Schema.String>;
+        }>>;
+        warnings: Schema.Array$<Schema.Struct<{
+            code: typeof Schema.String;
+            message: typeof Schema.String;
+            file: Schema.optional<typeof Schema.String>;
+            suggestion: Schema.optional<typeof Schema.String>;
+        }>>;
+    }>>;
+    /** Error message if the build or validation failed. */
+    error: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Options for creating a GitHubAction builder instance.
+ *
+ * @remarks
+ * All options are optional. When no options are provided, the builder
+ * auto-detects configuration from `action.config.ts` in the current directory.
+ *
+ * @public
+ */
+export declare interface GitHubActionOptions {
+    /**
+     * Configuration object or path to config file.
+     *
+     * @remarks
+     * - If a string is provided, it's treated as a path to a config file
+     * - If an object is provided, it's used directly as configuration
+     * - If not provided, auto-detects `action.config.ts` or uses defaults
+     */
+    config?: Partial<ConfigInput> | string;
+    /**
+     * Working directory for the build.
+     *
+     * @defaultValue `process.cwd()`
+     */
+    cwd?: string;
+    /**
+     * Skip validation before building.
+     *
+     * @remarks
+     * Skipping validation is not recommended for production builds.
+     *
+     * @defaultValue `false`
+     */
+    skipValidation?: boolean;
+    /**
+     * Clean output directory before building.
+     *
+     * @defaultValue `true`
+     */
+    clean?: boolean;
+    /**
+     * Custom Effect Layer to use instead of the default AppLayer.
+     *
+     * @remarks
+     * Advanced option for testing or customizing service implementations.
+     */
+    layer?: Layer.Layer<ConfigService | ValidationService | BuildService>;
+}
+
+/**
+ * Options for loading configuration.
+ * @public
+ */
+export declare type LoadConfigOptions = typeof LoadConfigOptionsSchema.Type;
+
+/**
+ * Options for loading configuration.
+ * @internal
+ */
+export declare const LoadConfigOptionsSchema: Schema.Struct<{
+    /** Working directory to search for config. Accepts string, Buffer, or URL. */
+    cwd: Schema.optional<Schema.transform<Schema.Union<[typeof Schema.String, Schema.instanceOf<Buffer<ArrayBufferLike>>, Schema.instanceOf<URL_2>]>, typeof Schema.String>>;
+    /** Explicit path to config file. Accepts string, Buffer, or URL. */
+    configPath: Schema.optional<Schema.transform<Schema.Union<[typeof Schema.String, Schema.instanceOf<Buffer<ArrayBufferLike>>, Schema.instanceOf<URL_2>]>, typeof Schema.String>>;
+}>;
+
+/**
+ * Result of configuration loading.
+ * @public
+ */
+export declare interface LoadConfigResult {
+    /** The resolved configuration. */
+    config: Config;
+    /** Path to the config file that was loaded, if any. */
+    configPath?: string;
+    /** Whether defaults were used (no config file found). */
+    usingDefaults: boolean;
+}
+
+/**
+ * Error when the required main entry point is missing.
+ *
+ * @public
+ */
+export declare class MainEntryMissing extends MainEntryMissingBase<{
+    /**
+     * The expected path for the main entry.
+     */
+    readonly expectedPath: string;
+    /**
+     * The working directory that was searched.
+     */
+    readonly cwd: string;
+}> {
+}
+
+/**
+ * Base class for MainEntryMissing error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const MainEntryMissingBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "MainEntryMissing";
+} & Readonly<A>;
+
+/**
+ * Options for validation.
+ * @public
+ */
+export declare type ValidateOptions = typeof ValidateOptionsSchema.Type;
+
+/**
+ * Options for validation.
+ * @internal
+ */
+export declare const ValidateOptionsSchema: Schema.Struct<{
+    /** Working directory for file operations. Accepts string, Buffer, or URL. */
+    cwd: Schema.optional<Schema.transform<Schema.Union<[typeof Schema.String, Schema.instanceOf<Buffer<ArrayBufferLike>>, Schema.instanceOf<URL_2>]>, typeof Schema.String>>;
+    /** Force strict mode regardless of environment. Auto-detects from CI when undefined. */
+    strict: Schema.optional<typeof Schema.Boolean>;
+}>;
+
+/**
+ * Union of all validation-related errors.
+ *
+ * @public
+ */
+export declare type ValidationError = MainEntryMissing | EntryFileMissing | ActionYmlMissing | ActionYmlSyntaxError | ActionYmlSchemaError | ValidationFailed;
+
+/**
+ * A validation error item.
+ * @public
+ */
+export declare type ValidationErrorItem = typeof ValidationErrorSchema.Type;
+
+/**
+ * A validation error item.
+ * @internal
+ */
+export declare const ValidationErrorSchema: Schema.Struct<{
+    /** Error code for categorization. */
+    code: typeof Schema.String;
+    /** Human-readable error message. */
+    message: typeof Schema.String;
+    /** File path where error occurred. */
+    file: Schema.optional<typeof Schema.String>;
+    /** Suggestion for fixing the error. */
+    suggestion: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Error when validation fails in strict mode (CI environment).
+ *
+ * @public
+ */
+export declare class ValidationFailed extends ValidationFailedBase<{
+    /**
+     * Number of errors encountered.
+     */
+    readonly errorCount: number;
+    /**
+     * Number of warnings encountered.
+     */
+    readonly warningCount: number;
+    /**
+     * Formatted validation result message.
+     */
+    readonly message: string;
+}> {
+}
+
+/**
+ * Base class for ValidationFailed error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const ValidationFailedBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "ValidationFailed";
+} & Readonly<A>;
+
+/**
+ * Layer providing ValidationService (depends on ConfigService).
+ *
+ * @remarks
+ * Includes ConfigService automatically.
+ *
+ * @public
+ */
+export declare const ValidationLayer: Layer.Layer<ValidationService, never, never>;
+
+/**
+ * Validation options for the build process.
+ *
+ * @public
+ */
+export declare type ValidationOptions = typeof ValidationOptionsSchema.Type;
+
+/**
+ * Schema for validation options.
+ *
+ * @remarks
+ * Validation options control how strictly the build process validates
+ * the project structure and configuration before building.
+ *
+ * @internal
+ */
+export declare const ValidationOptionsSchema: Schema.Struct<{
+    /** Require action.yml to exist and be valid. Defaults to true. */
+    requireActionYml: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+    /** Maximum bundle size before warning/error (e.g., "5mb", "500kb"). */
+    maxBundleSize: Schema.optional<typeof Schema.String>;
+    /** Treat warnings as errors. Auto-detects from CI when undefined. */
+    strict: Schema.optional<typeof Schema.Boolean>;
+}>;
+
+/**
+ * Validation result with errors and warnings.
+ * @public
+ */
+export declare type ValidationResult = typeof ValidationResultSchema.Type;
+
+/**
+ * Validation result with errors and warnings.
+ * @internal
+ */
+export declare const ValidationResultSchema: Schema.Struct<{
+    /** Whether validation passed (no errors, or only warnings in non-strict mode). */
+    valid: typeof Schema.Boolean;
+    /** Validation errors. */
+    errors: Schema.Array$<Schema.Struct<{
+        /** Error code for categorization. */
+        code: typeof Schema.String;
+        /** Human-readable error message. */
+        message: typeof Schema.String;
+        /** File path where error occurred. */
+        file: Schema.optional<typeof Schema.String>;
+        /** Suggestion for fixing the error. */
+        suggestion: Schema.optional<typeof Schema.String>;
+    }>>;
+    /** Validation warnings. */
+    warnings: Schema.Array$<Schema.Struct<{
+        /** Warning code for categorization. */
+        code: typeof Schema.String;
+        /** Human-readable warning message. */
+        message: typeof Schema.String;
+        /** File path where warning occurred. */
+        file: Schema.optional<typeof Schema.String>;
+        /** Suggestion for addressing the warning. */
+        suggestion: Schema.optional<typeof Schema.String>;
+    }>>;
+}>;
+
+/**
+ * ValidationService interface for validation capabilities.
+ *
+ * @remarks
+ * This service handles:
+ * - Validating configuration and entry points
+ * - Validating action.yml structure and schema
+ * - Formatting validation results for display
+ * - CI-aware strict mode handling
+ *
+ * @example Using ValidationService with Effect
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AppLayer, ConfigService, ValidationService } from "@savvy-web/github-action-builder";
+ *
+ * const program = Effect.gen(function* () {
+ *   const configService = yield* ConfigService;
+ *   const validationService = yield* ValidationService;
+ *
+ *   const { config } = yield* configService.load();
+ *   const result = yield* validationService.validate(config);
+ *
+ *   if (!result.valid) {
+ *     console.error("Validation failed:", result.errors);
+ *   }
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(AppLayer)));
+ * ```
+ *
+ * @public
+ */
+export declare interface ValidationService {
+    /**
+     * Validate configuration and project structure.
+     *
+     * @param config - Configuration to validate
+     * @param options - Validation options
+     * @returns Effect that resolves to validation result
+     */
+    readonly validate: (config: Config, options?: ValidateOptions) => Effect.Effect<ValidationResult, ValidationError>;
+    /**
+     * Validate action.yml file.
+     *
+     * @param path - Path to action.yml file
+     * @returns Effect that resolves to action.yml validation result
+     */
+    readonly validateActionYml: (path: string) => Effect.Effect<ActionYmlResult, ValidationError>;
+    /**
+     * Format validation result for display.
+     *
+     * @param result - Validation result to format
+     * @returns Formatted string for terminal output
+     */
+    readonly formatResult: (result: ValidationResult) => string;
+    /**
+     * Check if running in CI environment.
+     *
+     * @returns Effect that resolves to true if in CI
+     */
+    readonly isCI: () => Effect.Effect<boolean>;
+    /**
+     * Check if strict mode is enabled.
+     *
+     * @param configStrict - Optional config override
+     * @returns Effect that resolves to true if strict mode
+     */
+    readonly isStrict: (configStrict?: boolean) => Effect.Effect<boolean>;
+}
+
+/**
+ * ValidationService tag for dependency injection.
+ *
+ * @public
+ */
+export declare const ValidationService: Context.Tag<ValidationService, ValidationService>;
+
+/**
+ * A validation warning.
+ * @public
+ */
+export declare type ValidationWarning = typeof ValidationWarningSchema.Type;
+
+/**
+ * A validation warning.
+ * @internal
+ */
+export declare const ValidationWarningSchema: Schema.Struct<{
+    /** Warning code for categorization. */
+    code: typeof Schema.String;
+    /** Human-readable warning message. */
+    message: typeof Schema.String;
+    /** File path where warning occurred. */
+    file: Schema.optional<typeof Schema.String>;
+    /** Suggestion for addressing the warning. */
+    suggestion: Schema.optional<typeof Schema.String>;
+}>;
+
+/**
+ * Error when writing output files fails.
+ *
+ * @public
+ */
+export declare class WriteError extends WriteErrorBase<{
+    /**
+     * The path that failed to write.
+     */
+    readonly path: string;
+    /**
+     * The underlying error message.
+     */
+    readonly cause: string;
+}> {
+}
+
+/**
+ * Base class for WriteError error.
+ *
+ * @privateRemarks
+ * This export is required for api-extractor documentation generation.
+ * Effect's Data.TaggedError creates an anonymous base class that must be
+ * explicitly exported to avoid "forgotten export" warnings. Do not delete.
+ *
+ * @internal
+ */
+export declare const WriteErrorBase: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: "WriteError";
+} & Readonly<A>;
+
+export { }