type TravelMode = "drive" | "light_truck" | "medium_truck" | "truck" | "heavy_truck" | "truck_dangerous_goods" | "long_truck" | "bus" | "scooter" | "motorcycle" | "bicycle" | "mountain_bike" | "road_bike" | "walk" | "hike" | "transit" | "approximated_transit";

type AvoidType = "tolls" | "tolls:importance" | "ferries" | "ferries:importance" | "highways" | "highways:importance" | "locations" | "location" | "location_lonlat";

type TrafficType = "free_flow" | "approximated";

type DistanceUnitType = "metric" | "imperial";

type RouteType = "balanced" | "short" | "less_maneuvers";

interface BreakData {
    duration?: number;
    time_windows: [number, number][];
}

interface AgentData {
    start_location?: [number, number];
    start_location_index?: number;
    end_location?: [number, number];
    end_location_index?: number;
    pickup_capacity?: number;
    delivery_capacity?: number;
    capabilities: string[];
    time_windows: [number, number][];
    breaks: BreakData[];
    id?: string;
    description?: string;
}

interface CoordinatesData {
    lon?: number;
    lat?: number;
}

interface AvoidData {
    type?: AvoidType;
    importance?: number;
    values: CoordinatesData[];
}

interface JobData {
    location?: [number, number];
    location_index?: number;
    priority?: number;
    duration?: number;
    pickup_amount?: number;
    delivery_amount?: number;
    requirements: string[];
    time_windows: [number, number][];
    id?: string;
    description?: string;
}

interface LocationData {
    id?: string;
    location?: [number, number];
}

interface ShipmentStepData {
    location?: [number, number];
    location_index?: number;
    duration?: number;
    time_windows: [number, number][];
}

interface ShipmentData {
    id?: string;
    pickup?: ShipmentStepData;
    delivery?: ShipmentStepData;
    requirements: string[];
    priority?: number;
    description?: string;
    amount?: number;
}

type RouteDetailsType = "instruction_details" | "route_details" | "elevation";

interface RoutingOptionsExtended extends RoutingOptions {
    lang?: string;
    details?: RouteDetailsType[];
}
interface RoutingOptions {
    mode?: TravelMode;
    type?: RouteType;
    avoid?: AvoidData[];
    traffic?: TrafficType;
    max_speed?: number;
    units?: DistanceUnitType;
}
interface RoutePlannerInputData extends RoutingOptions {
    agents: AgentData[];
    jobs: JobData[];
    shipments: ShipmentData[];
    locations: LocationData[];
}

interface GeometryResponseData {
    type: string;
    coordinates: [number, number][][];
}

interface RouteLegStepData {
    distance: number;
    time: number;
    from_index: number;
    to_index: number;
}

interface RouteLegData {
    distance: number;
    time: number;
    steps: RouteLegStepData[];
    from_waypoint_index: number;
    to_waypoint_index: number;
}

interface RouteActionData {
    type: string;
    start_time: number;
    duration: number;
    index: number;
    shipment_index?: number;
    shipment_id?: string;
    location_index?: number;
    location_id?: string;
    job_index?: number;
    job_id?: string;
    waypoint_index?: number;
}

interface WaypointData {
    original_location: [number, number];
    original_location_index?: number;
    original_location_id?: string;
    location?: [number, number];
    start_time: number;
    duration: number;
    actions: RouteActionData[];
    prev_leg_index?: number;
    next_leg_index?: number;
}

interface AgentPlanData {
    agent_index: number;
    agent_id: string;
    time: number;
    start_time: number;
    end_time: number;
    distance: number;
    mode: string;
    legs: RouteLegData[];
    actions: RouteActionData[];
    waypoints: WaypointData[];
}

interface FeatureResponseData {
    geometry: GeometryResponseData;
    type: string;
    properties: AgentPlanData;
}

interface RoutePlannerResultResponseData {
    type: string;
    properties: {
        mode: string;
        params: {
            mode?: TravelMode;
            agents: AgentData[];
            jobs: JobData[];
            shipments: ShipmentData[];
            locations: LocationData[];
            avoid?: AvoidData[];
            traffic?: TrafficType;
            type?: RouteType;
            max_speed?: number;
            units?: DistanceUnitType;
        };
        issues?: RoutePlannerIssues;
    };
    features: FeatureResponseData[];
}
interface RoutePlannerIssues {
    unassigned_agents?: number[];
    unassigned_jobs?: number[];
    unassigned_shipments?: number[];
}

declare class Violation {
    readonly agentIndex: number;
    name: string;
    message: string;
    constructor(message: string, agentIndex: number);
    toString(): string;
}
declare class AgentPickupCapacityExceeded extends Violation {
    readonly totalAmount: number;
    readonly capacity: number;
    constructor(message: string, agentIndex: number, totalAmount: number, capacity: number);
}
declare class AgentDeliveryCapacityExceeded extends Violation {
    readonly totalAmount: number;
    readonly capacity: number;
    constructor(message: string, agentIndex: number, totalAmount: number, capacity: number);
}
declare class AgentMissingCapability extends Violation {
    readonly missingCapabilities: string[];
    constructor(message: string, agentIndex: number, missingCapabilities: string[]);
}
declare class TimeWindowViolation extends Violation {
    constructor(message: string, agentIndex: number);
}
declare class BreakViolation extends Violation {
    constructor(message: string, agentIndex: number);
}
declare class InvalidParameter extends Error {
    parameterName: string;
    constructor(message: string, parameterName: string);
}
declare class AgentNotFound extends Error {
    agentIdOrIndex?: string | number | undefined;
    constructor(message: string, agentIdOrIndex?: string | number | undefined);
}
declare class JobNotFound extends Error {
    jobIdOrIndex?: string | number | undefined;
    constructor(message: string, jobIdOrIndex?: string | number | undefined);
}
declare class ShipmentNotFound extends Error {
    shipmentIdOrIndex?: string | number | undefined;
    constructor(message: string, shipmentIdOrIndex?: string | number | undefined);
}
declare class AgentHasNoPlan extends Error {
    agentIndex: number;
    constructor(message: string, agentIndex: number);
}
declare class ItemsNotUnique extends Error {
    itemType: string;
    constructor(message: string, itemType: string);
}
declare class NoItemsProvided extends Error {
    itemType: string;
    constructor(message: string, itemType: string);
}
declare class ItemAlreadyAssigned extends Error {
    itemType: string;
    itemIndex: number;
    agentIndex: number;
    constructor(message: string, itemType: string, itemIndex: number, agentIndex: number);
}
declare class InvalidInsertionPosition extends Error {
    agentIndex: number;
    waypointIndex?: number | undefined;
    actionId?: string | undefined;
    constructor(message: string, agentIndex: number, waypointIndex?: number | undefined, actionId?: string | undefined);
}
declare class UnknownStrategy extends Error {
    strategy: string;
    operationType: 'assign' | 'remove';
    constructor(message: string, strategy: string, operationType: 'assign' | 'remove');
}
declare class RouteMatrixApiError extends Error {
    statusCode?: number | undefined;
    statusText?: string | undefined;
    constructor(message: string, statusCode?: number | undefined, statusText?: string | undefined);
}
declare class RoutingApiError extends Error {
    statusCode?: number | undefined;
    statusText?: string | undefined;
    constructor(message: string, statusCode?: number | undefined, statusText?: string | undefined);
}

interface RoutePlannerResultResponseDataExtended extends RoutePlannerResultResponseData {
    properties: RoutePlannerResultResponseData['properties'] & {
        violations?: Violation[];
    };
}

interface RoutePlannerResultData {
    agents: AgentPlanData[];
    inputData: RoutePlannerInputData;
    unassignedAgents: number[];
    unassignedJobs: number[];
    unassignedShipments: number[];
}

type ActionResponseData = RouteActionData;

interface RoutePlannerTimelineLabel {
    position: string;
    label: string;
}

interface TimelineItem {
    position: string;
    actualWidth: string;
    minWidth: string;
    form: 'full' | 'standard' | 'minimal';
    type: 'start' | 'job' | 'end' | 'break';
    description: string;
}

interface Timeline {
    label: string;
    mode?: TravelMode;
    color: string;
    description: string;
    routeVisible: boolean;
    agentIndex: number;
    timelineLength: string;
    distanceLineLength: string;
    timelineLeft: string;
    itemsByTime: TimelineItem[];
    itemsByDistance: TimelineItem[];
}

interface TimelineMenuItem {
    key: string;
    label?: string;
    disabled?: boolean;
    hidden?: boolean;
    callback: (agentIndex: number) => void;
}

declare class Break {
    private raw;
    constructor(raw?: BreakData);
    getRaw(): BreakData;
    setRaw(value: BreakData): this;
    addTimeWindow(start: number, end: number): this;
    setDuration(duration: number): this;
}

declare class Agent {
    private raw;
    constructor(raw?: AgentData);
    getRaw(): AgentData;
    setRaw(value: AgentData): this;
    setStartLocation(lon: number, lat: number): this;
    setStartLocationIndex(value: number): this;
    setEndLocation(lon: number, lat: number): this;
    setEndLocationIndex(value: number): this;
    setPickupCapacity(value: number): this;
    setDeliveryCapacity(value: number): this;
    addCapability(value: string): this;
    addTimeWindow(start: number, end: number): this;
    addBreak(value: Break): this;
    setId(value: string): this;
    setDescription(value: string): this;
}

declare class Avoid {
    private raw;
    constructor(raw?: AvoidData);
    getRaw(): AvoidData;
    setRaw(value: AvoidData): this;
    setType(type: AvoidType): this;
    addValue(lon: number, lat: number): this;
}

declare class Coordinates {
    private raw;
    constructor(raw?: CoordinatesData);
    getRaw(): CoordinatesData;
    setRaw(value: CoordinatesData): this;
    setLat(lat: number): this;
    setLon(lon: number): this;
}

declare class Job {
    private raw;
    constructor(raw?: JobData);
    getRaw(): JobData;
    setRaw(value: JobData): this;
    setLocation(lon: number, lat: number): this;
    setLocationIndex(value: number): this;
    setPriority(value: number): this;
    setDuration(value: number): this;
    setPickupAmount(value: number): this;
    setDeliveryAmount(value: number): this;
    addRequirement(value: string): this;
    addTimeWindow(start: number, end: number): this;
    setId(value: string): this;
    setDescription(value: string): this;
}

declare class Location {
    private raw;
    constructor(raw?: LocationData);
    getRaw(): LocationData;
    setRaw(value: LocationData): this;
    setId(id: string): this;
    setLocation(lon: number, lat: number): this;
}

declare class ShipmentStep {
    private raw;
    constructor(raw?: ShipmentStepData);
    getRaw(): ShipmentStepData;
    setRaw(value: ShipmentStepData): this;
    setLocation(lon: number, lat: number): this;
    setLocationIndex(value: number): this;
    setDuration(value: number): this;
    addTimeWindow(start: number, end: number): this;
}

declare class Shipment {
    private raw;
    constructor(raw?: ShipmentData);
    getRaw(): ShipmentData;
    setRaw(value: ShipmentData): this;
    setId(id: string): this;
    setPickup(value: ShipmentStep): this;
    setDelivery(value: ShipmentStep): this;
    addRequirement(value: string): this;
    setPriority(value: number): this;
    setDescription(value: string): this;
    setAmount(value: number): this;
}

declare class RouteLegStep {
    private readonly raw;
    constructor(raw?: RouteLegStepData);
    getRaw(): RouteLegStepData;
    getDistance(): number;
    getTime(): number;
    getFromIndex(): number;
    getToIndex(): number;
}

declare class RouteLeg {
    private readonly raw;
    constructor(raw?: RouteLegData);
    getRaw(): RouteLegData;
    getTime(): number;
    getDistance(): number;
    getSteps(): RouteLegStep[];
    getFromWaypointIndex(): number;
    getToWaypointIndex(): number;
}

declare class RouteAction {
    private readonly raw;
    constructor(raw?: ActionResponseData);
    getRaw(): ActionResponseData;
    getType(): string;
    getStartTime(): number;
    getDuration(): number;
    getShipmentIndex(): number | undefined;
    getShipmentId(): string | undefined;
    getLocationIndex(): number | undefined;
    getLocationId(): string | undefined;
    getJobIndex(): number | undefined;
    getJobId(): string | undefined;
    getActionIndex(): number;
    getWaypointIndex(): number | undefined;
}

declare class Waypoint {
    private readonly raw;
    constructor(raw?: WaypointData);
    getRaw(): WaypointData;
    getOriginalLocation(): [number, number];
    getOriginalLocationIndex(): number | undefined;
    getOriginalLocationId(): string | undefined;
    getLocation(): [number, number];
    getStartTime(): number;
    getDuration(): number;
    getActions(): RouteAction[];
    getPrevLegIndex(): number | undefined;
    getNextLegIndex(): number | undefined;
}

interface RoutePlannerCallOptions {
    apiKey: string;
    baseUrl?: string;
    httpOptions?: Record<string, any>;
}

declare class AgentPlan {
    private readonly raw;
    private readonly agentInputData;
    private readonly routingOptions;
    private readonly callOptions;
    private readonly violations;
    constructor(raw: AgentPlanData, agentInputData: AgentData, routingOptions: RoutingOptions, callOptions: RoutePlannerCallOptions, violations: Violation[]);
    getRaw(): AgentPlanData;
    getAgentIndex(): number;
    getAgentId(): string;
    getTime(): number;
    getStartTime(): number;
    getEndTime(): number;
    getDistance(): number;
    getMode(): string;
    getLegs(): RouteLeg[];
    getActions(): RouteAction[];
    getDelays(): RouteAction[];
    getWaypoints(): Waypoint[];
    getPlannedShipments(): number[];
    getPlannedJobs(): number[];
    getAgentInputData(): AgentData | undefined;
    containsShipment(shipmentIdOrIndex: string | number): boolean;
    containsJob(jonIdOrIndex: string | number): boolean;
    getViolations(): Violation[];
    /**
     * Retrieves the route for a specific agent.
     * @param agentIdOrIndex - The ID or index of the agent.
     * @param options - The routing options.
     */
    getRoute(routingOptions?: RoutingOptionsExtended): Promise<any | undefined>;
    private constructRoutingRequest;
}

declare class RoutePlannerError extends Error {
    errorName: string;
    message: string;
    rawResponse: any;
    constructor(errorName: string, message: string, rawResponse: any);
}

declare class JobPlan {
    private readonly jobIndex;
    private readonly jobInputData;
    private readonly agentPlan;
    constructor(jobIndex: number, jobInputData: JobData, agentPlan: AgentPlan | undefined);
    getAgentId(): string | undefined;
    getAgentIndex(): number | undefined;
    getRouteActions(): RouteAction[];
    getAgentPlan(): AgentPlan | undefined;
    getJobInputData(): JobData;
    getJobIndex(): number;
}

declare class ShipmentPlan {
    private readonly shipmentIndex;
    private readonly shipmentInputData;
    private readonly agentPlan;
    constructor(shipmentIndex: number, shipmentInputData: ShipmentData, agentPlan: AgentPlan | undefined);
    getAgentId(): string | undefined;
    getAgentIndex(): number | undefined;
    getShipmentId(): string | undefined;
    getShipmentIndex(): number;
    getRouteActions(): RouteAction[];
    getAgentPlan(): AgentPlan | undefined;
    getShipmentInputData(): ShipmentData;
}

/**
 * Provides convenient methods for reading Route Planner API results.
 */
declare class RoutePlannerResult {
    private readonly callOptions;
    private readonly rawData;
    private data;
    private agentPlans;
    private shipmentPlans;
    private jobPlans;
    constructor(callOptions: RoutePlannerCallOptions, rawData: RoutePlannerResultResponseData | RoutePlannerResultResponseDataExtended);
    /**
     * Returns the data returned by the Route Planner API.
     */
    getData(): RoutePlannerResultData;
    /**
     * Returns the raw data returned by the Route Planner API.
     */
    getRaw(): RoutePlannerResultResponseData;
    /**
     * Returns a list of all assigned agent solutions.
     */
    getAgentPlans(): (AgentPlan | undefined)[];
    /**
     * Finds an agent's solution by their ID.
     */
    getAgentPlan(agentIdOrIndex: string | number): AgentPlan | undefined;
    /**
     * Retrieves unassigned agents.
     */
    getUnassignedAgents(): AgentData[];
    /**
     * Retrieves unassigned jobs.
     */
    getUnassignedJobs(): JobData[];
    /**
     * Retrieves unassigned shipments.
     */
    getUnassignedShipments(): ShipmentData[];
    /**
     * Returns a list of all assigned jobs
     */
    getJobPlans(): JobPlan[];
    /**
     * Finds job solution by their ID or index.
     */
    getJobPlan(jobIdOrIndex: string | number): JobPlan | undefined;
    /**
     * Returns a list of all shipments
     */
    getShipmentPlans(): (ShipmentPlan)[];
    /**
     * Finds shipment solution by their ID or index.
     */
    getShipmentPlan(shipmentIdOrIndex: string | number): ShipmentPlan | undefined;
    getCallOptions(): RoutePlannerCallOptions;
    getRoutingOptions(): RoutingOptions;
    private getAgentViolations;
}

interface RoutePlannerTimelineOptions {
    timelineType?: 'time' | 'distance';
    hasLargeDescription?: boolean;
    capacityUnit?: string;
    agentLabel?: string;
    label?: string;
    description?: string;
    timeLabels?: RoutePlannerTimelineLabel[];
    distanceLabels?: RoutePlannerTimelineLabel[];
    agentColors?: string[];
    showWaypointPopup?: boolean;
    showTimelineLabels?: boolean;
    waypointPopupGenerator?: (waypoint: Waypoint) => HTMLElement;
    agentMenuItems?: TimelineMenuItem[];
}

declare const REOPTIMIZE: "reoptimize";
declare const PRESERVE_ORDER: "preserveOrder";
type AddAssignStrategy = typeof REOPTIMIZE | typeof PRESERVE_ORDER;
type RemoveStrategy = typeof REOPTIMIZE | typeof PRESERVE_ORDER;
interface AddAssignOptions {
    strategy?: AddAssignStrategy;
    removeStrategy?: RemoveStrategy;
    afterWaypointIndex?: number;
    afterId?: string;
    append?: boolean;
}
interface RemoveOptions {
    strategy?: RemoveStrategy;
}
interface ReoptimizeOptions {
    includeUnassigned?: boolean;
    allowViolations?: boolean;
}

declare class RoutePlanner {
    private raw;
    private options;
    private baseUrl;
    constructor(options: RoutePlannerCallOptions, raw?: RoutePlannerInputData);
    getRaw(): RoutePlannerInputData;
    setRaw(value: RoutePlannerInputData): this;
    setMode(mode: TravelMode): this;
    addAgent(agent: Agent): this;
    addJob(job: Job): this;
    addLocation(location: Location): this;
    addShipment(shipment: Shipment): this;
    addAvoid(avoid: Avoid): this;
    setTraffic(traffic: TrafficType): this;
    setType(type: RouteType): this;
    setMaxSpeed(max_speed: number): this;
    setUnits(units: DistanceUnitType): this;
    plan(): Promise<RoutePlannerResult>;
    private callPlan;
}

/**
 * Editor for modifying route planner results.
 *
 * Provides methods to assign, remove, and add jobs/shipments to agent routes.
 * Supports two strategies: reoptimize (default) and preserveOrder.
 *
 * @example
 * ```typescript
 * import { RoutePlannerResultEditor, PRESERVE_ORDER, REOPTIMIZE } from '@geoapify/route-planner-sdk';
 *
 * const editor = new RoutePlannerResultEditor(plannerResult);
 *
 * // Assign job to agent (with full reoptimization)
 * await editor.assignJobs('agent-A', ['job-1']);
 *
 * // Find optimal insertion point without reordering (Route Matrix API)
 * await editor.assignJobs('agent-A', ['job-2'], { strategy: PRESERVE_ORDER });
 *
 * // Append job to end of route (no API call)
 * await editor.assignJobs('agent-A', ['job-2'], { strategy: PRESERVE_ORDER, append: true });
 *
 * // Remove job while keeping route order
 * await editor.removeJobs(['job-3'], { strategy: PRESERVE_ORDER });
 *
 * // Get the modified result
 * const modifiedResult = editor.getModifiedResult();
 * ```
 */
declare class RoutePlannerResultEditor {
    private rawData;
    private callOptions;
    private routingOptions;
    private jobEditor;
    private shipmentEditor;
    /**
     * Creates a new RoutePlannerResultEditor.
     * Note: The editor works on a cloned copy of the result, not the original.
     *
     * @param result - The route planner result to edit
     */
    constructor(result: RoutePlannerResult);
    /**
     * Assigns jobs to an agent. Removes the jobs if they're currently assigned to another agent.
     *
     * @param agentIdOrIndex - The ID or index of the agent
     * @param jobIndexesOrIds - Array of job IDs or indexes to assign
     * @param options - Assignment options
     * @returns Promise resolving to true if successful
     *
     * @example
     * ```typescript
     * // Default: full reoptimization (Route Planner API)
     * await editor.assignJobs('agent-A', ['job-1', 'job-2']);
     *
     * // Find optimal insertion point (Route Matrix API)
     * await editor.assignJobs('agent-A', ['job-1'], { strategy: 'preserveOrder' });
     *
     * // Insert at specific position (no API call)
     * await editor.assignJobs('agent-A', ['job-2'], {
     *   strategy: 'preserveOrder',
     *   afterId: 'job-1'
     * });
     *
     * // Append to end of route (no API call)
     * await editor.assignJobs('agent-A', ['job-1'], {
     *   strategy: 'preserveOrder',
     *   append: true
     * });
     * ```
     */
    assignJobs(agentIdOrIndex: string | number, jobIndexesOrIds: number[] | string[], options?: AddAssignOptions): Promise<boolean>;
    /**
     * Assigns shipments to an agent. Removes the shipments if they're currently assigned to another agent.
     *
     * @param agentIdOrIndex - The ID or index of the agent
     * @param shipmentIndexesOrIds - Array of shipment IDs or indexes to assign
     * @param options - Assignment options
     * @returns Promise resolving to true if successful
     *
     * @example
     * ```typescript
     * // Default: full reoptimization (Route Planner API)
     * await editor.assignShipments('agent-A', ['shipment-1']);
     *
     * // Find optimal insertion point (Route Matrix API)
     * await editor.assignShipments('agent-A', ['shipment-1'], { strategy: 'preserveOrder' });
     *
     * // Append pickup and delivery to end of route (no API call)
     * await editor.assignShipments('agent-A', ['shipment-1'], {
     *   strategy: 'preserveOrder',
     *   append: true
     * });
     * ```
     */
    assignShipments(agentIdOrIndex: string | number, shipmentIndexesOrIds: number[] | string[], options?: AddAssignOptions): Promise<boolean>;
    /**
     * Removes jobs from the plan, marking them as unassigned.
     *
     * @param jobIndexesOrIds - Array of job IDs or indexes to remove
     * @param options - Removal options
     * @returns Promise resolving to true if successful
     *
     * @example
     * ```typescript
     * // Default: reoptimize remaining route
     * await editor.removeJobs(['job-1', 'job-2']);
     *
     * // Remove without reordering remaining jobs
     * await editor.removeJobs(['job-1'], { strategy: 'preserveOrder' });
     * ```
     */
    removeJobs(jobIndexesOrIds: number[] | string[], options?: RemoveOptions): Promise<boolean>;
    /**
     * Removes shipments from the plan, marking them as unassigned.
     *
     * @param shipmentIndexesOrIds - Array of shipment IDs or indexes to remove
     * @param options - Removal options
     * @returns Promise resolving to true if successful
     *
     * @example
     * ```typescript
     * // Default: reoptimize remaining route
     * await editor.removeShipments(['shipment-1']);
     *
     * // Remove without reordering remaining shipments
     * await editor.removeShipments(['shipment-1'], { strategy: 'preserveOrder' });
     * ```
     */
    removeShipments(shipmentIndexesOrIds: number[] | string[], options?: RemoveOptions): Promise<boolean>;
    /**
     * Adds new jobs to an agent's schedule.
     *
     * @param agentIdOrIndex - The ID or index of the agent
     * @param jobs - Array of Job objects to add
     * @param options - Assignment options
     * @returns Promise resolving to true if successful
     *
     * @example
     * ```typescript
     * const newJob = new Job()
     *   .setId('new-job')
     *   .setLocation(44.5, 40.2)
     *   .setDuration(300);
     *
     * // Default: reoptimize with new job (Route Planner API)
     * await editor.addNewJobs('agent-A', [newJob]);
     *
     * // Find optimal insertion point (Route Matrix API)
     * await editor.addNewJobs('agent-A', [newJob], { strategy: 'preserveOrder' });
     *
     * // Append to end of route (no API call)
     * await editor.addNewJobs('agent-A', [newJob], { strategy: 'preserveOrder', append: true });
     * ```
     */
    addNewJobs(agentIdOrIndex: string | number, jobs: Job[], options?: AddAssignOptions): Promise<boolean>;
    /**
     * Adds new shipments to an agent's schedule.
     *
     * @param agentIdOrIndex - The ID or index of the agent
     * @param shipments - Array of Shipment objects to add
     * @param options - Assignment options
     * @returns Promise resolving to true if successful
     *
     * @example
     * ```typescript
     * const newShipment = new Shipment()
     *   .setId('new-shipment')
     *   .setPickup(new ShipmentStep().setLocation(44.5, 40.2).setDuration(120))
     *   .setDelivery(new ShipmentStep().setLocation(44.6, 40.3).setDuration(120));
     *
     * // Default: reoptimize with new shipment (Route Planner API)
     * await editor.addNewShipments('agent-A', [newShipment]);
     *
     * // Find optimal insertion point (Route Matrix API)
     * await editor.addNewShipments('agent-A', [newShipment], { strategy: 'preserveOrder' });
     *
     * // Append to end of route (no API call)
     * await editor.addNewShipments('agent-A', [newShipment], {
     *   strategy: 'preserveOrder',
     *   append: true
     * });
     * ```
     */
    addNewShipments(agentIdOrIndex: string | number, shipments: Shipment[], options?: AddAssignOptions): Promise<boolean>;
    getModifiedResult(): RoutePlannerResult;
    reoptimizeAgentPlan(agentIdOrIndex: string | number, options?: ReoptimizeOptions): Promise<boolean>;
    addDelayAfterWaypoint(agentIdOrIndex: string | number, waypointIndex: number, delaySeconds: number): void;
    /**
     * @deprecated use addDelayAfterWaypoint()
     */
    addTimeOffsetAfterWaypoint(agentIdOrIndex: string | number, waypointIndex: number, offsetSeconds: number): void;
    moveWaypoint(agentIdOrIndex: string | number, fromWaypointIndex: number, toWaypointIndex: number): Promise<void>;
    private assertArray;
    private normalizeAddAssignOptions;
    private resolveInsertPosition;
    private validateAfterWaypointIndex;
    private normalizeRemoveOptions;
    private getJobEditor;
    private getShipmentEditor;
}

declare class RoutePlannerTimeline {
    private readonly WAYPOINT_POPUP_INITIALIZED_ATTRIBUTE;
    private readonly WAYPOINT_POPUP_CONTAINER_ID;
    defaultColors: string[];
    timelineTemplate: (timeline: Timeline, index: number, timelineType: 'time' | 'distance', timeLabels: RoutePlannerTimelineLabel[], distanceLabels: RoutePlannerTimelineLabel[], agentMenuItems?: TimelineMenuItem[]) => string;
    container: HTMLElement;
    inputData?: RoutePlannerInputData;
    result?: RoutePlannerResult;
    options: RoutePlannerTimelineOptions;
    waypointPopupContainer: HTMLElement | null;
    eventListeners: {
        [key: string]: Function[];
    };
    constructor(container: HTMLElement, inputData?: RoutePlannerInputData, result?: RoutePlannerResult, options?: RoutePlannerTimelineOptions);
    getHasLargeDescription(): boolean | undefined;
    setHasLargeDescription(value: boolean): void;
    getTimelineType(): 'time' | 'distance' | undefined;
    setTimelineType(value: 'time' | 'distance'): void;
    getAgentColors(): string[] | undefined;
    setAgentColors(value: string[]): void;
    getCapacityUnit(): string | undefined;
    setCapacityUnit(value: string | undefined): void;
    getTimeLabels(): RoutePlannerTimelineLabel[] | undefined;
    setTimeLabels(value: RoutePlannerTimelineLabel[]): void;
    getShowTimelineLabels(): boolean | undefined;
    setShowTimelineLabels(value: boolean): void;
    getDistanceLabels(): RoutePlannerTimelineLabel[] | undefined;
    setDistanceLabels(value: RoutePlannerTimelineLabel[]): void;
    getAgentLabel(): string | undefined;
    setAgentLabel(value: string): void;
    getAgentMenuItems(): TimelineMenuItem[] | undefined;
    setAgentMenuItems(value: TimelineMenuItem[]): void;
    getResult(): RoutePlannerResult | undefined;
    setResult(value: RoutePlannerResult): void;
    on(eventName: string, handler: Function): void;
    off(eventName: string, handler: Function): void;
    getAgentColorByIndex(index: number): string;
    private generateAgentTimeline;
    private drawTimelines;
    private generateTimelinesData;
    private emit;
    private generateItemsByTime;
    private generateItemsByDistance;
    private generateTimeLabels;
    private generateDistanceLabels;
    private getTimelineLabelsWidth;
    private generateAgentDescription;
    private initializeGlobalTooltip;
    private createWaypointPopupContainer;
    private initializeWaypointPopups;
    private showWaypointPopup;
    private hideWaypointPopup;
    private initializeThreeDotMenus;
    private generateAgentMenuItemsOnThreeDotClick;
    private generateMenuItemsForAgent;
    private updateMenuItems;
    private toggleThreeDotMenu;
    private closeAllThreeDotMenus;
}

export { type ActionResponseData, type AddAssignOptions, type AddAssignStrategy, Agent, type AgentData, AgentDeliveryCapacityExceeded, AgentHasNoPlan, AgentMissingCapability, AgentNotFound, AgentPickupCapacityExceeded, AgentPlan, type AgentPlanData, Avoid, type AvoidData, type AvoidType, Break, type BreakData, BreakViolation, Coordinates, type CoordinatesData, type DistanceUnitType, type FeatureResponseData, type GeometryResponseData, InvalidInsertionPosition, InvalidParameter, ItemAlreadyAssigned, ItemsNotUnique, Job, type JobData, JobNotFound, Location, type LocationData, NoItemsProvided, PRESERVE_ORDER, REOPTIMIZE, type RemoveOptions, type RemoveStrategy, type ReoptimizeOptions, RouteAction, type RouteActionData, RouteLeg, type RouteLegData, RouteLegStep, type RouteLegStepData, RouteMatrixApiError, RoutePlanner, RoutePlannerError, type RoutePlannerInputData, type RoutePlannerIssues, RoutePlannerResult, type RoutePlannerResultData, RoutePlannerResultEditor, type RoutePlannerResultResponseData, type RoutePlannerResultResponseDataExtended, RoutePlannerTimeline, type RoutePlannerTimelineLabel, type RoutePlannerTimelineOptions, type RouteType, RoutingApiError, type RoutingOptions, type RoutingOptionsExtended, Shipment, type ShipmentData, ShipmentNotFound, ShipmentStep, type ShipmentStepData, TimeWindowViolation, type Timeline, type TimelineItem, type TimelineMenuItem, type TrafficType, type TravelMode, UnknownStrategy, Violation, Waypoint, type WaypointData, RoutePlanner as default };