import type { PcbInternalState } from './pcb_state.js';
/**
 * Creates a graphical line on the board.
 * @param pcb - PCB instance to access graphics storage
 * @param options - Line configuration options
 * @param options.start - Starting point coordinates {x, y}
 * @param options.end - Ending point coordinates {x, y}
 * @param options.layer - Layer name (default: 'F.SilkS')
 * @param options.width - Line width/thickness (default: 0.15mm)
 * @param options.locked - Lock the line to prevent editing (default: false)
 * @example
 * ```ts
 * // Basic line on front silkscreen
 * pcbLine(pcbInstance, { start: { x: 0, y: 0 }, end: { x: 10, y: 10 } });
 *
 * // Line on edge cuts with custom width
 * pcbLine(pcbInstance, {
 *   start: { x: 0, y: 0 },
 *   end: { x: 100, y: 0 },
 *   layer: 'Edge.Cuts',
 *   width: 0.1
 * });
 *
 * // Locked line on user drawings layer
 * pcbLine(pcbInstance, {
 *   start: { x: 20, y: 20 },
 *   end: { x: 80, y: 80 },
 *   layer: 'Dwgs.User',
 *   width: 0.2,
 *   locked: true
 * });
 * ```
 */
export declare function pcbLine(state: PcbInternalState, options: {
    start: {
        x: number;
        y: number;
    };
    end: {
        x: number;
        y: number;
    };
    layer?: string;
    width?: number;
    locked?: boolean;
}): void;
/**
 * Creates a graphical circle on the board.
 * @param pcb - PCB instance to access graphics storage
 * @param options - Circle configuration options
 * @param options.center - Center point coordinates {x, y}
 * @param options.radius - Circle radius (alternative to using end point)
 * @param options.end - Radius endpoint coordinates {x, y} (alternative to radius)
 * @param options.layer - Layer name (default: 'F.SilkS')
 * @param options.width - Outline width/thickness (default: 0.15mm)
 * @param options.fill - Fill the circle (default: false)
 * @param options.locked - Lock the circle to prevent editing (default: false)
 * @example
 * ```ts
 * // Circle with radius
 * pcbCircle(pcbInstance, { center: { x: 50, y: 50 }, radius: 10 });
 *
 * // Filled circle on copper layer
 * pcbCircle(pcbInstance, {
 *   center: { x: 30, y: 30 },
 *   radius: 5,
 *   layer: 'F.Cu',
 *   width: 0.2,
 *   fill: true
 * });
 *
 * // Circle using endpoint (radius point)
 * pcbCircle(pcbInstance, {
 *   center: { x: 0, y: 0 },
 *   end: { x: 10, y: 0 },  // Radius = 10
 *   layer: 'Dwgs.User'
 * });
 * ```
 */
export declare function pcbCircle(state: PcbInternalState, options: {
    center: {
        x: number;
        y: number;
    };
    radius?: number;
    end?: {
        x: number;
        y: number;
    };
    layer?: string;
    width?: number;
    fill?: boolean;
    locked?: boolean;
}): void;
/**
 * Creates a graphical rectangle on the board.
 * @param pcb - PCB instance to access graphics storage
 * @param options - Rectangle configuration options
 * @param options.x - X-coordinate of top-left corner (alternative to start)
 * @param options.y - Y-coordinate of top-left corner (alternative to start)
 * @param options.width - Rectangle width (alternative to end)
 * @param options.height - Rectangle height (alternative to end)
 * @param options.start - Top-left corner coordinates {x, y} (alternative to x/y)
 * @param options.end - Bottom-right corner coordinates {x, y} (alternative to width/height)
 * @param options.layer - Layer name (default: 'F.SilkS')
 * @param options.strokeWidth - Outline width/thickness (default: 0.15mm)
 * @param options.fill - Fill the rectangle (default: false)
 * @param options.locked - Lock the rectangle to prevent editing (default: false)
 * @example
 * ```ts
 * // Rectangle using x, y, width, height
 * pcbRect(pcbInstance, { x: 10, y: 10, width: 30, height: 20 });
 *
 * // Filled rectangle on copper layer
 * pcbRect(pcbInstance, {
 *   x: 50, y: 50,
 *   width: 40, height: 30,
 *   layer: 'F.Cu',
 *   strokeWidth: 0.2,
 *   fill: true
 * });
 *
 * // Rectangle using start and end points
 * pcbRect(pcbInstance, {
 *   start: { x: 0, y: 0 },
 *   end: { x: 100, y: 80 },
 *   layer: 'Dwgs.User'
 * });
 *
 * // Locked outline rectangle
 * pcbRect(pcbInstance, {
 *   x: 5, y: 5, width: 90, height: 70,
 *   layer: 'Edge.Cuts',
 *   strokeWidth: 0.1,
 *   locked: true
 * });
 * ```
 */
export declare function pcbRect(state: PcbInternalState, options: {
    x?: number;
    y?: number;
    width?: number;
    height?: number;
    start?: {
        x: number;
        y: number;
    };
    end?: {
        x: number;
        y: number;
    };
    layer?: string;
    strokeWidth?: number;
    fill?: boolean;
    locked?: boolean;
}): void;
/**
 * Creates a graphical polygon on the board.
 * @param pcb - PCB instance to access graphics storage
 * @param options - Polygon configuration options
 * @param options.points - Array of vertex coordinates [{x, y}, ...]
 * @param options.layer - Layer name (default: 'F.SilkS')
 * @param options.width - Outline width/thickness (default: 0.15mm)
 * @param options.fill - Fill the polygon (default: false)
 * @param options.locked - Lock the polygon to prevent editing (default: false)
 * @example
 * ```ts
 * // Triangle
 * pcbPoly(pcbInstance, {
 *   points: [
 *     { x: 0, y: 0 },
 *     { x: 10, y: 0 },
 *     { x: 5, y: 10 }
 *   ]
 * });
 *
 * // Filled hexagon on copper layer
 * pcbPoly(pcbInstance, {
 *   points: [
 *     { x: 50, y: 40 },
 *     { x: 60, y: 45 },
 *     { x: 60, y: 55 },
 *     { x: 50, y: 60 },
 *     { x: 40, y: 55 },
 *     { x: 40, y: 45 }
 *   ],
 *   layer: 'F.Cu',
 *   width: 0.2,
 *   fill: true
 * });
 *
 * // Pentagon on user drawings layer
 * pcbPoly(pcbInstance, {
 *   points: [
 *     { x: 100, y: 90 },
 *     { x: 110, y: 95 },
 *     { x: 108, y: 105 },
 *     { x: 92, y: 105 },
 *     { x: 90, y: 95 }
 *   ],
 *   layer: 'Dwgs.User',
 *   width: 0.15,
 *   locked: true
 * });
 * ```
 */
export declare function pcbPoly(state: PcbInternalState, options: {
    points: {
        x: number;
        y: number;
    }[];
    layer?: string;
    width?: number;
    fill?: boolean;
    locked?: boolean;
}): void;
/**
 * Creates a rectangular outline on the Edge.Cuts layer.
 * @param pcb - PCB instance to access graphics storage
 * @param x - The x-coordinate of the rectangle's start point.
 * @param y - The y-coordinate of the rectangle's start point.
 * @param width - The width of the rectangle.
 * @param height - The height of the rectangle.
 * @param filletRadius - The radius for filleted corners (0 for sharp).
 * @param conceptualUuidFromUser - Optional UUID for the conceptual outline.
 */
export declare function pcbOutline(state: PcbInternalState, x: number, y: number, width: number, height: number, filletRadius?: number, conceptualUuidFromUser?: string): void;
export declare function pcbText(state: PcbInternalState, options: import('./pcb_interfaces.js').IGrTextOptions): void;
//# sourceMappingURL=pcb_graphics.d.ts.map