import * as i0 from '@angular/core';
import { Signal, InputSignalWithTransform, InputSignal, ElementRef, ModelSignal, WritableSignal, AfterContentInit, OnInit, OutputEmitterRef, EventEmitter } from '@angular/core';
import { CheckboxControlValueAccessor, DefaultValueAccessor, RadioControlValueAccessor, ControlValueAccessor } from '@angular/forms';
import { Middleware } from '@floating-ui/dom';

declare class AddArrowKeysDirective {
    private readonly items;
    private readonly renderer;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddArrowKeysDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AddArrowKeysDirective, "[vAddArrowKeys]", never, {}, {}, ["items"], never, true, never>;
}

/**
 * Directive to add alternate surface class, <code>class="v-alternate"</code>, to the host element.
 */
declare class AlternateDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<AlternateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AlternateDirective, "[vAlternate]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare const BreakpointType: {
    readonly XS: "xs";
    readonly SM: "sm";
    readonly MD: "md";
    readonly LG: "lg";
    readonly XL: "xl";
    readonly XXL: "xxl";
    readonly MOBILE: "mobile";
    readonly DESKTOP: "desktop";
};
type BreakpointType = (typeof BreakpointType)[keyof typeof BreakpointType];
declare const coerceBreakpoint: (type: "container" | "media", classes: BreakpointType | BreakpointType[] | null) => string | null;
declare class BreakpointsDirective {
    protected readonly classes: Signal<string>;
    /**
     * Hides element when within given _container_ breakpoint.
     */
    readonly vContainerHide: InputSignalWithTransform<string | null, BreakpointType | BreakpointType[] | null>;
    /**
     * Hides element when true.
     */
    readonly vHide: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Hides element when within given _media_ breakpoint.
     */
    readonly vMediaHide: InputSignalWithTransform<string | null, BreakpointType | BreakpointType[] | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreakpointsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BreakpointsDirective, "[vContainerHide], [vMediaHide], [vHide]", never, { "vContainerHide": { "alias": "vContainerHide"; "required": false; "isSignal": true; }; "vHide": { "alias": "vHide"; "required": false; "isSignal": true; }; "vMediaHide": { "alias": "vMediaHide"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * The class, <code>class="v-icon-tow-color"</code>, applied by this directive only changes Visa Library icons.
 */
declare class DualIconDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DualIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DualIconDirective, "[v-icon-two-color], ", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare const ElevationType: {
    readonly NONE: "none";
    readonly INSET: "inset";
    readonly XS: "xs";
    readonly SM: "sm";
    readonly MD: "md";
    readonly LG: "lg";
    readonly XL: "xl";
    readonly XXL: "xxl";
};
type ElevationType = (typeof ElevationType)[keyof typeof ElevationType];
declare class ElevationDirective {
    /**
     * Applies elevation given.
     */
    readonly vElevation: InputSignal<ElevationType | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ElevationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ElevationDirective, "[vElevation]", never, { "vElevation": { "alias": "vElevation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const DOWN_ARROW_KEY = "ArrowDown";
declare const END_KEY = "End";
declare const ESCAPE_KEY = "Escape";
declare const HOME_KEY = "Home";
declare const LEFT_ARROW_KEY = "ArrowLeft";
declare const RIGHT_ARROW_KEY = "ArrowRight";
declare const SPACE_KEY = " ";
declare const SPACE_CODE = "Space";
declare const TAB_KEY = "Tab";
declare const UP_ARROW_KEY = "ArrowUp";
declare const ENTER_KEY = "Enter";
declare const BACKSPACE_KEY = "Backspace";
declare const SpacingProperties: {
    readonly INHERIT: "inherit";
    readonly NORMAL: "normal";
    readonly AUTO: "auto";
};
type SpacingProperties = (typeof SpacingProperties)[keyof typeof SpacingProperties] | number;

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class FlexDirective {
    protected readonly classes: Signal<string>;
    /**
   /**
     * Sets property <code>align-content: space-around</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignContentAround: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: space-between</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignContentBetween: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: center</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above)
     */
    readonly vAlignContentCenter: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: end</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignContentEnd: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: start</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above)
     */
    readonly vAlignContentStart: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: space-evenly</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignContentEvenly: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-items: baseline</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignItemsBaseline: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: center</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignItemsCenter: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: end</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignItemsEnd: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-content: start</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignItemsStart: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-items: stretch</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vAlignItemsStretch: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-self: auto</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vAlignSelfAuto: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-self: baseline</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vAlignSelfBaseline: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-self: center</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vAlignSelfCenter: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-self: end</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vAlignSelfEnd: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-self: start</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vAlignSelfStart: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>align-self: stretch</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vAlignSelfStretch: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>column-gap</code>. <br>Accepts gap: 0 - 48 and SpacingProperties.
     */
    readonly vColGap: InputSignal<null | number | SpacingProperties | string | undefined>;
    /**
     * Sets property <code>display: flex</code>. <br>
     * This property is also a selector and can be used by itself on a flex element.
     */
    readonly vFlex: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-basis: &lt;value&gt;</code>. <br>
     * Accepts a string that should be in the form of a percentage or CSS unit. <br />
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vFlexBasis: InputSignal<null | string>;
    /**
     * Sets property <code>flex-direction: column</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexCol: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-direction: column-reverse</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexColReverse: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-grow: 1</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vFlexGrow: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-grow: 0</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vFlexGrow0: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>display: inline-flex</code>. <br>
     * This property is also a selector and can be used by itself on a flex element.
     */
    readonly vFlexInline: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-wrap: no-wrap</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexNoWrap: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-direction: row</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexRow: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-direction: row-reverse</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexRowReverse: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-shrink: 1</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vFlexShrink: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-shrink: 0</code>. <br>
     * This property is also a selector and can be used by itself on the <i>child</i> of a flex element.
     */
    readonly vFlexShrink0: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-wrap: wrap</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexWrap: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>flex-wrap: wrap-reverse</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vFlexWrapReverse: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>gap</code>. <br>Accepts gap: 0 - 48 and SpacingProperties.
     */
    readonly vGap: InputSignal<null | number | SpacingProperties | string | undefined>;
    /**
     * Sets property <code>justify-content: space-around</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vJustifyContentAround: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>justify-content: space-between</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vJustifyContentBetween: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>justify-content: center</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vJustifyContentCenter: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>justify-content: end</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vJustifyContentEnd: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>justify-content: space-evenly</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vJustifyContentEvenly: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>justify-content: start</code>. <br>
     * This property should be used alongside a FlexDirective selector (see selectors above).
     */
    readonly vJustifyContentStart: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets property <code>row-gap</code>. <br>Accepts gap: 0 - 48 and SpacingProperties.
     */
    readonly vRowGap: InputSignal<null | number | SpacingProperties | string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlexDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexDirective, "[vFlex], [vFlexInline], [vGap], [vFlexGrow], [vFlexGrow0],  [vFlexShrink], [vFlexShrink0], [vFlexBasis], [vAlignSelfStart], [vAlignSelfEnd],  [vAlignSelfCenter], [vAlignSelfStretch], [vAlignSelfAuto], [vAlignSelfBaseline],", never, { "vAlignContentAround": { "alias": "vAlignContentAround"; "required": false; "isSignal": true; }; "vAlignContentBetween": { "alias": "vAlignContentBetween"; "required": false; "isSignal": true; }; "vAlignContentCenter": { "alias": "vAlignContentCenter"; "required": false; "isSignal": true; }; "vAlignContentEnd": { "alias": "vAlignContentEnd"; "required": false; "isSignal": true; }; "vAlignContentStart": { "alias": "vAlignContentStart"; "required": false; "isSignal": true; }; "vAlignContentEvenly": { "alias": "vAlignContentEvenly"; "required": false; "isSignal": true; }; "vAlignItemsBaseline": { "alias": "vAlignItemsBaseline"; "required": false; "isSignal": true; }; "vAlignItemsCenter": { "alias": "vAlignItemsCenter"; "required": false; "isSignal": true; }; "vAlignItemsEnd": { "alias": "vAlignItemsEnd"; "required": false; "isSignal": true; }; "vAlignItemsStart": { "alias": "vAlignItemsStart"; "required": false; "isSignal": true; }; "vAlignItemsStretch": { "alias": "vAlignItemsStretch"; "required": false; "isSignal": true; }; "vAlignSelfAuto": { "alias": "vAlignSelfAuto"; "required": false; "isSignal": true; }; "vAlignSelfBaseline": { "alias": "vAlignSelfBaseline"; "required": false; "isSignal": true; }; "vAlignSelfCenter": { "alias": "vAlignSelfCenter"; "required": false; "isSignal": true; }; "vAlignSelfEnd": { "alias": "vAlignSelfEnd"; "required": false; "isSignal": true; }; "vAlignSelfStart": { "alias": "vAlignSelfStart"; "required": false; "isSignal": true; }; "vAlignSelfStretch": { "alias": "vAlignSelfStretch"; "required": false; "isSignal": true; }; "vColGap": { "alias": "vColGap"; "required": false; "isSignal": true; }; "vFlex": { "alias": "vFlex"; "required": false; "isSignal": true; }; "vFlexBasis": { "alias": "vFlexBasis"; "required": false; "isSignal": true; }; "vFlexCol": { "alias": "vFlexCol"; "required": false; "isSignal": true; }; "vFlexColReverse": { "alias": "vFlexColReverse"; "required": false; "isSignal": true; }; "vFlexGrow": { "alias": "vFlexGrow"; "required": false; "isSignal": true; }; "vFlexGrow0": { "alias": "vFlexGrow0"; "required": false; "isSignal": true; }; "vFlexInline": { "alias": "vFlexInline"; "required": false; "isSignal": true; }; "vFlexNoWrap": { "alias": "vFlexNoWrap"; "required": false; "isSignal": true; }; "vFlexRow": { "alias": "vFlexRow"; "required": false; "isSignal": true; }; "vFlexRowReverse": { "alias": "vFlexRowReverse"; "required": false; "isSignal": true; }; "vFlexShrink": { "alias": "vFlexShrink"; "required": false; "isSignal": true; }; "vFlexShrink0": { "alias": "vFlexShrink0"; "required": false; "isSignal": true; }; "vFlexWrap": { "alias": "vFlexWrap"; "required": false; "isSignal": true; }; "vFlexWrapReverse": { "alias": "vFlexWrapReverse"; "required": false; "isSignal": true; }; "vGap": { "alias": "vGap"; "required": false; "isSignal": true; }; "vJustifyContentAround": { "alias": "vJustifyContentAround"; "required": false; "isSignal": true; }; "vJustifyContentBetween": { "alias": "vJustifyContentBetween"; "required": false; "isSignal": true; }; "vJustifyContentCenter": { "alias": "vJustifyContentCenter"; "required": false; "isSignal": true; }; "vJustifyContentEnd": { "alias": "vJustifyContentEnd"; "required": false; "isSignal": true; }; "vJustifyContentEvenly": { "alias": "vJustifyContentEvenly"; "required": false; "isSignal": true; }; "vJustifyContentStart": { "alias": "vJustifyContentStart"; "required": false; "isSignal": true; }; "vRowGap": { "alias": "vRowGap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class MarginDirective {
    protected readonly classes: Signal<string>;
    /**
     * Sets margin-block-start property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vM: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets margin-inline-end property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vMB: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets margin-block-end property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vML: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets margin-inline-start property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vMR: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets margin-inline property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vMT: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets margin-block property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vMX: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets margin property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vMY: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MarginDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MarginDirective, "[vM], [vMB], [vML], [vMR], [vMT], [vMX], [vMY], ", never, { "vM": { "alias": "vM"; "required": false; "isSignal": true; }; "vMB": { "alias": "vMB"; "required": false; "isSignal": true; }; "vML": { "alias": "vML"; "required": false; "isSignal": true; }; "vMR": { "alias": "vMR"; "required": false; "isSignal": true; }; "vMT": { "alias": "vMT"; "required": false; "isSignal": true; }; "vMX": { "alias": "vMX"; "required": false; "isSignal": true; }; "vMY": { "alias": "vMY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class OpensInNewTabDirective {
    constructor();
    private readonly el;
    private readonly textContent;
    /**
     * Allows user to set custom aria-label attribute.
     * @default '&lt;inner-text-of-link&gt; (opens in new tab)'
     */
    readonly ariaLabelInput: InputSignal<string | null>;
    readonly ariaLabel: Signal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpensInNewTabDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<OpensInNewTabDirective, "[vOpensInNewTab], ", never, { "ariaLabelInput": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class PaddingDirective {
    protected readonly classes: Signal<string>;
    /**
     * Sets padding-block-start property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vP: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets padding-inline-end property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vPB: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets padding-block-end property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vPL: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets padding-inline-start property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vPR: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets padding-inline property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vPT: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets padding-block property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vPX: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    /**
     * Sets padding property. <br>
     * Accepts: 0 - 48 or <code>SpacingProperties</code>.
     */
    readonly vPY: InputSignalWithTransform<string | null, SpacingProperties | string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaddingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PaddingDirective, "[vP], [vPB], [vPL], [vPR], [vPT], [vPX], [vPY], ", never, { "vP": { "alias": "vP"; "required": false; "isSignal": true; }; "vPB": { "alias": "vPB"; "required": false; "isSignal": true; }; "vPL": { "alias": "vPL"; "required": false; "isSignal": true; }; "vPR": { "alias": "vPR"; "required": false; "isSignal": true; }; "vPT": { "alias": "vPT"; "required": false; "isSignal": true; }; "vPX": { "alias": "vPX"; "required": false; "isSignal": true; }; "vPY": { "alias": "vPY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ScreenreaderOnlyDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenreaderOnlyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ScreenreaderOnlyDirective, "[vSr], [vSR], [vScreenreader], [vScreenReader]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

/**
 * I don't love having 'surface' in the key names,
 * but using just numbers does not work as expected.
 */
declare const SurfaceType: {
    readonly Surface1: "1";
    readonly Surface2: "2";
    readonly Surface3: "3";
};
type SurfaceType = (typeof SurfaceType)[keyof typeof SurfaceType];
/**
 * Directive to add default surface class, <code>class="v-surface"</code>, to the host element.
 */
declare class SurfaceDirective {
    /**
     * Applies given surface class. <br>
     */
    readonly vSurface: InputSignal<'' | SurfaceType | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SurfaceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SurfaceDirective, "[vSurface]", never, { "vSurface": { "alias": "vSurface"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NovaCommonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NovaCommonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NovaCommonModule, never, [typeof AddArrowKeysDirective, typeof AlternateDirective, typeof BreakpointsDirective, typeof DualIconDirective, typeof ElevationDirective, typeof FlexDirective, typeof MarginDirective, typeof OpensInNewTabDirective, typeof PaddingDirective, typeof ScreenreaderOnlyDirective, typeof SurfaceDirective], [typeof AddArrowKeysDirective, typeof AlternateDirective, typeof BreakpointsDirective, typeof DualIconDirective, typeof ElevationDirective, typeof FlexDirective, typeof MarginDirective, typeof OpensInNewTabDirective, typeof PaddingDirective, typeof ScreenreaderOnlyDirective, typeof SurfaceDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NovaCommonModule>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
type Unsubscribable = {
    unsubscribe: () => void;
};

declare class ListenerService {
    listeners: (() => void)[];
    navListeners: (() => void)[];
    navSubscriptions: (Unsubscribable | undefined)[];
    subscriptions: (Unsubscribable | undefined)[];
    cleanupEffect: i0.EffectRef;
    cleanup(): void;
    cleanupNavListeners(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListenerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ListenerService>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class CheckboxDirective extends CheckboxControlValueAccessor {
    constructor();
    readonly el: ElementRef<HTMLInputElement>;
    private readonly idGenerator;
    readonly listenerService: ListenerService;
    /**
     * Sets checked state of component. <br />
     * Because 'checked' is a native attribute of input[type="checkbox"], it can only be set false by using [checked]="false", not checked="false" <br />
     * Use [checked] when you want to handle the checked state of the checkbox.
     * Use (checkedChange) when you want the library to handle the checked state of the checkbox, but get notified of changes.
     * Use [(checked)] when you want the checked state to reflect changes by both you and the library.
     */
    readonly checked: ModelSignal<boolean | null | string>;
    private readonly checkedEffect;
    /**
     * Sets checkbox to disabled when true
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    private readonly disabledInternal;
    readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(isDisabled: boolean | null): void;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-checkbox')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Marks checkbox as invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Sets checkbox to indeterminate when true.
     * @default false
     */
    readonly indeterminate: InputSignalWithTransform<boolean | null, unknown>;
    private readonly indeterminateEffect;
    /**
     * Marks checkbox as required when true.
     * @default false
     */
    readonly required: InputSignalWithTransform<boolean | null, unknown>;
    handleChange(event: Event): void;
    writeValue(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxDirective, "[v-checkbox]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

/**
 * This directive is used to group radio buttons together and manage their state. <br />
 * Typically used for a required group to relay that one of the group is required to be selected.
 */
declare class RadioGroupDirective extends DefaultValueAccessor {
    private readonly idGenerator;
    readonly radios: Signal<readonly RadioDirective[]>;
    /**
     * Sets radio group as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabledInternal: WritableSignal<boolean | null>;
    readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(disabled: boolean): void;
    /**
     * Marks radio group as invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Shared name of radio group.
     * @default this.uuidService.getUUID('v-radio-group-');
     * @builtin true
     */
    readonly name: InputSignal<string>;
    /**
     * Marks radio group as required when true.
     * @default false
     */
    readonly required: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Value of radio group.
     * Use [value] when you want to handle the value of the toggle container.
     * Use (valuedChange) when you want the library to handle the value of the toggle container, but get notified of changes.
     * Use [(value)] when you want the value to reflect changes by both you and the library.
     */
    readonly value: ModelSignal<string | number | null | undefined>;
    private readonly valueEffect;
    private readonly activeRadio;
    private readonly activeRadioEffect;
    writeValue(value: string | number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioGroupDirective, "[v-radio-group]", never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["radios"], never, true, never>;
}

declare class RadioDirective extends RadioControlValueAccessor {
    ngOnInit(): void;
    private _control;
    private readonly injector;
    readonly el: ElementRef;
    private readonly idGenerator;
    protected readonly radioGroup: RadioGroupDirective | null;
    private readonly toggle;
    private readonly toggleContainer;
    /**
     * Sets checked state of component. <br />
     * Because 'checked' is a native attribute of input[type="checkbox"], it can only be set false by using [checked]="false", not checked="false" <br />
     * Use [checked] when you want to handle the checked state of the checkbox.
     * Use (checkedChange) when you want the library to handle the checked state of the checkbox, but get notified of changes.
     * Use [(checked)] when you want the checked state to reflect changes by both you and the library.
     */
    readonly checked: ModelSignal<boolean | null | string>;
    readonly checkedEffect: i0.EffectRef;
    private checkName;
    private readonly radioGroupValueEffect;
    /**
     * Sets radio as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabledInternal: WritableSignal<boolean | null>;
    readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(disabled: boolean | null): void;
    /**
     * @ignore
     */
    readonly formName: InputSignal<string | null>;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-radio')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Marks radio as invalid when true.
     * @default false
     */
    readonly invalidInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly invalid: Signal<boolean | null>;
    /**
     * @ignore
     */
    readonly nameInput: InputSignal<string | null>;
    readonly nameSignal: Signal<string | null>;
    private readonly namesEffect;
    /**
     * Marks component as required when true.
     * @default false
     */
    readonly requiredInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly required: Signal<boolean | null>;
    /**
     * Value of radio input.
     * @default idGenerator.newId('v-radio') when toggle is true, otherwise null
     */
    readonly valueInput: InputSignal<string | number | null>;
    readonly valueSignal: Signal<string | number | null>;
    private readonly valueEffect;
    handleChange(event: Event): void;
    writeValue(value: string | number | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<RadioDirective, "[v-radio]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "formName": { "alias": "formControlName"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "invalid"; "required": false; "isSignal": true; }; "nameInput": { "alias": "name"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
}

declare class CheckboxPanelDirective {
    private readonly appReadyService;
    private readonly checkbox;
    private readonly radio;
    handleClick(event: Event): void;
    /**
     * Toggles checkbox or radio programmatically.
     * @param control Checkbox or Radio item to toggle.
     * @param event Event to check if target is the control.
     */
    toggleControl(control: RadioDirective | CheckboxDirective, event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxPanelDirective, "[v-checkbox-panel], [v-radio-panel]", never, {}, {}, ["checkbox", "radio"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class AccordionDirective {
    private readonly flex;
    private readonly idGenerator;
    readonly singleSelectItemsName: WritableSignal<string>;
    protected readonly removeDefaultFlex: Signal<boolean | undefined>;
    protected readonly removeDefaultGap: Signal<boolean | undefined | null | any>;
    /**
     * Allows multiple accordion items to be expanded when true.
     * @default false
     */
    readonly multiselect: InputSignalWithTransform<boolean, unknown>;
    /**
     * Applies subtle accordion styling when true.
     * @default false
     */
    readonly subtle: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionDirective, "[v-accordion]", never, { "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "subtle": { "alias": "subtle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class AccordionHeadingDirective implements AfterContentInit {
    readonly accordion: AccordionDirective | null;
    readonly hostButton: ButtonDirective | null;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionHeadingDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionHeadingDirective, "[v-accordion-heading]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class AccordionDetailsDirective implements OnInit {
    ngOnInit(): void;
    private readonly el;
    private readonly accordion;
    protected readonly heading: Signal<AccordionHeadingDirective>;
    /**
     *
     * Sets expanded state ('open' or 'closed') of component. <br />
     * Because 'open' is a native attribute of <details>, it can only be set false by using [open]="false", not open="false" <br />
     * Use [open] when you want to handle the expanded state of the accordion item.
     * Use (openChange) when you want the library to handle the expanded state of the accordion item, but get notified of changes.
     * Use [(open)] when you want the expanded state to reflect changes by both you and the library.
     */
    readonly expanded: ModelSignal<boolean | null | string>;
    /** @ignore */
    readonly nameInput: InputSignal<string | null>;
    readonly name: Signal<string | null>;
    /**
     * Emits expanded state of item when toggled.
     */
    readonly toggled: OutputEmitterRef<boolean>;
    toggle(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionDetailsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionDetailsDirective, "[v-accordion-item]", never, { "expanded": { "alias": "open"; "required": false; "isSignal": true; }; "nameInput": { "alias": "name"; "required": false; "isSignal": true; }; }, { "expanded": "openChange"; "toggled": "toggled"; }, ["heading"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class FloatingUITriggerDirective {
    readonly el: ElementRef;
    readonly button: ButtonDirective | null;
    private readonly floatingUIContainer;
    protected readonly floatingElemID: Signal<string | null>;
    protected readonly triggersDropdownMenu: Signal<boolean | null>;
    protected readonly triggersTooltip: Signal<boolean | null>;
    readonly isShown: WritableSignal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingUITriggerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingUITriggerDirective, "[v-floating-ui-trigger]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class NavDirective {
    /**
     * Sets navigation to drawer variation when true.
     * @default false
     */
    readonly drawer: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets navigation to vertical orientation when true.
     * @default false
     */
    readonly vertical: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NavDirective, "[v-nav]", never, { "drawer": { "alias": "drawer"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PanelContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PanelContentDirective, "[v-panel-content]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class TabListDirective implements AfterContentInit {
    prevTabs: WritableSignal<TabItemDirective[] | undefined>;
    constructor();
    ngAfterContentInit(): void;
    readonly tabListParent: TabListDirective | null;
    readonly navParent: NavDirective | null;
    protected readonly panelParent: PanelContentDirective | null;
    private readonly el;
    private readonly novaLibService;
    readonly buttons: Signal<readonly ButtonDirective[]>;
    readonly tabs: Signal<readonly TabItemDirective[]>;
    /**
     * Sets custom role.
     * @default 'tablist'
     * @default null if nested tab list or within Navigation.
     * @builtin true
     */
    readonly roleInput: InputSignal<string | null>;
    protected readonly role: Signal<string | null>;
    /**
     * Sets tab list to vertical orientation when true.
     * @default false
     */
    readonly vertical: InputSignalWithTransform<boolean, unknown>;
    private setUpTabs;
    private readonly prevActiveTab;
    private readonly activeTabEffect;
    private setUpFocusListener;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabListDirective, "[v-tabs]", never, { "roleInput": { "alias": "role"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, ["buttons", "tabs"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class TabItemDirective implements OnInit, AfterContentInit {
    ngOnInit(): void;
    constructor();
    readonly tabList: TabListDirective | null;
    readonly button: Signal<ButtonDirective | undefined>;
    readonly stackedButton: Signal<ButtonDirective | undefined>;
    readonly trigger: Signal<FloatingUITriggerDirective | undefined>;
    /**
     * Marks item as selected when true. <br />
     * Can be used with navigational tabs as an alternative to Angular Router's routerLinkActive. When active is true, child buttons will automatically receive aria-current="page".
     * Use [active] when you want to handle the active state of the tab item.
     * Use (activeChange) when you want the library to handle the active state of the tab item, but get notified of changes.
     * Use [(active)] when you want the active state to reflect changes by both you and the library.
     */
    readonly active: ModelSignal<boolean | string | null>;
    /**
     * Marks the tab as a disclosure item when true. <br />
     * This item cannot be active and should expand and collapse when pressed.
     * @default false
     */
    readonly disclosureTab: InputSignalWithTransform<boolean, unknown>;
    /**
     * Emits expanded state when the child button is clicked.
     */
    readonly disclosureTabToggled: OutputEmitterRef<boolean>;
    /**
     * Sets expanded state of disclosure tab item.
     * Use [expanded] when you want to handle the expanded state of the tab item.
     * Use (expandedChange) when you want the library to handle the expanded state of the tab item, but get notified of changes.
     * Use [(expanded)] when you want the expanded state to reflect changes by both you and the library.
  
     * @default false
     */
    readonly expanded: ModelSignal<boolean | null | string>;
    /**
     * Sets role of tab item. <br />
     * If no custom role is set, role may be set by a parent component (nav, tabs, etc.).
     * @builtin true
     */
    readonly roleInput: InputSignal<HTMLElement['role']>;
    protected readonly role: Signal<HTMLElement['role'] | undefined>;
    /**
     * Marks the tab as a section title when true. <br />
     * This item titles a subset of tabs and is not interactive.
     * @default false
     */
    readonly sectionTitle: InputSignalWithTransform<boolean, unknown>;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TabItemDirective, "[v-tab-item]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "disclosureTab": { "alias": "disclosureTab"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "roleInput": { "alias": "role"; "required": false; "isSignal": true; }; "sectionTitle": { "alias": "sectionTitle"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; "disclosureTabToggled": "disclosureTabToggled"; "expanded": "expandedChange"; }, ["button", "trigger"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class IconToggleDefaultTemplateDirective {
    protected readonly iconToggle: IconToggleComponent | null;
    readonly tabItem: TabItemDirective | null;
    readonly tabSuffix: Signal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconToggleDefaultTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IconToggleDefaultTemplateDirective, "[v-toggle-default-template]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class IconToggleRotatedTemplateDirective {
    protected readonly iconToggle: IconToggleComponent | null;
    readonly tabItem: TabItemDirective | null;
    readonly tabSuffix: Signal<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconToggleRotatedTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IconToggleRotatedTemplateDirective, "[v-toggle-rotated-template]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class IconToggleComponent {
    private readonly button;
    readonly accordion: AccordionDetailsDirective | null;
    readonly defaultTemplate: Signal<IconToggleDefaultTemplateDirective | undefined>;
    readonly rotatedTemplate: Signal<IconToggleRotatedTemplateDirective | undefined>;
    readonly tabSuffix: Signal<boolean | null>;
    /** @ignore */
    readonly alignment: InputSignal<string>;
    /** @ignore */
    readonly color: InputSignal<string>;
    /** @ignore */
    readonly pointerEvents: InputSignal<string>;
    /**
     * Shows the rotated template when true and the default template when false.
     * @default false
     **/
    readonly rotatedInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly rotatedInternal: WritableSignal<boolean | null>;
    protected readonly rotated: Signal<boolean | null | string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconToggleComponent, "v-icon-visa-toggle", never, { "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "pointerEvents": { "alias": "pointerEvents"; "required": false; "isSignal": true; }; "rotatedInput": { "alias": "rotated"; "required": false; "isSignal": true; }; }, {}, ["defaultTemplate", "rotatedTemplate"], ["[v-toggle-rotated-template]", "[v-toggle-default-template]"], true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const IconSize: {
    readonly TINY: "tiny";
    readonly LOW: "low";
    readonly HIGH: "high";
};
type IconSize = (typeof IconSize)[keyof typeof IconSize];
declare const IconLibrary: {
    readonly VISA: "visa";
    readonly GENERIC: "generic";
};
type IconLibrary = (typeof IconLibrary)[keyof typeof IconLibrary];
declare const IconToggle: {
    readonly ACCORDION_COLLAPSED: "chevron-right";
    readonly ACCORDION_EXPANDED: "chevron-down";
    readonly COLLAPSED: "chevron-down";
    readonly EXPANDED: "chevron-up";
};
type IconToggle = (typeof IconToggle)[keyof typeof IconToggle];

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

/**
 * This directive can be used alongside the <code>v-icon</code> component to show a toggle icon when the item is collapsed or expanded. <br>
 * It is for use in icons that are part of icon sprites and not standalone icons.
 */
declare class IconToggleDirective {
    protected readonly accordion: AccordionDetailsDirective | null;
    private readonly floatingContainer;
    readonly rotatedInternal: WritableSignal<boolean | null>;
    readonly expanded: Signal<boolean | string | null>;
    /**
     * Icon to show when item is collapsed / hidden. <br>
     * Will render this icon when no <code>icon</code> or <code>customIcon</code> is provided to <code>v-icon</code>. <br>
     * Should refer to an icon in VPDS' [Icon Library](https://design.visa.com/components/icons-illustrations/).
     * @default 'chevron-right' / IconToggle.COLLAPSED <br>
     * @builtin true
     */
    readonly collapsedIconInput: InputSignal<string | null>;
    readonly collapsedIcon: Signal<string>;
    /**
     * Icon to show when item is expanded / shown. <br>
     * Will render this icon when no <code>icon</code> or <code>customIcon</code> is provided to <code>v-icon</code>. <br>
     * Should refer to an icon in VPDS' [Icon Library](https://design.visa.com/components/icons-illustrations/).
     * @default 'chevron-down' / IconToggle.EXPANDED <br>
     * @builtin true
     */
    readonly expandedIconInput: InputSignal<IconToggle | null>;
    readonly expandedIcon: Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IconToggleDirective, "[v-icon-toggle]", never, { "collapsedIconInput": { "alias": "collapsedIcon"; "required": false; "isSignal": true; }; "expandedIconInput": { "alias": "expandedIcon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const ButtonSize: {
    readonly SMALL: "small";
    readonly MEDIUM: "medium";
    readonly LARGE: "large";
};
type ButtonSize = (typeof ButtonSize)[keyof typeof ButtonSize];
declare const ButtonColor: {
    readonly PRIMARY: "primary";
    readonly SECONDARY: "secondary";
    readonly TERTIARY: "tertiary";
};
type ButtonColor = (typeof ButtonColor)[keyof typeof ButtonColor];

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ButtonDirective {
    constructor();
    readonly el: ElementRef;
    readonly listenerService: ListenerService;
    private readonly combobox;
    private readonly toggleContainer;
    private readonly inputContainer;
    private readonly tabItem;
    private readonly tagName;
    protected readonly isLink: Signal<boolean>;
    protected readonly isSummary: Signal<boolean>;
    private noTabRole;
    private readonly badge;
    readonly toggleIcon: Signal<IconToggleDirective | undefined>;
    readonly toggleIconComponent: Signal<IconToggleComponent | undefined>;
    /**
     * Aria attribute relaying whether button is selected. <br />
     * <code>aria-current</code> and <code>aria-selected</code> cannot be used together.
     * @default null
     * @builtin true
     */
    readonly ariaCurrentInput: InputSignalWithTransform<HTMLButtonElement['ariaCurrent'] | boolean, unknown>;
    protected readonly ariaCurrent: Signal<string | boolean | null>;
    /**
     * Aria attribute pointing to id of descriptive element. <br />
     * If the button has a badge, the <code>aria-describedby</code> will be set to the badge's id by default.
     * @default false
     */
    readonly ariaDescribedbyInput: InputSignal<string | null>;
    protected readonly ariaDescribedby: Signal<string | undefined>;
    /**
     * Sets aria disabled state for accessibility purposes. <br />
     * When true, indicates that the button is disabled and not interactive.
     * @default false
     */
    readonly ariaDisabledInput: InputSignal<HTMLElement['ariaDisabled']>;
    readonly ariaDisabled: Signal<HTMLElement['ariaDisabled']>;
    /**
     * Aria attribute relaying whether button is expanded.
     * @default null
     * @builtin true
     */
    readonly ariaExpandedInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly ariaExpandedInternal: WritableSignal<boolean | null>;
    readonly ariaExpanded: Signal<boolean | null>;
    /**
     * Sets button to combobox toggle button when true.
     * @default false
     * @default true when button is used within combobox and no custom value is given.
     * @builtin true
     */
    readonly ariaHaspopupInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly ariaHaspopup: Signal<string | null>;
    /**
     * Aria attribute relaying whether button is selected. <br />
     * <code>aria-current</code> and <code>aria-selected</code> cannot be used together.
     * @default null
     * @builtin true
     */
    readonly ariaSelectedInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly ariaSelected: Signal<boolean | string | null>;
    /**
     * Sets button size.
     * @default 'medium' / ButtonSize.MEDIUM
     * @options 'small' | ButtonSize.SMALL | <br> 'medium' | ButtonSize.MEDIUM | <br> 'large' | ButtonSize.LARGE
     */
    readonly buttonSizeInput: InputSignal<ButtonSize | null>;
    readonly buttonSizeInternal: WritableSignal<ButtonSize | null>;
    protected readonly buttonSize: Signal<ButtonSize>;
    /**
     * Sets button color scheme.
     * @default 'primary' / ButtonColor.PRIMARY
     * @options 'primary' | ButtonSize.PRIMARY | <br> 'secondary' | ButtonSize.SECONDARY | <br> 'tertiary' | ButtonSize.TERTIARY
     */
    readonly buttonColorInput: InputSignal<ButtonColor | null>;
    readonly buttonColorInternal: WritableSignal<ButtonColor | null>;
    protected readonly buttonColor: Signal<ButtonColor>;
    readonly buttonIcon: InputSignalWithTransform<boolean, unknown>;
    readonly buttonStacked: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets button to destructive variant when true.
     * @default false
     */
    readonly destructive: InputSignalWithTransform<boolean, unknown>;
    /**
     * Disables button when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabled: Signal<boolean | null>;
    /**
     * Sets role of button. <br />
     * If no custom role is given, role may be set by a parent component (nav, tabs, etc.).
     * @builtin true
     */
    readonly roleInput: InputSignal<HTMLElement['role']>;
    readonly role: Signal<HTMLElement['role']>;
    /**
     * Sets button to subtle variant when true.
     * @default false
     */
    readonly subtle: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets button's tabIndex.
     * @default null
     * @default -1 when button is used within combobox and no custom value is given.
     * @builtin true
     */
    readonly tabindexInput: InputSignalWithTransform<number | null, unknown>;
    protected readonly tabindex: Signal<string | number | null>;
    /**
     * Emits event when host interactive element is blurred.
     */
    readonly blurred: EventEmitter<FocusEvent>;
    /**
     * Emits event when host interactive element is clicked.
     */
    readonly clicked: EventEmitter<Event>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ButtonDirective, "[v-button], [v-button-icon], [v-button-stacked], [v-panel-toggle]", never, { "ariaCurrentInput": { "alias": "aria-current"; "required": false; "isSignal": true; }; "ariaDescribedbyInput": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "ariaDisabledInput": { "alias": "aria-disabled"; "required": false; "isSignal": true; }; "ariaExpandedInput": { "alias": "aria-expanded"; "required": false; "isSignal": true; }; "ariaHaspopupInput": { "alias": "aria-haspopup"; "required": false; "isSignal": true; }; "ariaSelectedInput": { "alias": "aria-selected"; "required": false; "isSignal": true; }; "buttonSizeInput": { "alias": "buttonSize"; "required": false; "isSignal": true; }; "buttonColorInput": { "alias": "buttonColor"; "required": false; "isSignal": true; }; "buttonIcon": { "alias": "v-button-icon"; "required": false; "isSignal": true; }; "buttonStacked": { "alias": "v-button-stacked"; "required": false; "isSignal": true; }; "destructive": { "alias": "destructive"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "roleInput": { "alias": "role"; "required": false; "isSignal": true; }; "subtle": { "alias": "subtle"; "required": false; "isSignal": true; }; "tabindexInput": { "alias": "tabindex"; "required": false; "isSignal": true; }; }, {}, ["badge", "toggleIcon", "toggleIconComponent"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ChipDirective {
    readonly button: Signal<ButtonDirective | undefined>;
    protected readonly checkbox: Signal<CheckboxDirective | undefined>;
    /**
     * Sets chip to compact variant when true.
     * @default false
     */
    readonly compact: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ChipDirective, "[v-chip]", never, { "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, ["button", "checkbox"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const FloatingUIPlacements: {
    readonly TOP: "top";
    readonly TOP_START: "top-start";
    readonly TOP_END: "top-end";
    readonly RIGHT: "right";
    readonly RIGHT_START: "right-start";
    readonly RIGHT_END: "right-end";
    readonly BOTTOM: "bottom";
    readonly BOTTOM_START: "bottom-start";
    readonly BOTTOM_END: "bottom-end";
    readonly LEFT: "left";
    readonly LEFT_START: "left-start";
    readonly LEFT_END: "left-end";
};
type FloatingUIPlacements = (typeof FloatingUIPlacements)[keyof typeof FloatingUIPlacements];
declare const FloatingUIVisibility: {
    readonly SHOW: "show";
    readonly HIDE: "hide";
};
type FloatingUIVisibility = (typeof FloatingUIVisibility)[keyof typeof FloatingUIVisibility];
type UIEventVisibilityPair = [UIEvent, FloatingUIVisibility?][] | ((UIEvent | 'show')[] | (UIEvent | 'hide')[])[];

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class TooltipArrowDirective {
    readonly el: ElementRef;
    /**
     * Sets custom size *in pixels* for the arrow.
     * @default 8
     */
    readonly customSize: InputSignalWithTransform<number, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipArrowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipArrowDirective, "[v-tooltip-arrow]", never, { "customSize": { "alias": "customSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

/**
 * This internal service is used by Combobox, Dropdown Menu, and Tooltip components. <br />
 * It can be used with generic FloatingUIContainer, FloatingUIElementDirective, and FloatingUITriggerDirective to create your own custom floating-ui. <br />
 * If you are using any of the components mentioned, you will typically not need to use this service directly. <br />
 * Derived from [Floating UI documentation](https://floating-ui.com/).
 */
declare class FloatingUIService {
    /** @ignore */
    private readonly rendererFactory;
    /** @ignore */
    private renderer;
    /** @ignore */
    private trigger?;
    /** @ignore */
    private floatingUI?;
    /** @ignore */
    private arrow?;
    /** @ignore */
    private offset;
    /** @ignore */
    private offsetDefault;
    /** @ignore */
    comboboxMiddleware: any;
    /** @ignore */
    private middlewareDefault;
    /** @ignore */
    private middleware;
    /** @ignore */
    private placement;
    /** @ignore */
    isShown: WritableSignal<boolean>;
    private readonly isShownEffect;
    /**
     * Displays property of the floating UI element.
     * @default 'flex'
     */
    private display;
    /**
     * Time in milliseconds to wait before hiding the floating UI element when the trigger is hovered over.
     * @default A factor of the offset middleware option if provided, otherwise 50.
     */
    private hideOnHoverTimeout;
    private rendererListeners;
    /**
     * Emits true when this floating UI element is shown and false when hidden.
     */
    readonly isShownEmitter: EventEmitter<boolean>;
    /**
     * The setUpFloatingUI method is required to initialize the floating element and its trigger. <br />
     * Called by default with FloatingUIContainer or ComboboxDirective.
     * @param referenceEl References element that will trigger floating UI.
     * @param floatingEl References floating UI element.
     * @param eventArray Array of events for the reference/trigger element to listen for. <br> i.e. <code>[new UIEvent('focus'), FloatingUIVisibility.SHOW]</code> <br> tells the element to show the floating UI when the triggering element is focused.
     */
    setUpfloatingUI(referenceEl: ElementRef | HTMLElement, floatingEl: ElementRef, eventArray: UIEventVisibilityPair | null): void;
    /**
     * The nativeElement method returns the Element type of the reference element.
     * @param element Element to be converted to Element type.
     * @returns Element
     */
    private nativeElement;
    /**
     * The customizeFloatingUI method allows you to provide custom placement and middleware options to the Floating UI service.
     * @param placement Optional. See <code>FloatingUIPlacements</code> enum.
     * @param middleware Optional. Visit the official Floating UI documentation for more on [middleware options](https://floating-ui.com/docs/computePosition#middleware).
     * @param display Optional. Sets CSS display property for the floating UI element.
     * @param tooltipArrow Optional. Directive reference to the arrow element. See TooltipArrowDirective.
     */
    customizeFloatingUI(placement?: FloatingUIPlacements | null, middleware?: any | null, display?: string | null, tooltipArrow?: TooltipArrowDirective | null): void;
    /**
     * The positionFloatingUI method positions the Floating UI based on the given placement and middleware. <br />
     * For more details on the internal function, refer to Floating UI's [compute position documentation](https://floating-ui.com/docs/computePosition).
     * @param trigger The triggering element.
     * @param floatingUI The element that will "float" when triggered.
     * @param placement Reference FloatingUIPlacements.
     * @param middleware Visit the official Floating UI documentation for more on [middleware options](https://floating-ui.com/docs/computePosition#middleware).
     */
    positionFloatingUI(trigger?: Element | undefined, floatingUI?: HTMLElement | undefined, placement?: FloatingUIPlacements): void;
    /**
     * The showFloatingUI method displays the Floating UI element.
     */
    showfloatingUI(): void;
    /**
     * The hideFloatingUI method hides the Floating UI element.
     */
    hidefloatingUI(): void;
    /**
     * The toggleFloatingUI method toggles the visibility of the Floating UI element.
     */
    toggleFloatingUI(): void;
    /**
     * The closeOnClickOut method closes the menu when a click occurs outside of the menu and the triggering element.
     * @param event Document click event.
     */
    private closeOnClickOut;
    /**
     * The closeAndFocus method hides the Floating UI element and focuses the trigger element. <br />
     * This is typically used when closing the menu with the escape key or clicking outside of the floating UI element.
     */
    private readonly closeAndFocus;
    /**
     * The restoreFocus method focuses the trigger element. <br />
     * This method is useful if you've set `closeOnClick` to false and want to manually restore focus.
     */
    readonly restoreFocus: () => void;
    /**
     * The addCloseActions method adds default close actions to the Floating UI component. These actions include closing the menu when the escape key is pressed or when clicking outside of the floating element.
     */
    private addCloseActions;
    /**
     * The setUpTrigger method configures the triggering element by setting up the events to listen for and the actions to take when those events are triggered.
     * @param eventArray Array of events for the reference/trigger element to listen for.<br> i.e. <code>[new UIEvent('focus'), FloatingUIVisibility.SHOW]</code> <br> tells the element to show the floating UI when the triggering element is focused.
     */
    private setUpTrigger;
    /** @ignore */
    onTooltip: boolean;
    /** @ignore */
    onTrigger: boolean;
    /**
     * The keepOnHover method keeps the floating element visible when hovering over the trigger or the floating element.
     */
    private keepOnHover;
    cleanupListeners(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingUIService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FloatingUIService>;
}

declare class FloatingUIContainer implements AfterContentInit {
    private readonly idGenerator;
    private readonly renderer;
    readonly floatingUIService: FloatingUIService;
    private readonly el;
    /**
     * we need to find child containers so we can SKIP setting up any of their children
     * We want to set up any toggle buttons, tooltips, menus, etc in this current container
     * but not in any child containers
     */
    private readonly containers;
    /**
     * Gather accordions so we can SKIP setting up any of their children as toggle icons
     */
    private readonly accordions;
    private readonly buttons;
    private readonly genericFloatingUIComponent;
    private readonly listbox;
    private readonly menu;
    private readonly tooltip;
    private readonly triggers;
    private readonly dropdownItems;
    private readonly tabItems;
    private readonly toggleIconComponent;
    private readonly toggleIconDirective;
    private prevButtons;
    private prevDropdownItems;
    private prevListItems;
    private prevTabItems;
    private prevTrigger;
    private childrenClickSubscriptions;
    /**
     * Dropdown items that are direct children of this container (not nested in child containers).
     */
    private readonly ownDropdownItems;
    /**
     * Listbox items that are direct children of this container (not nested in child containers).
     */
    private readonly ownListItems;
    /**
     * Tab items that are direct children of this container (not nested in child containers).
     */
    private readonly ownTabItems;
    private childrenEffect;
    private readonly floatingElement;
    private readonly floatingUITrigger;
    private readonly floatingUIToggleIcon;
    readonly floatingElementID: Signal<string | null>;
    readonly triggersDropdownMenu: WritableSignal<boolean>;
    readonly triggersTooltip: WritableSignal<boolean>;
    readonly isCombobox: WritableSignal<boolean>;
    private readonly floatingUIToggleButton;
    private tooltipDefaultEvents;
    private dropdownMenuDefaultEvents;
    /** @ignore */
    readonly isShown: Signal<boolean | null>;
    private isShownEffect;
    /**
     * Placement of floating content relevant to triggering element.
     * @default FloatingUIPlacements.BOTTOM_START
     * @see 'FloatingUIPlacements'.
     */
    readonly placement: InputSignal<FloatingUIPlacements>;
    readonly placementEffect: i0.EffectRef;
    /**
     * Middleware for FloatingUIService.
     * @default [ offset(2), flip(), shift() ] for tooltip <br />
     * @default [ offset(0), flip(), shift() ] for combobox <br />
     * @see [Floating UI](https://floating-ui.com/docs/middleware) for options.
     */
    readonly middlewareInput: InputSignal<Middleware[] | null>;
    private readonly middleware;
    private middlewareEffect;
    /**
     * Events array for FloatingUIService. <br />
     * This array specifies whether to show or hide the floating element on a given UIEvent. <br />
     * This should be an array of [UIEvent, FloatingUIVisibility].
     * @default [ [new UIEvent('mouseenter'), FloatingUIVisibility.SHOW], <br /> [new UIEvent('mouseleave'), FloatingUIVisibility.HIDE], <br /> [new UIEvent('focus'), FloatingUIVisibility.SHOW], <br /> [new UIEvent('blur'), FloatingUIVisibility.HIDE] <br />] for tooltip
     * @default [ [new UIEvent('click')] ] for dropdown-menu and floating-ui-element
     * @default [] Ie. events are removed for combobox.
     */
    readonly eventsArrayInput: InputSignal<UIEventVisibilityPair | null>;
    private readonly eventsArrayInternal;
    private readonly eventsArray;
    /**
     * Closes the menu on item click/select when true. <br>
     * If <code>multiselect</code> is set to <code>true</code>, it will not take effect.<br>
     * @default true
     */
    readonly closeOnClick: InputSignalWithTransform<boolean, unknown>;
    /**
     * Emits whether or not the floating UI element is visible.
     */
    readonly floatingUIToggled: OutputEmitterRef<boolean>;
    private tabPressed;
    tab(event: KeyboardEvent): void;
    focusout(event: FocusEvent): void;
    ngAfterContentInit(): void;
    private setUpTooltip;
    private setUpMenu;
    private setUpGenericFloatingUIComponent;
    private floatingUISetup;
    private setUpTrigger;
    private setUpToggleIcon;
    private autoCloseOnItemClick;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingUIContainer, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingUIContainer, "[v-floating-ui-container]", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "middlewareInput": { "alias": "middleware"; "required": false; "isSignal": true; }; "eventsArrayInput": { "alias": "eventsArray"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; }, { "floatingUIToggled": "floatingUIToggled"; }, ["containers", "accordions", "buttons", "genericFloatingUIComponent", "listbox", "menu", "tooltip", "triggers", "dropdownItems", "tabItems", "toggleIconComponent", "toggleIconDirective"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class InputDirective extends DefaultValueAccessor {
    private readonly combobox;
    readonly el: ElementRef;
    private readonly idGenerator;
    readonly isFocused: WritableSignal<boolean>;
    private readonly inCombobox;
    /**
     * Aria attribute relaying what active element the input refers to.
     * @default null
     * @default '&lt;listbox-item-id&gt;' when input is used within combobox and an option is highlighted or active.
     * @builtin true
     */
    readonly ariaActiveDescendantInput: InputSignal<string | null>;
    protected readonly ariaActiveDescendant: Signal<string | null>;
    /**
     * Aria attribute relaying autocomplete type.
     * @default null
     * @default 'list' when input is used within combobox and no custom value is provided.
     * @builtin true
     */
    readonly ariaAutocompleteInput: InputSignal<string | null>;
    protected readonly ariaAutocomplete: Signal<string | null>;
    /**
     * Aria attribute relaying what element the input controls.
     * @default null
     * @default '&lt;listbox-id&gt;' when input is used within combobox and combobox menu is open.
     * @builtin true
     */
    readonly ariaControlsInput: InputSignal<string | null>;
    protected readonly ariaControls: Signal<string | null>;
    /**
     * Aria attribute relaying whether input is expanded.
     * @default null
     * @builtin true
     */
    readonly ariaExpandedInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly ariaExpanded: Signal<boolean | null>;
    /**
     * Sets input aria-haspopup attribute.
     * @default null
     * @default 'listbox' when input is used within combobox and no custom value is given.
     * @builtin true
     */
    readonly ariaHaspopupInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly ariaHaspopup: Signal<boolean | 'listbox' | null>;
    /**
     * Sets input aria-owns attribute.
     * @default null
     * @default '&lt;listbox-container-id&gt;' when input is used within combobox and no custom value is given.
     * @builtin true
     */
    readonly ariaOwnsInput: InputSignal<string | null>;
    protected readonly ariaOwns: Signal<string | null>;
    /**
     * Sets component as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabledInternal: WritableSignal<boolean | null>;
    readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(isDisabled: boolean): void;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-input')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Marks component as invalid when true.
     * @default false
     */
    readonly invalidInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly invalid: Signal<boolean | null>;
    /**
     * Removes resize from textarea when true.
     * @default false
     */
    readonly noResize: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Sets input to one-time-passcode (OTP) variant when true.
     * @default false
     */
    readonly otp: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Sets input as readonly when true.
     * @default false
     */
    readonly readonlyInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly readonly: Signal<boolean | null>;
    /**
     * Sets custom role.
     * @default null
     * @default 'combobox' when input is used within combobox and no custom role is provided.
     * @builtin true
     */
    readonly roleInput: InputSignal<HTMLElement['role']>;
    protected readonly role: Signal<HTMLElement['role']>;
    /**
     * Value of input.
     * Use [value] when you want to handle the value of the input.
     * Use (valuedChange) when you want the library to handle the value of the input, but get notified of changes.
     * Use [(value)] when you want the value to reflect changes by both you and the library.
     */
    readonly value: ModelSignal<string | null>;
    private prevInputValue;
    private readonly valueEffect;
    /**
     * Emits value when the input event is triggered or backspace key is pressed.
     */
    readonly inputEvent: OutputEmitterRef<string>;
    /**
     * Emits event when host interactive element is blurred.
     */
    readonly blurred: EventEmitter<FocusEvent>;
    /**
     * Emits event when host interactive element is clicked.
     */
    readonly clicked: EventEmitter<Event>;
    handleBlur(event: FocusEvent): void;
    handleInput(event: Event): void;
    handleReadonlySpace(event: KeyboardEvent): void;
    writeValue(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective, "[v-input]", never, { "ariaActiveDescendantInput": { "alias": "aria-activedescendant"; "required": false; "isSignal": true; }; "ariaAutocompleteInput": { "alias": "aria-autocomplete"; "required": false; "isSignal": true; }; "ariaControlsInput": { "alias": "aria-controls"; "required": false; "isSignal": true; }; "ariaExpandedInput": { "alias": "aria-expanded"; "required": false; "isSignal": true; }; "ariaHaspopupInput": { "alias": "aria-haspopup"; "required": false; "isSignal": true; }; "ariaOwnsInput": { "alias": "aria-owns"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "invalid"; "required": false; "isSignal": true; }; "noResize": { "alias": "noResize"; "required": false; "isSignal": true; }; "otp": { "alias": "otp"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "roleInput": { "alias": "role"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "inputEvent": "inputEvent"; }, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class LinkDirective {
    readonly el: ElementRef;
    readonly listenerService: ListenerService;
    /**
     * Disables link when true. <br />
     * Adds <code>role="link"</code> and <code>aria-disabled="true"</code> when true for a11y.
     * @default false
     */
    readonly disabled: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Removes underline on link when true.
     * @default false
     */
    readonly noUnderline: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LinkDirective, "[v-link]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "noUnderline": { "alias": "noUnderline"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type Item = (ButtonDirective | CheckboxDirective | ListboxItemComponent) | undefined;
type Items = readonly Item[];
/**
 * This service manages navigation states within the application, ensuring smooth transitions and a consistent user experience. <br />
 * It’s primarily used internally by the library but can also be leveraged directly for custom implementations.
 */
declare class NovaLibService {
    private rendererFactory;
    private document;
    /** @ignore */
    private renderer;
    /**
     * The addArrowKeyNavigation method adds arrow key navigation to an array of elements of type <code>ButtonDirective</code>, <code>ListboxItemComponent</code>, <code>or CheckboxDirective</code>.
     * @param itemsArray Array of items to add arrow key navigation to.
     * @param removeTabNavigation Optionally remove tab navigation from an array you're adding arrow navigation to.
     * @param arrowDirections Optionally specify which arrow key directions to use for navigation.
     * @param listbox Optionally specify a ListboxDirective to track highlighted item.
     */
    addArrowKeyNavigation(itemsArray: Items, removeTabNavigation?: boolean, arrowDirections?: 'both' | 'horizontal' | 'vertical', listbox?: ListboxDirective): void;
    /**
     * The removeTabNavigation method removes tab navigation for an array of elements of type ButtonDirective, ListboxItemComponent, or CheckboxDirective. <br />
     * When this functionality is added, it will disable tabbing between these specified elements.
     * @param itemsArray Array of items to remove tab navigation from.
     */
    private removeTabNavigation;
    /**
     * This method resets navigation behaviors for an array of elements of type <code>ButtonDirective</code>, <code>ListboxItemComponent</code>, or <code>CheckboxDirective</code>. <br />
     * It removes any tabindex or event listeners added by <code>addArrowKeyNavigation</code> or <code>removeTabNavigation</code>.
     * @param itemsArray Array of items to reset navigation behaviors for.
     */
    resetNavigationBehaviors(itemsArray: Items): void;
    /**
     * The findStartingFocus method finds the item to start navigation on. <br />
     * The starting focusable item is either the first item or the currently selected item.
     * @param itemsArray Array of items to find starting focus for.
     */
    findStartingFocus(itemsArray: Items): void;
    /**
     * The nextEnabledItem method finds the next item in the array that is not disabled. <br />
     * When this functionality is added, it will automatically skip over disabled items to locate the next enabled one.
     * @param items Array of items to search for next enabled item.
     * @param currentIndex Index to start searching from.
     * @returns Index of next item that is not disabled.
     */
    nextEnabledItem(items: Items, currentIndex?: number): number;
    /**
     * The lastEnabledItem method retrieves the last item in an array that is not disabled.
     * @param items Array of items to search for last enabled item.
     * @returns Index of most last item that is not disabled.
     */
    lastEnabledItem(items: Items): number;
    /**
     * The firstEnabledItem methods retrieves the first item in array that is not disabled.
     * @param items Array of items to search for first enabled item.
     * @returns Index of first item that is not disabled.
     */
    firstEnabledItem(items: Items): number;
    /**
     * The previousEnabledItem method finds the previous item in the array that is not disabled. <br />
     * When this functionality is added, it will automatically skip over disabled items to locate the previous enabled one.
     * @param items Array of items to search for previous enabled item.
     * @param currentIndex Index to start reverse searching from.
     * @returns Index of first previous item that is not disabled.
     */
    previousEnabledItem(items: Items, currentIndex?: number): number;
    /**
     * The addAutomaticActivation method enables automatic tab activation for the specified tab or listbox list. <br />
     * When this functionality is added, focusing on an item will also select and activate it.
     * @param items Array of items to add automatic activation to.
     */
    addAutomaticActivation(items: readonly (ListboxItemComponent | TabItemDirective)[]): void;
    /** @ignore */
    private currentLink;
    /**
     * @deprecated
     * @deprecationMessage instead of `setAriaCurrent`, use `handleAriaCurrent` for a list of LinkDirectives,
     * or manipulate the property via template binding to [attr.aria-current].
     * The setAriaCurrent method sets the aria-current="true" attribute on the element with the specified ID.
     * @param id ID of element to set aria-current="true" on.
     */
    setAriaCurrent(id: string): void;
    /**
     * The handleAriaCurrent method handles the aria-current value on click for a list of links.
     * @param links List of links to add aria-current functionality to.
     */
    handleAriaCurrent(links: readonly LinkDirective[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NovaLibService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NovaLibService>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const ComboboxFilterType: {
    readonly SELECTION: "selection";
    readonly INPUT: "input";
    readonly RESET: "reset";
};
type ComboboxFilterType = (typeof ComboboxFilterType)[keyof typeof ComboboxFilterType];
type ListboxItemType = {
    label: string;
    value: string | number;
};
type SingleSelectValue = number | string;
type MultiSelectValue = SingleSelectValue[];
type ComboboxValue = {
    label?: string;
    value: MultiSelectValue | SingleSelectValue | null;
} | null;

type ListboxValue = string | number | (string | number)[] | null;
declare class ListboxDirective extends DefaultValueAccessor {
    readonly combobox: ComboboxDirective | null;
    readonly el: ElementRef;
    private readonly idGenerator;
    private readonly listboxService;
    readonly novaLibService: NovaLibService;
    readonly listItems: Signal<readonly ListboxItemComponent[]>;
    prevListItems: ListboxItemComponent[] | undefined;
    private readonly listboxItemsChangeEffect;
    private readonly inCombobox;
    listboxHeight: number;
    listboxItemHeight: number;
    listboxGap: number;
    listboxScrollStylesSet: boolean;
    listeners: (() => void)[];
    keyword: string;
    highlightedItem: WritableSignal<ListboxItemComponent | null>;
    showFocus: WritableSignal<boolean>;
    isHotkeyEvent: Boolean;
    timeoutId: number;
    readonly ariaActiveDescendant: Signal<string | null>;
    readonly recentSelectedItem: Signal<ListboxItemComponent | undefined>;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-listbox')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Sets listbox to multiselect variant when true.
     * @default false
     */
    readonly multiselect: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Sets component and any ListboxItemComponent children as disabled when true. <br>
     * Will automatically become true if all children are disabled.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabledInternal: WritableSignal<boolean | null>;
    readonly disabledChildren: Signal<boolean | null>;
    readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(isDisabled: boolean): void;
    /**
     * Sets component and any ListboxItemComponent children as invalid when true. <br>
     * @default false
     */
    readonly invalidInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly invalid: Signal<boolean | null>;
    /**
     * Marks component as required when true.
     * @default false
     */
    readonly requiredInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly required: Signal<boolean | null>;
    /**
     * Sets CSS variable <code>--v-listbox-block-size-scroll</code>. <br />
     * If true, the default 180px will be the listbox's <code>max-block-size</code>. <br />
     * If set to a number or string representing a number (ie <code>[containHeight]="250"</code>), the variable will be set to that amount of pixels.
     */
    readonly containHeight: InputSignalWithTransform<boolean | null | number, unknown>;
    protected readonly scrollHeight: Signal<string | null>;
    /**
     * Value of listbox.
     */
    readonly value: ModelSignal<SingleSelectValue | MultiSelectValue | null>;
    private prevListboxValue;
    private readonly valueChangeEffect;
    /**
     * Overrides default scroll control behavior. <br />
     * By default the listbox will scroll to the last selected item.
     * @default false
     */
    readonly customScrollControl: InputSignalWithTransform<boolean, unknown>;
    writeValue(value: SingleSelectValue | MultiSelectValue | null): void;
    readonly manualUserChange: i0.OutputEmitterRef<void>;
    readonly userChange: () => void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListboxDirective, "[v-listbox]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "invalid"; "required": false; "isSignal": true; }; "requiredInput": { "alias": "required"; "required": false; "isSignal": true; }; "containHeight": { "alias": "containHeight"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "customScrollControl": { "alias": "customScrollControl"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "manualUserChange": "manualUserChange"; }, ["listItems"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ListboxItemComponent implements OnInit {
    constructor();
    readonly ready: WritableSignal<boolean>;
    ngOnInit(): void;
    readonly el: ElementRef;
    protected readonly listbox: ListboxDirective | null;
    readonly listenerService: ListenerService;
    readonly multiselect: Signal<boolean>;
    readonly label: WritableSignal<string | null>;
    /**
     * Marks item as **intitally** selected when true. <br />
     * Use the listbox directive's <code>value</code> to update the active state of the items.
     * @default false
     */
    readonly activeInput: InputSignalWithTransform<boolean | null, unknown>;
    private readonly initialActiveEffect;
    readonly active: Signal<boolean | null>;
    /**
     * Emits event when host interactive element is clicked.
     */
    readonly clicked: EventEmitter<Event>;
    /**
     * Marks item as selected when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabledInternal: WritableSignal<boolean | null>;
    readonly disabled: Signal<boolean | null>;
    handleClick(event: Event): void;
    /**
     * Marks item as highlighted when true. Occurs natively with :focus-visible.
     * @default false
     * @builtin true
     */
    readonly highlighted: Signal<boolean | null>;
    /**
     * Sets custom id.
     * @default 'v-listbox-item-<value>'
     * @builtin true
     */
    readonly idInput: InputSignal<string | null>;
    readonly id: Signal<string>;
    /**
     * Value of listbox item. <br />
     * A value <strong>must</strong> be present on every list item if it does not have a child radio or checkbox.
     */
    readonly value: InputSignal<string | number>;
    handleKeyup(event: KeyboardEvent): void;
    handleKeyDown(event: KeyboardEvent): void;
    selectItem(newState?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListboxItemComponent, "[v-listbox-item] ", never, { "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class ComboboxDirective implements ControlValueAccessor, OnInit, AfterContentInit {
    readonly floatingContainer: FloatingUIContainer | null;
    private readonly idGenerator;
    private readonly listboxService;
    private readonly novaLibService;
    private readonly renderer;
    readonly listenerService: ListenerService;
    readonly chips: Signal<readonly ChipDirective[]>;
    private readonly inputContainer;
    readonly input: Signal<InputDirective | undefined>;
    private readonly listboxContainer;
    readonly listbox: Signal<ListboxDirective | undefined>;
    private readonly label;
    highlightedIndex: Signal<number | null>;
    activeIndex: Signal<number | null>;
    prevActiveItem: ListboxItemComponent | any;
    autoSelect: WritableSignal<boolean>;
    selectFirstFilteredItemEffect: i0.EffectRef;
    /**
     * children aria attributes
     */
    readonly ariaOwns: Signal<string | null>;
    readonly ariaExpanded: Signal<boolean | null>;
    readonly ariaControls: Signal<string | null>;
    readonly ariaActiveDescendant: Signal<string | null>;
    /**
     * Removes appended screenreader readonly text when true. <br>
     * By default &#40;when <code>removeReadonlyText="false"</code>&#41;, if a combobox is readonly, a span element with text '&#40;readonly&#41;' will be appended to the label element for screenreader support.
     * @default false
     */
    readonly removeReadonlyText: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets component as readonly when true.
     * @default false
     */
    readonly readonlyInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly readonly: Signal<boolean | null>;
    private readonly readonlyEffect;
    /**
     * Sets component as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    private readonly disabledInternal;
    private readonly disabledInputChild;
    private readonly disabledListboxChild;
    readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(disabled: boolean): void;
    /**
     * Marks component as invalid when true.
     * @default false
     */
    readonly invalidInput: InputSignalWithTransform<boolean | null, unknown>;
    private readonly invalidInternal;
    readonly invalid: Signal<boolean | null>;
    /**
     * Marks component as required when true.
     * @default false
     */
    readonly required: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Value of combobox.
     * Use [value] when you want to handle the value of the combobox.
     * Use (valuedChange) when you want the library to handle the value of the combobox, but get notified of changes.
     * Use [(value)] when you want the value to reflect changes by both you and the library.
     */
    readonly value: ModelSignal<ComboboxValue>;
    private readonly labelIdEffect;
    selectedItem: WritableSignal<ListboxItemComponent | undefined>;
    private readonly selectedItemLabelReady;
    prevInputValue: string | null;
    private readonly inputValueEffect;
    prevListboxValue: SingleSelectValue | MultiSelectValue | null;
    private readonly listboxValueEffect;
    prevValue: ComboboxValue;
    private readonly valueEffect;
    /**
     * Emits value of selected item(s).
     */
    readonly itemSelected: OutputEmitterRef<SingleSelectValue | MultiSelectValue | null>;
    /**
     * Emitted when a listbox item is selected, when an input value is entered, and when the combobox is reset. <br />
     * Subscribe to provide your own filter function when this event is emitted. <br />
     * Emits { type: 'selection' | 'input' | 'reset'; listbox: string; input: string } where type is the type of filter event, listbox is the value of the selected item(s), and input is the value of the input.
     */
    readonly filter: OutputEmitterRef<{
        type: ComboboxFilterType;
        listbox: SingleSelectValue | MultiSelectValue | null;
        input?: string | null;
    }>;
    /**
     * Emits the filtered array of ListboxItemComponents when the list is filtered by ComboboxService.
     */
    readonly filteredListEmitter: OutputEmitterRef<any[]>;
    ngOnInit(): void;
    private readonly manualChange;
    ngAfterContentInit(): void;
    /**
     * Public method to handle listbox item clicks directly
     * This can be called from the listbox-item component to ensure the click is processed
     */
    handleListboxItemClick(): void;
    hostKeyDown(event: KeyboardEvent): void;
    /**
     * Highlight next enabled item or previous enabled item depending on type.
     * @param type 'next' | 'prev'
     */
    private highlightNextPrevItem;
    /**
     * @param index
     * @returns ListboxItemComponent at index given.
     */
    private getListItem;
    private readonlySpanID?;
    private appendReadonlyText;
    /**
     * For our comparison purposes, we don't want to trigger a value change effect if
     * the first combobox value passed is set to an empty string or null,
     * and second the combobox value passed is set to an empty combobox value object
     * with an empty label and value.
     * @param a combobox value
     * @param b combobox value
     * @returns boolean indicating whether the values are meaningfully different.
     */
    private meaningfulComboboxValueChange;
    private onChange;
    onTouched: (_: any) => void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    writeValue(value: ComboboxValue): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ComboboxDirective, "[v-combobox]", never, { "removeReadonlyText": { "alias": "removeReadonlyText"; "required": false; "isSignal": true; }; "readonlyInput": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "itemSelected": "itemSelected"; "filter": "filter"; "filteredListEmitter": "filteredListEmitter"; }, ["chips", "inputContainer", "input", "listboxContainer", "listbox", "label"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class FloatingUIElementDirective {
    readonly el: ElementRef;
    private readonly floatingUIContainer;
    /**
     * Sets custom ID.
     */
    readonly idInput: InputSignal<string | null>;
    readonly idInternal: WritableSignal<string | null>;
    readonly id: Signal<string | null>;
    readonly inlineSize: InputSignal<string>;
    protected readonly isShown: Signal<boolean | null>;
    /**
     * Provides custom z-index to control stacking order.
     * @default 200;
     */
    readonly zIndex: InputSignalWithTransform<string | number, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingUIElementDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FloatingUIElementDirective, "[v-floating-ui-element]", never, { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "inlineSize": { "alias": "inlineSize"; "required": false; "isSignal": true; }; "zIndex": { "alias": "z-index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class SelectDirective {
    readonly el: ElementRef<HTMLElement>;
    /**
     * Marks select as invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean | null, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectDirective, "[v-select]", never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class InputContainerComponent {
    readonly buttons: Signal<readonly ButtonDirective[]>;
    private readonly checkbox;
    protected readonly input: Signal<InputDirective | undefined>;
    private readonly radio;
    protected readonly select: Signal<SelectDirective | undefined>;
    /**
     * Removes the default toggle icon when true, allowing you to provide your own. <br>
     * After the closing <code>select</code> tag, provide your custom icon inside a <code>&lt;div class=&#8220;v-input-control&#8221;&gt;</code>.
     * @default false
     */
    readonly useCustomIcon: InputSignalWithTransform<boolean, unknown>;
    readonly childButtonsDisabled: Signal<boolean | null>;
    readonly labelId: Signal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputContainerComponent, "[v-input-container]", never, { "useCustomIcon": { "alias": "useCustomIcon"; "required": false; "isSignal": true; }; }, {}, ["buttons", "checkbox", "input", "radio", "select"], ["*", "v-icon-visa-toggle", "[v-icon-visa-chevron-down-tiny]", "[v-icon-visa-chevron-up-tiny]", "[v-icon][icon='chevron-down']", "[v-icon][icon='chevron-up']"], true, never>;
}

declare class InputMessageDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputMessageDirective, "[v-input-message] ", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class LabelDirective {
    private readonly circularProgress;
    readonly el: ElementRef;
    private readonly idGenerator;
    private readonly inputContainer;
    /**
     * Attribute set to the id of the element it's labeling. <br />
     * This property is set by default for radio and checkbox components when used within <code>v-input-container</code> as directed.
     */
    readonly htmlForInput: InputSignal<string | null>;
    readonly htmlForInternal: WritableSignal<string | null>;
    protected readonly htmlFor: Signal<string | null>;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-label')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Swaps <code>v-label</code> class for <code>v-progress-label</code> when true. <br />
     * Intended for use when label is describing a progress component. <br />
     * Automatically set to true when used within a Circular Progress component.
     * @default false
     */
    readonly progressLabelInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly progressLabel: Signal<boolean>;
    readonly switchLabel: InputSignalWithTransform<boolean | null, unknown>;
    handleClick(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelDirective, "[v-label], [v-switch-label]", never, { "htmlForInput": { "alias": "for"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "progressLabelInput": { "alias": "progressLabel"; "required": false; "isSignal": true; }; "switchLabel": { "alias": "v-switch-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ListboxContainerDirective {
    private readonly idGenerator;
    protected readonly listbox: Signal<ListboxDirective | undefined>;
    /**
     * Aria attribute relaying what active element the listbox container refers to.
     * @builtin true
     */
    readonly ariaActiveDescendantInput: InputSignal<string | null>;
    protected readonly ariaActiveDescendant: Signal<string | null | undefined>;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-listbox-container')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListboxContainerDirective, "[v-listbox-container]", never, { "ariaActiveDescendantInput": { "alias": "aria-activedescendant"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["listbox"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class SwitchDirective extends CheckboxControlValueAccessor {
    constructor();
    readonly el: ElementRef<HTMLInputElement>;
    /**
     * Sets checked state of component. <br />
     * Because 'checked' is a native attribute of input[type="checkbox"], it can only be set false by using [checked]="false", not checked="false" <br />
     * Use [checked] when you want to handle the checked state of the checkbox.
     * Use (checkedChange) when you want the library to handle the checked state of the checkbox, but get notified of changes.
     * Use [(checked)] when you want the checked state to reflect changes by both you and the library.
     */
    readonly checked: ModelSignal<boolean | null | string>;
    /**
     * Sets switch as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabledInternal: WritableSignal<boolean | null>;
    protected readonly disabled: Signal<boolean | null>;
    /** Fires when a formControl's disabled state updates  */
    setDisabledState(isDisabled: boolean): void;
    /**
     * Marks switch as invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Marks switch as required when true.
     * @default false
     */
    readonly required: InputSignalWithTransform<boolean, unknown>;
    handleChange(event: Event): void;
    writeValue(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SwitchDirective, "[v-switch]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ToggleDirective {
    private readonly checkbox;
    private readonly radio;
    /**
     * Sets the `for` attribute to the id of the radio or checkbox.
     * @default &lt;radio-id&gt; or &lt;checkbox-id&gt;
     * @builtin true
     */
    protected readonly htmlFor: Signal<string | null>;
    /**
     * Adds <code>v-toggle-icon</code> class for when toggle has icons only.
     * @default false
     */
    readonly toggleIcon: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToggleDirective, "[v-toggle]", never, { "toggleIcon": { "alias": "toggleIcon"; "required": false; "isSignal": true; }; }, {}, ["checkbox", "radio"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ToggleButtonDirective {
    private readonly idGenerator;
    private readonly toggleContainer;
    private readonly multi;
    constructor();
    /**
     * Sets the `aria-pressed` attribute to indicate the pressed (active) state of the button.
     * Use [active] when you want to handle the active state of the toggle button.
     * Use (activeChange) when you want the library to handle the active state of the toggle button, but get notified of changes.
     * Use [(active)] when you want the active state to reflect changes by both you and the library.
     */
    readonly active: ModelSignal<boolean | string | null>;
    /**
     * Disables button when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly disabled: Signal<boolean | null>;
    /**
     * Sets the value of the button to be used in the toggle container.
     * @default this.idGenerator.newId('v-toggle-button')
     * @builtin true
     */
    readonly value: InputSignal<string | number>;
    handleClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToggleButtonDirective, "button[v-toggle]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

type ToggleContainerValue = number | string | (string | number | null)[] | null;
declare class ToggleContainerDirective implements ControlValueAccessor, AfterContentInit {
    constructor();
    private readonly idGenerator;
    readonly buttons: Signal<readonly ToggleButtonDirective[]>;
    private readonly activeButtons;
    previousSSValue: Signal<ToggleButtonDirective | null>;
    /**
     * Sets custom name.
     * @default this.idGenerator.newId('v-toggle');
     * @builtin true
     */
    readonly name: InputSignal<string>;
    /**
     * Allows multiple buttons to be selected when true. <br />
     * To be used with child Button components, not Radio or Checkbox.
     * @default false
     */
    readonly multiselectInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly multiselect: Signal<boolean>;
    /**
     * Sets component as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    private readonly disabledInternal;
    readonly disabled: Signal<boolean | null>;
    setDisabledState(disabled: boolean): void;
    /**
     * Marks component as invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Value of toggle container.
     * Use [value] when you want to handle the value of the toggle container.
     * Use (valuedChange) when you want the library to handle the value of the toggle container, but get notified of changes.
     * Use [(value)] when you want the value to reflect changes by both you and the library.
     */
    readonly value: ModelSignal<ToggleContainerValue>;
    private readonly valueEffect;
    ngAfterContentInit(): void;
    /**
     * Sets the value of the toggle container.
     * Used in toggle button directive to avoid circular dependency.
     */
    updateValue(value?: ToggleContainerValue | undefined): void;
    private onChange;
    onTouched: (_: any) => void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    writeValue(value: ToggleContainerValue): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToggleContainerDirective, "[v-toggle-container]", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "multiselectInput": { "alias": "multiselect"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, ["buttons"], never, true, never>;
}

declare class NovaFormsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NovaFormsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NovaFormsModule, never, [typeof CheckboxDirective, typeof CheckboxPanelDirective, typeof ChipDirective, typeof ComboboxDirective, typeof FloatingUIContainer, typeof FloatingUIElementDirective, typeof FloatingUITriggerDirective, typeof InputDirective, typeof InputContainerComponent, typeof InputMessageDirective, typeof IconToggleComponent, typeof IconToggleDefaultTemplateDirective, typeof IconToggleRotatedTemplateDirective, typeof LabelDirective, typeof ListboxDirective, typeof ListboxContainerDirective, typeof ListboxItemComponent, typeof RadioDirective, typeof RadioGroupDirective, typeof SelectDirective, typeof SwitchDirective, typeof ToggleDirective, typeof ToggleButtonDirective, typeof ToggleContainerDirective], [typeof CheckboxDirective, typeof CheckboxPanelDirective, typeof ChipDirective, typeof ComboboxDirective, typeof FloatingUIContainer, typeof FloatingUIElementDirective, typeof FloatingUITriggerDirective, typeof IconToggleComponent, typeof IconToggleDefaultTemplateDirective, typeof IconToggleRotatedTemplateDirective, typeof InputDirective, typeof InputContainerComponent, typeof InputMessageDirective, typeof LabelDirective, typeof ListboxDirective, typeof ListboxContainerDirective, typeof ListboxItemComponent, typeof RadioDirective, typeof RadioGroupDirective, typeof SelectDirective, typeof SwitchDirective, typeof ToggleDirective, typeof ToggleButtonDirective, typeof ToggleContainerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NovaFormsModule>;
}

declare class AccordionPanelDirective {
    protected readonly accordion: AccordionDirective | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<AccordionPanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AccordionPanelDirective, "[v-accordion-panel]", never, {}, {}, never, never, true, never>;
}

declare class AnchorLinkMenuDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorLinkMenuDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AnchorLinkMenuDirective, "[v-anchor-link-menu]", never, {}, {}, never, never, true, never>;
}

declare class AnchorLinkMenuHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<AnchorLinkMenuHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AnchorLinkMenuHeaderDirective, "[v-anchor-link-menu-header]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class AvatarDirective {
    constructor();
    private readonly el;
    private readonly tagName;
    protected readonly defaultRole: Signal<string | null>;
    /**
     * Sets avatar to small variant when true.
     * @default false
     */
    readonly small: InputSignalWithTransform<boolean, unknown>;
    readonly role: InputSignal<HTMLElement['role'] | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AvatarDirective, "[v-avatar]", never, { "small": { "alias": "small"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare const BadgeType: {
    readonly ACTIVE: "active";
    readonly CRITICAL: "critical";
    readonly DEFAULT: "default";
    readonly NEGATIVE: "negative";
    readonly NEUTRAL: "neutral";
    readonly NUMBER: "number";
    readonly STABLE: "stable";
    readonly SUBTLE: "subtle";
    readonly WARNING: "warning";
};
type BadgeType = (typeof BadgeType)[keyof typeof BadgeType];
declare class BadgeDirective {
    private readonly idGenerator;
    /**
     * Sets badge type.
     * @default 'default' | BadgeType.DEFAULT
     * @options 'default' | BadgeType.DEFAULT | <br> 'neutral' | BadgeType.NEUTRAL | <br> 'critical' | BadgeType.CRITICAL | <br> 'stable' | BadgeType.STABLE | <br> 'warning' | BadgeType.WARNING | <br> 'subtle' | BadgeType.SUBTLE | <br> 'number' | BadgeType.NUMBER
     */
    readonly badgeType: InputSignal<BadgeType>;
    /**
     * Whether or not badge contains an icon.
     * @default false
     */
    readonly icon: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets custom id.
     * @default uuidService.getUUID('v-badge-')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Removes background color from badge when true.
     */
    readonly noBackground: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets badge to number variant when true. <br />
     * Using this flag rather than <code>badgeType="number"</code> allows for number badges with other badge types.
     * @default false
     */
    readonly number: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BadgeDirective, "[v-badge]", never, { "badgeType": { "alias": "badgeType"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "noBackground": { "alias": "noBackground"; "required": false; "isSignal": true; }; "number": { "alias": "number"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class BannerDirective {
    /**
     * Provides sticky styling for global banners. <br />
     * When true, the following CSS rules are applied - <code>position: sticky; top: 0; z-index: 888;</code>.
     * @default false
     */
    readonly isGlobal: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BannerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BannerDirective, "[v-banner]", never, { "isGlobal": { "alias": "isGlobal"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class BreadcrumbsDirective {
    /**
     * Removes separator inserted by CSS and allows you to provide your own separator within the markup.
     * @default false
     */
    readonly hasInlineSeparator: InputSignalWithTransform<boolean, unknown>;
    /**
     * Replaces the default '<code>/</code>' separator with the string provided.
     * @default false
     */
    readonly separator: InputSignal<null | string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbsDirective, "[v-breadcrumbs]", never, { "hasInlineSeparator": { "alias": "hasInlineSeparator"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class CircularProgressComponent {
    constructor();
    private readonly label;
    private readonly progressBar;
    private readonly radius;
    protected readonly fallbackRadius: Signal<number>;
    protected readonly dashOffset: Signal<number>;
    protected readonly initialSize: Signal<number>;
    readonly complete: Signal<boolean>;
    /**
     * Sets progress to determinate when true.
     * @default false
     */
    readonly determinate: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets progress to invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets custom role.
     * @default 'progressbar' when determinate
     * @default null when indeterminate
     * @builtin true
     */
    readonly role: InputSignal<HTMLElement['role']>;
    /**
     * Sets the percentage for a <code>determinate</code> circular progress.
     * @default 0
     */
    readonly percentage: InputSignalWithTransform<number, unknown>;
    /**
     * Sets progress to small variant when true.
     * @default false
     */
    readonly small: InputSignalWithTransform<boolean, unknown>;
    /**
     * Aria attribute pointing to id of labelling element.
     * @default &lt;child-label-id&gt;
     * @builtin true
     */
    readonly ariaLabelledbyInput: InputSignal<string | null>;
    protected readonly ariaLabelledby: Signal<string | null | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircularProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircularProgressComponent, "[v-progress-circular], [v-circular-progress]", never, { "determinate": { "alias": "determinate"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "percentage": { "alias": "percentage"; "required": false; "isSignal": true; }; "small": { "alias": "small"; "required": false; "isSignal": true; }; "ariaLabelledbyInput": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, {}, ["label"], ["*"], true, never>;
}

declare class ContentCardBodyDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentCardBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContentCardBodyDirective, "[v-content-card-body]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ContentCardDirective {
    private readonly titleLink;
    /**
     * Transforms card into a clickable card when true.
     * @default false
     */
    readonly clickable: InputSignalWithTransform<boolean, unknown>;
    /**
     * Displays indicator line at the bottom of the card when true.
     * @default false
     */
    readonly indicator: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets component as disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabled: Signal<boolean | null | undefined>;
    handleClick(): void;
    handleSpaceKeydown(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentCardDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContentCardDirective, "[v-content-card]", never, { "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["titleLink"], never, true, never>;
}

declare class ContentCardImageDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentCardImageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContentCardImageDirective, "[v-content-card-image]", never, {}, {}, never, never, true, never>;
}

declare class ContentCardSubtitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentCardSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContentCardSubtitleDirective, "[v-content-card-subtitle]", never, {}, {}, never, never, true, never>;
}

declare class ContentCardTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentCardTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContentCardTitleDirective, "[v-content-card-title]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ContentCardTitleLinkDirective {
    private readonly el;
    private readonly contentCard;
    /**
     * Disables link and sets content card to disabled when true.
     * @default false
     */
    readonly disabledInput: InputSignalWithTransform<boolean | null, unknown>;
    readonly disabled: Signal<boolean | null>;
    readonly handleClick: (event: Event) => void;
    handleParentClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ContentCardTitleLinkDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ContentCardTitleLinkDirective, "[v-content-card-title-link]", never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const MessageType: {
    readonly CLOSE: "close";
    readonly ERROR: "error";
    readonly INFORMATION: "information";
    readonly SUBTLE: "subtle";
    readonly SUCCESS: "success";
    readonly WARNING: "warning";
};
type MessageType = (typeof MessageType)[keyof typeof MessageType];

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class DialogDirective {
    private readonly idGenerator;
    /**
     * Aria attribute pointing to id of descriptive element.
     * @default '&lt;this.id&gt;-description'
     * @builtin true
     */
    readonly descriptionLabelInput: InputSignal<null | string>;
    readonly descriptionLabel: Signal<string>;
    /**
     * Sets custom id.
     * @default idGenerator.newId('v-dialog')
     * @builtin true
     */
    readonly id: InputSignal<string>;
    /**
     * Aria attribute pointing to id of labelling element.
     * @default '&lt;this.id&gt;-title'
     * @builtin true
     */
    readonly labelInput: InputSignal<null | string>;
    readonly label: Signal<string>;
    /**
     * @ignore
     */
    readonly messageType: InputSignal<MessageType | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDirective, "[v-dialog]", never, { "descriptionLabelInput": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "labelInput": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "messageType": { "alias": "messageType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class DialogHeaderDirective {
    private readonly dialogComponent;
    /**
     * Sets custom id.
     * @default '&lt;parent-dialog-id&gt;-label' if no id is provided
     * @builtin true
     */
    readonly idInput: InputSignal<string | null>;
    protected readonly id: Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogHeaderDirective, "[v-dialog-header]", never, { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class DialogTextDirective {
    private readonly dialog;
    /**
     * Sets custom id.
     * @default '&lt;parent-dialog-id&gt;-description' if no id is provided.
     * @builtin true
     */
    readonly idInput: InputSignal<HTMLElement['id'] | null>;
    protected readonly id: Signal<string | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTextDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogTextDirective, "[v-dialog-text]", never, { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const DividerType: {
    readonly DEFAULT: "default";
    readonly SECTION: "section";
    readonly DECORATIVE: "decorative";
};
type DividerType = (typeof DividerType)[keyof typeof DividerType];

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class DividerDirective {
    readonly ariaHidden: InputSignal<string | null>;
    /**
     * Sets divider style.
     * @default 'default' / DividerType.DEFAULT
     * @options 'default' | DividerType.DEFAULT | <br> 'section' | DividerType.SECTION | <br> 'decorative' | DividerType.DECORATIVE
     */
    readonly dividerType: InputSignal<DividerType>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DividerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DividerDirective, "[v-divider]", never, { "ariaHidden": { "alias": "aria-hidden"; "required": false; "isSignal": true; }; "dividerType": { "alias": "dividerType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class DropdownItemDirective {
    constructor();
    readonly el: ElementRef;
    readonly listenerService: ListenerService;
    private readonly tagName;
    protected readonly buttonItem: Signal<boolean>;
    /**
     * Marks item as selected when true.
     * @default false
     */
    readonly disabled: InputSignalWithTransform<boolean | null, unknown>;
    /**
     * Emits event when host interactive element is clicked.
     */
    readonly clicked: EventEmitter<Event>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownItemDirective, "[v-dropdown-item]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DropdownListDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownListDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownListDirective, "[v-dropdown-list]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class DropdownMenuDirective {
    readonly el: ElementRef;
    private readonly floatingUIContainer;
    /**
     * Sets custom ID.
     */
    readonly idInput: InputSignal<string | null>;
    readonly idInternal: WritableSignal<string | null>;
    readonly id: Signal<string | null>;
    protected readonly isShown: Signal<boolean | null>;
    /**
     * Provides custom z-index to control stacking order.
     * @default 200;
     */
    readonly zIndex: InputSignalWithTransform<string | number, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenuDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownMenuDirective, "[v-menu], [v-dropdown-menu]", never, { "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "zIndex": { "alias": "z-index"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FlagDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<FlagDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FlagDirective, "[v-flag]", never, {}, {}, never, never, true, never>;
}

declare class FooterDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FooterDirective, "[v-footer]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

/**
 * <code>IconComponent</code> is intended <i>only</i> for use with icons used with an icon sprite. <br />
 * <strong>Standalone icons from @visa/nova-icons-angular is recommended over using the <code>IconComponent</code>.</strong>. <br />
 * Icon component for displaying icons from VPDS' [Icon Library](https://design.visa.com/components/icons-illustrations/). <br />
 */
declare class IconComponent {
    /**
     * Set CSS variable <code>--v-icon-height</code> which customizes icon height. <code>isBadgeEllipse</code> must be true for this to have an affect. <br />
     * @default '8'
     */
    readonly customHeight: InputSignal<string>;
    /**
     * Name of <strong>custom</strong> icon reference. <br />
     * Should refer to an icon within an icon sprite in your application. <br />
     * The href will reference the string provided directly. No library or iconSize will be added.
     */
    readonly customIcon: InputSignal<string | undefined>;
    /**
     * Set CSS variable <code>--v-icon-width</code> which customizes icon width. <code>isBadgeEllipse</code> must be true for this to have an affect. <br />
     * @default '8'
     */
    readonly customWidth: InputSignal<string>;
    /**
     * Name of icon to display. <br />
     * Should refer to an icon in VPDS' [Icon Library](https://design.visa.com/components/icons-illustrations/).
     */
    readonly iconInput: InputSignal<string | null>;
    private readonly icon;
    private readonly iconToggle;
    /**
     * Sets icon resolution/size.
     * @default 'tiny' / IconSize.TINY
     * @options 'tiny' | IconSize.TINY | <br> 'low' | IconSize.LOW | <br> 'high' | IconSize.HIGH
     */
    readonly iconSize: InputSignal<IconSize>;
    /**
     * Sets icon to badge-ellipse variant when true. <br />
     * Intended for use in badges with an indicator.
     * @default false
     */
    readonly isBadgeEllipse: InputSignalWithTransform<boolean, unknown>;
    /**
     * Tells icon which library to reference.
     * @default 'visa' / IconLibrary.VISA
     * @options 'visa' | IconLibrary.VISA | <br> 'generic' | IconLibrary.GENERIC
     */
    readonly library: InputSignal<IconLibrary>;
    /**
     * Flips icon from right to left when true and <code>dir="rtl" is present on a parent element.
     * @default false
     */
    readonly rtl: InputSignalWithTransform<boolean, unknown>;
    readonly tabSuffix: WritableSignal<boolean>;
    protected readonly computedSize: Signal<number>;
    protected readonly iconRef: Signal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "[v-icon]", never, { "customHeight": { "alias": "customHeight"; "required": false; "isSignal": true; }; "customIcon": { "alias": "customIcon"; "required": false; "isSignal": true; }; "customWidth": { "alias": "customWidth"; "required": false; "isSignal": true; }; "iconInput": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSize": { "alias": "iconSize"; "required": false; "isSignal": true; }; "isBadgeEllipse": { "alias": "isBadgeEllipse"; "required": false; "isSignal": true; }; "library": { "alias": "library"; "required": false; "isSignal": true; }; "rtl": { "alias": "rtl"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class LinearProgressDirective {
    /**
     * Hide progress from screen readers when true. By default, indeterminate progress is hidden and determinate progress is visible.
     * @default 'true' when <code>determinate</code> is false
     * @default null when <code>determinate</code> is true
     * @builtin true
     */
    readonly ariaHidden: InputSignal<string | void | null>;
    /**
     * Marks progress as complete when true. By default, determinate progress is marked complete
     * when value is greater than or equal to max, and indeterminate progress is never marked complete.
     * @default null
     */
    readonly completeInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly complete: Signal<boolean>;
    /**
     * Sets progress to determinate when true.
     * @default false
     */
    readonly determinate: InputSignalWithTransform<boolean, unknown>;
    /**
     * Marks progress as invalid when true.
     * @default false
     */
    readonly invalid: InputSignalWithTransform<boolean, unknown>;
    /**
     * The max value for a <code>determinate</code> progress bar.
     * @default 100
     */
    readonly maxInput: InputSignalWithTransform<number, unknown>;
    readonly max: Signal<number | null>;
    /**
     * The current progress as a percentage (0-100). Use this for simple percentage-based progress.
     * @default null
     */
    readonly percentage: InputSignalWithTransform<number | null, unknown>;
    /**
     * The current progress value. Works with the max attribute to calculate percentage.
     * Use when tracking progress with custom units (e.g., items processed out of a total).
     * @default 100
     */
    readonly valueInput: InputSignalWithTransform<number, unknown>;
    readonly value: Signal<number | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinearProgressDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LinearProgressDirective, "[v-progress-linear], [v-linear-progress]", never, { "ariaHidden": { "alias": "aria-hidden"; "required": false; "isSignal": true; }; "completeInput": { "alias": "complete"; "required": false; "isSignal": true; }; "determinate": { "alias": "determinate"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "maxInput": { "alias": "max"; "required": false; "isSignal": true; }; "percentage": { "alias": "percentage"; "required": false; "isSignal": true; }; "valueInput": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MessageContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MessageContentDirective, "[v-message-content]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class MessageDirective {
    /**
     * Sets message type.
     * @default 'information' / MessageType.INFORMATION
     * @options "error" | MessageType.ERROR | <br> "information" | MessageType.INFORMATION | <br> "success" | MessageType.SUCCESS | <br> "warning" | MessageType.WARNING | <br> "close" | MessageType.CLOSE | <br> "subtle" | MessageType.SUBTLE
     */
    readonly messageType: InputSignal<MessageType>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MessageDirective, "[v-message]", never, { "messageType": { "alias": "messageType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MessageIconDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageIconDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MessageIconDirective, "[v-message-icon]", never, {}, {}, never, never, true, never>;
}

declare class PaginationDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationDirective, "[v-pagination]", never, {}, {}, never, never, true, never>;
}

declare class PaginationOverflowDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationOverflowDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PaginationOverflowDirective, "[v-pagination-overflow]", never, {}, {}, never, never, true, never>;
}

declare class PanelBodyDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PanelBodyDirective, "[v-panel-body]", never, {}, {}, never, never, true, never>;
}

declare class PanelToggleDirective {
    readonly button: ButtonDirective | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PanelToggleDirective, "[v-panel-toggle]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class PanelDirective implements AfterContentInit {
    protected readonly toggleButton: Signal<PanelToggleDirective | undefined>;
    /**
     * Sets panel to expandable variant when true.
     * @default false
     * @default true if panel contains a <code>PanelToggleDirective</code>.
     */
    readonly expandable: InputSignalWithTransform<boolean, unknown>;
    /**
     * Expands panel by default when true. <br />
     * To be used when <code>expandable</code> is true.
     * @default false
     */
    readonly expandedInput: InputSignalWithTransform<boolean | null, unknown>;
    private readonly expandedInternal;
    readonly expanded: Signal<boolean | null>;
    /**
     * Sets panel to responsive variant when true and places panel on same layer as content around it.
     * @default false
     */
    readonly responsive: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets custom role.
     * @default 'dialog' if panel is not responsive.
     * @builtin true
     */
    readonly roleInput: InputSignal<string | null>;
    protected readonly role: Signal<string | null>;
    /**
     * Adds skrim (shadow overlay) to modal variant (responsive="false") when true.
     * @default false
     */
    readonly skrim: InputSignalWithTransform<boolean, unknown>;
    ngAfterContentInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PanelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PanelDirective, "[v-panel]", never, { "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "expandedInput": { "alias": "expanded"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "roleInput": { "alias": "role"; "required": false; "isSignal": true; }; "skrim": { "alias": "skrim"; "required": false; "isSignal": true; }; }, {}, ["toggleButton"], never, true, never>;
}

declare class SectionMessageDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<SectionMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SectionMessageDirective, "[v-section]", never, {}, {}, never, never, true, never>;
}

/**
 * Directive to provide a skip to content link.
 * @default .v-skip-link
 */
declare class SkipToContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<SkipToContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SkipToContentDirective, "[v-skip-to-content]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/
declare const TableSize: {
    readonly COMPACT: "compact";
    readonly MEDIUM: "medium";
    readonly LARGE: "large";
};
type TableSize = (typeof TableSize)[keyof typeof TableSize];
declare const tableBlockMap: {
    compact: string;
    large: string;
    medium: string;
};
declare const tablePaddingMap: {
    compact: string;
    large: string;
    medium: string;
};

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class TableDirective {
    /**
     * Sets table as subtle variant when true.
     * @default false
     */
    readonly alternate: InputSignalWithTransform<boolean, unknown>;
    /**
     * Adds vertical and horizontal divider lines when true.
     * @default false
     */
    readonly dividerLines: InputSignalWithTransform<boolean, unknown>;
    /**
     * Adds horizontal divider lines when true.
     * @default false
     */
    readonly horizontalDividerLines: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets table as key-value variant when true.
     * @default false
     */
    readonly keyValue: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets table as subtle variant when true.
     * @default false
     */
    readonly subtle: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets table size.
     * @default 'medium' / TableSize.MEDIUM
     * @options 'compact' | TableSize.COMPACT | <br> 'medium' | TableSize.MEDIUM | <br> 'large' | TableSize.LARGE
     */
    readonly tableSize: InputSignal<TableSize>;
    readonly tableBlockDefault: Signal<string>;
    readonly tablePaddingBlock: Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDirective, "[v-table]", never, { "alternate": { "alias": "alternate"; "required": false; "isSignal": true; }; "dividerLines": { "alias": "dividerLines"; "required": false; "isSignal": true; }; "horizontalDividerLines": { "alias": "horizontalDividerLines"; "required": false; "isSignal": true; }; "keyValue": { "alias": "keyValue"; "required": false; "isSignal": true; }; "subtle": { "alias": "subtle"; "required": false; "isSignal": true; }; "tableSize": { "alias": "tableSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class TableWrapperDirective {
    /**
     * Sets CSS variable <code>--v-table-wrapper-block-size</code> to customize the block size of the scroll area.
     */
    readonly scrollBlockSize: InputSignalWithTransform<string, unknown>;
    /**
     * Sets CSS variable <code>--v-table-wrapper-inline-size</code> to customize the inline size of the scroll area.
     */
    readonly scrollInlineSize: InputSignalWithTransform<string, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableWrapperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TableWrapperDirective, "[v-table-wrapper]", never, { "scrollBlockSize": { "alias": "scrollBlockSize"; "required": false; "isSignal": true; }; "scrollInlineSize": { "alias": "scrollInlineSize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TdDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<TdDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TdDirective, "[v-td]", never, {}, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class ThDirective {
    private readonly tableDirective;
    readonly tdDirective: TdDirective | null;
    /**
     * Alternate header for when there are two levels of headers (group headers).
     */
    readonly groupHeader: InputSignalWithTransform<boolean, unknown>;
    protected readonly isKeyValue: Signal<boolean | undefined>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ThDirective, "[v-th]", never, { "groupHeader": { "alias": "groupHeader"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class TooltipDirective {
    readonly el: ElementRef;
    readonly arrow: Signal<TooltipArrowDirective | undefined>;
    /**
     * Sets custom display when tooltip is visible. Initial display is set to none to hide tooltip.
     * @builtin true
     */
    readonly display: InputSignal<string>;
    /**
     * Sets custom ID.
     */
    readonly idInput: InputSignal<HTMLElement['id'] | null>;
    readonly idInternal: WritableSignal<HTMLElement['id'] | null>;
    readonly id: Signal<HTMLElement['id'] | null>;
    /**
     * Sets custom z-index.
     * @default '700'
     * @builtin true
     */
    readonly zIndex: InputSignalWithTransform<string | number, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[v-tooltip]", never, { "display": { "alias": "display"; "required": false; "isSignal": true; }; "idInput": { "alias": "id"; "required": false; "isSignal": true; }; "zIndex": { "alias": "z-index"; "required": false; "isSignal": true; }; }, {}, ["arrow"], never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare const TypographyColor: {
    readonly Default: "default";
    readonly Active: "active";
    readonly Subtle: "subtle";
    readonly OnActive: "on-active";
};
type TypographyColor = (typeof TypographyColor)[keyof typeof TypographyColor];
declare const TypographyType: {
    readonly Display1: "display-1";
    readonly Display2: "display-2";
    readonly Headline1: "headline-1";
    readonly Headline2: "headline-2";
    readonly Headline3: "headline-3";
    readonly Headline4: "headline-4";
    readonly Subtitle1: "subtitle-1";
    readonly Subtitle2: "subtitle-2";
    readonly Subtitle3: "subtitle-3";
    readonly Overline: "overline";
    readonly Body1: "body-1";
    readonly Body2: "body-2";
    readonly Body2Bold: "body-2-bold";
    readonly Body2Link: "body-2-link";
    readonly Body2Medium: "body-2-medium";
    readonly Body3: "body-3";
    readonly ButtonSmall: "button-small";
    readonly ButtonMedium: "button-medium";
    readonly ButtonLarge: "button-large";
    readonly Label: "label";
    readonly LabelSmall: "label-small";
    readonly LabelActive: "label-active";
    readonly LabelLarge: "label-large";
    readonly LabelLargeActive: "label-large-active";
    readonly LabelSmallActive: "label-small-active";
};
type TypographyType = (typeof TypographyType)[keyof typeof TypographyType];
declare class TypographyDirective {
    protected readonly classes: Signal<string>;
    /**
     * Applies given typography class, alias for <code>vTypography</code>.
     */
    readonly vFont: InputSignal<'' | TypographyType | null>;
    /**
     * Applies given typography color class, alias for <code>vTypographyColor</code>.
     */
    readonly vFontColor: InputSignal<'' | TypographyColor | null>;
    /**
     * Applies given typography class. <br>
     * Can be used as a more succinct alias for <code>vTypography</code>.
     */
    readonly vTypographyInput: InputSignal<'' | TypographyType | null>;
    private readonly vTypography;
    /**
     * Applies given typography color class. <br>
     * Can be used as a more succinct alias for <code>vTypographyColor</code>.
     */
    readonly vTypographyColorInput: InputSignal<'' | TypographyColor | null>;
    private readonly vTypographyColor;
    static ɵfac: i0.ɵɵFactoryDeclaration<TypographyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TypographyDirective, "[vTypography], [vFont], [vTypographyColor], [vFontColor]", never, { "vFont": { "alias": "vFont"; "required": false; "isSignal": true; }; "vFontColor": { "alias": "vFontColor"; "required": false; "isSignal": true; }; "vTypographyInput": { "alias": "vTypography"; "required": false; "isSignal": true; }; "vTypographyColorInput": { "alias": "vTypographyColor"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class VisaLogoComponent {
    /**
     * Sets height of logo image.
     * @default 23
     */
    readonly height: InputSignalWithTransform<number, unknown>;
    /**
     * Sets width of logo image.
     * @default 71
     */
    readonly width: InputSignalWithTransform<number, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisaLogoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VisaLogoComponent, "[v-logo-visa]", never, { "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class WizardDirective {
    /**
     * Sets wizard to compact variant when true.
     * @default false
     */
    readonly compact: InputSignalWithTransform<boolean, unknown>;
    /**
     * Sets wizard to vertical orientation when true.
     * @default false
     */
    readonly vertical: InputSignalWithTransform<boolean, unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WizardDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WizardDirective, "[v-wizard]", never, { "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

declare class WizardStepDirective {
    private readonly accordion;
    /**
     * Marks the step as current step when true.
     * @default false
     */
    readonly activeInput: InputSignalWithTransform<boolean | null, unknown>;
    protected readonly active: Signal<string | boolean | null>;
    readonly ariaCurrent: InputSignal<string | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<WizardStepDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<WizardStepDirective, "[v-wizard-step]", never, { "activeInput": { "alias": "active"; "required": false; "isSignal": true; }; "ariaCurrent": { "alias": "aria-current"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NovaLibModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NovaLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NovaLibModule, never, [typeof AccordionDetailsDirective, typeof AccordionDirective, typeof AccordionHeadingDirective, typeof AccordionPanelDirective, typeof AddArrowKeysDirective, typeof AlternateDirective, typeof AnchorLinkMenuDirective, typeof AnchorLinkMenuHeaderDirective, typeof AvatarDirective, typeof BadgeDirective, typeof BannerDirective, typeof BreadcrumbsDirective, typeof BreakpointsDirective, typeof ButtonDirective, typeof CheckboxDirective, typeof CheckboxPanelDirective, typeof ChipDirective, typeof CircularProgressComponent, typeof ComboboxDirective, typeof ContentCardBodyDirective, typeof ContentCardDirective, typeof ContentCardImageDirective, typeof ContentCardSubtitleDirective, typeof ContentCardTitleDirective, typeof ContentCardTitleLinkDirective, typeof DialogDirective, typeof DialogHeaderDirective, typeof DialogTextDirective, typeof DividerDirective, typeof DropdownItemDirective, typeof DropdownListDirective, typeof DropdownMenuDirective, typeof DualIconDirective, typeof ElevationDirective, typeof FlagDirective, typeof FlexDirective, typeof FloatingUIContainer, typeof FloatingUIElementDirective, typeof FloatingUITriggerDirective, typeof FooterDirective, typeof IconComponent, typeof IconToggleComponent, typeof IconToggleDefaultTemplateDirective, typeof IconToggleDirective, typeof IconToggleRotatedTemplateDirective, typeof InputContainerComponent, typeof InputDirective, typeof InputMessageDirective, typeof LabelDirective, typeof LinearProgressDirective, typeof LinkDirective, typeof ListboxContainerDirective, typeof ListboxDirective, typeof ListboxItemComponent, typeof MarginDirective, typeof MessageContentDirective, typeof MessageDirective, typeof MessageIconDirective, typeof NavDirective, typeof OpensInNewTabDirective, typeof PaddingDirective, typeof PaginationDirective, typeof PaginationOverflowDirective, typeof PanelBodyDirective, typeof PanelDirective, typeof PanelContentDirective, typeof PanelToggleDirective, typeof RadioDirective, typeof RadioGroupDirective, typeof ScreenreaderOnlyDirective, typeof SectionMessageDirective, typeof SelectDirective, typeof SkipToContentDirective, typeof SurfaceDirective, typeof SwitchDirective, typeof TabItemDirective, typeof TableDirective, typeof TableWrapperDirective, typeof TabListDirective, typeof TdDirective, typeof ThDirective, typeof ToggleDirective, typeof ToggleButtonDirective, typeof ToggleContainerDirective, typeof TooltipDirective, typeof TooltipArrowDirective, typeof TypographyDirective, typeof VisaLogoComponent, typeof WizardDirective, typeof WizardStepDirective], [typeof AccordionDetailsDirective, typeof AccordionDirective, typeof AccordionHeadingDirective, typeof AccordionPanelDirective, typeof AddArrowKeysDirective, typeof AlternateDirective, typeof AnchorLinkMenuDirective, typeof AnchorLinkMenuHeaderDirective, typeof AvatarDirective, typeof BadgeDirective, typeof BannerDirective, typeof BreadcrumbsDirective, typeof BreakpointsDirective, typeof ButtonDirective, typeof CheckboxDirective, typeof CheckboxPanelDirective, typeof ChipDirective, typeof CircularProgressComponent, typeof ComboboxDirective, typeof ContentCardBodyDirective, typeof ContentCardDirective, typeof ContentCardImageDirective, typeof ContentCardSubtitleDirective, typeof ContentCardTitleDirective, typeof ContentCardTitleLinkDirective, typeof DialogDirective, typeof DialogHeaderDirective, typeof DialogTextDirective, typeof DividerDirective, typeof DropdownItemDirective, typeof DropdownListDirective, typeof DropdownMenuDirective, typeof DualIconDirective, typeof ElevationDirective, typeof FlagDirective, typeof FlexDirective, typeof FloatingUIContainer, typeof FloatingUIElementDirective, typeof FloatingUITriggerDirective, typeof FooterDirective, typeof IconComponent, typeof IconToggleComponent, typeof IconToggleDefaultTemplateDirective, typeof IconToggleDirective, typeof IconToggleRotatedTemplateDirective, typeof InputContainerComponent, typeof InputDirective, typeof InputMessageDirective, typeof LabelDirective, typeof LinearProgressDirective, typeof LinkDirective, typeof ListboxContainerDirective, typeof ListboxDirective, typeof ListboxItemComponent, typeof MarginDirective, typeof MessageContentDirective, typeof MessageDirective, typeof MessageIconDirective, typeof NavDirective, typeof OpensInNewTabDirective, typeof PaddingDirective, typeof PaginationDirective, typeof PaginationOverflowDirective, typeof PanelBodyDirective, typeof PanelDirective, typeof PanelContentDirective, typeof PanelToggleDirective, typeof RadioDirective, typeof RadioGroupDirective, typeof ScreenreaderOnlyDirective, typeof SectionMessageDirective, typeof SelectDirective, typeof SkipToContentDirective, typeof SurfaceDirective, typeof SwitchDirective, typeof TabItemDirective, typeof TableDirective, typeof TableWrapperDirective, typeof TabListDirective, typeof TdDirective, typeof ThDirective, typeof ToggleDirective, typeof ToggleButtonDirective, typeof ToggleContainerDirective, typeof TooltipDirective, typeof TooltipArrowDirective, typeof TypographyDirective, typeof VisaLogoComponent, typeof WizardDirective, typeof WizardStepDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NovaLibModule>;
}

/**
 *              © 2025-2026 Visa
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **/

/**
 * Generates an array from number to from + length
 * @param {number} from
 * @param {number} length
 * @returns {number[]}
 */
declare const generateArray: (from: number, length: number) => number[];
type PaginationControlOptions = {
    /** Max block length for all blocks, this gets overwritten by `startBlockMaxLength`, `middleBlockMaxLength`, `endBlockMaxLength` */
    blockMaxLength: number;
    /** Forces pages not to paginate */
    compact: boolean;
    /** Default selected page */
    defaultSelected: number;
    /** Default total amount of page */
    defaultTotalPages: number;
    /** What to separate the pagination array up with, usually this delimiter will be replaced with icon or ellipses when shown in the UI */
    delimiter: number | string;
    /** Maximum length of pages to show on the end pagination block, overwrites `blockMaxLength` for end block */
    endBlockMaxLength: number;
    /** Maximum page number to be shown, (default null for no maximum) */
    maxPageNumber: number | null;
    /** Maximum length of pages to show on the middle pagination block, overwrites `blockMaxLength` for middle block */
    middleBlockMaxLength: number;
    /** Signal to be used for selected page, otherwise control will create one */
    selectedPage?: WritableSignal<number> | null;
    /** Maximum length of pages to show on the start pagination block, overwrites `blockMaxLength` for start block */
    startBlockMaxLength: number;
    /** Start from this page */
    startPage: number;
};
/**
 * PaginationControl is a signals-based approach to handling and controlling pagination components.
 * It’s customizable, reusable, and allows you to bring your own signal for `selectedPage`.
 * @docs {@link https://design.visa.com/components/pagination/?code_library=angular | See docs}
 */
declare class PaginationControl {
    constructor(options?: Partial<PaginationControlOptions>);
    readonly compact: WritableSignal<boolean>;
    private readonly options;
    private readonly selectedPage;
    readonly totalPages: WritableSignal<number>;
    /** Can paginate or just show all pages */
    private readonly canPaginate;
    /** Pages to show at the end */
    private readonly endBlock;
    /** Ideal last page without maxPageNumber interfering */
    private readonly idealLastPage;
    /** Is first element selected */
    readonly isFirstPage: Signal<boolean>;
    /** Selected page is in end block */
    private readonly isInEndBlock;
    /** Selected page is in middle block */
    private readonly isInMiddleBlock;
    /** Selected page is in start block */
    private readonly isInStartBlock;
    /** Is last element selected */
    readonly isLastPage: Signal<boolean>;
    /** Last page */
    private readonly lastPage;
    /** Pages to show in the middle */
    private readonly middleBlock;
    /** Array of pages arrays to loop over */
    readonly pages: Signal<(string | number)[]>;
    /** Pages to show at the start */
    private readonly startBlock;
    /** Getter for selectedPage, we shouldn't directly manipulate the `selectedPage` signal, use `goToPage` to do this safely */
    get currentPage(): number;
    private get compactPages();
    /**
     * The getToFrom method calculates which range of items is currently visible from pagination.
     * @param {number} items - how many items we have
     * @param {number} itemsPerPage - how many items there are, per page
     * @returns to from object with calculated values
     */
    getToFrom(items: number, itemsPerPage: number): {
        0: number;
        1: number;
        from: number;
        to: number;
    };
    /** The getTotalPages method calculates the total number of pages. */
    getTotalPages: typeof PaginationControl.getTotalPages;
    /** This goToFirstPage method navigates to the first page in the dataset. */
    goToFirstPage(): void;
    /** The goToLastPage method navigates to the last page in the dataset. */
    goToLastPage(): void;
    /** The goToNextPage method navigates to the next page relative to the current page. */
    goToNextPage(): void;
    /** The goToPage method navigates directly to a specific page number. */
    goToPage(pageNumber: number | string): void;
    /** The goToPreviosPage method moves to the previous page relative to the current page. */
    goToPreviousPage(): void;
    /** The isCurrentPage method checks if the given page number is currently active. */
    isCurrentPage(page: number | string): boolean;
    /**
     * The resetPageCount method recalculates the total number of pages based
     * on the current items-per-page setting, automatically adjusting the pagination control.
     * By default, this also resets the view to the first page.
     */
    resetPageCount(totalItems: number, itemsPerPage: number, autoResetToFirstPage?: boolean): void;
    /**
     * Calculates which range of items that is currently visible from pagination
     * @param {number} items - how many items we have
     * @param {number} itemsPerPage - how many items there are, per page
     * @param {number} currentPage - which page is visible
     * @param {number} startPage - which page we're starting from, defaults to page 1 (optional)
     * @returns to from object with calculated values
     */
    static getToFrom: (items: number, itemsPerPage: number, currentPage: number, startPage?: number) => {
        0: number;
        1: number;
        from: number;
        to: number;
    };
    /**
     * Calculates how many pages there are
     * @param {number} items - how many items we have
     * @param {number} itemsPerPage - how many items there are, per page
     * @returns {number} how many pages there are in total
     */
    static getTotalPages(items: number, itemsPerPage: number): number;
}

/**
 * @note Where possible, use Angular's new `afterRender` and `afterNextRender` lifecycle hooks instead of this service.
 * This service is used internally by the library and can optionally be used directly. <br />
 * It’s required for SSR integration but not necessary for functions behind Angular's renderer.
 */
declare class AppReadyService {
    private document;
    private platformId;
    /**
     * The isPlatformBrowser property checks if the platform is a browser (as opposed to server).
     */
    readonly isPlatformBrowser: boolean;
    /**
     * The isBrowserAndDomAvailable property checks for both the document and the browser platform.
     */
    readonly isBrowserAndDomAvailable: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<AppReadyService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AppReadyService>;
}

/**
 * Service containing optional functions for the ComboboxDirective. <br />
 * Can only be used within the context of a ComboboxDirective. <br />
 */
declare class ComboboxService {
    /**
     * The closeMenuOnItemClick method automatically closes the menu when an item is selected. <br />
     * To keep the menu open after an item is selected, you must provide <code>[closeOnClick]="false"</code> to the combobox component.
     * @param combobox Combobox to apply behavior to.
     */
    closeMenuOnItemClick(combobox: ComboboxDirective): void;
    /**
     * The selectHighlightedOnMenuClose method selects the last highlighted item when the menu is closed.
     * This method is called by default within <code>autoSelectItem</code>. <br />
     * @param combobox Combobox to apply behavior to.
     */
    selectHighlightedOnMenuClose(combobox: ComboboxDirective): void;
    /**
     * The autoFilter method filters items in the combobox based on the list of items you pass. <br />
     * This method allows customization of the filtering criteria, enabling you to filter items based on properties such as id, label, value, etc. To access the filtered list, subscribe to <code>the filteredListEmitter</code>, which emits the filtered list in the same shape as <code>fullList</code>. <br />
     * @param combobox Combobox to apply filter function to.
     * @param fullList List of all items to filter through.
     * @param condition Condition to filter the list by. Should match what is passed to the listbox item's inner text. ie if you want to use id, your html should look like `<li v-listbox-item>{{ item.id }}</li>`
     */
    autoFilter<T extends Record<string | number, unknown> = Record<string | number, unknown>>(combobox: ComboboxDirective, fullList: T[], condition?: string): void;
    /**
     * The autoFilterBasedOnList method filters items in the combobox based on the list of items you pass. <br />
     * This method allows customization of the filtering criteria, enabling you to filter items based on properties such as id, label, value, etc. To access the filtered list, subscribe to <code>the filteredListEmitter</code>, which emits the filtered list in the same shape as <code>fullList</code>. <br />
     * @param combobox Combobox to apply filter function to.
     * @param fullList List of all items to filter through.
     * @param condition Condition to filter the list by. Should match what is passed to the listbox item's inner text. ie if you want to use id, your html should look like `<li v-listbox-item>{{ item.id }}</li>`
     */
    autoFilterBasedOnList<T extends Record<string | number, unknown> = Record<string | number, unknown>>(combobox: ComboboxDirective, fullList: T[], condition?: keyof T): void;
    /**
     * The updateList method updates the combobox component with the given filtered list items,
     setting the active and highlighted index appropriately. <br />
     * This method is called by default within <code>autoFilterDisplayedItems</code> and <code>autoFilterBasedOnList</code>.
     * @param combobox Combobox to update.
     * @param filteredListItems Filtered array of listbox items.
     */
    private updateList;
    /**
     * The autoSelectItem method highlights the first list item based on user input. <br />
     * This ensures that when the menu closes, if an input value was entered, an item is selected.
     * @param combobox Combobox to apply automatic selection to.
     */
    autoSelectItem(combobox: ComboboxDirective): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ComboboxService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ComboboxService>;
}

/**
 * Service that generates unique IDs for DOM nodes.
 * Note that this service should not be used inside templates and should only be used within classes or else id will change with every render.
 * @docs {@link https://design.visa.com/developing/angular/services/id-generator | See docs}
 */
declare class IdGenerator {
    private readonly appId;
    /**
     * Generates a unique ID with a specific prefix.
     * @param prefix Prefix to add to the ID.
     */
    newId(prefix?: string): string;
    /**
     * Resets the counters for the IDs.
     * This is useful when testing to ensure that the IDs are deterministic.
     * @deprecated WARNING: This should only be used in tests. Do NOT use this in an actual application.
     */
    static reset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdGenerator, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IdGenerator>;
}

/**
 * Service used to create listbox behavior. Some functions are used within listbox component, others are optional additions.
 */
declare class ListboxService {
    constructor();
    /** @ignore */
    private appReadyService;
    private novaLibService;
    private rendererFactory;
    /** @ignore */
    private renderer;
    /**
     * The setUpListbox method configures the listbox with the expected keyboard behaviors and sets the aria-activedescendant attribute. <br>
     * This method is called by default within <code>ListboxDirective</code>.
     * @param listbox Listbox to set up.
     */
    setUpListbox(listbox: ListboxDirective): void;
    /**
     * The scrollItemIntoView method scrolls given item to top of listbox. <br>
     * It’s called by default in <code>ListBoxDirective</code> unless <code>customScrollControl</code> is present. <br>
     * This method can also call to scroll to a custom index. By default it will scroll to the first active item, but you can provide a specific item if desired.
     * @param listbox Listbox to scroll.
     * @param indexToScrollTo Optional specific index to scroll to top (othwerwise, scrolls to first active item).
     */
    scrollItemIntoView(listbox: ListboxDirective, indexToScrollTo?: number): void;
    /**
     * The addShortcuts method adds keyboard shortcuts to the listbox and is called by default within <code>setUpListbox</code>.
     * @param listbox Listbox to add shortcuts to.
     */
    private addShortcuts;
    /**
     * The handleKeyup method handles item selection on keyup events for the listbox and is called by default within <code>addShortcuts</code>.
     * @param event Keyup event
     * @param listbox Listbox to handle keyup event for.
     */
    private handleKeyUp;
    /**
     * The handleKeydown handles keydown events for the listbox and is called by default within <code>addShortcuts</code>.
     * @param event Keydown event
     * @param listbox Listbox to handle keyup event for.
     */
    private handleKeyDown;
    /**
     * The updateFocusItem method  is activated by Meta + Shift + Home/End and selects all items between the focused item and the first or last item, then sets focus to the first or last item. <br>
     * This method is called by default within <code>handleKeyDown</code>.
     * @param event Keyboard event
     * @param listbox Listbox to update focus item for.
     */
    private updateFocusItem;
    /**
     * The searchKeyword method  handles keys A-Z, a-z, and 0-9, moving the focus to the next item with a name starting with the typed character. <br>
     * In the case of rapid succession, it moves the focus to the next item whose name matches the sequence of characters typed. <br />
     * This method is called by default within <code>handleKeyDown</code>.
     * @param event Keyboard event
     * @param listbox Listbox to search for items in.
     */
    private searchKeyword;
    /**
     * The selectAll method is activated by the Meta + A keys and selects or deselects all items in the listbox. <br>
     * This method is called by default within <code>handleKeyDown</code>.
     * @param listbox Listbox to select all items in.
     */
    private selectAll;
    /**
     * The selectFromCloserSelectedToFocused method selects all items between the currently focused item and the closest selected item. <br>
     * This method is called by default within <code>handleKeyDown</code>.
     */
    private selectContiguousItems;
    /**
     * The toggleSelectedState method is activated by Shift + ↑/↓ and moves the focus to, and toggles the selected state of, the next or previous option. <br>
     * This method is called by default within <code>handleKeyDown</code>.
     * @param event Keyboard event
     * @param listbox Listbox to toggle selected state for.
     */
    private toggleSelectedState;
    /**
     * The selectItems method selects items from start_index to end_index in a list of listbox items. By default, it selects all items if no indices are specified.
     * @param items Array of listbox items that you want to manipulate.
     * @param start Index of the first item you want to manipulate.
     * @param end Index of the last item you want to manipulate.
     * @param prop The property name you want to set to true (ie. active, highlighted, etc.). Defaults to 'active'.
     */
    private selectItems;
    /**
     * The deselectItems method deselect items out of a list of listbox items.
     * @param items List of items that contains the items you want to manipulate.
     * @param index Optional index of the item you DO NOT want to manipulate.
     * @param prop The property name you want to set to false (ie. active, highlighted, etc.). Defaults to 'active'.
     */
    private deselectItems;
    /**
     * The detectAllItemsSelected method checks whether all items in a given list of tab or listbox items are selected.
     * @param items List of items that contains the items you want to check.
     * @returns true if all items are selected, false if not.
     */
    private detectAllItemsSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListboxService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ListboxService>;
}

export { AccordionDetailsDirective, AccordionDirective, AccordionHeadingDirective, AccordionPanelDirective, AddArrowKeysDirective, AlternateDirective, AnchorLinkMenuDirective, AnchorLinkMenuHeaderDirective, AppReadyService, AvatarDirective, BACKSPACE_KEY, BadgeDirective, BadgeType, BannerDirective, BreadcrumbsDirective, BreakpointType, BreakpointsDirective, ButtonColor, ButtonDirective, ButtonSize, CheckboxDirective, CheckboxPanelDirective, ChipDirective, CircularProgressComponent, ComboboxDirective, ComboboxFilterType, ComboboxService, ContentCardBodyDirective, ContentCardDirective, ContentCardImageDirective, ContentCardSubtitleDirective, ContentCardTitleDirective, ContentCardTitleLinkDirective, DOWN_ARROW_KEY, DialogDirective, DialogHeaderDirective, DialogTextDirective, DividerDirective, DividerType, DropdownItemDirective, DropdownListDirective, DropdownMenuDirective, DualIconDirective, END_KEY, ENTER_KEY, ESCAPE_KEY, ElevationDirective, ElevationType, FlagDirective, FlexDirective, FloatingUIContainer, FloatingUIElementDirective, FloatingUIPlacements, FloatingUIService, FloatingUITriggerDirective, FloatingUIVisibility, FooterDirective, HOME_KEY, IconComponent, IconLibrary, IconSize, IconToggle, IconToggleComponent, IconToggleDefaultTemplateDirective, IconToggleDirective, IconToggleRotatedTemplateDirective, IdGenerator, InputContainerComponent, InputDirective, InputMessageDirective, LEFT_ARROW_KEY, LabelDirective, LinearProgressDirective, LinkDirective, ListboxContainerDirective, ListboxDirective, ListboxItemComponent, ListboxService, MarginDirective, MessageContentDirective, MessageDirective, MessageIconDirective, MessageType, NavDirective, NovaCommonModule, NovaFormsModule, NovaLibModule, NovaLibService, OpensInNewTabDirective, PaddingDirective, PaginationControl, PaginationDirective, PaginationOverflowDirective, PanelBodyDirective, PanelContentDirective, PanelDirective, PanelToggleDirective, RIGHT_ARROW_KEY, RadioDirective, RadioGroupDirective, SPACE_CODE, SPACE_KEY, ScreenreaderOnlyDirective, SectionMessageDirective, SelectDirective, SkipToContentDirective, SpacingProperties, SurfaceDirective, SurfaceType, SwitchDirective, TAB_KEY, TabItemDirective, TabListDirective, TableDirective, TableSize, TableWrapperDirective, TdDirective, ThDirective, ToggleButtonDirective, ToggleContainerDirective, ToggleDirective, TooltipArrowDirective, TooltipDirective, TypographyColor, TypographyDirective, TypographyType, UP_ARROW_KEY, VisaLogoComponent, WizardDirective, WizardStepDirective, coerceBreakpoint, generateArray, tableBlockMap, tablePaddingMap };
export type { ComboboxValue, ListboxItemType, ListboxValue, MultiSelectValue, PaginationControlOptions, SingleSelectValue, ToggleContainerValue, UIEventVisibilityPair };