import { EventEmitter } from '../../stencil-public-runtime';
import { VehicleLookupDTO } from "../../global/types/generated/vehicle-lookup/vehicle-lookup-dto";
import specificationSchema from "../../locales/vehicleLookup/specification/type";
import { VehicleInfoLayoutInterface, VerdictState } from "../../features/vehicle-info-layout/index";
import { VehicleLookupComponent, VehicleLookupMock } from "../../features/vehicle-lookup-component/index";
import { BlazorInvokable, DotNetObjectReference, BlazorInvokableFunction } from "../../features/blazor-ref/index";
import { ComponentLocale, ErrorKeys, LanguageKeys, MultiLingual } from "../../features/multi-lingual/index";
/**
 * The build record for a VIN: what this vehicle *is* — model, year, grade, and the codes a parts
 * counter or a claim form asks for.
 *
 * It reads five sub-objects and no others (`SpecificationRecord`). Two facts decide what it may
 * say: `isAuthorized === false` means the distributor has no record, so every value dashes; and an
 * *empty* record is not a record, so `hasRecords` counts values rather than objects.
 */
export declare class VehicleSpecification implements MultiLingual, VehicleInfoLayoutInterface, VehicleLookupComponent, BlazorInvokable {
    language: LanguageKeys;
    locale: ComponentLocale<typeof specificationSchema>;
    componentWillLoad(): Promise<void>;
    /**
     * A re-layout, not a state change: never sets a loading flag. Covers or a dropped head would
     * say a lookup had happened.
     */
    changeLanguage(newLanguage: LanguageKeys): Promise<void>;
    coreOnly: boolean;
    blazorRef?: DotNetObjectReference;
    setBlazorRef(newBlazorRef: DotNetObjectReference): Promise<void>;
    isDev: boolean;
    today?: string;
    disableVinValidation: boolean;
    baseUrl: string;
    headers: object;
    queryString: string;
    errorCallback?: BlazorInvokableFunction<(errorMessage: ErrorKeys) => void>;
    loadingStateChange?: BlazorInvokableFunction<(isLoading: boolean) => void>;
    loadedResponse?: BlazorInvokableFunction<(response: VehicleLookupDTO) => void>;
    isError: boolean;
    errorMessage?: ErrorKeys;
    isLoading: boolean;
    vehicleLookup?: VehicleLookupDTO;
    el: HTMLElement;
    mockData: any;
    abortController: AbortController;
    networkTimeoutRef: ReturnType<typeof setTimeout>;
    setMockData(newMockData: VehicleLookupMock): Promise<void>;
    fetchVin(newData: VehicleLookupDTO | string, headers?: any): Promise<void>;
    /**
     * The panel's own failure arrives with the head already out of the band, so assigning at once
     * *is* the arrive. Called cold, the card is settled, so the error enters through the leave —
     * otherwise the red pill mounts into a summary row at full opacity.
     */
    setErrorMessage(message: ErrorKeys): Promise<void>;
    /** Back to "no vehicle": the head leaves the band and the covers come up, then the panel is emptied unseen. */
    clearData(): Promise<void>;
    onLoadingChange(newValue: boolean): void;
    /** The panel is on its way to empty: the head is out of the band and the covers are up. */
    leaving: boolean;
    private leaveGeneration;
    /** How long a state change takes to settle: the --settle token plus a margin for the frame it starts on. */
    private settleMs;
    /**
     * Takes the head out of the band and raises the covers, resolving once settled, so the caller
     * can swap the vehicle while nothing readable is on screen. The generation counter lets a newer
     * lookup win without the older one flipping `leaving` back.
     */
    private leave;
    private emptyPanel;
    /**
     * Fires on every verdict change, idle included, so a composite can colour its accent from the
     * active panel.
     */
    verdictChange: EventEmitter<VerdictState>;
    private lastVerdict?;
    private currentVerdict;
    private announceVerdict;
    /**
     * The one piece of state that is not a function of the response. Expanded on load, so nothing is
     * hidden from a reader who does not know the control exists, and a new vehicle does **not** reset
     * it — that would undo the reader's choice once a minute. Only `clearData()` resets it.
     */
    detailsOpen: boolean;
    private toggleDetails;
    /**
     * Kept while the block is shut so the groups slide away rather than blink out; dropped a settle
     * later, while nothing is on screen.
     */
    private retainedGroups;
    private retainTimer?;
    private groups;
    private retainDetails;
    /**
     * An enclosing <flexible-container> cannot see transitions inside this shadow root and would
     * keep clipping at the old height, so every render that moved something announces it.
     */
    private heightAnnouncer?;
    private layoutSignature?;
    private valuesChanged;
    /**
     * A value block is the same slot on every vehicle but not the same size — a name or a year note
     * wraps to a second line. Without this the height changes in one frame under a lifting cover.
     */
    private resizeSettle;
    /**
     * Everything that can move the card's height, joined. A render that changes none of it announces
     * nothing and pins no heights.
     */
    private signature;
    componentWillRender(): void;
    componentDidRender(): void;
    disconnectedCallback(): void;
    /**
     * The response narrowed to the five sub-objects the panel may read. Everything downstream — the
     * render, `hasRecords`, the signature — takes this, so a field outside the barrier has no way in.
     */
    private record;
    render(): any;
}