import { R as Result } from './types-Cgumy1N4.js';
import { d as ToolBaseOptions, c as DicomJsonModel } from './dcmodify-B-_uUIKB.js';
export { a as DcmodifyOptions, b as DcmodifyResult, D as DicomJsonElement, T as TagModification, e as dcmodify } from './dcmodify-B-_uUIKB.js';

/**
 * DICOM to XML conversion using the dcm2xml binary.
 *
 * Converts a DICOM file to the DCMTK Native DICOM Model XML format.
 *
 * @module dcm2xml
 */

/**
 * Charset handling modes for dcm2xml.
 */
declare const Dcm2xmlCharset: {
    /** Use UTF-8 encoding (default). */
    readonly UTF8: "utf8";
    /** Use Latin-1 encoding. */
    readonly LATIN1: "latin1";
    /** Use ASCII encoding. */
    readonly ASCII: "ascii";
};
type Dcm2xmlCharsetValue = (typeof Dcm2xmlCharset)[keyof typeof Dcm2xmlCharset];
/** Options for {@link dcm2xml}. */
interface Dcm2xmlOptions extends ToolBaseOptions {
    /** Include namespace declaration in XML output. Defaults to false. */
    readonly namespace?: boolean | undefined;
    /** Character set for XML output. Defaults to 'utf8'. */
    readonly charset?: Dcm2xmlCharsetValue | undefined;
    /** Write binary data to XML (base64 encoded). Defaults to false. */
    readonly writeBinaryData?: boolean | undefined;
    /** Encode binary data inline instead of referencing external files. Defaults to true when writeBinaryData is true. */
    readonly encodeBinaryBase64?: boolean | undefined;
}
/** Result of a successful dcm2xml conversion. */
interface Dcm2xmlResult {
    /** The XML output string in DCMTK Native DICOM Model format. */
    readonly xml: string;
}
/**
 * Converts a DICOM file to XML using the dcm2xml binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param options - Conversion options
 * @returns A Result containing the XML string or an error
 *
 * @example
 * ```ts
 * const result = await dcm2xml('/path/to/study.dcm');
 * if (result.ok) {
 *     console.log(result.value.xml);
 * }
 * ```
 */
declare function dcm2xml(inputPath: string, options?: Dcm2xmlOptions): Promise<Result<Dcm2xmlResult>>;

/**
 * DICOM to JSON conversion using a two-phase strategy.
 *
 * Primary: dcm2xml → xmlToJson (more reliable output)
 * Fallback: dcm2json binary → repairJson → JSON.parse
 *
 * The result includes a `source` discriminant indicating which strategy succeeded.
 *
 * @module dcm2json
 */

/** Indicates which conversion strategy produced the result. */
type Dcm2jsonSource = 'xml' | 'direct';
/** Options for {@link dcm2json}. */
interface Dcm2jsonOptions extends ToolBaseOptions {
    /** Skip the XML primary path and use direct dcm2json only. Defaults to false. */
    readonly directOnly?: boolean | undefined;
}
/** Result of a successful dcm2json conversion. */
interface Dcm2jsonResult {
    /** The DICOM JSON Model object. */
    readonly data: DicomJsonModel;
    /** Which conversion strategy produced this result. */
    readonly source: Dcm2jsonSource;
}
/**
 * Converts a DICOM file to the DICOM JSON Model.
 *
 * Uses a two-phase strategy:
 * 1. Primary: dcm2xml → XML-to-JSON conversion (more reliable)
 * 2. Fallback: direct dcm2json binary with JSON repair
 *
 * @param inputPath - Path to the DICOM input file
 * @param options - Conversion options
 * @returns A Result containing the DICOM JSON Model with source discriminant
 *
 * @example
 * ```ts
 * const result = await dcm2json('/path/to/study.dcm');
 * if (result.ok) {
 *     console.log(result.value.source); // 'xml' or 'direct'
 *     console.log(result.value.data['00100010']); // Patient Name
 * }
 * ```
 */
declare function dcm2json(inputPath: string, options?: Dcm2jsonOptions): Promise<Result<Dcm2jsonResult>>;

/**
 * Dump DICOM metadata as text using the dcmdump binary.
 *
 * @module dcmdump
 */

/**
 * Output format for dcmdump.
 */
declare const DcmdumpFormat: {
    /** Print standard DCMTK format. */
    readonly STANDARD: "standard";
    /** Print tag and value only. */
    readonly SHORT: "short";
};
type DcmdumpFormatValue = (typeof DcmdumpFormat)[keyof typeof DcmdumpFormat];
/** Options for {@link dcmdump}. */
interface DcmdumpOptions extends ToolBaseOptions {
    /** Output format. Defaults to 'standard'. */
    readonly format?: DcmdumpFormatValue | undefined;
    /** Print all tags including private tags. Defaults to false. */
    readonly allTags?: boolean | undefined;
    /** Search for a specific tag. */
    readonly searchTag?: string | undefined;
    /** Print tag values with enhanced detail. Defaults to false. */
    readonly printValues?: boolean | undefined;
}
/** Result of a successful dcmdump operation. */
interface DcmdumpResult {
    /** The text output from dcmdump. */
    readonly text: string;
}
/**
 * Dumps DICOM metadata as text using the dcmdump binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param options - Dump options
 * @returns A Result containing the text dump or an error
 *
 * @example
 * ```ts
 * const result = await dcmdump('/path/to/study.dcm');
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function dcmdump(inputPath: string, options?: DcmdumpOptions): Promise<Result<DcmdumpResult>>;

/**
 * Convert DICOM file encoding/transfer syntax using the dcmconv binary.
 *
 * @module dcmconv
 */

/**
 * Transfer syntax presets for dcmconv.
 */
declare const TransferSyntax: {
    /** Implicit VR Little Endian. */
    readonly IMPLICIT_LITTLE: "+ti";
    /** Explicit VR Little Endian. */
    readonly EXPLICIT_LITTLE: "+te";
    /** Explicit VR Big Endian (deprecated in DICOM). */
    readonly EXPLICIT_BIG: "+tb";
    /** JPEG Lossless. */
    readonly JPEG_LOSSLESS: "+tl";
    /** JPEG 2000 Lossless. */
    readonly JPEG2K_LOSSLESS: "+t2";
    /** RLE Lossless. */
    readonly RLE: "+tr";
    /** Deflated Explicit VR Little Endian. */
    readonly DEFLATED: "+td";
};
type TransferSyntaxValue = (typeof TransferSyntax)[keyof typeof TransferSyntax];
/** Options for {@link dcmconv}. */
interface DcmconvOptions extends ToolBaseOptions {
    /** Target transfer syntax. Required. */
    readonly transferSyntax: TransferSyntaxValue;
}
/** Result of a successful dcmconv conversion. */
interface DcmconvResult {
    /** Path to the converted output file. */
    readonly outputPath: string;
}
/**
 * Converts a DICOM file's transfer syntax using the dcmconv binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the converted output file
 * @param options - Conversion options (transfer syntax required)
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmconv('/path/to/input.dcm', '/path/to/output.dcm', {
 *     transferSyntax: '+te', // Explicit VR Little Endian
 * });
 * if (result.ok) {
 *     console.log(`Converted: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmconv(inputPath: string, outputPath: string, options: DcmconvOptions): Promise<Result<DcmconvResult>>;

/**
 * Test if a file is a valid DICOM Part 10 file using the dcmftest binary.
 *
 * @module dcmftest
 */

/** Options for {@link dcmftest}. */
interface DcmftestOptions extends ToolBaseOptions {
}
/** Result of a successful dcmftest check. */
interface DcmftestResult {
    /** Whether the tested file is a valid DICOM Part 10 file. */
    readonly isDicom: boolean;
}
/**
 * Tests whether a file is a valid DICOM Part 10 file using the dcmftest binary.
 *
 * The dcmftest binary always returns exit code 0 regardless of result.
 * The determination is made by parsing stdout for "yes:" (DICOM) or "no:" (not DICOM).
 *
 * @param inputPath - Path to the file to test
 * @param options - Test options
 * @returns A Result containing the isDicom flag or an error
 *
 * @example
 * ```ts
 * const result = await dcmftest('/path/to/file.dcm');
 * if (result.ok) {
 *     console.log(result.value.isDicom ? 'Valid DICOM' : 'Not DICOM');
 * }
 * ```
 */
declare function dcmftest(inputPath: string, options?: DcmftestOptions): Promise<Result<DcmftestResult>>;

/**
 * Create a DICOMDIR file from DICOM files using the dcmgpdir binary.
 *
 * @module dcmgpdir
 */

/** Options for {@link dcmgpdir}. */
interface DcmgpdirOptions extends ToolBaseOptions {
    /** One or more DICOM file paths to include in the DICOMDIR. */
    readonly inputFiles: readonly string[];
    /** Output DICOMDIR file path. Maps to +D flag. **Warning:** defaults to 'DICOMDIR' in the current working directory if omitted. */
    readonly outputFile?: string | undefined;
    /** File-set ID to embed in the DICOMDIR. Maps to +F flag. */
    readonly filesetId?: string | undefined;
    /** Root directory for referenced DICOM files. Maps to +id flag. */
    readonly inputDirectory?: string | undefined;
    /** Map filenames to DICOM format (uppercase, strip trailing period). Maps to +m flag. */
    readonly mapFilenames?: boolean | undefined;
    /** Invent missing DICOMDIR type 1 attributes. Maps to +I flag. */
    readonly inventAttributes?: boolean | undefined;
}
/** Result of a successful dcmgpdir operation. */
interface DcmgpdirResult {
    /** Path to the generated DICOMDIR file. */
    readonly outputPath: string;
}
/**
 * Creates a DICOMDIR file from DICOM files using the dcmgpdir binary.
 *
 * @param options - DICOMDIR creation options (inputFiles required)
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmgpdir({
 *     inputFiles: ['/path/to/file1.dcm', '/path/to/file2.dcm'],
 *     outputFile: '/path/to/DICOMDIR',
 *     filesetId: 'MY_FILESET',
 * });
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmgpdir(options: DcmgpdirOptions): Promise<Result<DcmgpdirResult>>;

/**
 * Create a DICOMDIR file from DICOM files using the dcmmkdir binary.
 *
 * @module dcmmkdir
 */

/** Options for {@link dcmmkdir}. */
interface DcmmkdirOptions extends ToolBaseOptions {
    /** One or more DICOM file paths to include in the DICOMDIR. */
    readonly inputFiles: readonly string[];
    /** Output DICOMDIR file path. Maps to +D flag. **Warning:** defaults to 'DICOMDIR' in the current working directory if omitted. */
    readonly outputFile?: string | undefined;
    /** File-set ID to embed in the DICOMDIR. Maps to +F flag. */
    readonly filesetId?: string | undefined;
    /** Append to existing DICOMDIR. Maps to +A flag. Defaults to false. */
    readonly append?: boolean | undefined;
    /** Root directory for referenced DICOM files. Maps to +id flag. */
    readonly inputDirectory?: string | undefined;
    /** Map filenames to DICOM format (uppercase, strip trailing period). Maps to +m flag. */
    readonly mapFilenames?: boolean | undefined;
    /** Invent missing DICOMDIR type 1 attributes. Maps to +I flag. */
    readonly inventAttributes?: boolean | undefined;
}
/** Result of a successful dcmmkdir operation. */
interface DcmmkdirResult {
    /** Path to the generated DICOMDIR file. */
    readonly outputPath: string;
}
/**
 * Creates a DICOMDIR file from DICOM files using the dcmmkdir binary.
 *
 * @param options - DICOMDIR creation options (inputFiles required)
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmmkdir({
 *     inputFiles: ['/path/to/file1.dcm', '/path/to/file2.dcm'],
 *     outputFile: '/path/to/DICOMDIR',
 *     filesetId: 'MY_FILESET',
 * });
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmmkdir(options: DcmmkdirOptions): Promise<Result<DcmmkdirResult>>;

/**
 * Register DICOM files in a dcmqrscp index database using the dcmqridx binary.
 *
 * @module dcmqridx
 */

/** Options for {@link dcmqridx}. */
interface DcmqridxOptions extends ToolBaseOptions {
    /** Storage area / index directory path (required). */
    readonly indexDirectory: string;
    /** DICOM files to register. Omit for print-only mode. */
    readonly inputFiles?: readonly string[] | undefined;
    /** List database contents (-p flag). */
    readonly print?: boolean | undefined;
    /** Mark status as "not new" (-n flag). */
    readonly notNew?: boolean | undefined;
}
/** Result of a successful dcmqridx operation. */
type DcmqridxResult = {
    readonly mode: 'register';
} | {
    readonly mode: 'print';
    readonly output: string;
};
/**
 * Register DICOM files in a dcmqrscp index database or print database contents.
 *
 * @param options - Index operation options (indexDirectory required)
 * @returns A Result containing the operation result or an error
 */
declare function dcmqridx(options: DcmqridxOptions): Promise<Result<DcmqridxResult>>;

/**
 * Convert an XML file to DICOM format using the xml2dcm binary.
 *
 * @module xml2dcm
 */

/** Options for {@link xml2dcm}. */
interface Xml2dcmOptions extends ToolBaseOptions {
    /** Generate new Study/Series/SOP Instance UIDs. Defaults to false. */
    readonly generateNewUIDs?: boolean | undefined;
    /** Validate the XML document. Defaults to false. */
    readonly validateDocument?: boolean | undefined;
}
/** Result of a successful xml2dcm conversion. */
interface Xml2dcmResult {
    /** Path to the generated DICOM output file. */
    readonly outputPath: string;
}
/**
 * Converts an XML file to DICOM format using the xml2dcm binary.
 *
 * @param inputPath - Path to the XML input file
 * @param outputPath - Path for the DICOM output file
 * @param options - Conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await xml2dcm('/path/to/input.xml', '/path/to/output.dcm', {
 *     generateNewUIDs: true,
 * });
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function xml2dcm(inputPath: string, outputPath: string, options?: Xml2dcmOptions): Promise<Result<Xml2dcmResult>>;

/**
 * Convert a JSON file to DICOM format using the json2dcm binary.
 *
 * @module json2dcm
 */

/** Options for {@link json2dcm}. */
type Json2dcmOptions = ToolBaseOptions;
/** Result of a successful json2dcm conversion. */
interface Json2dcmResult {
    /** Path to the generated DICOM output file. */
    readonly outputPath: string;
}
/**
 * Converts a JSON file to DICOM format using the json2dcm binary.
 *
 * @param inputPath - Path to the JSON input file
 * @param outputPath - Path for the DICOM output file
 * @param options - Conversion options (timeout, signal)
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await json2dcm('/path/to/input.json', '/path/to/output.dcm');
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function json2dcm(inputPath: string, outputPath: string, options?: Json2dcmOptions): Promise<Result<Json2dcmResult>>;

/**
 * Convert a dump file to DICOM format using the dump2dcm binary.
 *
 * @module dump2dcm
 */

/** Options for {@link dump2dcm}. */
interface Dump2dcmOptions extends ToolBaseOptions {
    /** Generate new Study/Series/SOP Instance UIDs. Defaults to false. */
    readonly generateNewUIDs?: boolean | undefined;
    /** Write output as DICOM file format (with preamble + meta header). Defaults to false. */
    readonly writeFileFormat?: boolean | undefined;
}
/** Result of a successful dump2dcm conversion. */
interface Dump2dcmResult {
    /** Path to the generated DICOM output file. */
    readonly outputPath: string;
}
/**
 * Converts a dump file to DICOM format using the dump2dcm binary.
 *
 * @param inputPath - Path to the dump input file
 * @param outputPath - Path for the DICOM output file
 * @param options - Conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dump2dcm('/path/to/input.dump', '/path/to/output.dcm', {
 *     generateNewUIDs: true,
 * });
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dump2dcm(inputPath: string, outputPath: string, options?: Dump2dcmOptions): Promise<Result<Dump2dcmResult>>;

/**
 * Convert an image file to DICOM format using the img2dcm binary.
 *
 * @module img2dcm
 */

/**
 * Supported input image formats for img2dcm.
 */
declare const Img2dcmInputFormat: {
    /** JPEG image. */
    readonly JPEG: "jpeg";
    /** BMP image. */
    readonly BMP: "bmp";
};
type Img2dcmInputFormatValue = (typeof Img2dcmInputFormat)[keyof typeof Img2dcmInputFormat];
/** Options for {@link img2dcm}. */
interface Img2dcmOptions extends ToolBaseOptions {
    /** Input image format. Maps to `-i JPEG` or `-i BMP`. */
    readonly inputFormat?: Img2dcmInputFormatValue | undefined;
    /** Path to a DICOM dataset file to copy attributes from. Maps to `-df path`. */
    readonly datasetFrom?: string | undefined;
}
/** Result of a successful img2dcm conversion. */
interface Img2dcmResult {
    /** Path to the generated DICOM output file. */
    readonly outputPath: string;
}
/**
 * Converts an image file to DICOM format using the img2dcm binary.
 *
 * @param inputPath - Path to the image input file
 * @param outputPath - Path for the DICOM output file
 * @param options - Conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await img2dcm('/path/to/photo.jpg', '/path/to/output.dcm', {
 *     inputFormat: 'jpeg',
 * });
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function img2dcm(inputPath: string, outputPath: string, options?: Img2dcmOptions): Promise<Result<Img2dcmResult>>;

/**
 * Encapsulate a PDF file into a DICOM object using the pdf2dcm binary.
 *
 * @module pdf2dcm
 */

/** Options for {@link pdf2dcm}. */
type Pdf2dcmOptions = ToolBaseOptions;
/** Result of a successful pdf2dcm operation. */
interface Pdf2dcmResult {
    /** Path to the output DICOM file. */
    readonly outputPath: string;
}
/**
 * Encapsulate a PDF file into a DICOM object using the pdf2dcm binary.
 *
 * @param inputPath - Path to the PDF input file
 * @param outputPath - Path for the output DICOM file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 */
declare function pdf2dcm(inputPath: string, outputPath: string, options?: Pdf2dcmOptions): Promise<Result<Pdf2dcmResult>>;

/**
 * Extract an encapsulated PDF from a DICOM file using the dcm2pdf binary.
 *
 * @module dcm2pdf
 */

/** Options for {@link dcm2pdf}. */
type Dcm2pdfOptions = ToolBaseOptions;
/** Result of a successful dcm2pdf operation. */
interface Dcm2pdfResult {
    /** Path to the extracted PDF file. */
    readonly outputPath: string;
}
/**
 * Extract an encapsulated PDF from a DICOM file using the dcm2pdf binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the extracted PDF output file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 */
declare function dcm2pdf(inputPath: string, outputPath: string, options?: Dcm2pdfOptions): Promise<Result<Dcm2pdfResult>>;

/**
 * Encapsulate a CDA document into a DICOM object using the cda2dcm binary.
 *
 * @module cda2dcm
 */

/** Options for {@link cda2dcm}. */
type Cda2dcmOptions = ToolBaseOptions;
/** Result of a successful cda2dcm operation. */
interface Cda2dcmResult {
    /** Path to the output DICOM file. */
    readonly outputPath: string;
}
/**
 * Encapsulate a CDA document into a DICOM object using the cda2dcm binary.
 *
 * @param inputPath - Path to the CDA input file
 * @param outputPath - Path for the output DICOM file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 */
declare function cda2dcm(inputPath: string, outputPath: string, options?: Cda2dcmOptions): Promise<Result<Cda2dcmResult>>;

/**
 * Extract an encapsulated CDA document from a DICOM file using the dcm2cda binary.
 *
 * @module dcm2cda
 */

/** Options for {@link dcm2cda}. */
type Dcm2cdaOptions = ToolBaseOptions;
/** Result of a successful dcm2cda operation. */
interface Dcm2cdaResult {
    /** Path to the extracted CDA file. */
    readonly outputPath: string;
}
/**
 * Extract an encapsulated CDA document from a DICOM file using the dcm2cda binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the extracted CDA output file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 */
declare function dcm2cda(inputPath: string, outputPath: string, options?: Dcm2cdaOptions): Promise<Result<Dcm2cdaResult>>;

/**
 * Convert an STL file to a DICOM object using the stl2dcm binary.
 *
 * @module stl2dcm
 */

/** Options for {@link stl2dcm}. */
interface Stl2dcmOptions extends ToolBaseOptions {
}
/** Result of a successful stl2dcm conversion. */
interface Stl2dcmResult {
    /** Path to the generated DICOM output file. */
    readonly outputPath: string;
}
/**
 * Converts an STL file to a DICOM object using the stl2dcm binary.
 *
 * @param inputPath - Path to the STL input file
 * @param outputPath - Path for the DICOM output file
 * @param options - Conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await stl2dcm('/path/to/model.stl', '/path/to/output.dcm');
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function stl2dcm(inputPath: string, outputPath: string, options?: Stl2dcmOptions): Promise<Result<Stl2dcmResult>>;

/**
 * Encode a DICOM file with RLE compression using the dcmcrle binary.
 *
 * @module dcmcrle
 */

/** Options for {@link dcmcrle}. */
interface DcmcrleOptions extends ToolBaseOptions {
    /** Always write new SOP Instance UID. Maps to +ua flag. */
    readonly uidAlways?: boolean | undefined;
}
/** Result of a successful dcmcrle encoding. */
interface DcmcrleResult {
    /** Path to the RLE-compressed output file. */
    readonly outputPath: string;
}
/**
 * Encodes a DICOM file with RLE compression using the dcmcrle binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the RLE-compressed output file
 * @param options - Encoding options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmcrle('/path/to/input.dcm', '/path/to/output.dcm', {
 *     uidAlways: true,
 * });
 * if (result.ok) {
 *     console.log(`Encoded: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmcrle(inputPath: string, outputPath: string, options?: DcmcrleOptions): Promise<Result<DcmcrleResult>>;

/**
 * Decode an RLE-compressed DICOM file using the dcmdrle binary.
 *
 * @module dcmdrle
 */

/** Options for {@link dcmdrle}. */
interface DcmdrleOptions extends ToolBaseOptions {
    /** Always write new SOP Instance UID. Maps to +ua flag. */
    readonly uidAlways?: boolean | undefined;
}
/** Result of a successful dcmdrle decoding. */
interface DcmdrleResult {
    /** Path to the decoded output file. */
    readonly outputPath: string;
}
/**
 * Decodes an RLE-compressed DICOM file using the dcmdrle binary.
 *
 * @param inputPath - Path to the RLE-compressed DICOM input file
 * @param outputPath - Path for the decoded output file
 * @param options - Decoding options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmdrle('/path/to/compressed.dcm', '/path/to/output.dcm', {
 *     uidAlways: true,
 * });
 * if (result.ok) {
 *     console.log(`Decoded: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmdrle(inputPath: string, outputPath: string, options?: DcmdrleOptions): Promise<Result<DcmdrleResult>>;

/**
 * Encapsulate a non-DICOM document into a DICOM file using the dcmencap binary.
 *
 * @module dcmencap
 */

/** Options for {@link dcmencap}. */
interface DcmencapOptions extends ToolBaseOptions {
    /** Document title for the encapsulated document. Maps to --title. */
    readonly documentTitle?: string | undefined;
}
/** Result of a successful dcmencap operation. */
interface DcmencapResult {
    /** Path to the output DICOM file. */
    readonly outputPath: string;
}
/**
 * Encapsulate a non-DICOM document into a DICOM file using the dcmencap binary.
 *
 * @param inputPath - Path to the input document
 * @param outputPath - Path for the output DICOM file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 */
declare function dcmencap(inputPath: string, outputPath: string, options?: DcmencapOptions): Promise<Result<DcmencapResult>>;

/**
 * Extract an encapsulated document from a DICOM file using the dcmdecap binary.
 *
 * @module dcmdecap
 */

/** Options for {@link dcmdecap}. */
interface DcmdecapOptions extends ToolBaseOptions {
}
/** Result of a successful dcmdecap operation. */
interface DcmdecapResult {
    /** Path to the extracted output file. */
    readonly outputPath: string;
}
/**
 * Extract an encapsulated document from a DICOM file using the dcmdecap binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the extracted output file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 */
declare function dcmdecap(inputPath: string, outputPath: string, options?: DcmdecapOptions): Promise<Result<DcmdecapResult>>;

/**
 * Compress a DICOM file with JPEG encoding using the dcmcjpeg binary.
 *
 * @module dcmcjpeg
 */

/** Options for {@link dcmcjpeg}. */
interface DcmcjpegOptions extends ToolBaseOptions {
    /** JPEG quality factor (1-100). Maps to +q. */
    readonly quality?: number | undefined;
    /** Use lossless JPEG compression (SV1). Maps to +e1. */
    readonly lossless?: boolean | undefined;
}
/** Result of a successful dcmcjpeg operation. */
interface DcmcjpegResult {
    /** Path to the compressed output DICOM file. */
    readonly outputPath: string;
}
/**
 * Compress a DICOM file with JPEG encoding using the dcmcjpeg binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the compressed output DICOM file
 * @param options - Optional compression options
 * @returns A Result containing the output path or an error
 */
declare function dcmcjpeg(inputPath: string, outputPath: string, options?: DcmcjpegOptions): Promise<Result<DcmcjpegResult>>;

/**
 * Decompress a JPEG-compressed DICOM file using the dcmdjpeg binary.
 *
 * @module dcmdjpeg
 */

/**
 * Color conversion modes for dcmdjpeg.
 */
declare const ColorConversion: {
    /** Use photometric interpretation from the dataset. */
    readonly PHOTOMETRIC: "photometric";
    /** Always convert to RGB. */
    readonly ALWAYS: "always";
    /** Never convert color space. */
    readonly NEVER: "never";
};
type ColorConversionValue = (typeof ColorConversion)[keyof typeof ColorConversion];
/** Options for {@link dcmdjpeg}. */
interface DcmdjpegOptions extends ToolBaseOptions {
    /** Color conversion mode. Maps to +cp, +ca, or +cn. */
    readonly colorConversion?: ColorConversionValue | undefined;
}
/** Result of a successful dcmdjpeg operation. */
interface DcmdjpegResult {
    /** Path to the decompressed output DICOM file. */
    readonly outputPath: string;
}
/**
 * Decompress a JPEG-compressed DICOM file using the dcmdjpeg binary.
 *
 * @param inputPath - Path to the JPEG-compressed DICOM input file
 * @param outputPath - Path for the decompressed output DICOM file
 * @param options - Optional decompression options
 * @returns A Result containing the output path or an error
 */
declare function dcmdjpeg(inputPath: string, outputPath: string, options?: DcmdjpegOptions): Promise<Result<DcmdjpegResult>>;

/**
 * Compress a DICOM file with JPEG-LS encoding using the dcmcjpls binary.
 *
 * @module dcmcjpls
 */

/** Options for {@link dcmcjpls}. */
interface DcmcjplsOptions extends ToolBaseOptions {
    /** Use lossless JPEG-LS compression (default). Maps to +el. */
    readonly lossless?: boolean | undefined;
    /** Maximum pixel deviation for near-lossless mode. Maps to +md. */
    readonly maxDeviation?: number | undefined;
}
/** Result of a successful dcmcjpls operation. */
interface DcmcjplsResult {
    /** Path to the compressed output DICOM file. */
    readonly outputPath: string;
}
/**
 * Compress a DICOM file with JPEG-LS encoding using the dcmcjpls binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the compressed output DICOM file
 * @param options - Optional compression options
 * @returns A Result containing the output path or an error
 */
declare function dcmcjpls(inputPath: string, outputPath: string, options?: DcmcjplsOptions): Promise<Result<DcmcjplsResult>>;

/**
 * Decompress a JPEG-LS-compressed DICOM file using the dcmdjpls binary.
 *
 * @module dcmdjpls
 */

/**
 * Color conversion modes for dcmdjpls.
 */
declare const JplsColorConversion: {
    /** Use photometric interpretation from the dataset. */
    readonly PHOTOMETRIC: "photometric";
    /** Always convert to RGB. */
    readonly ALWAYS: "always";
    /** Never convert color space. */
    readonly NEVER: "never";
};
type JplsColorConversionValue = (typeof JplsColorConversion)[keyof typeof JplsColorConversion];
/** Options for {@link dcmdjpls}. */
interface DcmdjplsOptions extends ToolBaseOptions {
    /** Color conversion mode. Maps to +cp, +ca, or +cn. */
    readonly colorConversion?: JplsColorConversionValue | undefined;
}
/** Result of a successful dcmdjpls operation. */
interface DcmdjplsResult {
    /** Path to the decompressed output DICOM file. */
    readonly outputPath: string;
}
/**
 * Decompress a JPEG-LS-compressed DICOM file using the dcmdjpls binary.
 *
 * @param inputPath - Path to the JPEG-LS-compressed DICOM input file
 * @param outputPath - Path for the decompressed output DICOM file
 * @param options - Optional decompression options
 * @returns A Result containing the output path or an error
 */
declare function dcmdjpls(inputPath: string, outputPath: string, options?: DcmdjplsOptions): Promise<Result<DcmdjplsResult>>;

/**
 * Convert a DICOM image to a standard image format using the dcmj2pnm binary.
 *
 * @module dcmj2pnm
 */

/**
 * Output format presets for dcmj2pnm.
 */
declare const Dcmj2pnmOutputFormat: {
    /** Portable aNy Map format. */
    readonly PNM: "pnm";
    /** PNG format. */
    readonly PNG: "png";
    /** BMP format. */
    readonly BMP: "bmp";
    /** TIFF format. */
    readonly TIFF: "tiff";
    /** JPEG format. */
    readonly JPEG: "jpeg";
};
type Dcmj2pnmOutputFormatValue = (typeof Dcmj2pnmOutputFormat)[keyof typeof Dcmj2pnmOutputFormat];
/** Options for {@link dcmj2pnm}. */
interface Dcmj2pnmOptions extends ToolBaseOptions {
    /** Output image format. Defaults to PNM if not specified. */
    readonly outputFormat?: Dcmj2pnmOutputFormatValue | undefined;
    /** Frame number to extract (0-based). */
    readonly frame?: number | undefined;
}
/** Result of a successful dcmj2pnm operation. */
interface Dcmj2pnmResult {
    /** Path to the converted output file. */
    readonly outputPath: string;
}
/**
 * Convert a DICOM image to a standard image format using the dcmj2pnm binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the converted output image file
 * @param options - Optional conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmj2pnm('/path/to/input.dcm', '/path/to/output.png', {
 *     outputFormat: 'png',
 * });
 * if (result.ok) {
 *     console.log(`Converted: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmj2pnm(inputPath: string, outputPath: string, options?: Dcmj2pnmOptions): Promise<Result<Dcmj2pnmResult>>;

/**
 * Convert a DICOM image to PNM/PNG/BMP/TIFF format using the dcm2pnm binary.
 *
 * @module dcm2pnm
 */

/**
 * Output format presets for dcm2pnm.
 */
declare const Dcm2pnmOutputFormat: {
    /** Portable aNy Map format. */
    readonly PNM: "pnm";
    /** PNG format. */
    readonly PNG: "png";
    /** BMP format. */
    readonly BMP: "bmp";
    /** TIFF format. */
    readonly TIFF: "tiff";
};
type Dcm2pnmOutputFormatValue = (typeof Dcm2pnmOutputFormat)[keyof typeof Dcm2pnmOutputFormat];
/** Options for {@link dcm2pnm}. */
interface Dcm2pnmOptions extends ToolBaseOptions {
    /** Output image format. Defaults to PNM if not specified. */
    readonly outputFormat?: Dcm2pnmOutputFormatValue | undefined;
    /** Frame number to extract (0-based, max 65535). */
    readonly frame?: number | undefined;
}
/** Result of a successful dcm2pnm operation. */
interface Dcm2pnmResult {
    /** Path to the converted output file. */
    readonly outputPath: string;
}
/**
 * Convert a DICOM image to PNM/PNG/BMP/TIFF format using the dcm2pnm binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the converted output image file
 * @param options - Optional conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcm2pnm('/path/to/input.dcm', '/path/to/output.png', {
 *     outputFormat: 'png',
 * });
 * if (result.ok) {
 *     console.log(`Converted: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcm2pnm(inputPath: string, outputPath: string, options?: Dcm2pnmOptions): Promise<Result<Dcm2pnmResult>>;

/**
 * Scale a DICOM image using the dcmscale binary.
 *
 * @module dcmscale
 */

/** Options for {@link dcmscale}. */
interface DcmscaleOptions extends ToolBaseOptions {
    /** Horizontal scaling factor (max 100). */
    readonly xFactor?: number | undefined;
    /** Vertical scaling factor (max 100). */
    readonly yFactor?: number | undefined;
    /** Target width in pixels. */
    readonly xSize?: number | undefined;
    /** Target height in pixels. */
    readonly ySize?: number | undefined;
}
/** Result of a successful dcmscale operation. */
interface DcmscaleResult {
    /** Path to the scaled output file. */
    readonly outputPath: string;
}
/**
 * Scale a DICOM image using the dcmscale binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the scaled output file
 * @param options - Optional scaling options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmscale('/path/to/input.dcm', '/path/to/output.dcm', {
 *     xFactor: 0.5,
 *     yFactor: 0.5,
 * });
 * if (result.ok) {
 *     console.log(`Scaled: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmscale(inputPath: string, outputPath: string, options?: DcmscaleOptions): Promise<Result<DcmscaleResult>>;

/**
 * Quantize a color DICOM image to palette color using the dcmquant binary.
 *
 * @module dcmquant
 */

/** Options for {@link dcmquant}. */
interface DcmquantOptions extends ToolBaseOptions {
    /** Number of colors in the palette (2-65536). */
    readonly colors?: number | undefined;
    /** Frame number to extract (0-based, max 65535). */
    readonly frame?: number | undefined;
}
/** Result of a successful dcmquant operation. */
interface DcmquantResult {
    /** Path to the quantized output file. */
    readonly outputPath: string;
}
/**
 * Quantize a color DICOM image to palette color using the dcmquant binary.
 *
 * @param inputPath - Path to the DICOM input file
 * @param outputPath - Path for the quantized output file
 * @param options - Optional quantization options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmquant('/path/to/input.dcm', '/path/to/output.dcm', {
 *     colors: 256,
 * });
 * if (result.ok) {
 *     console.log(`Quantized: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmquant(inputPath: string, outputPath: string, options?: DcmquantOptions): Promise<Result<DcmquantResult>>;

/**
 * Export display function curves using the dcmdspfn binary.
 *
 * Generates GSDF (Grayscale Standard Display Function) lookup tables
 * for monitor, camera, or printer calibration.
 *
 * @module dcmdspfn
 */

/** Options for {@link dcmdspfn}. */
interface DcmdspfnOptions extends ToolBaseOptions {
    /** Path to monitor characteristics file. Maps to `+Im`. */
    readonly monitorFile?: string | undefined;
    /** Path to camera characteristics file. Maps to `+Ic`. */
    readonly cameraFile?: string | undefined;
    /** Path to printer characteristics file. Maps to `+Ip`. */
    readonly printerFile?: string | undefined;
    /** Ambient light value in cd/m2. Maps to `+Ca`. */
    readonly ambientLight?: number | undefined;
}
/** Result of a successful dcmdspfn operation. */
interface DcmdspfnResult {
    /** The text output from dcmdspfn. */
    readonly text: string;
}
/**
 * Exports display function curves using the dcmdspfn binary.
 *
 * @param options - Optional display function options
 * @returns A Result containing the text output or an error
 *
 * @example
 * ```ts
 * const result = await dcmdspfn({ monitorFile: '/path/to/monitor.lut' });
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function dcmdspfn(options?: DcmdspfnOptions): Promise<Result<DcmdspfnResult>>;

/**
 * Convert hardcopy OD values to softcopy P-values using the dcod2lum binary.
 *
 * Converts Optical Density (OD) calibration data from a hardcopy device
 * into luminance (P-value) data suitable for softcopy display.
 *
 * @module dcod2lum
 */

/** Options for {@link dcod2lum}. */
type Dcod2lumOptions = ToolBaseOptions;
/** Result of a successful dcod2lum operation. */
interface Dcod2lumResult {
    /** Path to the converted output file. */
    readonly outputPath: string;
}
/**
 * Converts hardcopy OD values to softcopy P-values using the dcod2lum binary.
 *
 * @param inputPath - Path to the OD input file
 * @param outputPath - Path for the converted luminance output file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcod2lum('/path/to/od.dat', '/path/to/lum.dat');
 * if (result.ok) {
 *     console.log(`Converted: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcod2lum(inputPath: string, outputPath: string, options?: Dcod2lumOptions): Promise<Result<Dcod2lumResult>>;

/**
 * Convert VeriLUM calibration data to DCMTK display format using the dconvlum binary.
 *
 * Reads VeriLUM luminance calibration data and converts it into
 * a format suitable for use with DCMTK display function tools.
 *
 * @module dconvlum
 */

/** Options for {@link dconvlum}. */
interface DconvlumOptions extends ToolBaseOptions {
    /** Ambient light value in cd/m2. Maps to `+Ca`. */
    readonly ambientLight?: number | undefined;
}
/** Result of a successful dconvlum operation. */
interface DconvlumResult {
    /** Path to the converted output file. */
    readonly outputPath: string;
}
/**
 * Converts VeriLUM calibration data to DCMTK display format using the dconvlum binary.
 *
 * @param inputPath - Path to the VeriLUM input file
 * @param outputPath - Path for the converted output file
 * @param options - Optional conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dconvlum('/path/to/verilum.dat', '/path/to/display.dat', {
 *     ambientLight: 10,
 * });
 * if (result.ok) {
 *     console.log(`Converted: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dconvlum(inputPath: string, outputPath: string, options?: DconvlumOptions): Promise<Result<DconvlumResult>>;

/**
 * C-ECHO verification using the echoscu binary.
 *
 * Tests DICOM network connectivity by sending a C-ECHO request
 * to a remote DICOM SCP (Service Class Provider).
 *
 * @module echoscu
 */

/** Options for {@link echoscu}. */
interface EchoscuOptions extends ToolBaseOptions {
    /** Remote host or IP address. **Security:** Not validated for SSRF — callers accepting user input should validate against private/internal IP ranges. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
}
/** Result of a successful C-ECHO. */
interface EchoscuResult {
    /** Always `true` when the Result is `ok` — redundant with `Result.ok` but kept for API compatibility. @deprecated Check `Result.ok` instead. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Sends a C-ECHO request to a remote DICOM SCP to verify connectivity.
 *
 * @param options - Echo options (host and port required)
 * @returns A Result containing the echo result or an error
 *
 * @example
 * ```ts
 * const result = await echoscu({ host: '192.168.1.100', port: 104 });
 * if (result.ok) {
 *     console.log(result.value.success ? 'Echo succeeded' : 'Echo failed');
 * }
 * ```
 */
declare function echoscu(options: EchoscuOptions): Promise<Result<EchoscuResult>>;

/**
 * C-STORE send using the dcmsend binary.
 *
 * Sends one or more DICOM files to a remote DICOM SCP.
 *
 * @module dcmsend
 */

/** Options for {@link dcmsend}. */
interface DcmsendOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** One or more DICOM file paths to send. */
    readonly files: readonly string[];
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
    /** Scan input directory recursively for DICOM files. Defaults to false. */
    readonly scanDirectory?: boolean | undefined;
}
/** Result of a successful C-STORE send. */
interface DcmsendResult {
    /** Whether the send completed successfully. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Sends DICOM files to a remote SCP using C-STORE via the dcmsend binary.
 *
 * @param options - Send options (host, port, files required)
 * @returns A Result containing the send result or an error
 *
 * @example
 * ```ts
 * const result = await dcmsend({
 *     host: '192.168.1.100',
 *     port: 104,
 *     files: ['/path/to/study.dcm'],
 *     calledAETitle: 'PACS',
 * });
 * if (result.ok && result.value.success) {
 *     console.log('Files sent successfully');
 * }
 * ```
 */
declare function dcmsend(options: DcmsendOptions): Promise<Result<DcmsendResult>>;

/**
 * Send DICOM files using C-STORE via the storescu binary.
 *
 * Sends one or more DICOM files to a remote DICOM SCP
 * (Service Class Provider) using the DICOM C-STORE protocol.
 *
 * @module storescu
 */

/** Proposed transfer syntax for outgoing C-STORE associations. */
declare const ProposedTransferSyntax: {
    readonly UNCOMPRESSED: "uncompressed";
    readonly LITTLE_ENDIAN: "littleEndian";
    readonly BIG_ENDIAN: "bigEndian";
    readonly IMPLICIT_VR: "implicitVR";
    readonly JPEG_LOSSLESS: "jpegLossless";
    readonly JPEG_8BIT: "jpeg8Bit";
    readonly JPEG_12BIT: "jpeg12Bit";
    readonly J2K_LOSSLESS: "j2kLossless";
    readonly J2K_LOSSY: "j2kLossy";
    readonly JLS_LOSSLESS: "jlsLossless";
    readonly JLS_LOSSY: "jlsLossy";
};
type ProposedTransferSyntaxValue = (typeof ProposedTransferSyntax)[keyof typeof ProposedTransferSyntax];
/** Options for {@link storescu}. */
interface StorescuOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** One or more DICOM file paths to send. */
    readonly files: readonly string[];
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
    /** Scan directories for DICOM files. */
    readonly scanDirectories?: boolean | undefined;
    /** Recurse into subdirectories (requires scanDirectories). */
    readonly recurse?: boolean | undefined;
    /** Proposed transfer syntax for the association. */
    readonly proposedTransferSyntax?: ProposedTransferSyntaxValue | undefined;
}
/** Result of a successful C-STORE send. */
interface StorescuResult {
    /** Whether the store completed successfully. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Send DICOM files using C-STORE via the storescu binary.
 *
 * @param options - Store options (host, port, files required)
 * @returns A Result containing the store result or an error
 *
 * @example
 * ```ts
 * const result = await storescu({
 *     host: '192.168.1.100',
 *     port: 104,
 *     files: ['/path/to/study.dcm'],
 *     calledAETitle: 'PACS',
 * });
 * if (result.ok && result.value.success) {
 *     console.log('Files sent successfully');
 * }
 * ```
 */
declare function storescu(options: StorescuOptions): Promise<Result<StorescuResult>>;

/**
 * Query a remote DICOM SCP using C-FIND via the findscu binary.
 *
 * Performs DICOM C-FIND queries against a remote SCP for worklist,
 * patient, or study-level information.
 *
 * @module findscu
 */

/** Supported C-FIND query models. */
declare const QueryModel: {
    readonly WORKLIST: "worklist";
    readonly PATIENT: "patient";
    readonly STUDY: "study";
};
/** Union of valid query model values. */
type QueryModelValue = (typeof QueryModel)[keyof typeof QueryModel];
/** Options for {@link findscu}. */
interface FindscuOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
    /** Query model to use. */
    readonly queryModel?: QueryModelValue | undefined;
    /** DICOM attribute keys for the query (each becomes -k). */
    readonly keys?: readonly string[] | undefined;
    /** Extract response datasets to individual DICOM files. */
    readonly extract?: boolean | undefined;
    /** Output directory for extracted response files (requires extract). */
    readonly outputDirectory?: string | undefined;
}
/** Result of a successful C-FIND query. */
interface FindscuResult {
    /** Whether the query completed successfully. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Query a remote DICOM SCP using C-FIND via the findscu binary.
 *
 * @param options - Find options (host and port required)
 * @returns A Result containing the find result or an error
 *
 * @example
 * ```ts
 * const result = await findscu({
 *     host: '192.168.1.100',
 *     port: 104,
 *     queryModel: 'study',
 *     keys: ['0008,0050=', '0010,0020=PATIENT1'],
 * });
 * if (result.ok) {
 *     console.log('Query succeeded');
 * }
 * ```
 */
declare function findscu(options: FindscuOptions): Promise<Result<FindscuResult>>;

/**
 * Retrieve DICOM objects using C-MOVE via the movescu binary.
 *
 * Sends a C-MOVE request to a remote DICOM SCP to retrieve
 * DICOM objects and have them sent to a specified destination.
 *
 * @module movescu
 */

/** Supported C-MOVE query models. */
declare const MoveQueryModel: {
    readonly PATIENT: "patient";
    readonly STUDY: "study";
};
/** Union of valid move query model values. */
type MoveQueryModelValue = (typeof MoveQueryModel)[keyof typeof MoveQueryModel];
/** Options for {@link movescu}. */
interface MovescuOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
    /** Query model to use. */
    readonly queryModel?: MoveQueryModelValue | undefined;
    /** DICOM attribute keys for the query (each becomes -k). */
    readonly keys?: readonly string[] | undefined;
    /** Move destination AE Title (maps to -aem). */
    readonly moveDestination?: string | undefined;
    /** Output directory for retrieved files (maps to -od). */
    readonly outputDirectory?: string | undefined;
}
/** Result of a successful C-MOVE retrieval. */
interface MovescuResult {
    /** Whether the move completed successfully. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Retrieve DICOM objects using C-MOVE via the movescu binary.
 *
 * @param options - Move options (host and port required)
 * @returns A Result containing the move result or an error
 *
 * @example
 * ```ts
 * const result = await movescu({
 *     host: '192.168.1.100',
 *     port: 104,
 *     queryModel: 'study',
 *     moveDestination: 'LOCALAE',
 *     keys: ['0020,000D=1.2.3.4'],
 * });
 * if (result.ok) {
 *     console.log('Move succeeded');
 * }
 * ```
 */
declare function movescu(options: MovescuOptions): Promise<Result<MovescuResult>>;

/**
 * Retrieve DICOM objects using C-GET via the getscu binary.
 *
 * Sends a C-GET request to a remote DICOM SCP to retrieve
 * DICOM objects directly over the same association.
 *
 * @module getscu
 */

/** Supported C-GET query models. */
declare const GetQueryModel: {
    readonly PATIENT: "patient";
    readonly STUDY: "study";
};
/** Union of valid get query model values. */
type GetQueryModelValue = (typeof GetQueryModel)[keyof typeof GetQueryModel];
/** Options for {@link getscu}. */
interface GetscuOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
    /** Query model to use. */
    readonly queryModel?: GetQueryModelValue | undefined;
    /** DICOM attribute keys for the query (each becomes -k). */
    readonly keys?: readonly string[] | undefined;
    /** Output directory for retrieved files (maps to -od). */
    readonly outputDirectory?: string | undefined;
}
/** Result of a successful C-GET retrieval. */
interface GetscuResult {
    /** Whether the get completed successfully. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Retrieve DICOM objects using C-GET via the getscu binary.
 *
 * @param options - Get options (host and port required)
 * @returns A Result containing the get result or an error
 *
 * @example
 * ```ts
 * const result = await getscu({
 *     host: '192.168.1.100',
 *     port: 104,
 *     queryModel: 'study',
 *     outputDirectory: '/tmp/dicom',
 *     keys: ['0020,000D=1.2.3.4'],
 * });
 * if (result.ok) {
 *     console.log('Get succeeded');
 * }
 * ```
 */
declare function getscu(options: GetscuOptions): Promise<Result<GetscuResult>>;

/**
 * Terminate a DICOM association using the termscu binary.
 *
 * Sends an A-ABORT or A-RELEASE request to terminate an existing
 * DICOM association with a remote SCP.
 *
 * @module termscu
 */

/** Options for {@link termscu}. */
interface TermscuOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
}
/** Result of a successful termscu operation. */
interface TermscuResult {
    /** Whether the termination succeeded (exit code 0). */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Terminates a DICOM association with a remote SCP using the termscu binary.
 *
 * @param options - Termination options (host and port required)
 * @returns A Result containing the termination result or an error
 *
 * @example
 * ```ts
 * const result = await termscu({ host: '192.168.1.100', port: 104 });
 * if (result.ok) {
 *     console.log(result.value.success ? 'Terminated' : 'Failed');
 * }
 * ```
 */
declare function termscu(options: TermscuOptions): Promise<Result<TermscuResult>>;

/**
 * Dump a DICOM structured report as text using the dsrdump binary.
 *
 * @module dsrdump
 */

/** Options for {@link dsrdump}. */
interface DsrdumpOptions extends ToolBaseOptions {
    /** Print filename for each document. Maps to +Pf. Defaults to false. */
    readonly printFilename?: boolean | undefined;
    /** Print long format with enhanced details. Maps to +Pl. Defaults to false. */
    readonly printLong?: boolean | undefined;
    /** Print concept name codes. Maps to +Pc. Defaults to false. */
    readonly printCodes?: boolean | undefined;
}
/** Result of a successful dsrdump operation. */
interface DsrdumpResult {
    /** The text output from dsrdump. */
    readonly text: string;
}
/**
 * Dumps a DICOM structured report as text using the dsrdump binary.
 *
 * @param inputPath - Path to the DICOM SR input file
 * @param options - Dump options
 * @returns A Result containing the text dump or an error
 *
 * @example
 * ```ts
 * const result = await dsrdump('/path/to/report.dcm');
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function dsrdump(inputPath: string, options?: DsrdumpOptions): Promise<Result<DsrdumpResult>>;

/**
 * Convert a DICOM structured report to XML using the dsr2xml binary.
 *
 * @module dsr2xml
 */

/** Options for {@link dsr2xml}. */
interface Dsr2xmlOptions extends ToolBaseOptions {
    /** Use XML namespace. Maps to +Xn. Defaults to false. */
    readonly useNamespace?: boolean | undefined;
    /** Add XML Schema reference. Maps to +Xs. Defaults to false. */
    readonly addSchemaRef?: boolean | undefined;
}
/** Result of a successful dsr2xml conversion. */
interface Dsr2xmlResult {
    /** The XML text output from dsr2xml. */
    readonly text: string;
}
/**
 * Converts a DICOM structured report to XML using the dsr2xml binary.
 *
 * @param inputPath - Path to the DICOM SR input file
 * @param options - Conversion options
 * @returns A Result containing the XML text or an error
 *
 * @example
 * ```ts
 * const result = await dsr2xml('/path/to/report.dcm', { useNamespace: true });
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function dsr2xml(inputPath: string, options?: Dsr2xmlOptions): Promise<Result<Dsr2xmlResult>>;

/**
 * Convert an XML document to a DICOM structured report using the xml2dsr binary.
 *
 * @module xml2dsr
 */

/** Options for {@link xml2dsr}. */
interface Xml2dsrOptions extends ToolBaseOptions {
    /** Generate new Study/Series/SOP Instance UIDs. Maps to +Ug. Defaults to false. */
    readonly generateNewUIDs?: boolean | undefined;
    /** Validate the SR document. Maps to +Vd. Defaults to false. */
    readonly validateDocument?: boolean | undefined;
}
/** Result of a successful xml2dsr conversion. */
interface Xml2dsrResult {
    /** Path to the generated DICOM SR output file. */
    readonly outputPath: string;
}
/**
 * Converts an XML document to a DICOM structured report using the xml2dsr binary.
 *
 * @param inputPath - Path to the XML input file
 * @param outputPath - Path for the DICOM SR output file
 * @param options - Conversion options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await xml2dsr('/path/to/report.xml', '/path/to/output.dcm', {
 *     generateNewUIDs: true,
 * });
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function xml2dsr(inputPath: string, outputPath: string, options?: Xml2dsrOptions): Promise<Result<Xml2dsrResult>>;

/**
 * Dump a DICOM RT file as text using the drtdump binary.
 *
 * @module drtdump
 */

/** Options for {@link drtdump}. */
interface DrtdumpOptions extends ToolBaseOptions {
    /** Print filename for each document. Maps to +Pf. Defaults to false. */
    readonly printFilename?: boolean | undefined;
}
/** Result of a successful drtdump operation. */
interface DrtdumpResult {
    /** The text output from drtdump. */
    readonly text: string;
}
/**
 * Dumps a DICOM RT file as text using the drtdump binary.
 *
 * @param inputPath - Path to the DICOM RT input file
 * @param options - Dump options
 * @returns A Result containing the text dump or an error
 *
 * @example
 * ```ts
 * const result = await drtdump('/path/to/rtplan.dcm');
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function drtdump(inputPath: string, options?: DrtdumpOptions): Promise<Result<DrtdumpResult>>;

/**
 * Create a DICOM presentation state from an image using the dcmpsmk binary.
 *
 * Generates a Grayscale Softcopy Presentation State (GSPS)
 * object from a DICOM image file.
 *
 * @module dcmpsmk
 */

/** Options for {@link dcmpsmk}. */
type DcmpsmkOptions = ToolBaseOptions;
/** Result of a successful dcmpsmk operation. */
interface DcmpsmkResult {
    /** Path to the created presentation state file. */
    readonly outputPath: string;
}
/**
 * Creates a DICOM presentation state from an image using the dcmpsmk binary.
 *
 * @param inputPath - Path to the DICOM image input file
 * @param outputPath - Path for the created presentation state output file
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmpsmk('/path/to/image.dcm', '/path/to/pstate.dcm');
 * if (result.ok) {
 *     console.log(`Created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmpsmk(inputPath: string, outputPath: string, options?: DcmpsmkOptions): Promise<Result<DcmpsmkResult>>;

/**
 * Check a DICOM presentation state for consistency using the dcmpschk binary.
 *
 * Validates a Grayscale Softcopy Presentation State (GSPS) object
 * and reports any inconsistencies or errors found.
 *
 * @module dcmpschk
 */

/** Options for {@link dcmpschk}. */
type DcmpschkOptions = ToolBaseOptions;
/** Result of a successful dcmpschk operation. */
interface DcmpschkResult {
    /** The text output from dcmpschk. */
    readonly text: string;
}
/**
 * Checks a DICOM presentation state for consistency using the dcmpschk binary.
 *
 * @param inputPath - Path to the presentation state DICOM file
 * @param options - Optional execution options
 * @returns A Result containing the validation text output or an error
 *
 * @example
 * ```ts
 * const result = await dcmpschk('/path/to/pstate.dcm');
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function dcmpschk(inputPath: string, options?: DcmpschkOptions): Promise<Result<DcmpschkResult>>;

/**
 * Send a DICOM print job to a remote printer using the dcmprscu binary.
 *
 * @module dcmprscu
 */

/** Options for {@link dcmprscu}. */
interface DcmprscuOptions extends ToolBaseOptions {
    /** Remote host or IP address. */
    readonly host: string;
    /** Remote port number. */
    readonly port: number;
    /** Calling AE Title. */
    readonly callingAETitle?: string | undefined;
    /** Called AE Title. */
    readonly calledAETitle?: string | undefined;
    /** Path to a configuration file. Maps to -c flag. */
    readonly configFile?: string | undefined;
}
/** Result of a successful dcmprscu operation. */
interface DcmprscuResult {
    /** Whether the print job was sent successfully. */
    readonly success: boolean;
    /** Raw stderr output for diagnostic info. */
    readonly stderr: string;
}
/**
 * Sends a DICOM print job to a remote printer using the dcmprscu binary.
 *
 * @param options - Print options (host and port required)
 * @returns A Result containing the print result or an error
 *
 * @example
 * ```ts
 * const result = await dcmprscu({
 *     host: '192.168.1.100',
 *     port: 104,
 *     callingAETitle: 'MYSCU',
 *     calledAETitle: 'PRINTER',
 * });
 * if (result.ok) {
 *     console.log(result.value.success ? 'Print sent' : 'Print failed');
 * }
 * ```
 */
declare function dcmprscu(options: DcmprscuOptions): Promise<Result<DcmprscuResult>>;

/**
 * Read a DICOM print job and render to printer using the dcmpsprt binary.
 *
 * @module dcmpsprt
 */

/** Options for {@link dcmpsprt}. */
interface DcmpsprtOptions extends ToolBaseOptions {
    /** Path to a configuration file. Maps to -c flag. */
    readonly configFile?: string | undefined;
}
/** Result of a successful dcmpsprt operation. */
interface DcmpsprtResult {
    /** The text output from dcmpsprt. */
    readonly text: string;
}
/**
 * Reads a DICOM print job and renders to printer using the dcmpsprt binary.
 *
 * @param inputPath - Path to the DICOM print job file
 * @param options - Optional print options
 * @returns A Result containing the text output or an error
 *
 * @example
 * ```ts
 * const result = await dcmpsprt('/path/to/printjob.dcm', {
 *     configFile: '/path/to/config.cfg',
 * });
 * if (result.ok) {
 *     console.log(result.value.text);
 * }
 * ```
 */
declare function dcmpsprt(inputPath: string, options?: DcmpsprtOptions): Promise<Result<DcmpsprtResult>>;

/**
 * Render a DICOM image with presentation state to a bitmap using the dcmp2pgm binary.
 *
 * @module dcmp2pgm
 */

/** Options for {@link dcmp2pgm}. */
interface Dcmp2pgmOptions extends ToolBaseOptions {
    /** Path to a DICOM presentation state file. Maps to -p flag. */
    readonly presentationState?: string | undefined;
    /** Frame number to render (0-based). Maps to -f flag. */
    readonly frame?: number | undefined;
}
/** Result of a successful dcmp2pgm operation. */
interface Dcmp2pgmResult {
    /** Path to the rendered output file. */
    readonly outputPath: string;
}
/**
 * Renders a DICOM image with presentation state to a bitmap using the dcmp2pgm binary.
 *
 * @param inputPath - Path to the DICOM input image file
 * @param outputPath - Path for the rendered output bitmap file
 * @param options - Optional rendering options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmp2pgm('/path/to/input.dcm', '/path/to/output.pgm', {
 *     presentationState: '/path/to/state.dcm',
 *     frame: 0,
 * });
 * if (result.ok) {
 *     console.log(`Rendered: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmp2pgm(inputPath: string, outputPath: string, options?: Dcmp2pgmOptions): Promise<Result<Dcmp2pgmResult>>;

/**
 * Add curve data to a DICOM image using the dcmmkcrv binary.
 *
 * @module dcmmkcrv
 */

/** Options for {@link dcmmkcrv}. */
interface DcmmkcrvOptions extends ToolBaseOptions {
}
/** Result of a successful dcmmkcrv operation. */
interface DcmmkcrvResult {
    /** Path to the output file with curve data added. */
    readonly outputPath: string;
}
/**
 * Adds curve data to a DICOM image using the dcmmkcrv binary.
 *
 * @param inputPath - Path to the input curve data file
 * @param outputPath - Path for the DICOM output file with curve data
 * @param options - Optional execution options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmmkcrv('/path/to/curves.txt', '/path/to/output.dcm');
 * if (result.ok) {
 *     console.log(`Curve data added: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmmkcrv(inputPath: string, outputPath: string, options?: DcmmkcrvOptions): Promise<Result<DcmmkcrvResult>>;

/**
 * Create DICOM look-up tables using the dcmmklut binary.
 *
 * @module dcmmklut
 */

/**
 * LUT type presets for dcmmklut.
 */
declare const LutType: {
    /** Modality LUT. */
    readonly MODALITY: "modality";
    /** Presentation LUT. */
    readonly PRESENTATION: "presentation";
    /** VOI LUT. */
    readonly VOI: "voi";
};
type LutTypeValue = (typeof LutType)[keyof typeof LutType];
/** Options for {@link dcmmklut}. */
interface DcmmklutOptions extends ToolBaseOptions {
    /** Type of LUT to create. Maps to +Tm, +Tp, or +Tv flags. */
    readonly lutType?: LutTypeValue | undefined;
    /** Gamma value for the LUT curve. Maps to +Cg flag. */
    readonly gamma?: number | undefined;
    /** Number of entries in the LUT. Maps to -e flag. */
    readonly entries?: number | undefined;
    /** Number of bits per LUT entry (8-16). Maps to -b flag. */
    readonly bits?: number | undefined;
}
/** Result of a successful dcmmklut operation. */
interface DcmmklutResult {
    /** Path to the created LUT output file. */
    readonly outputPath: string;
}
/**
 * Creates DICOM look-up tables using the dcmmklut binary.
 *
 * @param outputPath - Path for the LUT output file
 * @param options - Optional LUT creation options
 * @returns A Result containing the output path or an error
 *
 * @example
 * ```ts
 * const result = await dcmmklut('/path/to/output.dcm', {
 *     lutType: 'voi',
 *     gamma: 2.2,
 *     entries: 256,
 *     bits: 12,
 * });
 * if (result.ok) {
 *     console.log(`LUT created: ${result.value.outputPath}`);
 * }
 * ```
 */
declare function dcmmklut(outputPath: string, options?: DcmmklutOptions): Promise<Result<DcmmklutResult>>;

export { type Cda2dcmOptions, type Cda2dcmResult, ColorConversion, type ColorConversionValue, type Dcm2cdaOptions, type Dcm2cdaResult, type Dcm2jsonOptions, type Dcm2jsonResult, type Dcm2jsonSource, type Dcm2pdfOptions, type Dcm2pdfResult, type Dcm2pnmOptions, Dcm2pnmOutputFormat, type Dcm2pnmOutputFormatValue, type Dcm2pnmResult, Dcm2xmlCharset, type Dcm2xmlCharsetValue, type Dcm2xmlOptions, type Dcm2xmlResult, type DcmcjpegOptions, type DcmcjpegResult, type DcmcjplsOptions, type DcmcjplsResult, type DcmconvOptions, type DcmconvResult, type DcmcrleOptions, type DcmcrleResult, type DcmdecapOptions, type DcmdecapResult, type DcmdjpegOptions, type DcmdjpegResult, type DcmdjplsOptions, type DcmdjplsResult, type DcmdrleOptions, type DcmdrleResult, type DcmdspfnOptions, type DcmdspfnResult, DcmdumpFormat, type DcmdumpFormatValue, type DcmdumpOptions, type DcmdumpResult, type DcmencapOptions, type DcmencapResult, type DcmftestOptions, type DcmftestResult, type DcmgpdirOptions, type DcmgpdirResult, type Dcmj2pnmOptions, Dcmj2pnmOutputFormat, type Dcmj2pnmOutputFormatValue, type Dcmj2pnmResult, type DcmmkcrvOptions, type DcmmkcrvResult, type DcmmkdirOptions, type DcmmkdirResult, type DcmmklutOptions, type DcmmklutResult, type Dcmp2pgmOptions, type Dcmp2pgmResult, type DcmprscuOptions, type DcmprscuResult, type DcmpschkOptions, type DcmpschkResult, type DcmpsmkOptions, type DcmpsmkResult, type DcmpsprtOptions, type DcmpsprtResult, type DcmqridxOptions, type DcmqridxResult, type DcmquantOptions, type DcmquantResult, type DcmscaleOptions, type DcmscaleResult, type DcmsendOptions, type DcmsendResult, type Dcod2lumOptions, type Dcod2lumResult, type DconvlumOptions, type DconvlumResult, DicomJsonModel, type DrtdumpOptions, type DrtdumpResult, type Dsr2xmlOptions, type Dsr2xmlResult, type DsrdumpOptions, type DsrdumpResult, type Dump2dcmOptions, type Dump2dcmResult, type EchoscuOptions, type EchoscuResult, type FindscuOptions, type FindscuResult, GetQueryModel, type GetQueryModelValue, type GetscuOptions, type GetscuResult, Img2dcmInputFormat, type Img2dcmInputFormatValue, type Img2dcmOptions, type Img2dcmResult, JplsColorConversion, type JplsColorConversionValue, type Json2dcmOptions, type Json2dcmResult, LutType, type LutTypeValue, MoveQueryModel, type MoveQueryModelValue, type MovescuOptions, type MovescuResult, type Pdf2dcmOptions, type Pdf2dcmResult, ProposedTransferSyntax, type ProposedTransferSyntaxValue, QueryModel, type QueryModelValue, type Stl2dcmOptions, type Stl2dcmResult, type StorescuOptions, type StorescuResult, type TermscuOptions, type TermscuResult, ToolBaseOptions, TransferSyntax, type TransferSyntaxValue, type Xml2dcmOptions, type Xml2dcmResult, type Xml2dsrOptions, type Xml2dsrResult, cda2dcm, dcm2cda, dcm2json, dcm2pdf, dcm2pnm, dcm2xml, dcmcjpeg, dcmcjpls, dcmconv, dcmcrle, dcmdecap, dcmdjpeg, dcmdjpls, dcmdrle, dcmdspfn, dcmdump, dcmencap, dcmftest, dcmgpdir, dcmj2pnm, dcmmkcrv, dcmmkdir, dcmmklut, dcmp2pgm, dcmprscu, dcmpschk, dcmpsmk, dcmpsprt, dcmqridx, dcmquant, dcmscale, dcmsend, dcod2lum, dconvlum, drtdump, dsr2xml, dsrdump, dump2dcm, echoscu, findscu, getscu, img2dcm, json2dcm, movescu, pdf2dcm, stl2dcm, storescu, termscu, xml2dcm, xml2dsr };
