adp-web-components 0.3.20 → 0.4.0

package/dist/types/components/vehicle-lookup/components/SscCampaigns.d.ts

@@ -0,0 +1,128 @@
+import { FunctionalComponent } from '../../../stencil-public-runtime';
+import { InferType } from 'yup';
+import sscSchema from "../../../locales/vehicleLookup/ssc/type";
+import { SscDTO } from "../../../global/types/generated/vehicle-lookup/ssc-dto";
+import { SscRepairTraceDTO } from "../../../global/types/generated/vehicle-lookup/ssc-repair-trace-dto";
+export type SscLocale = InferType<typeof sscSchema>;
+/** The manufacturer's answer for a vehicle the distributor has no record of. */
+export type ManufacturerCheckStatus = 'noRecall' | 'recallExists' | 'noApplicableVehicleFound';
+/** Identifies a campaign row across renders. Campaign codes are expected to be unique per vehicle; the index guards the odd feed that repeats one. */
+export declare const sscTraceKey: (item: SscDTO | undefined, index: number) => string;
+/** What the card's body — everything below the lead strip — holds. */
+export type BodyKind = 'rows' | 'check' | 'run' | 'none';
+/** What the lead strip — the band between the card's header and its body — shows. */
+export type LeadKind = 'skeleton' | 'columns' | 'notice';
+/**
+ * `neutral` is a statement without a verdict; `attention` is a required action not taken yet — the
+ * check was not run — and has a hue of its own so it is never read as a verdict or as a statement.
+ */
+export type VerdictState = 'positive' | 'negative' | 'neutral' | 'attention' | 'idle';
+export type PanelVerdict = {
+    state: VerdictState;
+    text: string;
+};
+/** Everything the panel's verdict, lead and body are decided from. */
+export type PanelState = {
+    locale: SscLocale;
+    vehicleLoaded: boolean;
+    /**
+     * `isAuthorized` of the loaded vehicle. `false` means the distributor has no record of it, and
+     * then nothing in `campaigns` may be shown or summarised — see the invariant on `panelVerdict`.
+     */
+    authorized?: boolean;
+    /** Undefined until a vehicle is loaded; an empty list on an authorized vehicle means it is clear. */
+    campaigns?: SscDTO[];
+    /**
+     * The other panels show a vehicle but this panel's own lookup was not run for it (a wrapper with
+     * `sscQueryString` only counts the SSC tab's own request as a campaign check). Nothing is known,
+     * so the panel says so and offers to run the check — it must never look like "no campaigns".
+     */
+    skipped: boolean;
+    /** Whether the host configured the manufacturer check (a reCAPTCHA site key) for unauthorized vehicles. */
+    checkAvailable: boolean;
+    /** The manufacturer's answer, once it arrived. */
+    checkStatus?: ManufacturerCheckStatus | null;
+};
+type Props = PanelState & {
+    /** A lookup is in flight, or the panel is being cleared: chip and lead go to the sheen and the body shuts. */
+    loading: boolean;
+    /** The manufacturer check is in flight: chip and lead go to the sheen; the body stays open on the widget and its spinner. */
+    checking: boolean;
+    /**
+     * What the body keeps rendering while it is shut — the content on its way out, so it slides away
+     * instead of vanishing. The owner remembers the last non-empty body and drops it once shut.
+     */
+    retainedBody: BodyKind;
+    onRunLookup: () => void;
+    showTrace: boolean;
+    openTraceKey?: string;
+    traces: Record<string, SscRepairTraceDTO>;
+    traceLoading: boolean;
+    traceError?: string;
+    onToggleTrace: (key: string) => void;
+};
+/**
+ * The row whose evidence drawer is open: the wanted trace once there is something to show — the
+ * evidence, or the failure to get it. While it is being fetched the row's button spins instead and
+ * the drawer stays shut, so it never swaps a spinner for content mid-air. The owner watches this to
+ * bring the row into view as the drawer opens.
+ */
+export declare const openDrawerKey: ({ campaigns, showTrace, openTraceKey, traces, traceLoading, }: Pick<Props, "campaigns" | "showTrace" | "openTraceKey" | "traces" | "traceLoading">) => string | undefined;
+/**
+ * What the panel is allowed to assert about the vehicle, and in which colour.
+ *
+ * THE INVARIANT THIS ENCODES — read before touching it:
+ *
+ * Campaign status is a legal matter, and this panel must never give a verdict it has not earned.
+ * There are two separate paths and a vehicle is on exactly one of them:
+ *
+ *  1. An AUTHORIZED vehicle (`isAuthorized !== false`) is in the distributor's records. Its
+ *     campaigns are the list in `campaigns`; an empty list is a genuine "no campaign affects this
+ *     vehicle" — the distributor looked and found none.
+ *
+ *  2. An UNAUTHORIZED vehicle (`isAuthorized === false`) is NOT in the distributor's records. The
+ *     distributor knows nothing about its campaigns, so an empty `campaigns` here is *absence of
+ *     data*, not a clean bill. The only verdict available is the manufacturer's own answer, obtained
+ *     through the reCAPTCHA-gated check, and it is a yes/no with no list behind it. Until that answer
+ *     arrives the panel says "not in the distributor's records" and nothing more — never a green
+ *     "no campaign", never a table, never a count. A `campaigns` list on an unauthorized vehicle is a
+ *     data fault (the server derives `isAuthorized` partly *from* having SSC records) and is ignored
+ *     rather than displayed next to the check.
+ *
+ * And a third case that is neither: the lookup was SKIPPED for this panel (`skipped`). The other
+ * panels show the vehicle, this one holds nothing, and it says "not checked yet" and offers the
+ * check — a blank panel would read as "no campaigns", which is the same lie as case 2's.
+ *
+ * Two sessions independently built a green "no campaign" out of an empty list before this was
+ * written down; `SscCampaigns.spec.tsx` now fails if it happens again. The wider rule is in
+ * .shift/repos/adp/web-components/vehicle-lookup-invariants.md.
+ */
+export declare const panelVerdict: ({ locale, vehicleLoaded, authorized, campaigns, checkStatus, skipped }: PanelState) => PanelVerdict;
+/** What belongs below the lead strip for this state; `none` shuts the body. */
+export declare const panelBody: ({ vehicleLoaded, authorized, campaigns, checkAvailable, checkStatus, skipped }: PanelState) => BodyKind;
+/** The strip reads as the column headings only above a list; every other statement is a notice, and in flight it is a skeleton. */
+export declare const panelLead: (state: PanelState, busy: boolean) => LeadKind;
+/**
+ * The campaigns of one vehicle. The card is three fixed parts, and every state is a different
+ * content of the same three — nothing is added to or removed from the card between states, which
+ * is what lets every change be a movement (the rule is in lookup-motion.css and
+ * .shift/repos/adp/web-components/motion.md):
+ *
+ *  - the header: the title and the verdict pill. Idle the pill is a blank shape; in flight it
+ *    carries the sheen; settled it names the verdict.
+ *  - the lead strip: one band that is a skeleton (idle, in flight), the column headings (above a
+ *    list), or a notice (everything the panel has to say in a sentence — not in the records, the
+ *    manufacturer's answer, no campaign affects this vehicle, the check was skipped). The three are
+ *    layers of one cell and cross-fade; the strip never changes height.
+ *  - the body: a region that slides open and shut. Open it holds the campaign rows, the
+ *    manufacturer-check widget, or the "run the check" action; it shuts while a lookup is in
+ *    flight — with the outgoing content still inside it, so that content leaves with it — and opens
+ *    again on the new content once the lookup has settled.
+ *
+ * What the panel may assert is decided by `panelVerdict` — see the invariant there. The rows are
+ * a CSS grid with subgrid so the headings in the lead strip and the cells in the body share one
+ * set of column tracks: columns take what their content needs, the description absorbs the slack.
+ * Below the container breakpoint each row becomes a labelled card and the strip a single label.
+ */
+export declare const SscCampaigns: FunctionalComponent<Props>;
+export {};

package/dist/types/components/vehicle-lookup/components/glyphs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Inline SVG paths shared by the panels in the newer design language. Kept as path data rather
+ * than <img> assets so a glyph takes the colour of the badge it sits in and stays crisp at any
+ * size. All are drawn on a 512 x 512 box.
+ */
+export declare const BADGE_GLYPHS: {
+    /** A filled circle with a check mark: a positive verdict. */
+    readonly positive: "M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM369 209L241 337c-9.4 9.4-24.6 9.4-33.9 0l-64-64c-9.4-9.4-9.4-24.6 0-33.9s24.6-9.4 33.9 0l47 47L335 175c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9z";
+    /** A filled circle with a cross: a negative verdict. */
+    readonly negative: "M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM175 175c9.4-9.4 24.6-9.4 33.9 0l47 47 47-47c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-47 47 47 47c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-47-47-47 47c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l47-47-47-47c-9.4-9.4-9.4-24.6 0-33.9z";
+    /** A filled circle with an exclamation mark: a required action not taken yet — the check must be run. */
+    readonly alert: "M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zm0-384c13.3 0 24 10.7 24 24V264c0 13.3-10.7 24-24 24s-24-10.7-24-24V152c0-13.3 10.7-24 24-24zM224 352a32 32 0 1 1 64 0 32 32 0 1 1-64 0z";
+    /** A filled circle with a question mark: "why?", the trace trigger. */
+    readonly question: "M256 512A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM169.8 165.3c7.9-22.3 29.1-37.3 52.8-37.3h58.3c34.9 0 63.1 28.3 63.1 63.1 0 22.6-12.1 43.5-31.7 54.8L280 264.4c-.2 13-10.9 23.6-24 23.6-13.3 0-24-10.7-24-24v-13.5c0-8.6 4.6-16.5 12.1-20.8l44.3-25.4c4.7-2.7 7.6-7.7 7.6-13.1 0-8.4-6.8-15.1-15.1-15.1h-58.3c-3.4 0-6.4 2.1-7.5 5.3l-.4 1.2c-4.4 12.5-18.2 19-30.6 14.6s-19-18.2-14.6-30.6l.4-1.2zM224 352a32 32 0 1 1 64 0 32 32 0 1 1-64 0z";
+};

package/dist/types/components/vehicle-lookup/vehicle-claimable-items.d.ts

@@ -2,7 +2,7 @@ import { VehicleLookupDTO } from "../../global/types/generated/vehicle-lookup/ve
 import { VehicleServiceItemDTO } from "../../global/types/generated/vehicle-lookup/vehicle-service-item-dto";
 import { VehicleInfoLayoutInterface } from "../../features/vehicle-info-layout/index";
 import { BlazorInvokable, DotNetObjectReference, BlazorInvokableFunction } from "../../features/blazor-ref/index";
-import { VehicleLookupComponent } from "../../features/vehicle-lookup-component/index";
+import { RequestHeadersProvider, VehicleLookupComponent } from "../../features/vehicle-lookup-component/index";
 import { ComponentLocale, ErrorKeys, LanguageKeys, MultiLingual } from "../../features/multi-lingual/index";
 import { PopoverTarget } from './components/claimable-item-popover';
 import { VehicleItemClaimForm } from './vehicle-item-claim-form';
@@ -21,6 +21,11 @@ export declare class VehicleClaimableItems implements MultiLingual, VehicleInfoL
     headers: object;
     queryString: string;
     uploadMultipleDocumentsAtTheForm: boolean;
+    /** Asked for the current headers before every request this component makes itself (trace, claim); lets a host refresh its token on demand. */
+    requestHeadersProvider?: RequestHeadersProvider;
+    /** Name of a [JSInvokable] method on the Blazor reference that answers with the current headers. */
+    blazorRequestHeadersProvider: string;
+    lastRequestHeaders?: object;
     errorCallback?: BlazorInvokableFunction<(errorMessage: ErrorKeys) => void>;
     loadingStateChange?: BlazorInvokableFunction<(isLoading: boolean) => void>;
     loadedResponse?: BlazorInvokableFunction<(response: VehicleLookupDTO) => void>;

package/dist/types/components/vehicle-lookup/vehicle-lookup.d.ts

@@ -1,13 +1,14 @@
 import { VehicleLookupDTO } from "../../global/types/generated/vehicle-lookup/vehicle-lookup-dto";
+import { VehicleSsc } from './vehicle-ssc';
 import { VehicleAccessories } from './vehicle-accessories';
 import { VehicleSpecification } from './vehicle-specification';
 import { VehicleClaimableItems } from './vehicle-claimable-items';
 import { VehiclePaintThickness } from './vehicle-paint-thickness';
 import { VehicleServiceHistory } from './vehicle-service-history';
-import { VehicleWarrantyDetails } from './vehicle-warranty-details';
 import { VehicleWarrantyTimeline } from './vehicle-warranty-timeline';
 import { VehicleSaleInformation } from './vehicle-sale-information';
 import { DotNetObjectReference } from "../../features/blazor-ref/index";
+import { RequestHeadersProvider } from "../../features/vehicle-lookup-component/index";
 import { LanguageKeys, MultiLingual, SharedLocales } from "../../features/multi-lingual/index";
 declare const componentTags: {
     readonly vehicleAccessories: "vehicle-accessories";
@@ -16,7 +17,6 @@ declare const componentTags: {
     readonly vehicleServiceHistory: "vehicle-service-history";
     readonly vehicleClaimableItems: "vehicle-claimable-items";
     readonly vehicleSaleInformation: "vehicle-sale-information";
-    readonly vehicleWarrantyDetails: "vehicle-warranty-details";
     readonly vehicleWarrantyTimeline: "vehicle-warranty-timeline";
     readonly vehicleSsc: "vehicle-ssc";
 };
@@ -27,9 +27,8 @@ export type ComponentMap = {
     [componentTags.vehiclePaintThickness]: VehiclePaintThickness;
     [componentTags.vehicleClaimableItems]: VehicleClaimableItems;
     [componentTags.vehicleSaleInformation]: VehicleSaleInformation;
-    [componentTags.vehicleWarrantyDetails]: VehicleWarrantyDetails;
     [componentTags.vehicleWarrantyTimeline]: VehicleWarrantyTimeline;
-    [componentTags.vehicleSsc]?: VehicleWarrantyDetails;
+    [componentTags.vehicleSsc]: VehicleSsc;
 };
 export type ActiveElement = (typeof componentTags)[keyof typeof componentTags] | '';
 export declare class VehicleLookup implements MultiLingual {
@@ -44,10 +43,23 @@ export declare class VehicleLookup implements MultiLingual {
     mockRecaptcha: boolean;
     disableVinValidation: boolean;
     queryString: string;
+    /**
+     * Appended to the SSC tab's own lookup request only — e.g. a logging flag — so that only a search
+     * made from the SSC tab counts as a campaign check. A search from any other tab leaves the SSC tab
+     * in its "check required" state, which names the VIN and offers to run the check itself. Never
+     * joins the panel's trace request: a trace re-reads a lookup that was already logged.
+     */
     sscQueryString: string;
-    separateSsc: boolean;
     hiddenTabs: string;
     childrenProps?: string | object;
+    /**
+     * Asked for the current request headers before every request a child makes on its own — a
+     * trace, a claim, the unauthorized campaign lookup — so a host can refresh its token on demand
+     * instead of the children reusing the headers captured at the last search.
+     */
+    requestHeadersProvider?: RequestHeadersProvider;
+    /** Name of a [JSInvokable] method on the Blazor reference that answers with the current request headers. */
+    blazorRequestHeadersProvider: string;
     blazorErrorStateListener: string;
     errorStateListener?: (newError: string) => void;
     blazorOnLoadingStateChange: string;
@@ -59,6 +71,8 @@ export declare class VehicleLookup implements MultiLingual {
     isError: boolean;
     isLoading: boolean;
     private searchGeneration;
+    /** The headers the host passed with the most recent search; the fallback when it supplies no provider. */
+    private lastRequestHeaders?;
     blazorRef?: DotNetObjectReference;
     el: HTMLElement;
     private componentsList;
@@ -66,7 +80,12 @@ export declare class VehicleLookup implements MultiLingual {
     onIsDevChange(isDev: boolean): Promise<void>;
     private loadMockData;
     private syncErrorAcrossComponents;
-    private getSscElement;
+    /**
+     * The current headers for a request made on the host's behalf. The host's own provider wins —
+     * it can refresh a token before answering — and the headers it passed with the last search are
+     * the fallback for hosts that only ever push headers at search time.
+     */
+    private resolveRequestHeaders;
     handleLoadData(newResponse: VehicleLookupDTO, activeElement: any): Promise<void>;
     private loadingStateChangingMiddleware;
     errorListener(newState: any): Promise<void>;

package/dist/types/components/vehicle-lookup/vehicle-ssc.d.ts

@@ -0,0 +1,214 @@
+import { VehicleLookupDTO } from "../../global/types/generated/vehicle-lookup/vehicle-lookup-dto";
+import { SscRepairTraceDTO } from "../../global/types/generated/vehicle-lookup/ssc-repair-trace-dto";
+import sscSchema from "../../locales/vehicleLookup/ssc/type";
+import { ManufacturerCheckStatus } from './components/SscCampaigns';
+import { VehicleInfoLayoutInterface } from "../../features/vehicle-info-layout/index";
+import { BlazorInvokable, DotNetObjectReference, BlazorInvokableFunction } from "../../features/blazor-ref/index";
+import { RequestHeadersProvider, VehicleLookupComponent, VehicleLookupMock } from "../../features/vehicle-lookup-component/index";
+import { ComponentLocale, ErrorKeys, LanguageKeys, MultiLingual } from "../../features/multi-lingual/index";
+/**
+ * The Special Service Campaigns (safety recalls) affecting a vehicle, and nothing else: warranty
+ * coverage lives in <vehicle-warranty-timeline>. Replaces the campaign half of the retired
+ * <vehicle-warranty-details>.
+ *
+ * A vehicle is on exactly one of two paths, and the panel must never mix them (the rule is spelled
+ * out on `panelVerdict` in ./components/SscCampaigns.tsx and in
+ * .shift/repos/adp/web-components/vehicle-lookup-invariants.md):
+ *
+ *  - authorized (in the distributor's records): the campaign list is the verdict;
+ *  - unauthorized: the distributor has no records, so the only verdict is the manufacturer's
+ *    answer to the reCAPTCHA-gated check — a yes/no, no list. Until it arrives the panel says the
+ *    vehicle is not in the records and asserts nothing else.
+ *
+ * A third state is neither: a wrapper that only counts the SSC tab's own request as a campaign
+ * check (`sscQueryString`) tells this panel through `skipLookup` that a vehicle was looked up
+ * without it. The panel then says the check was not run and offers to run it, rather than sitting
+ * blank next to a VIN as if the vehicle had no campaigns.
+ *
+ * With `show-trace`, every campaign row can open the evidence behind its repair status: the labor
+ * codes accepted for the campaign, every warranty claim on the vehicle with how it was judged, and
+ * the service-history lines that matched. The trace is fetched on first use with `?trace=ssc`, so
+ * the ordinary lookup response stays small and the host can gate the detail behind a permission.
+ *
+ * Every state change is a movement (lookup-motion.css): the outgoing content stays rendered while
+ * the body shuts over it, and the incoming content is swapped in only while the body is shut. The
+ * shared lookup helper waits a second before it asks the server, which is what guarantees the body
+ * has settled shut before a response can land.
+ */
+export declare class VehicleSsc implements MultiLingual, VehicleInfoLayoutInterface, VehicleLookupComponent, BlazorInvokable {
+    language: LanguageKeys;
+    locale: ComponentLocale<typeof sscSchema>;
+    componentWillLoad(): Promise<void>;
+    changeLanguage(newLanguage: LanguageKeys): Promise<void>;
+    coreOnly: boolean;
+    isDev: boolean;
+    disableVinValidation: boolean;
+    baseUrl: string;
+    headers: object;
+    queryString: string;
+    /**
+     * Appended to the campaign lookup request only, never to the trace request. A wrapper passes its
+     * `sscQueryString` — typically a lookup-logging flag — here rather than into `queryString`, so
+     * opening a campaign's evidence (a re-read of a lookup that was already logged) is never counted
+     * as another lookup. The host's endpoint must refuse to log traced requests as well.
+     */
+    lookupQueryString: string;
+    /** Asked for the current headers before every request this component makes itself; lets a host refresh its token on demand. */
+    requestHeadersProvider?: RequestHeadersProvider;
+    /** Name of a [JSInvokable] method on the Blazor reference that answers with the current headers. */
+    blazorRequestHeadersProvider: string;
+    lastRequestHeaders?: object;
+    errorCallback?: BlazorInvokableFunction<(errorMessage: ErrorKeys) => void>;
+    loadingStateChange?: BlazorInvokableFunction<(isLoading: boolean) => void>;
+    loadedResponse?: BlazorInvokableFunction<(response: VehicleLookupDTO) => void>;
+    unauthorizedSscLookupResponse?: BlazorInvokableFunction<(sscLookupStatus: number) => 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>;
+    setErrorMessage(message: ErrorKeys): Promise<void>;
+    /** Back to "no vehicle": the body shuts over what it holds, then the panel is emptied unseen. */
+    clearData(): Promise<void>;
+    /**
+     * The other panels were given a vehicle but this one's own lookup was not run for it — a wrapper
+     * with `sscQueryString` only counts the SSC tab's own request as a campaign check. The panel says
+     * so and offers to run the check itself; the VIN is kept for that.
+     */
+    skipLookup(vin: string): Promise<void>;
+    onLoadingChange(newValue: boolean): void;
+    /** A vehicle was looked up without this panel; set by `skipLookup`, cleared by the next lookup. */
+    skippedVin?: string;
+    /** The panel is on its way to empty: the sheen is on and the body is shutting over its content. */
+    leaving: boolean;
+    private leaveGeneration;
+    /**
+     * The body's last non-empty content, kept while the body is shut so the content slides away
+     * with it instead of vanishing the frame the state changes. Dropped once the body has settled.
+     */
+    private retainedBody;
+    private retainTimer?;
+    /** How long a state change takes to settle: the --settle token plus a margin for the frame it starts on. */
+    private settleMs;
+    /**
+     * Puts the chip and lead on the sheen, shuts the body over whatever it holds, and resolves once
+     * they have settled — so the caller can swap the content while nothing is on screen. Resolves at
+     * once when there is nothing to leave. A lookup started meanwhile takes over.
+     */
+    private leave;
+    private emptyPanel;
+    /**
+     * Height changes here are CSS transitions inside this shadow root, which an enclosing
+     * <flexible-container> (the wrapper's tab strip) cannot see; it would keep clipping at the old
+     * height. So every render that moved something announces the change to those containers, the way
+     * a nested <flexible-container> does, and they stop clipping until it has settled.
+     */
+    private heightAnnouncer?;
+    private layoutSignature?;
+    componentDidRender(): void;
+    private runSkippedLookup;
+    /** Remembers what the body shows, and forgets it a settle after the body shut. */
+    private retainBody;
+    blazorRef?: DotNetObjectReference;
+    setBlazorRef(newBlazorRef: DotNetObjectReference): Promise<void>;
+    /** Shows a per-campaign "why this status?" control. The host gates it on its own permission check; the trace lists claim and invoice details. */
+    showTrace: boolean;
+    recaptchaKey: string;
+    /** Renders a click-to-pass stand-in for the reCAPTCHA widget. Implied by `isDev`; the real widget is only ever used in production mode. */
+    mockRecaptcha: boolean;
+    unauthorizedSscLookupBaseUrl: string;
+    unauthorizedSscLookupQueryString: string;
+    cityId?: string;
+    cityIntegrationId?: string;
+    companyId?: string;
+    companyIntegrationId?: string;
+    companyBranchId?: string;
+    companyBranchIntegrationId?: string;
+    userId?: string;
+    brandIntegrationId: string;
+    customerName?: string;
+    customerPhone?: string;
+    customerEmail?: string;
+    /** The check is offered: the vehicle is unauthorized and the host configured a site key. */
+    showRecaptcha: boolean;
+    checkingUnauthorizedSSC: boolean;
+    devRecaptchaChecked: boolean;
+    recaptchaRes: {
+        status: ManufacturerCheckStatus | null;
+    } | null;
+    private recaptchaIntervalRef;
+    private recaptchaHideTimer?;
+    private recaptchaWidgetId;
+    private recaptchaPortalEl?;
+    private recaptchaPlaceholderRef;
+    private recaptchaReady?;
+    private positionRAF;
+    /**
+     * Development never shows Google's widget. The stand-in is the default whenever `isDev` is on, and
+     * the real widget is created lazily, only when a production-mode lookup actually needs it — so a
+     * host that flips `isDev` after the element mounted (the dev showcase does) still gets the mock,
+     * instead of a real widget rendered at mount time sitting on top of a mock that never polls it.
+     */
+    private get useMockRecaptchaWidget();
+    private mockRecaptchaTrigger?;
+    onRecaptchaModeChange(): void;
+    private handleDevRecaptchaClick;
+    /** Stops the check from answering — polling, the stand-in's trigger, a request in flight — without touching what is on screen. */
+    private suspendManufacturerCheck;
+    /** Back to "nothing asked yet" — every new lookup, once the previous check has left the screen, and a cleared panel start here. */
+    private resetManufacturerCheck;
+    /**
+     * Offers the check for an unauthorized vehicle. Not awaited by the lookup: loading Google's script
+     * must not delay the vehicle landing on screen, so the real widget is armed in the background and
+     * checked against the lookup generation before it starts polling.
+     */
+    private prepareManufacturerCheck;
+    private armRealRecaptcha;
+    /** Loads Google's script and renders the widget into a body-level portal, once per element. */
+    private ensureRealRecaptcha;
+    private hideRealRecaptcha;
+    /**
+     * The real widget is visible only while a production-mode check is offered and unanswered. It
+     * lives outside the shadow root, so the body cannot clip it as it shuts; instead it follows the
+     * body's opacity (see `getAncestorOpacity`) and is only taken down once the body has settled.
+     */
+    private syncRealRecaptchaVisibility;
+    onRecaptchaStateChange(): void;
+    private runUnauthorizedSscLookup;
+    disconnectedCallback(): void;
+    private syncRecaptchaPosition;
+    /**
+     * How see-through the widget's place on the page is: the product of every ancestor's opacity,
+     * from the placeholder up through this shadow root (the body fading as it shuts) and on up the
+     * host page (a tab sliding out). The portal copies it, so the real widget leaves with the panel.
+     */
+    private getAncestorOpacity;
+    openTraceKey?: string;
+    traces: Record<string, SscRepairTraceDTO>;
+    traceLoading: boolean;
+    traceError?: string;
+    private traceAbortController?;
+    /** The VIN the cached traces belong to; a lookup for another vehicle invalidates them. */
+    private tracesVin?;
+    private resetTraces;
+    private toggleTrace;
+    private loadTraces;
+    /** The row whose drawer the page is following, and the way to let go of it. */
+    private followedDrawer?;
+    private stopFollowing?;
+    /**
+     * When a row's evidence opens, brings the row to the top of the page and keeps it there while the
+     * drawer slides open beneath it — as an expanded service-history line does — so the reader is
+     * looking at the evidence they asked for and not at the drawer's edge below the fold. Runs after
+     * every render and acts only when the open drawer changes; closing it, or leaving, lets go.
+     */
+    private followOpenDrawer;
+    private stopFollowingDrawer;
+    private panelState;
+    render(): any;
+}

package/dist/types/components/vehicle-lookup/vehicle-warranty-timeline.d.ts

@@ -8,10 +8,9 @@ import { ComponentLocale, ErrorKeys, LanguageKeys, MultiLingual } from "../../fe
  * Warranty coverage as a single dated rail: the standard warranty followed by every
  * extended coverage in sequence.
  *
- * Deliberately separate from `vehicle-warranty-details` rather than a mode of it. This
- * panel shows warranty and nothing else — no campaign table, no reCAPTCHA, no unauthorized
- * campaign lookup — so hosts adopt it by pointing their warranty tab at this tag and can
- * keep the original panel untouched for as long as they like.
+ * This panel shows warranty and nothing else — no campaign table, no reCAPTCHA, no
+ * unauthorized campaign lookup; those belong to `vehicle-ssc`. Hosts point their warranty
+ * tab at this tag and their campaign tab at that one.
  */
 export declare class VehicleWarrantyTimeline implements MultiLingual, VehicleInfoLayoutInterface, VehicleLookupComponent, BlazorInvokable {
     language: LanguageKeys;