import { Command } from 'commander';
import { Result, HttpClient } from '@oidfed/core';
import { z } from 'zod';

declare const ConfigSchema: z.ZodObject<{
    trust_anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
        entity_id: z.ZodString;
        jwks: z.ZodOptional<z.ZodObject<{
            keys: z.ZodArray<z.ZodObject<{
                kty: z.ZodEnum<{
                    RSA: "RSA";
                    EC: "EC";
                    OKP: "OKP";
                }>;
                kid: z.ZodOptional<z.ZodString>;
                use: z.ZodOptional<z.ZodEnum<{
                    sig: "sig";
                    enc: "enc";
                }>>;
                alg: z.ZodOptional<z.ZodString>;
                key_ops: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                    sign: "sign";
                    verify: "verify";
                    encrypt: "encrypt";
                    decrypt: "decrypt";
                    wrapKey: "wrapKey";
                    unwrapKey: "unwrapKey";
                    deriveKey: "deriveKey";
                    deriveBits: "deriveBits";
                }>>>;
                n: z.ZodOptional<z.ZodString>;
                e: z.ZodOptional<z.ZodString>;
                crv: z.ZodOptional<z.ZodString>;
                x: z.ZodOptional<z.ZodString>;
                y: z.ZodOptional<z.ZodString>;
            }, z.core.$loose>>;
        }, z.core.$strip>>;
    }, z.core.$strict>>>;
    http_timeout_ms: z.ZodDefault<z.ZodNumber>;
    max_chain_depth: z.ZodDefault<z.ZodNumber>;
}, z.core.$strict>;
type Config = z.infer<typeof ConfigSchema>;
declare const DEFAULT_CONFIG: Config;
/**
 * Load the CLI configuration.
 *
 * Path resolution order:
 *   1. The `path` argument if supplied (typically from `--config`).
 *   2. `process.env.OIDFED_CONFIG_PATH` if set.
 *   3. The default `~/.oidfed/config.yaml`.
 *
 * Missing files (ENOENT) silently produce DEFAULT_CONFIG; YAML or schema
 * validation errors are returned as `Result.err`.
 */
declare function loadConfig(path?: string): Promise<Result<Config>>;

interface OutputFormatter {
    format(data: unknown): string;
}

declare function createFormatter(options: {
    json?: boolean | undefined;
}): OutputFormatter;

/** Exit codes: 0 = success, 1 = federation error, 2 = usage error */
declare const ExitCode: {
    readonly OK: 0;
    readonly FEDERATION_ERROR: 1;
    readonly USAGE_ERROR: 2;
};
type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];
declare function resultToExitCode(result: Result<unknown>): ExitCode;

declare function createHttpClient(timeoutMs?: number): HttpClient;

interface LoggerOptions {
    readonly quiet: boolean;
    readonly verbose: boolean;
    readonly stderr?: Pick<NodeJS.WritableStream, "write">;
}
interface Logger {
    info(msg: string): void;
    error(msg: string): void;
    debug(msg: string): void;
    warn(msg: string): void;
}
declare function createLogger(opts: LoggerOptions): Logger;

interface ProgramOptions {
    readonly json?: boolean | undefined;
    readonly quiet?: boolean;
    readonly verbose?: boolean;
    readonly config?: string;
}
declare function createProgram(): Command;
declare function run(argv: string[]): Promise<number>;

export { type Config, DEFAULT_CONFIG, ExitCode, type Logger, type OutputFormatter, type ProgramOptions, createFormatter, createHttpClient, createLogger, createProgram, loadConfig, resultToExitCode, run };