@impartner/design-components 3.0.2 → 4.0.1

package/index.d.ts

@@ -1,5 +1,3636 @@
+import { Observable, Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnChanges, OnInit, AfterContentChecked, ElementRef, ChangeDetectorRef, EventEmitter, InjectionToken, AfterViewInit, AfterContentInit, OnDestroy, WritableSignal, Type, PipeTransform, DoCheck, Signal, QueryList, NgZone, SimpleChanges, TemplateRef, ViewContainerRef, ComponentFactoryResolver, AfterViewChecked } from '@angular/core';
+import * as i2 from '@angular/common';
+import { DatePipe, PercentPipe, DecimalPipe } from '@angular/common';
+import * as i4 from '@angular/forms';
+import { FormGroupDirective, NgForm, NgControl, AbstractControlDirective, AbstractControl, ControlValueAccessor, Validator, ValidationErrors, FormControl } from '@angular/forms';
+import * as _impartner_design_components from '@impartner/design-components';
+import * as i18 from '@ng-bootstrap/ng-bootstrap';
+import { NgbDropdown, NgbDropdownItem, NgbCollapse, NgbDateStruct, NgbTimeStruct, NgbDatepicker, NgbDatepickerI18n, NgbDate, DayTemplateContext } from '@ng-bootstrap/ng-bootstrap';
+
+declare const FontAwesomeIconThemes: string[];
+type FontAwesomeIconTheme = (typeof FontAwesomeIconThemes)[number];
+declare const FontAwesomeIcons: string[];
+type FontAwesomeIcon = (typeof FontAwesomeIcons)[number];
+declare const FontAwesomeFreeSolidIcons: FontAwesomeIcon[];
+declare const FontAwesomeFreeRegularIcons: FontAwesomeIcon[];
+
+declare enum ComponentSize {
+    XXSmall = "xxs",
+    XSmall = "xs",
+    Small = "sm",
+    Medium = "md",
+    Large = "lg",
+    XLarge = "xl",
+    XXLarge = "xxl",
+    Fullscreen = "fs"
+}
+type PrimaryComponentSizes = ComponentSize.XSmall | ComponentSize.Small | ComponentSize.Medium | ComponentSize.Large | ComponentSize.XLarge | ComponentSize.XXLarge;
+type SecondaryComponentSizes = ComponentSize.Small | ComponentSize.Medium | ComponentSize.Large;
+
+declare enum ComponentTheme {
+    Primary = "primary",
+    Secondary = "secondary",
+    Success = "success",
+    Danger = "danger",
+    Warning = "warning",
+    Info = "info",
+    Light = "light",
+    Dark = "dark"
+}
+declare const ComponentThemesArr: ComponentTheme[];
+type ComponentThemes = (typeof ComponentThemesArr)[number];
+
+interface IInteractableComponent {
+    readonly interactableId: string;
+    show: boolean;
+    hide?: () => void;
+}
+interface IBackdropComponent {
+    validate(): void;
+    invalidate(): void;
+    get valid(): boolean;
+}
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated (v4.0.0) This service is only used for other deprecated components and should no longer be used for any new components or modules.
  */
-/// <amd-module name="@impartner/design-components" />
-export * from './public-api';
+declare class InteractionService {
+    private _backdrop?;
+    private _interactables;
+    private readonly _backdropQueueSubject;
+    readonly showBackdrop$: Observable<boolean>;
+    get showBackdrop(): boolean;
+    registerBackdrop(modalBackdrop: IBackdropComponent): void;
+    unregisterBackdrop(modalBackdrop: IBackdropComponent): void;
+    add(interactable: IInteractableComponent): string;
+    remove(interactableId: string): void;
+    toggle(interactable: IInteractableComponent): boolean;
+    queueBackdrop(interactableId: string): void;
+    dequeueBackdrop(interactableId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InteractionService>;
+}
+
+/**
+ * The `TextHighlightComponent` (`<impdc-text-highlight` or `<any impdc-text-highlight`) is a component that highlights search-matched text.
+ * To use, import `TextHighlightModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class TextHighlightComponent implements OnChanges {
+    /**
+     * The text that will be searched and parts of it could be highlighted.
+     */
+    text: string;
+    /**
+     * The search regex/string to look for.
+     */
+    search: string;
+    /**
+     * The method of highlighting, or otherwise what is wrapping the search matches. Options `'mark'`,
+     * `'b'`, `'strong'`, and `'u'` will wrap matching contents inside of those respective native element types;
+     * option `'class'` will wrap matching contents inside a `<span>` with the CSS class specified via the
+     * `highlightClass` input.
+     */
+    method: 'mark' | 'b' | 'strong' | 'u' | 'class';
+    /**
+     * Be default the search is case-insensitive, this will require exact matches only.
+     */
+    exact: boolean;
+    /**
+     * The CSS `class` string applied to `<span>` elements containing matched text; only applied when specifying `'class'`
+     * for the `method` input property.
+     */
+    highlightClass: string;
+    result: string[];
+    ngOnChanges(): void;
+    private _escapeTextForRegExp;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextHighlightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextHighlightComponent, "impdc-text-highlight, [impdc-text-highlight]", never, { "text": { "alias": "text"; "required": true; }; "search": { "alias": "search"; "required": true; }; "method": { "alias": "method"; "required": false; }; "exact": { "alias": "exact"; "required": false; }; "highlightClass": { "alias": "highlightClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TextHighlightModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextHighlightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TextHighlightModule, never, [typeof TextHighlightComponent], [typeof TextHighlightComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TextHighlightModule>;
+}
+
+/**
+ * The `IconComponent` (`<impdc-icon` or `<any impdc-icon`) is an icon wrapper utilizing Font Awesome 5.
+ * To use, import `IconModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class IconComponent implements OnInit, AfterContentChecked {
+    private _changeDetectorRef;
+    private static readonly _licensed$;
+    private readonly _licensedChanges$;
+    private _loading;
+    /**
+     * The Font Awesome 5 icon name. See {@link https://fontawesome.com/v5/search}. Local
+     * development may not represent the complete list of available icons.
+     */
+    name?: FontAwesomeIcon;
+    /**
+     * The Font Awesome 5 icon style. Local development may fallback to a free available
+     * theme when possible.
+     */
+    theme: FontAwesomeIconTheme;
+    /**
+     * The icon size as a string or number. String values are used directly whereas numbers are
+     * interpreted as pixels.
+     */
+    size: string | number;
+    iconRef: ElementRef;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    get typeClass(): string;
+    get computedSize(): string;
+    ngOnInit(): void;
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "impdc-icon, [impdc-icon]", never, { "name": { "alias": "name"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IconModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IconModule, [typeof IconComponent], [typeof i2.CommonModule], [typeof IconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IconModule>;
+}
+
+type BadgeIcon = '' | 'arrow-up' | 'arrow-down' | 'dot';
+
+declare enum BadgeSize {
+    Default = "default",
+    Large = "large"
+}
+declare const BadgeSizesArr: BadgeSize[];
+type BadgeSizes = (typeof BadgeSizesArr)[number];
+
+/**
+ * The `BadgeComponent` (`<impdc-badge` or `any impdc-badge`) displays [preferably short] text with a rounded background and themed colors.
+ * To use, import `BadgeModule` or another module that imports and exports that module from `@impartner/design-components`.
+ *
+ * Use badges to communicate the status of an item or the result of an action taken. Badges are non-interactive, meaning they should not
+ * be added or removed by a user. Try and keep badge text as short and clear as possible, 2 or 3 words max is probably best. Using short
+ * words increases the ability to scan.
+ *
+ * Use Tags for interactive experiences where users can add or remove.
+ */
+declare class BadgeComponent {
+    /**
+     * The text displayed in the center of the Badge.
+     */
+    text: string;
+    /**
+     * An icon displayed left of the Badge text.
+     */
+    icon: BadgeIcon;
+    /**
+     * The color theme of the Badge. This will affect both text and background colors based on allowed designs.
+     */
+    theme: ComponentThemes;
+    /**
+     * The size of the Badge.
+     */
+    size: BadgeSizes;
+    /**
+     * Allows the background of the Badge to be removed.
+     */
+    hideBg: boolean;
+    /**
+     * This controls adding the `rounded-pill` class to the Badge.
+     */
+    rounded: boolean;
+    /**
+     * Adds a dismiss icon to the right of the Badge text.
+     *
+     * Deprecated - Use Tags for interactive elements that a user may add or remove.
+     *
+     * @deprecated
+     */
+    dismissable: boolean;
+    /**
+     * An event emitted when the component is dismissed.
+     *
+     * Deprecated - Use Tags for interactive elements that a user may add or remove.
+     *
+     * @deprecated
+     */
+    dismiss: EventEmitter<Event | MouseEvent>;
+    private get classBadge();
+    private get classBadgeRounded();
+    private get classNoPadding();
+    private _dismissed;
+    protected handleDismiss(event: MouseEvent | Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "impdc-badge, [impdc-badge]", never, { "text": { "alias": "text"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "size": { "alias": "size"; "required": false; }; "hideBg": { "alias": "hideBg"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "dismissable": { "alias": "dismissable"; "required": false; }; }, { "dismiss": "dismiss"; }, never, never, false, never>;
+}
+
+declare class BadgeModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BadgeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BadgeModule, [typeof BadgeComponent], [typeof i2.CommonModule, typeof IconModule], [typeof IconModule, typeof BadgeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BadgeModule>;
+}
+
+/** @docs-private */
+type Constructor<T> = new (...args: any[]) => T;
+/**
+ * This is a permissive type for abstract class constructors.
+ * @docs-private
+ */
+type AbstractConstructor<T = object> = abstract new (...args: any[]) => T;
+
+/** @docs-private */
+interface CanDisable {
+    /** Whether the component is disabled. */
+    disabled: boolean;
+}
+type CanDisableCtor = Constructor<CanDisable> & AbstractConstructor<CanDisable>;
+/** Mixin to augment a directive with a `disabled` property. */
+declare function mixinDisabled<T extends AbstractConstructor<{}>>(base: T): CanDisableCtor & T;
+
+declare class CornerActionComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CornerActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CornerActionComponent, "impdc-corner-action", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class CornerHintComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CornerHintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CornerHintComponent, "impdc-corner-hint", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const IMPDC_ERROR: InjectionToken<ErrorComponent>;
+declare class ErrorComponent {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorComponent, "impdc-error", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FloatingFeedbackComponent {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloatingFeedbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FloatingFeedbackComponent, "impdc-floating-feedback", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare const IMPDC_FORM_ROOT: InjectionToken<ImpdcFormRoot>;
+interface ImpdcFormRoot {
+    get submitted(): boolean;
+    get form(): FormGroupDirective | NgForm;
+}
+declare class RootFormGroupDirective implements ImpdcFormRoot {
+    private _formGroupDirective;
+    private _parentRoot?;
+    constructor(_formGroupDirective: FormGroupDirective, _parentRoot?: ImpdcFormRoot | undefined);
+    get submitted(): boolean;
+    get form(): FormGroupDirective | NgForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootFormGroupDirective, [{ host: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RootFormGroupDirective, "[formGroup]", never, {}, {}, never, never, true, never>;
+}
+declare class RootNgFormDirective implements ImpdcFormRoot {
+    private _ngForm;
+    private _parentRoot?;
+    constructor(_ngForm: NgForm, _parentRoot?: ImpdcFormRoot | undefined);
+    get submitted(): boolean;
+    get form(): FormGroupDirective | NgForm;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RootNgFormDirective, [{ host: true; }, { optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RootNgFormDirective, "[ngForm]", never, {}, {}, never, never, true, never>;
+}
+
+declare class HintComponent {
+    id: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HintComponent, "impdc-hint", never, { "id": { "alias": "id"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class LabelComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LabelComponent, "impdc-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const IMPDC_PREFIX: InjectionToken<PrefixDirective>;
+declare class PrefixDirective {
+    set isTextSelector(value: '');
+    isText: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrefixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PrefixDirective, "[impdcPrefix], [impdcTextPrefix]", never, { "isTextSelector": { "alias": "impdcTextPrefix"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SubLabelComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubLabelComponent, "impdc-sub-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const IMPDC_SUFFIX: InjectionToken<SuffixDirective>;
+declare class SuffixDirective {
+    set isTextSelector(value: '');
+    isText: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuffixDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SuffixDirective, "[impdcSuffix], [impdcTextSuffix]", never, { "isTextSelector": { "alias": "impdcTextSuffix"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const FORM_FIELD_SUBCOMPONENTS: readonly [typeof CornerHintComponent, typeof ErrorComponent, typeof FloatingFeedbackComponent, typeof CornerActionComponent, typeof SubLabelComponent, typeof RootFormGroupDirective, typeof RootNgFormDirective, typeof HintComponent, typeof LabelComponent, typeof PrefixDirective, typeof SuffixDirective];
+
+declare abstract class ImpdcFormFieldControl<T> {
+    /**
+     * The control's value.
+     */
+    abstract value: T | null;
+    /**
+     * Stream that should emit when the control's state changes in a way requiring
+     * the parent `FormFieldComponent` to run change detection.
+     */
+    abstract readonly stateChanges: Observable<void>;
+    abstract readonly id: string;
+    abstract readonly ngControl: NgControl | AbstractControlDirective | null;
+    abstract readonly focused: boolean;
+    abstract readonly disabled: boolean;
+    abstract readonly required: boolean;
+    abstract readonly errorState: boolean;
+    readonly controlType?: string;
+    abstract readonly supportsAffixes: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpdcFormFieldControl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ImpdcFormFieldControl<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare const IMPDC_FORM_FIELD: InjectionToken<FormFieldComponent>;
+declare class FormFieldComponent implements AfterViewInit, AfterContentInit, AfterContentChecked {
+    private readonly _elementRef;
+    private readonly _changeDetectorRef;
+    private readonly _destroyedSubject;
+    protected readonly _inputArea: i0.Signal<ElementRef<HTMLElement> | undefined>;
+    protected readonly _control: i0.Signal<ImpdcFormFieldControl<any> | undefined>;
+    protected readonly _prefixChildren: i0.Signal<readonly _impartner_design_components.PrefixDirective[]>;
+    protected readonly _suffixChildren: i0.Signal<readonly _impartner_design_components.SuffixDirective[]>;
+    protected readonly _errorChildren: i0.Signal<readonly _impartner_design_components.ErrorComponent[]>;
+    protected readonly _labelId: string;
+    protected readonly _hasTextPrefix: i0.Signal<boolean>;
+    protected readonly _hasTextSuffix: i0.Signal<boolean>;
+    ngAfterViewInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    protected _showErrors(): boolean;
+    protected _shouldForwardControlState(prop: keyof AbstractControlDirective): boolean;
+    private _initializeControl;
+    private _assertFormFieldControl;
+    private _updateFocusState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "impdc-form-field", ["impdcFormField"], {}, {}, ["_control", "_prefixChildren", "_suffixChildren", "_errorChildren"], ["impdc-label", "impdc-sub-label", "impdc-corner-hint", "impdc-corner-action", "[impdcPrefix],[impdcTextPrefix]", "*", "[impdcSuffix],[impdcTextSuffix]", "impdc-floating-feedback", "impdc-hint", "impdc-error"], true, never>;
+}
+
+declare class FormFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormFieldModule, never, [typeof FormFieldComponent, typeof CornerHintComponent, typeof ErrorComponent, typeof FloatingFeedbackComponent, typeof CornerActionComponent, typeof SubLabelComponent, typeof RootFormGroupDirective, typeof RootNgFormDirective, typeof HintComponent, typeof LabelComponent, typeof PrefixDirective, typeof SuffixDirective], [typeof FormFieldComponent, typeof CornerHintComponent, typeof ErrorComponent, typeof FloatingFeedbackComponent, typeof CornerActionComponent, typeof SubLabelComponent, typeof RootFormGroupDirective, typeof RootNgFormDirective, typeof HintComponent, typeof LabelComponent, typeof PrefixDirective, typeof SuffixDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormFieldModule>;
+}
+
+declare class ShowOnDirtyErrorStateMatcher implements ErrorStateMatcher {
+    isErrorState(control: AbstractControl<any, any> | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShowOnDirtyErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ShowOnDirtyErrorStateMatcher>;
+}
+declare class ErrorStateMatcher {
+    isErrorState(control: AbstractControl | null, form: FormGroupDirective | NgForm | null): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorStateMatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorStateMatcher>;
+}
+
+type UniqueSelectionDispatcherListener = (id: string, name: string) => void;
+/**
+ * Class to coordinate unique selection based on name.
+ * Intended to be consumed as an Angular service.
+ * This service is needed because native radio change events are only fired on the item currently
+ * being selected, and we still need to uncheck the previous selection.
+ *
+ * This service does not *store* any IDs and names because they may change at any time, so it is
+ * less error-prone if they are simply passed through when the events occur.
+ */
+declare class UniqueSelectionDispatcher implements OnDestroy {
+    private _listeners;
+    /**
+     * Notify other items that selection for the given name has been set.
+     * @param id ID of the item.
+     * @param name Name of the item.
+     */
+    notify(id: string, name: string): void;
+    /**
+     * Listen for future changes to item selection.
+     * @return Function used to deregister listener
+     */
+    listen(listener: UniqueSelectionDispatcherListener): () => void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UniqueSelectionDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UniqueSelectionDispatcher>;
+}
+
+/**
+ * @docs-private
+ */
+interface ICanUpdateErrorState {
+    updateErrorState(): void;
+    errorState: boolean;
+    errorStateSignal: WritableSignal<boolean>;
+    errorStateMatcher: ErrorStateMatcher | undefined;
+}
+type CanUpdateErrorStateCtor = Constructor<ICanUpdateErrorState> & AbstractConstructor<ICanUpdateErrorState>;
+/**
+ * @docs-private
+ */
+interface IHasErrorState {
+    _formRoot: ImpdcFormRoot | null;
+    _parentFormGroup: FormGroupDirective | null;
+    _parentForm: NgForm | null;
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    ngControl: NgControl | null;
+    stateChanges: Subject<void>;
+}
+/**
+ * Mixin to augment a directive with updateErrorState method.
+ * Intended for components with `errorState` and the need to update `errorState`.
+ */
+declare function mixinErrorState<T extends AbstractConstructor<IHasErrorState>>(base: T): CanUpdateErrorStateCtor & T;
+
+/** @ignore */
+interface HasTabIndex {
+    /** Tabindex of the component. */
+    tabIndex: number;
+    /** Tabindex to which to fall back to if no value is set. */
+    defaultTabIndex: number;
+}
+type HasTabIndexCtor = Constructor<HasTabIndex> & AbstractConstructor<HasTabIndex>;
+/** Mixin to augment a directive with a `tabIndex` property. */
+declare function mixinTabIndex<T extends AbstractConstructor<CanDisable>>(base: T, defaultTabIndex?: number): HasTabIndexCtor & T;
+
+type TagTheme = 'default' | 'outline' | 'inverse';
+declare const _TagComponentBase: _impartner_design_components.Constructor<HasTabIndex> & _impartner_design_components.AbstractConstructor<HasTabIndex> & _impartner_design_components.Constructor<CanDisable> & _impartner_design_components.AbstractConstructor<CanDisable> & {
+    new (): {};
+};
+/**
+ * Tags are interactive elements that can be added to UI objects to label, categorize, organize, and filter.
+ * They can be added and removed by users. Tags are used in multi-select inputs.
+ *
+ * Don’t use Tags to communicate the status of an object or the result of an action (like Enabled, Deleted,
+ * Submitted, Error...) — use badges instead.
+ */
+declare class TagComponent extends _TagComponentBase implements CanDisable, HasTabIndex {
+    /**
+     * Color theme to be used when rendering the tag.
+     */
+    theme: TagTheme;
+    /**
+     * Whether to use fully rounded borders for tag, granting a "pill"-like appearance.
+     */
+    rounded: boolean;
+    /**
+     * Where to include an interactable button inside of the tag, whose interactions can be listened
+     * for via the `(buttonClick)` event output.
+     */
+    withButton: boolean;
+    /**
+     * The FontAwesome icon to be displayed inside of the button when `withButton` is set to `true`. Value may be
+     * just a icon name, or optionally an icon name and specific FontAwesome theme/face.
+     */
+    buttonIcon: FontAwesomeIcon | {
+        name: FontAwesomeIcon;
+        theme: FontAwesomeIconTheme;
+    };
+    /**
+     * Event output for button events triggered when `withButton` is set to `true`.
+     */
+    readonly buttonClick: EventEmitter<Event>;
+    get themeClass(): string | null;
+    constructor(tabIndex?: string);
+    protected get buttonIconName(): FontAwesomeIcon;
+    protected get buttonIconTheme(): FontAwesomeIconTheme;
+    protected handleButtonClick(evt: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagComponent, [{ attribute: "tabindex"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagComponent, "impdc-tag", ["impdcTag"], { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "withButton": { "alias": "withButton"; "required": false; }; "buttonIcon": { "alias": "buttonIcon"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_rounded: unknown;
+    static ngAcceptInputType_withButton: unknown;
+}
+
+/**
+ * The `ProgressBarComponent` (`<impdc-progress-bar`) is a display-only slider to show progress.
+ * To use, import `ProgressBarModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class ProgressBarComponent {
+    /**
+     * The left/subject text of the Progress Bar.
+     */
+    labelText: string;
+    /**
+     * The right/status text of the Progress Bar.
+     */
+    statusText: string;
+    /**
+     * The color of the progress bar
+     */
+    barColor: string;
+    /**
+     * The color of the label and status
+     */
+    darkText: boolean;
+    /**
+     * The current value of the Progress Bar represented as a number between 0 and 100.
+     */
+    progressPercentage: number;
+    get textClass(): string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressBarComponent, "impdc-progress-bar", never, { "labelText": { "alias": "labelText"; "required": false; }; "statusText": { "alias": "statusText"; "required": false; }; "barColor": { "alias": "barColor"; "required": false; }; "darkText": { "alias": "darkText"; "required": false; }; "progressPercentage": { "alias": "progressPercentage"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProgressBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProgressBarModule, [typeof ProgressBarComponent], [typeof i2.CommonModule], [typeof ProgressBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProgressBarModule>;
+}
+
+type ButtonTheme = 'primary' | 'secondary' | 'danger' | 'secondary-danger' | 'custom' | 'close';
+
+/**
+ * The `ButtonComponent` (`<button impdcButton`) adds theming to the native button.
+ * For a container, see [ButtonGroupComponent](./?path=/docs/design-components-button-group--button-group).
+ * To use, import `ButtonModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `ButtonModule` also imports and exports [BrandingModule](./?path=/docs/design-components-directives-impdcbranded) and
+ * [IconModule](./?path=/docs/design-components-icon).
+ */
+declare class ButtonComponent {
+    /**
+     * The native type of the Button.
+     */
+    type: 'button' | 'submit' | 'reset';
+    /**
+     * The theme of the Button affecting text, icons, backgrounds, and borders.
+     */
+    theme: ButtonTheme;
+    /**
+     * The Button's text.
+     */
+    text: string;
+    /**
+     * Determines if the Button is disabled.
+     */
+    disabled: boolean;
+    /**
+     * An alternative to the native `title` attribute. Useful for hover text and accessibility.
+     */
+    titleText: string;
+    /**
+     * An alternative to the native `aria-label` attribute. Useful for accessibility.
+     */
+    ariaLabel: string;
+    private get attrType();
+    private classBtn;
+    private get classBtnPrimary();
+    private get classBtnDanger();
+    private get classBtnSecondary();
+    private get classBtnSecondaryDanger();
+    private get classBtnClose();
+    private get attrDisabled();
+    private get attrTitle();
+    private get attrAriaLabel();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "button[impdcButton]", never, { "type": { "alias": "type"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "text": { "alias": "text"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "titleText": { "alias": "titleText"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*", "[right]"], false, never>;
+}
+
+declare class BrandedDirective {
+    private brandedClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BrandedDirective, "[impdcBranded]", never, {}, {}, never, never, false, never>;
+}
+
+declare class BrandingModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BrandingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BrandingModule, [typeof BrandedDirective], [typeof i2.CommonModule], [typeof BrandedDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BrandingModule>;
+}
+
+declare class ButtonModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, [typeof ButtonComponent], [typeof i2.CommonModule, typeof BrandingModule, typeof IconModule], [typeof ButtonComponent, typeof BrandingModule, typeof IconModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
+}
+
+declare class CollapseMonitorDirective {
+    private readonly _ngbCollapse;
+    readonly collapsed: i0.WritableSignal<boolean>;
+    readonly ngbCollapsing: i0.WritableSignal<boolean>;
+    readonly collapseChange: EventEmitter<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseMonitorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CollapseMonitorDirective, "[impdcCollapseMonitor]", ["impdcCollapseMonitor"], {}, { "collapseChange": "collapseChange"; }, never, never, false, [{ directive: typeof i18.NgbCollapse; inputs: { "ngbCollapse": "impdcCollapseMonitor"; }; outputs: {}; }]>;
+}
+
+/**
+ * `TableDirective` (`table[impdcTable]`) is a directive that adds Hex styling to a `table` element.
+ */
+declare class TableDirective {
+    /**
+     * Stripes every other row in a slightly darker background color.
+     */
+    striped: boolean;
+    /**
+     * Whether table rows should apply hover styles when hovered over via cursor.
+     */
+    hover: boolean;
+    /**
+     * The layout algorithm to be used when rendering the table.
+     */
+    layout: 'auto' | 'fixed';
+    private classTable;
+    private get classTableStriped();
+    private get classTableHover();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableDirective, "table[impdcTable]", never, { "striped": { "alias": "striped"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare enum TableColumnType {
+    Badge = "Badge",
+    Boolean = "Boolean",
+    Link = "Link",
+    Text = "Text",
+    Input = "Input",
+    Currency = "Currency",
+    Decimal = "Decimal",
+    Date = "Date",
+    DateTime = "DateTime",
+    Percentage = "Percentage",
+    CellRender = "CellRender",
+    SingleSelect = "SingleSelect",
+    MultiSelect = "MultiSelect",
+    Icon = "Icon",
+    Email = "Email",
+    Url = "Url",
+    Actions = "Actions"
+}
+
+interface IIdentifiable {
+    id: string | number;
+}
+type ITableRowItemValueTypes = string | number | boolean | Date | object | Array<any> | null;
+interface ITableRowItemValue {
+    [field: string]: ITableRowItemValueTypes;
+}
+type ITableRowItem = IIdentifiable & ITableRowItemValue;
+
+interface ITableCellOption {
+    value: string;
+    label: string;
+}
+
+/**
+ * An interface for declaring row-level actions that a user may trigger.
+ */
+interface ITableRowAction<T extends ITableRowItem = ITableRowItem> {
+    /** A uniquely identifying string that event listeners will use to discern which action was triggered. */
+    apiName: string;
+    /** The text to display for the action. */
+    text: string;
+    /** The name of the FontAwesome icon to use, should the action be rendered as an icon. */
+    iconName: string;
+    /** The color theme to use when displaying the action as an icon. */
+    theme?: ComponentTheme;
+    /** A function to be evaluated against the row object in order to conditionally render an action for a given row. */
+    isVisible?: (rowItem: T) => boolean;
+}
+/**
+ * Empty object interface to denote divider elements between table row actions when displayed as a dropdown.
+ */
+interface ITableRowActionDivider {
+}
+
+/**
+ * An interface for specifying all of the configuration necessary for a column of cells in `TableComponent` tables.
+ */
+interface ITableColumnDef<T extends ITableRowItem = ITableRowItem> {
+    /** The type indicating how the column cells should should be displayed and their data interpreted. */
+    readonly columnType: TableColumnType;
+    /** The title of the column to be displayed in the table header. */
+    title: string;
+    /** The row object property from which cell data will be retrieved. */
+    field?: string;
+    /** A callable function that can be evaluated against the row object to resolve the cell value. */
+    valueGetter?: (record: T) => string;
+    /** A default color/theme that can be used when rendering the table cell. */
+    color?: ComponentTheme;
+    /** A callable function that can be evaluated against the row object to resolve a color/theme for the table cell. */
+    colorGetter?: (record: T) => ComponentTheme;
+    /** A row object property from which a table cell's color/theme may be retrieved. */
+    fieldColor?: string;
+    /** Whether the column is sortable. */
+    sorted?: boolean;
+    /**
+     * The name/key of the Angular component passed in the TableComponent's `[customCellComponents]` input that should
+     * be used to render cells in this column.
+     */
+    cellRendererComponent?: string;
+    /**
+     * Additional parameters that will be passed to the custom cell renderer's `[params]` input property at render time.
+     */
+    cellRendererParams?: object;
+    /** Whether to remove the default padding around cells for this column.*/
+    noPadding?: boolean;
+    /** Available options for selection when `columnType` is `'SingleSelect'` or `'MultiSelect'`. */
+    values?: ITableCellOption[];
+    /** The name of the FontAwesome icon to be displayed when `columnType` is `'Icon'`. */
+    iconName?: string;
+    /** Whether to disable the input control when `columnType` is `'Boolean'`, `'SingleSelect'`, or `'MultiSelect'`. */
+    disabled?: boolean;
+    /** @ignore */
+    boldedText?: boolean;
+    /** @ignore */
+    truncated?: number;
+}
+interface ITableActionsColumnDef<T extends ITableRowItem = ITableRowItem> extends ITableColumnDef<T> {
+    readonly columnType: TableColumnType.Actions;
+    actions: (ITableRowAction<T> | ITableRowActionDivider)[];
+    actionType: 'icon' | 'button' | 'link';
+}
+type TableColumnDef<T extends ITableRowItem = ITableRowItem> = ITableActionsColumnDef<T> | ITableColumnDef<T>;
+
+/**
+ * An interface for user input events originating from `TableComponent` rows, including clicked links and changed
+ * values in editable cells.
+ */
+interface ITableEventPayload<T extends ITableRowItem = ITableRowItem> {
+    /** The row from which the event originated. */
+    item: T;
+    /** The table column index from which the event originated. */
+    columnIndex: number;
+    /** The new or selected value that triggered the event, in the case of an editable table cell. */
+    value?: string | number | boolean | string[];
+}
+
+/**
+ * An interface for events emitted from `TableComponent` when the user requests to sort by a particular column.
+ */
+interface ISortByPayload {
+    /** The field the user has requested to sort by, if the sorted column is mapped to one. */
+    field: string;
+    /** The index of the relevant column in the table. */
+    columnIndex: number;
+    /** The direction or order in which the data is expected to be sorted. */
+    direction: 'asc' | 'desc';
+}
+
+/**
+ * The base interface type implemented by Angular components to be used as custom renderers for
+ * `TableComponent` table cells.
+ */
+interface ICellRenderer<T extends ITableRowItem = ITableRowItem, P = object> {
+    /** The resolved raw value for the cell, as per the column defintion. */
+    value: ITableRowItemValueTypes;
+    /** The row object for the current table row. */
+    rowItem: T;
+    /** The `cellRendererParams` value from the original column definition. */
+    params?: P;
+}
+
+type ICustomCellRendererComponents = Record<string, Type<ICellRenderer>>;
+
+/**
+ * An interface for events emitted from `TableComponent` when a user clicks or interacts with a row-level action
+ * button, link, or icon.
+ */
+interface ITableRowActionPayload<T extends ITableRowItem = ITableRowItem> {
+    /** The row object corresponding to the action taken. */
+    item: T;
+    /** The specific column index the action originated from. */
+    columnIndex: number;
+    /** The defined `apiName` for the action that triggered the event. */
+    actionApiName: string;
+}
+
+/**
+ * An interface for context objects that will be provided when rendering collapsible row content
+ * for `TableComponent` rows.
+ */
+interface ICollapsibleRowContentContext<T extends ITableRowItem = ITableRowItem> {
+    /**
+     * The current row object.
+     */
+    $implicit: T;
+    /**
+     * Whether the collapsible row is collapsed.
+     */
+    collapsed: boolean;
+    /**
+     * Whether the table row is selected, if row selection is available.
+     */
+    selected: boolean;
+    /**
+     * Index of the parent row in the currently displayed data set.
+     */
+    index: number;
+    /**
+     * Whether the parent row is the first row in the displayed data set.
+     */
+    first: boolean;
+    /**
+     * Whether the parent row is the last row in the displayed data set.
+     */
+    last: boolean;
+    /**
+     * Whether the parent row's index in the currently displayed data set is even.
+     */
+    even: boolean;
+    /**
+     * Whether the parent row's index in the currently displayed data set is odd.
+     */
+    odd: boolean;
+}
+
+/**
+ * An interface for events emitted from `TableComponent` when a user triggers the expansion or collapse of additional
+ * row-level content.
+ */
+interface ITableRowCollapseChange<T extends ITableRowItem = ITableRowItem> {
+    /** The row object for the row that is expanding or collapsing. */
+    readonly row: T;
+    /** Whether the row is in a collapsed state. */
+    readonly collapsed: boolean;
+}
+
+interface IFilteredRowActionBase {
+    readonly trackId: number;
+}
+interface IFilteredRowAction extends IFilteredRowActionBase {
+    readonly type: 'action';
+    readonly action: ITableRowAction;
+}
+interface IFilteredRowActionDivider extends IFilteredRowActionBase {
+    readonly type: 'divider';
+}
+type FilteredTableRowAction = IFilteredRowAction | IFilteredRowActionDivider;
+declare class FilterTableRowActionsPipe implements PipeTransform {
+    transform(rowActions: (ITableRowAction | ITableRowActionDivider)[], row: ITableRowItem): readonly FilteredTableRowAction[];
+    private _actionIsVisible;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterTableRowActionsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterTableRowActionsPipe, "filterTableRowActions", false>;
+}
+
+/**
+ * Type representing allowable values for a boolean input.
+ */
+type BooleanInput = string | boolean | null | undefined;
+
+declare class CheckboxChangeEvent {
+    /** The specific checkbox that changed. */
+    readonly source: CheckboxComponent;
+    /** Whether the changed checkbox was checked or unchecked at the time of the event. */
+    readonly checked: boolean;
+    constructor(
+    /** The specific checkbox that changed. */
+    source: CheckboxComponent, 
+    /** Whether the changed checkbox was checked or unchecked at the time of the event. */
+    checked: boolean);
+}
+declare abstract class CheckboxComponentBase {
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    _formRoot: ImpdcFormRoot;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    ngControl: NgControl | null;
+    readonly stateChanges: Subject<void>;
+    abstract disabled: boolean;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+}
+declare const _CheckboxComponentMixinBase: _impartner_design_components.Constructor<HasTabIndex> & _impartner_design_components.AbstractConstructor<HasTabIndex> & _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & typeof CheckboxComponentBase;
+/**
+ * The `CheckboxComponent` (`<impdc-checkbox`) is an input with a simple boolean value as a checkbox or toggle switch.
+ * This component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `CheckboxModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class CheckboxComponent extends _CheckboxComponentMixinBase implements DoCheck, OnDestroy, ControlValueAccessor, Validator, HasTabIndex, ImpdcFormFieldControl<boolean>, ICanUpdateErrorState, IHasErrorState {
+    private readonly _changeDetector;
+    private readonly _uid;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    protected _inputElement?: ElementRef<HTMLInputElement>;
+    id: string;
+    /**
+     * The primary label text for the checkbox control.
+     */
+    label: string;
+    /**
+     * Text to provide additional description or context for the checkbox control. Does not display when `inline` is `true`.
+     */
+    description: string;
+    /**
+     * Whether or not the input displays as a toggle switch.
+     */
+    isSwitch: boolean;
+    /**
+     * When `isSwitch` is `true`, sets whether or not the toggle switch uses icons.
+     */
+    switchIcons: boolean;
+    /**
+     * Whether or not the checkbox displays inline.
+     */
+    inline: boolean;
+    /**
+     * Opt to display the checkbox control before the label (`'check-start'`) or after the label (`'check-end'`)
+     */
+    layout: 'check-start' | 'check-end';
+    /**
+     * Whether or not the checkbox input is checked.
+     */
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    /**
+     * Whether or not the checkbox input is in an `indeterminate` state.
+     */
+    get indeterminate(): boolean;
+    set indeterminate(value: BooleanInput);
+    private _indeterminate;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Event emitted whenever the checkedness of the input changes.
+     */
+    readonly change: EventEmitter<CheckboxChangeEvent>;
+    /**
+     * Event emitted whenever the control enters or leaves an `indeterminate` state.
+     */
+    readonly indeterminateChange: EventEmitter<boolean>;
+    get inputId(): string;
+    constructor(_changeDetector: ChangeDetectorRef, tabIndex: string, defaultErrorStateMatcher: ErrorStateMatcher, formRoot: ImpdcFormRoot, parentForm: NgForm, parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    get value(): boolean;
+    set value(value: BooleanInput);
+    private _value;
+    get focused(): boolean;
+    private _focused;
+    /**
+     * Used to set requiredness of control in a template-based manner; not necessary when using the
+     * Angular reactive forms API and 'required' or `requiredTrue` validators.
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    /** @ignore */
+    validate(): ValidationErrors | null;
+    protected _getAriaChecked(): 'true' | 'false' | 'mixed';
+    protected _onBlur(): void;
+    protected _onFocus(): void;
+    protected _handleCheckClick(): void;
+    protected _onInteractionEvent(event: Event): void;
+    private _emitChangeEvents;
+    /**
+     *  Prevent click events that come from the `<label/>` element from bubbling. This prevents the
+     *  click handler on the host from triggering twice when clicking on the `<label/>` element. After
+     *  the click event on the `<label/>` propagates, the browsers dispatches click on the associated
+     *  `<input/>`. By preventing clicks on the label by bubbling, we ensure only one click event
+     *  bubbles when the label is clicked.
+     */
+    protected _preventBubblingFromLabel(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, [null, { attribute: "tabindex"; }, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "impdc-checkbox", ["impdcCheckControl"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "isSwitch": { "alias": "isSwitch"; "required": false; }; "switchIcons": { "alias": "switchIcons"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; "indeterminateChange": "indeterminateChange"; }, never, never, true, never>;
+}
+
+declare class CheckboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckboxModule, never, [typeof CheckboxComponent], [typeof CheckboxComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CheckboxModule>;
+}
+
+interface ICheckboxItem {
+    readonly checked: boolean;
+    readonly name: string;
+    readonly value: any;
+}
+
+declare class CheckboxGroupChangeEvent {
+    /** The last checkbox item that changed. */
+    readonly source: ICheckboxItem;
+    /** The currently selected values for the checkbox group. */
+    readonly value: any[];
+    constructor(
+    /** The last checkbox item that changed. */
+    source: ICheckboxItem, 
+    /** The currently selected values for the checkbox group. */
+    value: any[]);
+}
+
+declare class CheckboxItemChangeEvent {
+    /** The checkbox item that changed. */
+    readonly source: ICheckboxItem;
+    /** The new `checked` state for the changed checkbox item. */
+    readonly checked: boolean;
+    constructor(
+    /** The checkbox item that changed. */
+    source: ICheckboxItem, 
+    /** The new `checked` state for the changed checkbox item. */
+    checked: boolean);
+}
+
+interface IToggleGroupItem {
+    readonly isChecked: boolean;
+    readonly name: string;
+    readonly value: any;
+}
+
+declare class ToggleGroupItemChangeEvent {
+    readonly source: IToggleGroupItem;
+    readonly value: any;
+    readonly checked: boolean;
+    constructor(source: IToggleGroupItem, value: any, checked: boolean);
+}
+declare class ToggleGroupItemBlurEvent {
+    readonly source: IToggleGroupItem;
+    constructor(source: IToggleGroupItem);
+}
+
+declare class ToggleGroupItemComponent implements IToggleGroupItem, OnDestroy {
+    private readonly _parentGroup;
+    private readonly _radioDispatcher;
+    private readonly _uid;
+    private _removeUniqueSelectionListener;
+    readonly itemValue: i0.InputSignal<unknown>;
+    readonly label: i0.InputSignal<string>;
+    readonly type: i0.InputSignal<"radio" | "checkbox">;
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    readonly ariaLabelledby: i0.InputSignal<string | undefined>;
+    readonly ariaDescribedby: i0.InputSignal<string | undefined>;
+    readonly description: i0.InputSignal<string>;
+    readonly disabled: i0.InputSignal<boolean>;
+    readonly groupName: i0.InputSignal<string | undefined>;
+    readonly inline: i0.InputSignal<boolean>;
+    readonly itemTabIndex: i0.InputSignal<number>;
+    readonly required: i0.InputSignal<boolean>;
+    readonly checked: i0.ModelSignal<boolean>;
+    readonly toggleChanged: i0.OutputEmitterRef<ToggleGroupItemChangeEvent>;
+    readonly toggleBlurred: i0.OutputEmitterRef<ToggleGroupItemBlurEvent>;
+    readonly isInline: i0.Signal<boolean>;
+    readonly isDisabled: i0.Signal<boolean>;
+    readonly isRequired: i0.Signal<boolean>;
+    readonly isInvalid: i0.Signal<boolean>;
+    readonly resolvedGroupName: i0.Signal<string | undefined>;
+    protected readonly tabIndex: i0.Signal<string>;
+    get isChecked(): boolean;
+    get value(): unknown;
+    get name(): string;
+    ngOnDestroy(): void;
+    protected onInputChange(ev: Event): void;
+    protected onBlur(ev: FocusEvent): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleGroupItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleGroupItemComponent, "impdc-toggle-group-item", never, { "itemValue": { "alias": "itemValue"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "type": { "alias": "type"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "ariaDescribedby"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "groupName": { "alias": "groupName"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "itemTabIndex": { "alias": "itemTabIndex"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "toggleChanged": "toggleChanged"; "toggleBlurred": "toggleBlurred"; }, never, never, true, never>;
+}
+
+interface IToggleGroup {
+    readonly initialized: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly errorState: Signal<boolean>;
+    readonly inline: Signal<boolean>;
+    readonly groupName: Signal<string>;
+    readonly required: Signal<boolean>;
+    readonly value: Signal<readonly unknown[]>;
+    updateToggleState(item: IToggleGroupItem): void;
+    blur(evt: ToggleGroupItemBlurEvent): void;
+}
+
+declare class ToggleGroupChangeEvent {
+    readonly source: IToggleGroupItem;
+    readonly value: readonly unknown[];
+    constructor(source: IToggleGroupItem, value: readonly unknown[]);
+}
+
+declare class ToggleGroupComponent implements IToggleGroup, OnInit {
+    private readonly _initialized;
+    readonly initialized: i0.Signal<boolean>;
+    readonly type: i0.InputSignal<"radio" | "checkbox">;
+    readonly groupName: i0.InputSignal<string>;
+    readonly inline: i0.InputSignal<boolean>;
+    readonly disabled: i0.InputSignal<boolean>;
+    readonly errorState: i0.InputSignal<boolean>;
+    readonly required: i0.InputSignal<boolean>;
+    readonly value: i0.ModelSignal<readonly unknown[]>;
+    readonly valueChanged: i0.OutputEmitterRef<ToggleGroupChangeEvent>;
+    readonly toggleBlur: i0.OutputEmitterRef<ToggleGroupItemBlurEvent>;
+    ngOnInit(): void;
+    blur(evt: ToggleGroupItemBlurEvent): void;
+    updateToggleState(item: IToggleGroupItem, opts?: {
+        emitEvent: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleGroupComponent, "impdc-toggle-group", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "groupName": { "alias": "groupName"; "required": true; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "errorState": { "alias": "errorState"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, { "value": "valueChange"; "valueChanged": "valueChanged"; "toggleBlur": "toggleBlur"; }, never, ["*"], true, never>;
+}
+
+interface IToggleGroupAccessor {
+    readonly toggleGroup: IToggleGroup;
+}
+
+declare abstract class CheckboxItemComponentBase {
+    abstract disabled: boolean;
+    constructor();
+}
+declare const _CheckboxItemComponentMixinBase: _impartner_design_components.Constructor<HasTabIndex> & _impartner_design_components.AbstractConstructor<HasTabIndex> & typeof CheckboxItemComponentBase;
+declare class CheckboxItemComponent extends _CheckboxItemComponentMixinBase implements HasTabIndex, DoCheck {
+    private readonly _changeDetector;
+    private readonly _uid;
+    protected readonly toggleTabIndex: WritableSignal<number>;
+    protected readonly toggleItem: i0.Signal<ToggleGroupItemComponent>;
+    id: string;
+    /**
+     * Property for setting ARIA "label" attribute.
+     */
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    /**
+     * Property for setting ARIA "labelled by" attribute.
+     */
+    readonly ariaLabelledby: i0.InputSignal<string | undefined>;
+    /**
+     * Property for setting ARIA "described by" attribute.
+     */
+    readonly ariaDescribedby: i0.InputSignal<string | undefined>;
+    /**
+     * Whether or not the checkbox itiem is checked/selected.
+     */
+    readonly checked: i0.ModelSignal<boolean>;
+    /**
+     * The specific value represented by the checkbox item.
+     */
+    readonly value: i0.InputSignal<any>;
+    /**
+     * Whether or not the checkbox item displays inline; Inherited from the parent `CheckboxGroupComponent` when set there.
+     */
+    readonly inline: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Used to enable or disable the checkbox item, but will be overridden when the parent
+     * `CheckboxGroupComponent` is already disabled.
+     */
+    get disabled(): boolean;
+    set disabled(newDisabledState: boolean);
+    private _disabled;
+    /**
+     * The primary label text for the checkbox item.
+     */
+    readonly label: i0.InputSignal<string>;
+    /**
+     * Text to provide additional description or context for the checkbox item. Does
+     * not display when `inline` resolves as `true`.
+     */
+    readonly description: i0.InputSignal<string>;
+    /**
+     * Event emitted when the checkbox item becomes checked or unchecked.
+     */
+    readonly changes: EventEmitter<CheckboxItemChangeEvent>;
+    constructor();
+    ngDoCheck(): void;
+    protected onInputChange(event: ToggleGroupItemChangeEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxItemComponent, "impdc-checkbox-item", ["impdcCheckboxItem"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "changes": "changes"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Returns an exception to be thrown when attempting to assign a non-array value. Note that
+ * `undefined` and `null` are still valid values to allow for resetting the value.
+ * @ignore
+ */
+declare function getImpdcCheckboxGroupNonArrayValueError(): Error;
+declare const _CheckboxGroupComponentBase: _impartner_design_components.Constructor<_impartner_design_components.ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<_impartner_design_components.ICanUpdateErrorState> & {
+    new (): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: _impartner_design_components.ImpdcFormRoot | null;
+        _parentForm: NgForm | null;
+        _parentFormGroup: FormGroupDirective | null;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `CheckboxGroupComponent` (`<impdc-checkbox-group>`) is a container for selectable `CheckboxItemComponent`
+ * (`<impdc-checkbox-item>`) instances. This component can be used within a `FormFieldComponent` (`<impdc-form-field`)
+ * instance via content projection.
+ * To use, you may import the standalone `CheckboxGroupComponent` and `CheckboxItemComponent` types, or the
+ * `CheckboxGroupModule` or `ImpdcFormsModule` module types.
+ */
+declare class CheckboxGroupComponent extends _CheckboxGroupComponentBase implements IToggleGroupAccessor, ControlValueAccessor, ImpdcFormFieldControl<any[]>, AfterContentInit, DoCheck, OnDestroy, IHasErrorState {
+    private readonly _uid;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    private _initialized;
+    private _previousControl?;
+    private _suppressCvaOnChange;
+    private _suppressEmitValueChange;
+    protected readonly _toggleGroup: i0.Signal<ToggleGroupComponent>;
+    /**
+     * The unique name for the group of radio options; Autogenerated by default.
+     */
+    readonly name: i0.InputSignal<string>;
+    /**
+     * Whether or not the nested radio options should display inline.
+     */
+    readonly inline: i0.InputSignalWithTransform<boolean, unknown>;
+    errorStateMatcher: ErrorStateMatcher;
+    /** Event emitted whenever a new checkbox item is checked. */
+    readonly changes: i0.OutputEmitterRef<CheckboxGroupChangeEvent>;
+    /**
+     * Event emitted with the new value whenever one is selected.
+     */
+    readonly valueChange: i0.OutputEmitterRef<any[]>;
+    /** @ignore */
+    get toggleGroup(): IToggleGroup;
+    constructor();
+    /** @ignore */
+    ngAfterContentInit(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    get value(): any[];
+    set value(value: any[]);
+    protected readonly _valueInternal: i0.WritableSignal<readonly any[]>;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    get focused(): boolean;
+    protected _focused: boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected _disabled: boolean;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    readonly controlType = "impdc-checkbox-group";
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    /** @ignore */
+    protected emitChangesEvent(event: ToggleGroupChangeEvent): void;
+    protected handleBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxGroupComponent, "impdc-checkbox-group", ["impdcCheckboxGroup"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "changes": "changes"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class CheckboxGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CheckboxGroupModule, never, [typeof CheckboxItemComponent, typeof CheckboxGroupComponent], [typeof CheckboxItemComponent, typeof CheckboxGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CheckboxGroupModule>;
+}
+
+declare const _InputDirectiveBase: _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `InputDirective` (`<input impdcInput`, `<textarea impdcInput` or `<select impdcInput`) is a directive for text inputs.
+ * With this directive, the input, textarea, and select can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, import `ImpdcFormsModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class InputDirective extends _InputDirectiveBase implements ImpdcFormFieldControl<any>, ICanUpdateErrorState, IHasErrorState, OnChanges, OnDestroy, DoCheck {
+    protected _elementRef: ElementRef<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>;
+    private _inputValueAccessor;
+    protected _uid: string;
+    protected _isSelect: boolean;
+    protected _isTextarea: boolean;
+    focused: boolean;
+    readonly controlType?: string;
+    readonly supportsAffixes: boolean;
+    get elementRef(): ElementRef<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    protected _disabled: boolean;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Supports most standard `<input [type]>` attribute values. Does not support `button`, `checkbox`,
+     * `file`, `hidden`, `image`, `radio`, `range`, `reset`, or `button`, and does not apply to
+     * `<textarea>` or `<select>` elements.
+     *
+     * @default text
+     */
+    get type(): string;
+    set type(value: string);
+    protected _type: string;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    /**
+     * Used to put the control in a non-interactive readonly state; only supports `<input>` and
+     * `<textarea>` elements.
+     *
+     * To see the difference between `readonly` and `disabled`, refer to [MDN's documentation](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/readonly).
+     */
+    get readonly(): boolean;
+    set readonly(value: BooleanInput);
+    private _readonly;
+    errorStateMatcher: ErrorStateMatcher;
+    get value(): string;
+    set value(value: any);
+    constructor(_elementRef: ElementRef<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>, ngControl: NgControl, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, _defaultErrorStateMatcher: ErrorStateMatcher);
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    protected _focusChanged(isFocused: boolean): void;
+    protected _typeIsValid(inputType: string): boolean;
+    protected _onInput(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective, [null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective, "input[impdcInput], textarea[impdcInput], select[impdcNativeSelect]", ["impdcInput"], { "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "type": { "alias": "type"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IRadioButton {
+    readonly checked: boolean;
+    readonly name: string;
+    readonly value: any;
+}
+
+declare class RadioChangeEvent {
+    /** The specific radio button that changed. */
+    readonly source: IRadioButton;
+    /** The selected value. */
+    readonly value: any;
+    constructor(
+    /** The specific radio button that changed. */
+    source: IRadioButton, 
+    /** The selected value. */
+    value: any);
+}
+
+declare abstract class RadioButtonComponentBase {
+    abstract disabled: boolean;
+    constructor();
+}
+declare const _RadioButtonComponentMixinBase: _impartner_design_components.Constructor<HasTabIndex> & _impartner_design_components.AbstractConstructor<HasTabIndex> & typeof RadioButtonComponentBase;
+declare class RadioButtonComponent extends _RadioButtonComponentMixinBase implements HasTabIndex, DoCheck {
+    private readonly _changeDetector;
+    private readonly _uid;
+    protected readonly toggleTabIndex: WritableSignal<number>;
+    protected readonly toggleItem: i0.Signal<ToggleGroupItemComponent>;
+    id: string;
+    /**
+     * The unique name for a group of radio options; Inherited from the parent `RadioGroupComponent` when available.
+     */
+    readonly name: i0.InputSignal<string | undefined>;
+    /**
+     * Property for setting ARIA "label" attribute.
+     */
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    /**
+     * Property for setting ARIA "labelled by" attribute.
+     */
+    readonly ariaLabelledby: i0.InputSignal<string | undefined>;
+    /**
+     * Property for setting ARIA "described by" attribute.
+     */
+    readonly ariaDescribedby: i0.InputSignal<string | undefined>;
+    /**
+     * Whether or not the radio input is checked/selected.
+     */
+    readonly checked: i0.ModelSignal<boolean>;
+    /**
+     * The specific value represented by the radio button.
+     */
+    readonly value: i0.InputSignal<any>;
+    /**
+     * Whether or not the radio button displays inline; Inherited from the parent `RadioGroupComponent` when available.
+     */
+    readonly inline: i0.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Used to enable or disable the radio button, but will be overridden when the parent
+     * `RadioGroupComponent` is already disabled.
+     */
+    get disabled(): boolean;
+    set disabled(newDisabledState: boolean);
+    private _disabled;
+    /** @ignore */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    /**
+     * The primary label text for the radio button.
+     */
+    readonly label: i0.InputSignal<string>;
+    /**
+     * Text to provide additional description or context for the radio button. Does
+     * not display when `inline` resolves as `true`.
+     */
+    readonly description: i0.InputSignal<string>;
+    /**
+     * Event emitted when the radio button becomes selected/checked.
+     */
+    readonly change: EventEmitter<RadioChangeEvent>;
+    constructor(tabIndex?: string);
+    ngDoCheck(): void;
+    protected onInputChange(event: ToggleGroupItemChangeEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, [{ attribute: "tabindex"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "impdc-radio-button", ["impdcRadioButton"], { "tabIndex": { "alias": "tabIndex"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "change": "change"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare const _RadioGroupComponentBase: _impartner_design_components.Constructor<_impartner_design_components.ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<_impartner_design_components.ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `RadioGroupComponent` (`<impdc-radio-group>`) is a container for `RadioButtonComponent` (`<impdc-radio-button>`).
+ * This component can be used within a `FormFieldComponent` (`<impdc-form-field>`).
+ * To use, import `RadioModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class RadioGroupComponent extends _RadioGroupComponentBase implements IToggleGroupAccessor, ControlValueAccessor, ImpdcFormFieldControl<any>, AfterContentInit, DoCheck, OnDestroy, IHasErrorState {
+    private readonly _uid;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    private _initialized;
+    private _previousControl?;
+    private _suppressCvaOnChange;
+    private _suppressEmitValueChange;
+    protected readonly _toggleGroup: i0.Signal<ToggleGroupComponent>;
+    /**
+     * The unique name for the group of radio options; Autogenerated by default.
+     */
+    readonly name: i0.InputSignal<string>;
+    /**
+     * Whether or not the nested radio options should display inline.
+     */
+    readonly inline: i0.InputSignalWithTransform<boolean, unknown>;
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Event emitted whenever a new radio option is selected.
+     */
+    readonly change: EventEmitter<RadioChangeEvent>;
+    /**
+     * Event emitted with the new value whenever one is selected.
+     */
+    readonly valueChange: i0.OutputEmitterRef<any>;
+    /** @ignore */
+    get toggleGroup(): IToggleGroup;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+    /** @ignore */
+    ngAfterContentInit(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    get value(): any;
+    set value(value: any);
+    protected readonly _valueInternal: i0.WritableSignal<readonly any[]>;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    get focused(): boolean;
+    protected _focused: boolean;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    protected _disabled: boolean;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    readonly controlType = "impdc-radio-group";
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    /** @ignore */
+    protected emitChangesEvent(event: ToggleGroupChangeEvent): void;
+    protected handleBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioGroupComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioGroupComponent, "impdc-radio-group", ["impdcRadioGroup"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class RadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RadioModule, never, [typeof RadioButtonComponent, typeof RadioGroupComponent], [typeof RadioButtonComponent, typeof RadioGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RadioModule>;
+}
+
+interface ISelectOption {
+    readonly groupLabel?: string;
+    readonly label: string;
+    readonly value: any;
+    readonly disabled?: boolean;
+}
+
+interface ISelectOptionGroup {
+    readonly label: string;
+}
+declare class SelectOptionGroupComponent implements ISelectOptionGroup {
+    label: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectOptionGroupComponent, "impdc-select-option-group", never, { "label": { "alias": "label"; "required": true; }; }, {}, never, ["impdc-select-option"], true, never>;
+}
+
+declare class SelectOptionComponent implements ISelectOption {
+    private readonly _group?;
+    readonly uid: string;
+    /**
+     * The specific value represented by the select option.
+     */
+    value: any;
+    /**
+     * Label text describing the select option.
+     */
+    label: string;
+    /**
+     * Used to enable or disable the specific select option.
+     */
+    disabled: boolean;
+    get groupLabel(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectOptionComponent, "impdc-select-option", never, { "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface SelectChange<T> {
+    source: SelectModel<T>;
+    added: T[];
+    removed: T[];
+}
+declare class SelectModel<T> {
+    private readonly _multiple;
+    private readonly _emitChanges;
+    compareFunc?: ((a: T, b: T) => boolean) | undefined;
+    private _selection;
+    private _pendingDeselectionsToEmit;
+    private _pendingSelectionsToEmit;
+    private _selected;
+    get selected(): T[];
+    readonly changed$: Subject<SelectChange<T>>;
+    constructor(_multiple?: boolean, initialSelectedValues?: T[], _emitChanges?: boolean, compareFunc?: ((a: T, b: T) => boolean) | undefined);
+    select(...values: T[]): boolean | void;
+    deselect(...values: T[]): boolean | void;
+    setSelection(...values: T[]): boolean | void;
+    toggle(value: T): boolean | void;
+    clear(flushEvent?: boolean): boolean | void;
+    isSelected(value: T): boolean;
+    isEmpty(): boolean;
+    hasValue(): boolean;
+    sort(predicateFunc?: (a: T, b: T) => number): void;
+    isMultipleSelection(): boolean;
+    private _emitChangeEvent;
+    private _markSelected;
+    private _unmarkSelected;
+    private _unmarkAll;
+    private _verifyValueAssignment;
+    private _hasQueuedChanges;
+    private _getConcreteValue;
+}
+
+declare class SelectChangeEvent<TComponent> {
+    /** The specific SelectComponent that changed. */
+    readonly source: TComponent;
+    /** The selected value(s) */
+    readonly value: any;
+    constructor(
+    /** The specific SelectComponent that changed. */
+    source: TComponent, 
+    /** The selected value(s) */
+    value: any);
+}
+interface IRenderedSelectOption extends ISelectOption {
+    readonly selected?: boolean;
+    readonly showGroupLabel?: boolean;
+}
+declare const __SelectComponentBase: _impartner_design_components.Constructor<HasTabIndex> & _impartner_design_components.AbstractConstructor<HasTabIndex> & _impartner_design_components.Constructor<CanDisable> & _impartner_design_components.AbstractConstructor<CanDisable> & _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot | null, _parentForm: NgForm | null, _parentFormGroup: FormGroupDirective | null, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot | null;
+        _parentForm: NgForm | null;
+        _parentFormGroup: FormGroupDirective | null;
+        ngControl: NgControl | null;
+    };
+};
+declare abstract class _SelectComponentBase extends __SelectComponentBase implements ISelectOptionParentComponent, OnInit, AfterViewInit, OnChanges, DoCheck, OnDestroy, ControlValueAccessor, HasTabIndex, ImpdcFormFieldControl<any>, CanDisable, ICanUpdateErrorState, IHasErrorState {
+    protected staticOptions: QueryList<SelectOptionComponent>;
+    protected options: QueryList<SelectOptionDisplayComponent>;
+    protected ngbDropdown: NgbDropdown;
+    protected toggleButtonRef?: ElementRef<HTMLElement>;
+    protected searchInputRef?: ElementRef<HTMLInputElement>;
+    private readonly _ngDestroy;
+    private readonly _searchSubject;
+    private _previousControl?;
+    private _compareWith;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    protected readonly uid: string;
+    protected readonly changeDetector: ChangeDetectorRef;
+    protected readonly ngZone: NgZone;
+    protected readonly searchControl: FormControl<string | null>;
+    protected readonly BadgeTheme: typeof ComponentTheme;
+    protected readonly filteredOptions$: Observable<IRenderedSelectOption[]>;
+    protected selectionModel: SelectModel<ISelectOption>;
+    protected activeIndex: number;
+    /** @ignore */
+    readonly optionSelectionChanges: Observable<SelectOptionSelectionChangeEvent>;
+    /**
+     * Set whether or not an input field will appear for searching and
+     * filtering visible options.
+     *
+     * - `'none'`: No search control will be displayed, and all select options are provided via projected `<impdc-select-option>` elements.
+     * - `'static'`: A search control will be displayed, select options are provided via projected `<impdc-select-option>` elements, and
+     * filtering is performed against the `[label]` attribute value.
+     * @default 'none'
+     */
+    get search(): 'none' | 'static';
+    set search(value: 'none' | 'static');
+    /**
+     * The placeholder text that will be displayed when no selection has been made.
+     *
+     * @default \- Select -
+     */
+    get placeholder(): string;
+    set placeholder(value: string);
+    protected _placeholder: string;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    /**
+     * Whether the control is a single-select or multiple-select. Cannot be changed after component initialization.
+     */
+    get multiple(): boolean;
+    protected _multiple: boolean;
+    /**
+     * Function used to compare option values with selected values. The first arg is a
+     * `value` from an option, and the second arg is a `value` from the selection or another option.
+     *
+     * @returns Boolean indicating if the values are equivalent.
+     */
+    get compareWith(): (a: any, b: any) => boolean;
+    set compareWith(fn: (a: any, b: any) => boolean);
+    /**
+     * Document element that the select dropdown will be attached to in the DOM - either the
+     * document's `<body>` tag, or as a child of the component tag.
+     *
+     * The default value (`'body'`) is generally the correct choice, and should only be
+     * overridden when absolutely certain that the result behavior is what's desired.
+     */
+    dropdownContainer: 'body' | null;
+    errorStateMatcher: ErrorStateMatcher;
+    /** Events fire when selection has been changed by the user. */
+    readonly selectionChange: EventEmitter<SelectChangeEvent<this>>;
+    /**
+     * Events fire when raw value of select changes. Mainly exists to handle
+     * two-way binding of `value` input property.
+     * @ignore
+     */
+    readonly valueChange: EventEmitter<any>;
+    /**
+     * Events fire when the text value of the option search input control has changed.
+     */
+    readonly searchTextChanges: Observable<string | null>;
+    constructor(uid: string, tabIndex?: string);
+    get dropdownOpen(): boolean;
+    get empty(): boolean;
+    get selected(): ISelectOption | ISelectOption[];
+    /** @ignore */
+    focus(options?: FocusOptions): void;
+    protected handleOpenChange(isOpen: boolean): void;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    abstract readonly controlType: string;
+    abstract readonly supportsAffixes: boolean;
+    get value(): any;
+    set value(value: any);
+    protected _value: any;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    get focused(): boolean;
+    protected _focused: boolean;
+    /** @ignore */
+    writeValue(value: any): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState(isDisabled: boolean): void;
+    protected onFocus(): void;
+    /**
+     * Calls the CVA touched callback only if the dropdown is closed.
+     */
+    protected onBlur(): void;
+    protected clearSelection(): void;
+    protected handleSearchSubmit(evt: Event): void;
+    protected handleSearchUpDown(evt: Event, direction: 'up' | 'down'): void;
+    protected markActive(index: number): void;
+    protected selectedIsSingle(selected: ISelectOption | ISelectOption[]): selected is ISelectOption;
+    private _initializeSelection;
+    private _setSelectionByValue;
+    private _selectOptionByValue;
+    /** Assigns a value to the select control. Returns a boolean indicating whether or not
+     * the value has changed.
+     */
+    private _assignValue;
+    private _resetOptions;
+    private _onSelect;
+    private _sortValues;
+    protected _propagateChanges(fallbackValue?: any): void;
+    protected _buildChangeEvent(value: any): SelectChangeEvent<this>;
+    /** @ignore */
+    protected _deselectOption(option: ISelectOption, markTouched?: boolean): void;
+    private _scrollToSelectedOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<_SelectComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<_SelectComponentBase, never, never, { "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "searchTextChanges": "searchTextChanges"; }, ["staticOptions"], never, true, never>;
+}
+/**
+ * The `SelectComponent` (`<impdc-select`) is a select-style dropdown input where an item (or multiple items) can be picked
+ * from a list of *unique* available options. This component can be used within a `FormFieldComponent` (`<impdc-form-field`).
+ * To use, add `SelectModule` to the `imports` array of the relevant `NgModule` or standalone component.
+ */
+declare class SelectComponent extends _SelectComponentBase implements ISelectValueBadgesParentComponent {
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    constructor(tabIndex?: string);
+    /**
+     * Allow the user to click a button inside of the select control and clear their selection(s);
+     *
+     * @default true
+     */
+    allowClear: boolean;
+    get multiple(): boolean;
+    set multiple(value: boolean);
+    multipleDisplay: 'inside' | 'outside';
+    /** @ignore */
+    deselectOption(option: ISelectOption): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, [{ attribute: "tabindex"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "impdc-select", ["impdcSelect"], { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "search": { "alias": "search"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "dropdownContainer": { "alias": "dropdownContainer"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "allowClear": { "alias": "allowClear"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "multipleDisplay": { "alias": "multipleDisplay"; "required": false; }; }, { "selectionChange": "selectionChange"; "valueChange": "valueChange"; "searchTextChanges": "searchTextChanges"; }, never, never, true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_allowClear: unknown;
+    static ngAcceptInputType_multiple: unknown;
+}
+
+interface ISelectOptionParentComponent {
+    readonly multiple?: boolean;
+}
+declare const IMPDC_SELECT_OPTION_PARENT_COMPONENT: InjectionToken<ISelectOptionParentComponent>;
+interface ISelectValueBadgesParentComponent {
+    readonly selected: ISelectOption | ISelectOption[];
+    readonly selectionChange: Observable<SelectChangeEvent<ISelectValueBadgesParentComponent>>;
+    readonly stateChanges: Observable<void>;
+    readonly disabled: boolean;
+    deselectOption(option: ISelectOption): void;
+}
+declare const IMPDC_SELECT_VALUE_BADGES_PARENT_COMPONENT: InjectionToken<ISelectValueBadgesParentComponent>;
+
+declare class SelectOptionSelectionChangeEvent<T = any> {
+    source: SelectOptionDisplayComponent;
+    isUserInput: boolean;
+    constructor(source: SelectOptionDisplayComponent, isUserInput?: boolean);
+}
+declare class SelectOptionDisplayComponent extends NgbDropdownItem implements ISelectOption, OnDestroy {
+    protected readonly parent: ISelectOptionParentComponent | undefined;
+    private readonly _changeDetector;
+    /** @ignore */
+    readonly stateChanges: Subject<void>;
+    private _selected;
+    private __disabled;
+    /** @ignore */
+    get multiple(): boolean;
+    /** @ignore */
+    get selected(): boolean;
+    set selected(value: boolean | undefined);
+    /**
+     * The specific value represented by the select option.
+     */
+    value: any;
+    /**
+     * Label text describing the select option.
+     */
+    get label(): string;
+    set label(label: string);
+    private _label;
+    groupLabel?: string;
+    highlightText: string | null;
+    /** @ignore */
+    id: string;
+    /**
+     * Used to enable or disable the specific select option.
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /** @ignore */
+    readonly onSelectionChange: EventEmitter<SelectOptionSelectionChangeEvent<any>>;
+    constructor(parent: ISelectOptionParentComponent | undefined, _changeDetector: ChangeDetectorRef);
+    /** @ignore */
+    select(): void;
+    /** @ignore */
+    deselect(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** Ensures the option is selected when activated from the keyboard. */
+    protected handleKeydown(event: KeyboardEvent): void;
+    /**
+     * `Selects the option while indicating the selection came from the user. Used to
+     * determine if the select's view -> model callback should be invoked.`
+     */
+    protected selectViaInteraction(): void;
+    private _emitSelectionChangeEvent;
+    private _isInteractionKeyEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionDisplayComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectOptionDisplayComponent, "impdc-select-option-display", never, { "selected": { "alias": "selected"; "required": false; }; "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "groupLabel": { "alias": "groupLabel"; "required": false; }; "highlightText": { "alias": "highlightText"; "required": false; }; "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onSelectionChange": "onSelectionChange"; }, never, never, true, never>;
+}
+
+declare class SelectValueTagsDisplayComponent implements OnInit, OnChanges, OnDestroy {
+    private readonly _changeDetector;
+    private readonly _parentSelect;
+    private readonly _destroy$;
+    protected readonly BadgeTheme: typeof ComponentTheme;
+    protected truncate: boolean;
+    rounded: boolean;
+    get select(): ISelectValueBadgesParentComponent | null;
+    set select(value: ISelectValueBadgesParentComponent | null);
+    private _select;
+    protected get resolvedSelect(): ISelectValueBadgesParentComponent | null;
+    /**
+     * Render the control is a readonly state.
+     *
+     * Semantically distinct from `disabled`, `readonly` controls will still have their values bound in
+     * Angular forms and `FormGroup`s, whereas a disabled control's value would be omitted.
+     */
+    readonly: boolean;
+    /**
+     * The maximum number of values that will be displayed inline before truncation occurs.
+     */
+    truncateThreshold: number | undefined;
+    /**
+     * Text to be shown when displayed values are truncated, allowing the user to view all selected values.
+     */
+    showMoreLabel: string;
+    /**
+     * Text to be shown when displayed values have been expanded beyond the truncation threshold, allowing
+     * the user collapse the view again.
+     */
+    showLessLabel: string;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    protected toggleTruncate(): void;
+    protected observeStateChanges(select: ISelectValueBadgesParentComponent): void;
+    protected selectedIsMultiple(selected: ISelectOption | ISelectOption[]): selected is ISelectOption[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectValueTagsDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectValueTagsDisplayComponent, "impdc-select-value-tags-display", never, { "rounded": { "alias": "rounded"; "required": false; }; "select": { "alias": "select"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "truncateThreshold": { "alias": "truncateThreshold"; "required": false; }; "showMoreLabel": { "alias": "showMoreLabel"; "required": false; }; "showLessLabel": { "alias": "showLessLabel"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_rounded: unknown;
+}
+
+declare class SelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectModule, never, [typeof SelectOptionGroupComponent, typeof SelectOptionComponent, typeof SelectValueTagsDisplayComponent, typeof SelectComponent], [typeof SelectOptionGroupComponent, typeof SelectOptionComponent, typeof SelectValueTagsDisplayComponent, typeof SelectComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectModule>;
+}
+
+/**
+ * The `TagSelectComponent` (`<impdc-tag-select>`) is a form control where multiple "tag"-like values can
+ * be picked from a list of *unique* available options. This component can be used within a `FormFieldComponent`
+ * (`<impdc-form-field>`) component or on its own. To use, add `TagSelectComponent` to the `imports` array of
+ * the relevant `NgModule` or standalone component.
+ */
+declare class TagSelectComponent extends _SelectComponentBase implements ISelectValueBadgesParentComponent {
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    /**
+     * Render the control is a readonly state.
+     *
+     * Semantically distinct from `disabled`, `readonly` controls will still have their values bound in
+     * Angular forms and `FormGroup`s, whereas a disabled control's value would be omitted.
+     */
+    readonly: boolean;
+    /**
+     * The maximum number of values that will be displayed inline before truncation occurs.
+     */
+    truncateThreshold: number;
+    /**
+     * Text to be shown when displayed values are truncated, allowing the user to view all selected values.
+     */
+    showMoreLabel: string;
+    /**
+     * Text to be shown when displayed values have been expanded beyond the truncation threshold, allowing
+     * the user collapse the view again.
+     */
+    showLessLabel: string;
+    constructor(tabIndex?: string);
+    /** @ignore */
+    deselectOption(option: ISelectOption): void;
+    protected toggleDropdown(evt: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagSelectComponent, [{ attribute: "tabindex"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagSelectComponent, "impdc-tag-select", ["impdcTagSelect"], { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "search": { "alias": "search"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "dropdownContainer": { "alias": "dropdownContainer"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "truncateThreshold": { "alias": "truncateThreshold"; "required": false; }; "showMoreLabel": { "alias": "showMoreLabel"; "required": false; }; "showLessLabel": { "alias": "showLessLabel"; "required": false; }; }, { "selectionChange": "selectionChange"; "valueChange": "valueChange"; "searchTextChanges": "searchTextChanges"; }, never, never, true, never>;
+    static ngAcceptInputType_tabIndex: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_readonly: unknown;
+    static ngAcceptInputType_truncateThreshold: unknown;
+}
+
+/** @docs-private */
+declare function getImpdcFormFieldMissingControlError(): Error;
+
+declare class FeedbackTextCounterComponent {
+    readonly input: i0.InputSignal<InputDirective>;
+    readonly maxLength: i0.InputSignal<number>;
+    protected readonly isText: i0.Signal<boolean>;
+    protected readonly currentLength: i0.Signal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeedbackTextCounterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeedbackTextCounterComponent, "impdc-feedback-text-counter", never, { "input": { "alias": "input"; "required": true; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const FORM_FIELD_FEEDBACK_COMPONENTS: (typeof FeedbackTextCounterComponent)[];
+
+declare class ImpdcFormsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpdcFormsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImpdcFormsModule, never, [typeof i2.CommonModule, typeof FormFieldModule, typeof CheckboxModule, typeof CheckboxGroupModule, typeof RadioModule, typeof SelectModule, typeof TagSelectComponent, typeof InputDirective, typeof FeedbackTextCounterComponent], [typeof FormFieldModule, typeof CheckboxModule, typeof CheckboxGroupModule, typeof RadioModule, typeof SelectModule, typeof TagSelectComponent, typeof InputDirective, typeof FeedbackTextCounterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImpdcFormsModule>;
+}
+
+interface IElementSize {
+    height: number;
+    width: number;
+}
+
+declare class SizeDetectorDirective implements OnDestroy {
+    private readonly _elementRef;
+    readonly resized: EventEmitter<IElementSize>;
+    private _resizeObserver;
+    constructor(_elementRef: ElementRef);
+    ngOnDestroy(): void;
+    private _observe;
+    private _unobserve;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SizeDetectorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SizeDetectorDirective, "[impdcSizeDetector]", never, {}, { "resized": "resized"; }, never, never, false, never>;
+}
+
+declare class SizeDetectionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SizeDetectionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SizeDetectionModule, [typeof SizeDetectorDirective], [typeof i2.CommonModule], [typeof SizeDetectorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SizeDetectionModule>;
+}
+
+/**
+ * The `PaginationComponent` (`<impdc-pagination` or `<div impdc-pagination`) is a control for paged content such as tables or lists.
+ * To use, import `PaginationModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `ModalModule` imports and exports ImpdcFormsModule and [ButtonModule](./?path=/docs/design-components-button).
+ */
+declare class PaginationComponent {
+    private readonly _changeDetectorRef;
+    private readonly _domSanitizer;
+    private _summary;
+    /**
+     * The current page.
+     */
+    page: number;
+    /**
+     * The number of items shown per page. Items are commonly displayed as rows in a table.
+     */
+    perPage: number;
+    /**
+     * The total number of items.
+     */
+    total: number;
+    /**
+     * A formattable text summary of pagination data. `{firstPageResult}` The first item within the current page.
+     * `{lastPageResult}` The last item within the current page. `{total}` The total number of items.
+     */
+    set summary(summary: string);
+    get summary(): string;
+    /**
+     * The label text for the per page select input.
+     */
+    perPageLabel: string;
+    /**
+     * Emitted when the page number is changed, specifying the target page number.
+     */
+    readonly goToPage: EventEmitter<number>;
+    /**
+     * Emitted when the per page is changed, specifying the new value.
+     */
+    readonly perPageChange: EventEmitter<number>;
+    get totalPages(): number;
+    get firstPageResult(): number;
+    get lastPageResult(): number;
+    /** @ignore */
+    mobile: boolean;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    handleResize(size: IElementSize): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    goToExactPageFromEvent({ target }: FocusEvent): void;
+    goToExactPage(page: number | string): void;
+    handlePerPageChange(): void;
+    preventDefaultAndBlur(event: Event): void;
+    private _getPageClamped;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "impdc-pagination, div[impdc-pagination]", never, { "page": { "alias": "page"; "required": false; }; "perPage": { "alias": "perPage"; "required": false; }; "total": { "alias": "total"; "required": false; }; "summary": { "alias": "summary"; "required": false; }; "perPageLabel": { "alias": "perPageLabel"; "required": false; }; }, { "goToPage": "goToPage"; "perPageChange": "perPageChange"; }, never, never, false, never>;
+}
+
+declare class PaginationModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PaginationModule, [typeof PaginationComponent], [typeof i2.CommonModule, typeof ButtonModule, typeof i4.FormsModule, typeof ImpdcFormsModule, typeof IconModule, typeof SizeDetectionModule], [typeof ButtonModule, typeof ImpdcFormsModule, typeof IconModule, typeof PaginationComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PaginationModule>;
+}
+
+declare class ColumnHeadingComponent {
+    isSortable: boolean;
+    columnIndex?: number;
+    sortColumnIndex?: number;
+    direction: 'asc' | 'desc';
+    text: string;
+    get sortedColumn(): boolean;
+    sort: EventEmitter<number>;
+    onSort(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnHeadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnHeadingComponent, "impdc-column-heading", never, { "isSortable": { "alias": "isSortable"; "required": false; }; "columnIndex": { "alias": "columnIndex"; "required": false; }; "sortColumnIndex": { "alias": "sortColumnIndex"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "sort": "sort"; }, never, never, false, never>;
+}
+
+/**
+ * A container component for projecting displays and controls for performing bulk actions upon one
+ * or more selected table rows. Elements to be projected should be decorated with `[selectedTotal]`
+ * and `[bulkAction]` attributes.
+ */
+declare class TableBulkActionsComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBulkActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableBulkActionsComponent, "impdc-table-bulk-actions", never, {}, {}, never, ["[selectedTotal]", "[bulkAction]"], false, never>;
+}
+
+declare class RowActionsComponent {
+    columnDef: ITableActionsColumnDef<any>;
+    rowItem: ITableRowItem;
+    lastColumn: boolean;
+    actionClick: EventEmitter<string>;
+    /** @ignore */
+    branded: boolean;
+    constructor(_branded: BrandedDirective);
+    handleActionClick(apiName: string): void;
+    getColor(action: ITableRowAction): string;
+    protected getButtonThemeFromComponentTheme(componentTheme?: ComponentTheme): ButtonTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowActionsComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RowActionsComponent, "impdc-row-actions", never, { "columnDef": { "alias": "columnDef"; "required": true; }; "rowItem": { "alias": "rowItem"; "required": true; }; "lastColumn": { "alias": "lastColumn"; "required": false; }; }, { "actionClick": "actionClick"; }, never, never, false, never>;
+}
+
+/**
+ * The `TableComponent` (`<impdc-table`) is a data table component.
+ * To use, import `TableModule` from `@impartner/design-components`.
+ */
+declare class TableComponent implements OnChanges {
+    private readonly _datePipe;
+    private readonly _percentPipe;
+    private readonly _decmialPipe;
+    private readonly _changeDetectorRef;
+    private _branded;
+    /**
+     * Whether the table data is currently being loaded. The `<impdc-spinner>` will show if data is loading.
+     */
+    loading: boolean;
+    /**
+     * The visible columns of the table.  Each `ITableColumnDef` defines properties regarding the display, formatting and interaction of the column's cells.
+     * Column/cell color precedence is:
+     * 1) `fieldColor` - allows an `ITableColumnDef` to delegate the responsibility of cell color to an `ITableRowItem` property.
+     * 2) `colorGetter`- allows an `ITableColumnDef` to delegate the responsibility of cell color to a function of the `ITableRowItem` determined by the developer.
+     * 3) `color` - a property of an `ITableColumnDef`.
+     */
+    columnDefs: TableColumnDef<any>[];
+    /**
+     * Whether the table is striped.
+     */
+    striped: boolean;
+    /**
+     * Whether table rows should apply hover styles when hovered over via cursor.
+     */
+    hover: boolean;
+    /**
+     * The layout algorithm to be used when rendering the table.
+     */
+    layout: 'auto' | 'fixed';
+    /**
+     * Whether individual rows can be selected. Will be `true` if explicitly set to `true` or `canSelectAllRows` is `true`.
+     */
+    set canSelectRows(value: boolean);
+    get canSelectRows(): boolean;
+    /**
+     * Whether all rows can be selected at once. Will be `true` if explicitly set to `true` or if `TableBulkActionsComponent` is content projected.
+     */
+    set canSelectAllRows(value: boolean);
+    get canSelectAllRows(): boolean;
+    /**
+     * The placeholder text and empty value display text for `<impdc-select>` instances in cells with a `ITableColumnDef` `columnType` = `SingleSelect` or `MultiSelect`.
+     */
+    selectPlaceholder: string;
+    /**
+     * The `columnDefs` index of the currently sorted column.
+     */
+    sortColumnIndex: number;
+    /**
+     * The direction of the currently sorted column.
+     */
+    sortDirection: 'asc' | 'desc';
+    /**
+     * The table row data as an array of `ITableRowItem`.
+     */
+    tableData: ITableRowItem[];
+    /**
+     * An array of currently selected IDs from the `tableData` input.  Array must be of type `(string | number)[]`.
+     */
+    set selectedRowIds(value: (string | number)[]);
+    get selectedRowIds(): (string | number)[];
+    /**
+     * The registered custom cell renderer components available to be used in the table instance.
+     * For a given `ITableColumnDef` in the `columnDefs` input, the `cellRendererComponent` property should be set to the key of the registered component in this input.
+     */
+    customCellComponents?: ICustomCellRendererComponents;
+    /**
+     * An optional template for content that may be rendered below a row in an collapsible view. Value can either be an Angular template or a function that can evaluated
+     * to resolve to a template. The template will be rendered with a provided `ICollapsibleRowContentContext` object as template context, with the current `ITableRowData`
+     * implicitly available as a default template key.
+     */
+    collapsibleTemplate: TemplateRef<ICollapsibleRowContentContext<any>> | null | ((row: any) => TemplateRef<ICollapsibleRowContentContext<any>> | null);
+    /**
+     * The clickable control that will trigger expansion and collapse of content when using `collapsibleTemplate` functionality.
+     * When set to `button`, the collapsible content's state can only be toggled from a clickable button at the start of the row.
+     * When set to `row`, the entire row will become a clickable trigger.
+     */
+    collapsibleTrigger: 'button' | 'row';
+    /**
+     * Event emitted when one or multiple rows are selected. Emits `(string | number)[]` payload.
+     */
+    readonly rowSelect: EventEmitter<(string | number)[]>;
+    /**
+     * Event emitted when a column is sorted. Emits `ISortByPayload` payload.
+     */
+    readonly sortBy: EventEmitter<ISortByPayload>;
+    /**
+     * Event emitted when a row link is clicked. Emits `ITableEventPayload` payload.
+     */
+    readonly linkClick: EventEmitter<ITableEventPayload<any>>;
+    /**
+     * Event emitted when a row action is clicked. Emits an `ITableRowActionPayload` payload.
+     */
+    readonly rowActionClick: EventEmitter<ITableRowActionPayload<any>>;
+    /**
+     * Event emitted when a row input value is changed. Emitted cells of `columnType` `SingleSelect`, `MultiSelect`, `Input`, `Boolean` or `Icon`.
+     * Not emitted if column definition property `disabled` = `true`. Emits `ITableEventPayload` payload.
+     */
+    readonly inputChange: EventEmitter<ITableEventPayload<any>>;
+    /**
+     * Event emitted when a row with collapsible content has its collapse state changed.
+     */
+    readonly rowCollapseChange: EventEmitter<ITableRowCollapseChange<any>>;
+    /** @ignore */
+    paginationComponent?: PaginationComponent;
+    /** @ignore */
+    bulkActions?: TableBulkActionsComponent;
+    /** @ignore */
+    readonly cellType: typeof TableColumnType;
+    /** @ignore */
+    allSelected: boolean;
+    /** @ignore */
+    get someSelected(): boolean;
+    /** @ignore */
+    readonly branded: boolean;
+    /** @ignore */
+    get tableSpan(): number;
+    private _canSelectRows;
+    private _canSelectAllRows;
+    private _selectedRowIds;
+    private readonly _inputChange;
+    constructor(_datePipe: DatePipe, _percentPipe: PercentPipe, _decmialPipe: DecimalPipe, _changeDetectorRef: ChangeDetectorRef, _branded: BrandedDirective);
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @ignore */
+    getMailToValue(columnIndex: number, currentRow: ITableRowItem): string;
+    /** @ignore */
+    getStringValue(columnIndex: number, currentRow: ITableRowItem): string;
+    /** @ignore */
+    getValue(columnIndex: number, currentRow: ITableRowItem): string | string[];
+    /** @ignore */
+    getRawValue(columnIndex: number, currentRow: ITableRowItem): ITableRowItemValueTypes;
+    /** @ignore */
+    getCellColor(columnDefinition: TableColumnDef, item: ITableRowItem): string;
+    /** @ignore */
+    getTheme(columnDefinition: TableColumnDef, item: ITableRowItem): ComponentTheme;
+    /** @ignore */
+    isSortedColumn(columnIndex: number): boolean;
+    /** @ignore */
+    isRowSelected(id: string | number): boolean;
+    /** @ignore */
+    handleSelectAll(event: CheckboxChangeEvent): void;
+    /** @ignore */
+    handleSort(columnIndex: number): void;
+    /** @ignore */
+    handleRowSelect(event: CheckboxChangeEvent, rowId: number | string): void;
+    /** @ignore */
+    handleCellValueChange(columnIndex: number, rowIndex: number, value: string | number | boolean | string[]): void;
+    /** @ignore */
+    handleLinkClick(columnIndex: number, item: ITableRowItem, event: Event): void;
+    /** @ignore */
+    handleActionClick(columnIndex: number, item: ITableRowItem, actionApiName: string): void;
+    protected columnDefIsActions(columnDef: TableColumnDef<any>): columnDef is ITableActionsColumnDef<any>;
+    protected tryToggleCollapse(collapsibleForRowResult: {
+        template: TemplateRef<ICollapsibleRowContentContext> | null;
+    }, ngbCollapse: NgbCollapse, event: Event, source: 'button' | 'row'): void;
+    protected getCollapsibleTemplateForRow(row: ITableRowItem): {
+        template: TemplateRef<ICollapsibleRowContentContext> | null;
+    };
+    private _getColumnDefByIndex;
+    private _getValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, [null, null, null, null, { optional: true; host: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "impdc-table", never, { "loading": { "alias": "loading"; "required": false; }; "columnDefs": { "alias": "columnDefs"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "canSelectRows": { "alias": "canSelectRows"; "required": false; }; "canSelectAllRows": { "alias": "canSelectAllRows"; "required": false; }; "selectPlaceholder": { "alias": "selectPlaceholder"; "required": false; }; "sortColumnIndex": { "alias": "sortColumnIndex"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "tableData": { "alias": "tableData"; "required": false; }; "selectedRowIds": { "alias": "selectedRowIds"; "required": false; }; "customCellComponents": { "alias": "customCellComponents"; "required": false; }; "collapsibleTemplate": { "alias": "collapsibleTemplate"; "required": false; }; "collapsibleTrigger": { "alias": "collapsibleTrigger"; "required": false; }; }, { "rowSelect": "rowSelect"; "sortBy": "sortBy"; "linkClick": "linkClick"; "rowActionClick": "rowActionClick"; "inputChange": "inputChange"; "rowCollapseChange": "rowCollapseChange"; }, ["paginationComponent", "bulkActions"], ["impdc-table-bulk-actions", "[impdcTableBulkActions]", "[noData]", "impdc-pagination, div[impdc-pagination]"], false, never>;
+}
+
+declare class TableInjectComponentDirective implements OnInit {
+    private readonly _viewContainerRef;
+    private readonly _componentFactoryResolver;
+    columnDef: TableColumnDef;
+    value: ITableRowItemValueTypes;
+    rowItem: ITableRowItem;
+    customCellComponents: ICustomCellRendererComponents;
+    constructor(_viewContainerRef: ViewContainerRef, _componentFactoryResolver: ComponentFactoryResolver);
+    ngOnInit(): void;
+    private _renderCustomCell;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableInjectComponentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableInjectComponentDirective, "[impdcTableInjectComponent]", never, { "columnDef": { "alias": "columnDef"; "required": true; }; "value": { "alias": "value"; "required": false; }; "rowItem": { "alias": "rowItem"; "required": false; }; "customCellComponents": { "alias": "customCellComponents"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+/**
+ * The `SpinnerComponent` (`<impdc-spinner` or `<div impdc-spinner`) is used when data is processing and content isn't ready to be interacted with yet.
+ * To use, import `SpinnerModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class SpinnerComponent {
+    /**
+     * Accessibility text used by screen readers.
+     */
+    accessibilityText: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "impdc-spinner, div[impdc-spinner]", never, { "accessibilityText": { "alias": "accessibilityText"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SpinnerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SpinnerModule, [typeof SpinnerComponent], [typeof i2.CommonModule], [typeof SpinnerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SpinnerModule>;
+}
+
+declare class TableModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TableModule, [typeof CollapseMonitorDirective, typeof TableDirective, typeof FilterTableRowActionsPipe, typeof TableComponent, typeof ColumnHeadingComponent, typeof TableInjectComponentDirective, typeof TableBulkActionsComponent, typeof RowActionsComponent], [typeof i2.CommonModule, typeof ButtonModule, typeof PaginationModule, typeof IconModule, typeof ImpdcFormsModule, typeof i4.FormsModule, typeof SpinnerModule, typeof BadgeModule, typeof BrandingModule, typeof i18.NgbDropdownModule, typeof i18.NgbCollapseModule], [typeof ButtonModule, typeof TableDirective, typeof ColumnHeadingComponent, typeof TableBulkActionsComponent, typeof PaginationModule, typeof TableComponent, typeof IconModule, typeof TableInjectComponentDirective, typeof BrandingModule, typeof RowActionsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TableModule>;
+}
+
+/**
+ * @deprecated (v4.0.0) This component and its related components/modules should not be used, and instead should be replaced with NbgDropdownItem and its related directives from the `@ng-bootstrap/ng-bootstrap` package.
+ */
+declare class DropdownItemComponent {
+    /**
+     * Used in DropdownComponent to determine if the projected content should be rendered or it's a divider.
+     */
+    divider: boolean;
+    template: TemplateRef<never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownItemComponent, "impdc-dropdown-item", never, { "divider": { "alias": "divider"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+type DropdownPosition = 'down' | 'right' | 'left' | 'up';
+
+/**
+ * The `DropdownComponent` (`<impdc-dropdown` or `<any impdc-dropdown`) contains a button that toggles a dropdown where a user
+ * can select various actions. Items within must be wrapped with `DropdownItemComponent` (`<impdc-dropdown-item`).
+ * To use, import `DropdownModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `DropdownModule` imports and exports [ButtonModule](./?path=/docs/design-components-button).
+ *
+ * ### Deprecation Notice
+ *
+ * As of `@impartner/design-components` release v4, this component is deprecated. It is recommended to instead use the
+ * `NgbDropdown` component from `@ng-bootstrap/ng-bootstrap`. [Read here](./?path=/docs/ng-bootstrap-dropdown--docs)
+ * for our documentation and examples of using that package to build dropdowns in Hex.
+ *
+ * @deprecated (v4.0.0) This component and its related components/modules should not be used, and instead should be replaced with NbgDropdown and its related directives from the `@ng-bootstrap/ng-bootstrap` package.
+ */
+declare class DropdownComponent implements OnInit, OnDestroy, IInteractableComponent {
+    private _interactionService;
+    private readonly _interactableId;
+    private _initialized;
+    /**
+     * Whether or not the dropdown list is showing.
+     */
+    show: boolean;
+    /**
+     * The content projected `DropdownItemComponent` children.
+     */
+    items: QueryList<DropdownItemComponent>;
+    /**
+     * The theme of the button affecting text, icons, backgrounds, and borders.
+     */
+    buttonTheme: ButtonTheme;
+    /**
+     * The text of the button.
+     */
+    buttonText: string;
+    /**
+     * Where the list shows relative to the button when it is showing.
+     */
+    position: DropdownPosition;
+    /**
+     * If true, the icon is split from the button and only clicking the icon triggers the list showing/hiding.
+     */
+    split: boolean;
+    /**
+     * Emitted when the dropdown is toggled.
+     */
+    toggle: EventEmitter<boolean>;
+    /**
+     * Emitted when the button is clicked.
+     */
+    buttonClick: EventEmitter<MouseEvent>;
+    private classBtnGroup;
+    private get classDropdown();
+    private get classDropend();
+    private get classDropstart();
+    private get classDropup();
+    handleHostClick($event: MouseEvent): void;
+    handleDocumentClick(): void;
+    constructor(_interactionService: InteractionService);
+    get interactableId(): string;
+    get valid(): boolean;
+    get shown(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleToggle(): void;
+    handleButtonClick(event: MouseEvent): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "impdc-dropdown, [impdc-dropdown]", ["impdcDropdown"], { "show": { "alias": "show"; "required": false; }; "buttonTheme": { "alias": "buttonTheme"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "position": { "alias": "position"; "required": false; }; "split": { "alias": "split"; "required": false; }; }, { "toggle": "toggle"; "buttonClick": "buttonClick"; }, ["items"], ["*", "[toggle]"], false, never>;
+}
+
+/**
+ * @deprecated (v4.0.0) This module and its components should not be used, and instead should be replaced with NbgDropdownModule and its related directives from the `@ng-bootstrap/ng-bootstrap` package.
+ */
+declare class DropdownModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DropdownModule, [typeof DropdownItemComponent, typeof DropdownComponent], [typeof i2.CommonModule, typeof ButtonModule], [typeof ButtonModule, typeof DropdownItemComponent, typeof DropdownComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DropdownModule>;
+}
+
+type AlertTheme = 'warning' | 'danger' | 'info' | 'success';
+
+/**
+ * The `AlertComponent` (`<impdc-alert` or `<any impdc-alert`) is intended to show information or feedback inline with content.
+ * To use, import `AlertModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class AlertComponent {
+    /**
+     * The theme of the Alert affecting text, icons, backgrounds, and borders.
+     */
+    theme: AlertTheme;
+    /**
+     * Determines if the Alert should be shown immediately.
+     */
+    show: boolean;
+    /**
+     * The heading text of the Alert. Content can also be projected in the heading area using a `heading` directive.
+     */
+    headingText: string;
+    /**
+     * The body text of the Alert. Content can also be projected into the body area using default projection.
+     */
+    bodyText: string;
+    /**
+     * By default, an Alert is a "floating" notification. When set to "inline", these "floating" styles are replaced.
+     */
+    inline: boolean;
+    /**
+     * Removes the Alert icon provided by the theme or projected into the icon area using the `icon` directive.
+     */
+    hideIcon: boolean;
+    /**
+     * Removes the Alert border and background colors to only style icon and text according to theme.
+     */
+    borderless: boolean;
+    /**
+     * Allows the Alert to be dismissed.
+     */
+    dismissible: boolean;
+    /**
+     * Event emitted when the Alert is dismissed.
+     */
+    dismiss: EventEmitter<void>;
+    get componentClasses(): string;
+    get themeIconName(): string;
+    closeAlert(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "impdc-alert, [impdc-alert]", never, { "theme": { "alias": "theme"; "required": false; }; "show": { "alias": "show"; "required": false; }; "headingText": { "alias": "headingText"; "required": false; }; "bodyText": { "alias": "bodyText"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "hideIcon": { "alias": "hideIcon"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; }, { "dismiss": "dismiss"; }, never, ["[icon]", "[heading]", "*", "[action]"], false, never>;
+}
+
+declare class AlertModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AlertModule, [typeof AlertComponent], [typeof i2.CommonModule, typeof IconModule], [typeof IconModule, typeof AlertComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AlertModule>;
+}
+
+declare const ModalComponentSizesArr: ComponentSize[];
+type ModalComponentSizes = (typeof ModalComponentSizesArr)[number];
+
+declare enum ModalTheme {
+    Simple = "simple",
+    Working = "working",
+    Destructive = "destructive"
+}
+declare const ModalThemesArr: ModalTheme[];
+type ModalThemes = (typeof ModalThemesArr)[number];
+
+/**
+ * The `ModalComponent` (`<impdc-modal`) displays over the content of the page when a user action is required.
+ * To use, import `ModalModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `ModalModule` imports and exports BackdropModule, [ButtonModule](./?path=/docs/design-components-button),
+ * and [IconModule](./?path=/docs/design-components-icon).
+ *
+ * In addition,it is recommended to include `provideImpdcModalAppInitializer()` in the application's root environment providers.
+ * [Read here](./?path=/docs/ng-bootstrap-modal--docs#use-the-provideimpdcmodalappinitializer-app-initializer) for more details.
+ *
+ * ### Deprecation Notice
+ *
+ * As of `@impartner/design-components` release v4, this component is deprecated. It is recommended to instead use the
+ * `ModalLayoutComponent` component for modal content layouts and the `NgbModal` service from `@ng-bootstrap/ng-bootstrap`
+ * for creating and managing modal instances. [Read here](./?path=/docs/ng-bootstrap-modal--docs) for our
+ * documentation and examples of using that package to build modals in Hex.
+ *
+ * @deprecated (v4.0.0) This component and its related module should not be used, and instead should be replaced with ModalLayoutComponent for layouting and the NgbModal service from the `@ng-bootstrap/ng-bootstrap` package for creating and managing modal instances.
+ */
+declare class ModalComponent implements OnInit, OnDestroy, IInteractableComponent {
+    private readonly _interactionService;
+    private readonly _elementRef;
+    private readonly _interactableId;
+    private readonly _closed$;
+    private _initialized;
+    private _show;
+    private _dialogElementRef?;
+    /**
+     * Determines if the Modal should be shown immediately.
+     */
+    set show(show: boolean);
+    get show(): boolean;
+    /**
+     * The theme of the Modal. Affects the layout of the Modal as well as some colors.
+     */
+    theme: ModalThemes;
+    /**
+     * The size of the Modal.
+     */
+    size: ModalComponentSizes;
+    /**
+     * Whether to vertically center the modal.
+     */
+    centered: boolean;
+    /**
+     * The Font Awesome 5 icon name. Only supported when the theme is Working or Destructive.
+     */
+    iconName?: FontAwesomeIcon;
+    /**
+     * The Font Awesome 5 icon style. Fewer icons support the Regular theme and will fallback to Solid
+     * if not supported.
+     */
+    iconTheme: FontAwesomeIconTheme;
+    /**
+     * The subject text of the Modal.
+     */
+    titleText: string;
+    /**
+     * The fallback button text to accept the Modal. This is bypassed if you content-project the accept button.
+     */
+    acceptText: string;
+    /**
+     * Allows the Modal to be dismissed. This is different from `accept` and `deny`. If a Modal is meant to be re-opened frequently it should be dismissable.
+     */
+    dismissable?: boolean;
+    /**
+     * Determines if the Modal should fade in/out.
+     */
+    fade: boolean;
+    /**
+     * Shows a backdrop behind the Modal.
+     */
+    backdrop: boolean;
+    /**
+     * When `true`, Modal will not automatically render a fallback "accept" button in the footer.
+     */
+    noFallback: boolean;
+    /**
+     * Contains the dismiss button content projection.
+     */
+    dismissEl: ElementRef;
+    /**
+     * Contains the deny button content projection.
+     */
+    denyEl: ElementRef;
+    /**
+     * Contains the accept button content projection.
+     */
+    acceptEl: ElementRef;
+    /**
+     * Event emitted when the Modal content is dismissed.
+     */
+    dismiss: EventEmitter<Event | MouseEvent>;
+    /**
+     * Event emitted when the Modal content is denied.
+     */
+    deny: EventEmitter<Event | MouseEvent>;
+    /**
+     * Event emitted when the Modal content is accepted.
+     */
+    accept: EventEmitter<Event | MouseEvent>;
+    constructor(_interactionService: InteractionService, _elementRef: ElementRef<HTMLElement>);
+    get interactableId(): string;
+    get valid(): boolean;
+    get shown(): boolean;
+    get showWorkingIcon(): boolean;
+    get showDestructiveIcon(): boolean;
+    get acceptFallbackTheme(): ButtonTheme;
+    get hideHeader(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected handleDismiss(event: MouseEvent | Event): void;
+    protected handleDeny(event: MouseEvent | Event): void;
+    protected handleAccept(event: MouseEvent | Event): void;
+    /**
+     * Opens/shows the modal. Can be used programmatically.
+     */
+    open(): void;
+    /**
+     * Closes/hides the modal. Can be used programmatically.
+     */
+    close(): void;
+    private _setupEventHandling;
+    private _disableEventHandling;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "impdc-modal", never, { "show": { "alias": "show"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "size": { "alias": "size"; "required": false; }; "centered": { "alias": "centered"; "required": false; }; "iconName": { "alias": "iconName"; "required": false; }; "iconTheme": { "alias": "iconTheme"; "required": false; }; "titleText": { "alias": "titleText"; "required": false; }; "acceptText": { "alias": "acceptText"; "required": false; }; "dismissable": { "alias": "dismissable"; "required": false; }; "fade": { "alias": "fade"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "noFallback": { "alias": "noFallback"; "required": false; }; }, { "dismiss": "dismiss"; "deny": "deny"; "accept": "accept"; }, never, ["*", "[dismiss]", "[deny]", "[accept]"], false, never>;
+}
+
+/**
+ * The `BackdropComponent` (`<impdc-backdrop`) is a component to mask the background when an interaction is taking place.
+ * This component needs to be added to the body of the host application if a backdrop is desired.
+ * To use, import `BackdropModule` or another module that imports and exports that module from `@impartner/design-components`.
+ *
+ * @deprecated (v4.0.0) This component and its module have been deprecated alongside `ModalComponent`; they should no longer be used for new development.
+ */
+declare class BackdropComponent implements OnInit, OnDestroy, IBackdropComponent {
+    private readonly _interactionService;
+    private readonly _ngDestroy;
+    private readonly _showBackdrop;
+    protected readonly _valid: i0.WritableSignal<boolean>;
+    get valid(): boolean;
+    protected readonly show: i0.Signal<boolean>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    invalidate(): void;
+    validate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BackdropComponent, "impdc-backdrop", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated (v4.0.0) This module and its component have been deprecated alongside `ModalComponent`; they should no longer be used for new development.
+ */
+declare class BackdropModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackdropModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BackdropModule, never, [typeof BackdropComponent], [typeof BackdropComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BackdropModule>;
+}
+
+/**
+ * `ModalLayoutComponent` (`<impdc-modal-layout>`) is a simple component for constructing modal
+ * dialog layouts using basic inputs and content projection.
+ *
+ * - Title elements (icon, text, dismiss button) are managed by component inputs.
+ * - Body content is projected by selecting elements with the `slot="body"` element attribute/value pair.
+ * - Footer content is projected by selecting elements with the `slot="footer"` element attribute/value pair.
+ *   - Footer elements are justified toward the end of the footer container by default. Usage of margin styles
+ *     is encouraged if one or more elements should be justified toward the beginning.
+ *
+ * To use, directly import the standalone component class or `ModalModule`.
+ */
+declare class ModalLayoutComponent implements OnInit {
+    private readonly _ngbModal;
+    private readonly _uid;
+    protected readonly headingId: string;
+    /**
+     * The name of a Font Awesome 5 icon to be displayed in the heading of the modal.
+     * Only displayed when `theme` is `'working'` or `'destructive'`.
+     */
+    readonly iconName: i0.InputSignal<string | undefined>;
+    /**
+     * The display style of the displayed Font Awesome 5 icon. Not all icons support all themes,
+     * and will fallback to `'solid'` style if necessary.
+     */
+    readonly iconTheme: i0.InputSignal<string>;
+    /**
+     * The theme of the modal. Affects the layout of the modal as well as some colors.
+     */
+    readonly theme: i0.InputSignal<"simple" | "working" | "destructive" | ModalTheme>;
+    /**
+     * The title/subject text of the modal.
+     */
+    readonly titleText: i0.InputSignal<string>;
+    /**
+     * Whether to display a button element in the top-right corner for the user to signal
+     * they wish to dismiss/close the modal.
+     */
+    readonly showCornerDismiss: i0.InputSignal<boolean | undefined>;
+    /**
+     * Event emitted when the user clicks the corner close/dismiss button.
+     */
+    readonly dismissRequested: i0.OutputEmitterRef<Event | MouseEvent>;
+    protected readonly computedShowCornerDismiss: i0.Signal<boolean>;
+    protected readonly computedHideHeader: i0.Signal<boolean>;
+    protected readonly computedShowWorkingIcon: i0.Signal<boolean>;
+    ngOnInit(): void;
+    protected handleDismiss(event: MouseEvent | Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalLayoutComponent, "impdc-modal-layout", never, { "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "iconTheme": { "alias": "iconTheme"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "showCornerDismiss": { "alias": "showCornerDismiss"; "required": false; "isSignal": true; }; }, { "dismissRequested": "dismissRequested"; }, never, ["[slot=body]", "[slot=footer]"], true, never>;
+}
+
+declare class ModalModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ModalModule, [typeof ModalComponent], [typeof i2.CommonModule, typeof i4.FormsModule, typeof BackdropModule, typeof ButtonModule, typeof IconModule, typeof ModalLayoutComponent], [typeof BackdropModule, typeof ButtonModule, typeof IconModule, typeof ModalComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ModalModule>;
+}
+
+declare class FileDropDirective {
+    fileHovering: boolean;
+    filesDropped: EventEmitter<FileList>;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    OnDrop(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FileDropDirective, "[impdcFileDrop]", never, {}, { "filesDropped": "filesDropped"; }, never, never, false, never>;
+}
+
+declare const _FileUploadComponentBase: _impartner_design_components.Constructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.AbstractConstructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.Constructor<_impartner_design_components.CanDisable> & _impartner_design_components.AbstractConstructor<_impartner_design_components.CanDisable> & _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `FileUploadComponent` (`<impdc-file-upload` or `<any impdc-file-upload`) is a file selector that supports drag and drop.
+ * To use, import `FileUploadModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class FileUploadComponent extends _FileUploadComponentBase implements ControlValueAccessor, Validator, ImpdcFormFieldControl<File | File[]>, ICanUpdateErrorState, IHasErrorState, DoCheck, OnDestroy {
+    private readonly _changeDetector;
+    protected fileDropElementRef: ElementRef<HTMLElement>;
+    /** @ignore */
+    fileUploadInputEltRef: ElementRef<HTMLInputElement>;
+    /**
+     * Whether the control supports uploading multiple files.
+     */
+    multiple: boolean;
+    /**
+     * The instructional text to display in the file upload dropzone.
+     */
+    uploadText: string;
+    /**
+     * The comma-delimited list of file types that are accepted by the control.
+     */
+    accept: string;
+    errorStateMatcher: ErrorStateMatcher;
+    get canUpload(): boolean;
+    private get acceptTypes();
+    get empty(): boolean;
+    protected get filesForDisplay(): readonly File[];
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    private _uid;
+    constructor(_changeDetector: ChangeDetectorRef, _defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null);
+    /** @ignore */
+    handleChange(event: Event): void;
+    /** @ignore */
+    handleDrop(event: FileList): void;
+    /** @ignore */
+    removeFile(fileIndex: number): void;
+    /** @ignore */
+    focus(options?: FocusOptions): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /**
+     * The file(s) currently uploaded into the control. Returns `File | null` when `multiple` is `false`,
+     * and `File[]` when `multiple` is `true`.
+     */
+    get value(): File | File[] | null;
+    set value(newValue: File | File[] | null);
+    private _value;
+    /** @ignore */
+    get id(): string;
+    set id(value: string);
+    private _id;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    get focused(): boolean;
+    private _focused;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    /** @ignore */
+    writeValue(value: File[]): void;
+    /** @ignore */
+    registerOnChange(fn: Function): void;
+    /** @ignore */
+    registerOnTouched(fn: Function): void;
+    /** @ignore */
+    setDisabledState?(isDisabled: boolean): void;
+    /**
+     * @ignore
+     */
+    validate(): ValidationErrors | null;
+    protected _onFocus(): void;
+    protected _onBlur(): void;
+    private _updateValueFromInteraction;
+    private _mergeNewFilesWithExistingFiles;
+    private _getFileList;
+    private _getExtensions;
+    private _acceptedFileType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadComponent, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploadComponent, "impdc-file-upload, [impdc-file-upload]", never, { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "uploadText": { "alias": "uploadText"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HumanReadableByteSizePipe implements PipeTransform {
+    transform(bytes: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HumanReadableByteSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HumanReadableByteSizePipe, "humanReadableByteSize", false>;
+}
+
+declare class FileUploadModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FileUploadModule, [typeof FileDropDirective, typeof FileUploadComponent, typeof HumanReadableByteSizePipe], [typeof i2.CommonModule, typeof i4.FormsModule, typeof ButtonModule, typeof IconModule], [typeof IconModule, typeof FileDropDirective, typeof FileUploadComponent, typeof HumanReadableByteSizePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FileUploadModule>;
+}
+
+/**
+ * The `AvatarComponent` (`<impdc-avatar`) is a rounded user avatar/icon with an optional status color.
+ * For a horizontal container, see [AvatarGroupComponent](./?path=/docs/design-components-avatar--group).
+ * To use, import `AvatarModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class AvatarComponent {
+    /**
+     * The image source url to display as the Avatar's background.
+     */
+    imgSrc: string;
+    /**
+     * Initials to display if an `imgSrc` is not available.
+     */
+    initials: string;
+    /**
+     * A status to display as part of the Avatar.
+     */
+    status: '' | 'active' | 'inactive' | 'busy';
+    /**
+     * The size of the Avatar.
+     */
+    size: PrimaryComponentSizes;
+    get avatarHasImg(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarComponent, "impdc-avatar", never, { "imgSrc": { "alias": "imgSrc"; "required": false; }; "initials": { "alias": "initials"; "required": false; }; "status": { "alias": "status"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarModule, [typeof AvatarComponent], [typeof i2.CommonModule, typeof IconModule], [typeof IconModule, typeof AvatarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AvatarModule>;
+}
+
+/**
+ * The `AvatarGroupComponent` (`<impdc-avatar-group`) is a horizontal container for [AvatarComponent](./?path=/docs/design-components-avatar--single).
+ * To use, import `AvatarGroupModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `AvatarGroupModule` also imports and exports [AvatarModule](./?path=/docs/design-components-avatar--single)
+ */
+declare class AvatarGroupComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarGroupComponent, "impdc-avatar-group", never, {}, {}, never, ["impdc-avatar"], false, never>;
+}
+
+declare class AvatarGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarGroupModule, [typeof AvatarGroupComponent], [typeof i2.CommonModule, typeof AvatarModule], [typeof AvatarModule, typeof AvatarGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AvatarGroupModule>;
+}
+
+declare class BreadcrumbItemComponent {
+    contentTemplate: TemplateRef<never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbItemComponent, "impdc-breadcrumb-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+/**
+ * The `BreadcrumbComponent` (`<impdc-breadcrumb` or `<div impdc-breadcrumb`) is for historical navigation so the user can get back
+ * to a previous page. Items within must be wrapped with `BreadcrumbItemComponent` (`<impdc-breadcrumb-item`).
+ * To use, import `BreadcrumbModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class BreadcrumbComponent implements AfterViewInit {
+    private _changeDetectorRef;
+    /**
+     * Sets the `aria-label` attribute for the Breadcrumb's `nav` element for accessibility.
+     */
+    label: string;
+    private impdcBreadcrumb;
+    protected breadcrumbItems: QueryList<BreadcrumbItemComponent>;
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "impdc-breadcrumb, div[impdc-breadcrumb]", never, { "label": { "alias": "label"; "required": false; }; }, {}, ["breadcrumbItems"], never, false, never>;
+}
+
+declare class BreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbModule, [typeof BreadcrumbItemComponent, typeof BreadcrumbComponent], [typeof i2.CommonModule], [typeof BreadcrumbItemComponent, typeof BreadcrumbComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BreadcrumbModule>;
+}
+
+interface IDatetimePickerValue<TDate = NgbDateStruct, TTime = NgbTimeStruct> {
+    readonly date: TDate | null;
+    readonly time?: TTime | null;
+}
+
+interface ITimeOptions {
+    readonly border: boolean;
+    readonly layout: 'inline' | 'stacked';
+}
+declare const _DatetimePickerComponentBase: _impartner_design_components.Constructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.AbstractConstructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.Constructor<_impartner_design_components.CanDisable> & _impartner_design_components.AbstractConstructor<_impartner_design_components.CanDisable> & _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * A control for selecting date or datetime via an inline calendar control.
+ *
+ * Implements [ControlValueAccessor](https://angular.io/api/forms/ControlValueAccessor) to support two-way binding with
+ * Angular forms via usage of the \`[(ngModel)]\`, \`[formControl]\`, and \`[formControlName]\` directives.
+ *
+ * The date and time controls inside this component leverage the value adapter patterns and services of NG-Bootstrap's
+ * [Datepicker](https://ng-bootstrap.github.io/#/components/datepicker/overview#date-model) and
+ * [Timepicker](https://ng-bootstrap.github.io/#/components/timepicker/examples#adapter) components when working with input values.
+ * This means that `date` values will be [NgbDateStruct](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateStruct)
+ * objects and `time` values will be [NgbTimeStruct](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeStruct) objects
+ * by default, and the [NgbDateAdapter](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateAdapter) and
+ * [NgbTimeAdapter](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeAdapter) services will be used to handle them respectively.
+ * If usage of alternative date and time models is desired, consult NG-Bootstrap's documentation for directions.
+ */
+declare class DatetimePickerComponent extends _DatetimePickerComponentBase implements ControlValueAccessor, DoCheck, OnChanges, OnDestroy, OnInit, ImpdcFormFieldControl<IDatetimePickerValue<any, any> | null>, ICanUpdateErrorState, IHasErrorState {
+    private readonly _changeDetector;
+    private readonly _destroyRef;
+    private readonly _hostElement;
+    private readonly _ngbDateAdapter;
+    private readonly _uid;
+    private _previousControl?;
+    protected readonly formGroup: i4.FormGroup<{
+        date: FormControl<any>;
+        time: FormControl<any>;
+        use24hrTime: FormControl<boolean>;
+    }>;
+    protected cvaOnChange: (_: any) => void;
+    protected cvaOnTouched: () => void;
+    protected ngbDatepicker: NgbDatepicker;
+    /**
+     * A callback function that can be evaluated to decide if a given date is disabled
+     * in the calendar view.
+     *
+     * @param date An [`NgbDate`](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDate) value describing the singular date being evaluated.
+     * @param current The month and year selected for the current calendar view.
+     */
+    markDateDisabled?: (date: NgbDateStruct, current?: {
+        month: number;
+        year: number;
+    }) => boolean;
+    /**
+     * The earliest allowable date for display or selection.
+     *
+     * @default { year: 1900, month: 1, day: 1 }
+     */
+    get minDate(): NgbDateStruct;
+    set minDate(value: NgbDateStruct | null);
+    private _minDate;
+    /**
+     * The latest allowable date for display or selection.
+     *
+     * @default { year: 2099, month: 12, day: 31 }
+     */
+    get maxDate(): NgbDateStruct;
+    set maxDate(value: NgbDateStruct | null);
+    private _maxDate;
+    /**
+     * Configurable options for setting the layout of the date and time controls within the component.
+     */
+    get timeLayout(): ITimeOptions;
+    set timeLayout(value: Partial<ITimeOptions>);
+    private _timeLayout;
+    /**
+     * Label to be displayed with time controls to allow the user to input 24-hour or meridian-based (AM, PM) time.
+     */
+    meridianToggleLabel: string;
+    /**
+     * Set whether to display controls for selecting a time value in addition to the date.
+     */
+    withTime: boolean;
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Events fire when raw value of picker input changes. Mainly exists to handle
+     * two-way binding of `value` input property.
+     * @ignore
+     */
+    readonly valueChange: EventEmitter<IDatetimePickerValue<any, any> | null>;
+    /** @ignore */
+    readonly blur: EventEmitter<FocusEvent>;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+    /** @ignore */
+    focus(): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    writeValue(obj: IDatetimePickerValue<any, any> | any): void;
+    /** @ignore */
+    registerOnChange(fn: any): void;
+    /** @ignore */
+    registerOnTouched(fn: any): void;
+    /** @ignore */
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): IDatetimePickerValue<any, any> | null;
+    set value(value: IDatetimePickerValue<any, any> | null);
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    get focused(): boolean;
+    protected _focused: boolean;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    protected get use24hrTime(): boolean;
+    protected get use24hrTimeLabelText(): string;
+    protected handleFocusOut(evt: FocusEvent): void;
+    private _getValueFromFormModel;
+    private _dateIsOutsideCurrentMonth;
+    protected readonly markDateDisabledFn: (date: NgbDateStruct, current?: {
+        month: number;
+        year: number;
+    }) => boolean;
+    protected _onFocus(): void;
+    protected _onBlur(focusEvent: FocusEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimePickerComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimePickerComponent, "impdc-datetime-picker", never, { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "markDateDisabled": { "alias": "markDateDisabled"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "timeLayout": { "alias": "timeLayout"; "required": false; }; "meridianToggleLabel": { "alias": "meridianToggleLabel"; "required": false; }; "withTime": { "alias": "withTime"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "valueChange": "valueChange"; "blur": "blur"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+}
+
+interface IDatetimePickerPopupButtonLabels {
+    readonly cancelLabel: string;
+    readonly clearLabel: string;
+    readonly saveLabel: string;
+}
+declare const _DatetimePickerInputComponentBase: _impartner_design_components.Constructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.AbstractConstructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.Constructor<_impartner_design_components.CanDisable> & _impartner_design_components.AbstractConstructor<_impartner_design_components.CanDisable> & _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * A control for selecting date or datetime via an interactive dropdown control.
+ *
+ * Implements [ControlValueAccessor](https://angular.io/api/forms/ControlValueAccessor) to support two-way binding with
+ * Angular forms via usage of the \`[(ngModel)]\`, \`[formControl]\`, and \`[formControlName]\` directives.
+ *
+ * The date and time controls inside this component leverage the value adapter patterns and services of NG-Bootstrap's
+ * [Datepicker](https://ng-bootstrap.github.io/#/components/datepicker/overview#date-model) and
+ * [Timepicker](https://ng-bootstrap.github.io/#/components/timepicker/examples#adapter) components when working with input values.
+ * This means that `date` values will be [NgbDateStruct](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateStruct)
+ * objects and `time` values will be [NgbTimeStruct](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeStruct) objects
+ * by default, and the [NgbDateAdapter](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateAdapter) and
+ * [NgbTimeAdapter](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeAdapter) services will be used to handle them respectively.
+ * If usage of alternative date and time models is desired, consult NG-Bootstrap's documentation for directions.
+ */
+declare class DatetimePickerInputComponent extends _DatetimePickerInputComponentBase implements ControlValueAccessor, DoCheck, OnChanges, OnDestroy, OnInit, ImpdcFormFieldControl<IDatetimePickerValue<any, any> | null>, ICanUpdateErrorState, IHasErrorState {
+    private readonly _changeDetector;
+    private readonly _destroyRef;
+    private readonly _ngbDateAdapter;
+    private readonly _ngbTimeAdapter;
+    private readonly _datetimeFormatter;
+    private readonly _uid;
+    private _previousControl?;
+    private _dropdownOpen;
+    protected readonly datetimePickerControl: FormControl<IDatetimePickerValue<any, any> | null>;
+    protected cvaOnChange: (_: any) => void;
+    protected cvaOnTouched: () => void;
+    protected _toggleButtonRef: ElementRef<HTMLButtonElement>;
+    /**
+     * A callback function that can be evaluated to decide if a given date is disabled
+     * in the calendar view.
+     *
+     * @param date An [`NgbDate`](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDate) value describing the singular date being evaluated.
+     * @param current The month and year selected for the current calendar view.
+     */
+    markDateDisabled?: (date: NgbDateStruct, current?: {
+        month: number;
+        year: number;
+    }) => boolean;
+    /**
+     * The earliest allowable date for display or selection.
+     *
+     * @default { year: 1900, month: 1, day: 1 }
+     */
+    get minDate(): NgbDateStruct;
+    set minDate(value: NgbDateStruct | null);
+    private _minDate;
+    /**
+     * The latest allowable date for display or selection.
+     *
+     * @default { year: 2099, month: 12, day: 31 }
+     */
+    get maxDate(): NgbDateStruct;
+    set maxDate(value: NgbDateStruct | null);
+    private _maxDate;
+    /**
+     * Set whether to display controls for selecting a time value in addition to the date.
+     */
+    withTime: boolean;
+    /**
+     * Label to be displayed with time controls to allow the user to input 24-hour or meridian-based (AM, PM) time.
+     */
+    meridianToggleLabel: string;
+    /**
+     * Object dictating the labels used for the buttons displayed in the footer of the datetime picker popup.
+     *
+     * @default { cancelLabel: "Cancel", clearLabel: "Clear", saveLabel: "Save" }
+     */
+    get popupButtonLabels(): IDatetimePickerPopupButtonLabels;
+    set popupButtonLabels(value: Partial<IDatetimePickerPopupButtonLabels>);
+    private _popupButtonLabels;
+    /**
+     * The placeholder text that will be displayed when no selection has been made.
+     *
+     * @default YYYY-MM-DD hh:mm
+     */
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    errorStateMatcher: ErrorStateMatcher;
+    /**
+     * Events fire when raw value of picker input changes. Mainly exists to handle
+     * two-way binding of `value` input property.
+     * @ignore
+     */
+    readonly valueChange: EventEmitter<IDatetimePickerValue<any, any> | null>;
+    constructor(_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+    /** @ignore */
+    get empty(): boolean;
+    /** @ignore */
+    focus(options?: FocusOptions): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    writeValue(obj: any): void;
+    /** @ignore */
+    registerOnChange(fn: any): void;
+    /** @ignore */
+    registerOnTouched(fn: any): void;
+    /** @ignore */
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): IDatetimePickerValue<any, any> | null;
+    set value(value: IDatetimePickerValue<any, any> | null);
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    get focused(): boolean;
+    protected _focused: boolean;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    protected displayedValue: string;
+    protected get placeholderText(): string;
+    protected updateValue(newValue: IDatetimePickerValue<any, any> | null): void;
+    protected handleOpenChange(isOpen: boolean): void;
+    protected _onFocus(): void;
+    protected _onBlur(): void;
+    private _updateDisplayedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimePickerInputComponent, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimePickerInputComponent, "impdc-datetime-picker-input", never, { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "markDateDisabled": { "alias": "markDateDisabled"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "withTime": { "alias": "withTime"; "required": false; }; "meridianToggleLabel": { "alias": "meridianToggleLabel"; "required": false; }; "popupButtonLabels": { "alias": "popupButtonLabels"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ngAcceptInputType_required: unknown;
+}
+
+declare class DatetimePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DatetimePickerModule, never, [typeof DatetimePickerComponent, typeof DatetimePickerInputComponent], [typeof DatetimePickerComponent, typeof DatetimePickerInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DatetimePickerModule>;
+}
+
+declare class DesignComponentsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignComponentsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DesignComponentsModule, never, [typeof i2.CommonModule, typeof i4.FormsModule, typeof TextHighlightModule, typeof IconModule, typeof BadgeModule, typeof TagComponent, typeof ProgressBarModule, typeof ButtonModule, typeof TableModule, typeof DropdownModule, typeof AlertModule, typeof ModalModule, typeof FileUploadModule, typeof AvatarModule, typeof AvatarGroupModule, typeof BreadcrumbModule, typeof BrandingModule, typeof DatetimePickerModule], [typeof TextHighlightModule, typeof IconModule, typeof BadgeModule, typeof TagComponent, typeof ProgressBarModule, typeof ButtonModule, typeof TableModule, typeof DropdownModule, typeof AlertModule, typeof ModalModule, typeof FileUploadModule, typeof AvatarModule, typeof AvatarGroupModule, typeof BreadcrumbModule, typeof BrandingModule, typeof DatetimePickerModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DesignComponentsModule>;
+}
+
+/**
+ * The `ButtonGroupComponent` (`<impdc-button-group` or `<any impdc-button-group`) is a container for multiple [ButtonComponent](./?path=/docs/design-components-button)s.
+ * To use, import `ButtonGroupModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `ButtonGroupModule` imports and exports [ButtonModule](./?path=/docs/design-components-button).
+ */
+declare class ButtonGroupComponent {
+    /**
+     * Changes the orientation of the Button Group to vertical, making any Button within it stack vertically.
+     */
+    vertical: boolean;
+    /**
+     * Sets the `aria-label` attribute for the Button Group's element.
+     */
+    ariaLabel: string;
+    private get classBtnGroup();
+    private get classBtnGroupVertical();
+    private attrRole;
+    private get attrAriaLabel();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonGroupComponent, "impdc-button-group, [impdc-button-group]", never, { "vertical": { "alias": "vertical"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class ButtonGroupModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonGroupModule, [typeof ButtonGroupComponent], [typeof i2.CommonModule, typeof ButtonModule], [typeof ButtonModule, typeof ButtonGroupComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonGroupModule>;
+}
+
+declare class TableThemeHelper {
+    static getTheme({ fieldColor, color, colorGetter }: TableColumnDef, currentRow: ITableRowItem): ComponentTheme | undefined;
+    static getCellColor(columnDefinition: TableColumnDef, currentRow: ITableRowItem): string;
+    static getColor(color?: ComponentTheme): string;
+}
+
+declare const provideImpdcModalAppInitializer: () => i0.EnvironmentProviders;
+
+/**
+ * The `CardHeadingComponent` (`<impdc-card-heading` or `<div impdc-card-heading`) is used to display projected content as a card with a consistent heading.
+ * To use, import `CardHeadingModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class CardHeadingComponent {
+    /**
+     * The subject text for a Card.
+     */
+    title: string;
+    /**
+     * The description, subtitle, or other pre-text for a Card.
+     */
+    description: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeadingComponent, "impdc-card-heading, div[impdc-card-heading]", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; }, {}, never, ["impdc-avatar", "button[impdcButton]", "*"], false, never>;
+}
+
+declare class CardHeadingModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeadingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CardHeadingModule, [typeof CardHeadingComponent], [typeof i2.CommonModule], [typeof CardHeadingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CardHeadingModule>;
+}
+
+/**
+ * The `ScrollableComponent` (`<impdc-scrollable` or `<div impdc-scrollable`) is a container that hides items that wouldn't fit
+ * with arrows on the left and right to slide between them.
+ * To use, import `ScrollableModule` or another module that imports and exports that module from `@impartner/design-components`.
+ * `ScrollableModule` also imports and exports [BrandingModule](./?path=/docs/design-components-directives-impdcbranded).
+ */
+declare class ScrollableComponent implements OnChanges, AfterViewInit {
+    private _cd;
+    private readonly _hostElementRef;
+    private readonly GET_ANCESTOR_BG_SEARCH_DEPTH;
+    /**
+     * The base amount to scroll.
+     */
+    scrollUnit: number;
+    /**
+     * Used in combination with `scrollUnit` to determine how far the Scrollable scrolls when directional arrows are clicked.
+     */
+    clickScrollMultiplier: number;
+    private _scrollableBgColor;
+    get canScrollLeft(): boolean;
+    get canScrollRight(): boolean;
+    private _width;
+    containerRef: ElementRef | undefined;
+    private get _containerElement();
+    contentRef: ElementRef | undefined;
+    private get _contentElement();
+    constructor(_cd: ChangeDetectorRef, _hostElementRef: ElementRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    scroll(direction: number): Promise<void>;
+    widthChanged(elementSize: IElementSize): void;
+    private _scrollToPosition;
+    private _getBackgroundColorForButtons;
+    private _getAncestorBackgroundColor;
+    private _getBackGroundColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScrollableComponent, "impdc-scrollable, div[impdc-scrollable]", never, { "scrollUnit": { "alias": "scrollUnit"; "required": false; }; "clickScrollMultiplier": { "alias": "clickScrollMultiplier"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class ScrollableModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ScrollableModule, [typeof ScrollableComponent], [typeof i2.CommonModule, typeof SizeDetectionModule, typeof BrandingModule, typeof IconModule], [typeof ScrollableComponent, typeof BrandingModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ScrollableModule>;
+}
+
+declare class ImpdcSelectIconChange {
+    source: SelectIconComponent;
+    value: any;
+    constructor(source: SelectIconComponent, value: any);
+}
+declare const _SelectIconComponentBase: _impartner_design_components.Constructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.AbstractConstructor<_impartner_design_components.HasTabIndex> & _impartner_design_components.Constructor<_impartner_design_components.CanDisable> & _impartner_design_components.AbstractConstructor<_impartner_design_components.CanDisable> & _impartner_design_components.Constructor<ICanUpdateErrorState> & _impartner_design_components.AbstractConstructor<ICanUpdateErrorState> & {
+    new (_defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl | null): {
+        readonly stateChanges: Subject<void>;
+        _defaultErrorStateMatcher: ErrorStateMatcher;
+        _formRoot: ImpdcFormRoot;
+        _parentForm: NgForm;
+        _parentFormGroup: FormGroupDirective;
+        ngControl: NgControl | null;
+    };
+};
+/**
+ * The `SelectIconComponent` (`<impdc-select-icon`) is a select dropdown with search that shows all standard icons from Bootstrap 5.
+ * To use, import `SelectIconModule` or another module that imports and exports that module from `@impartner/design-components`.
+ */
+declare class SelectIconComponent extends _SelectIconComponentBase implements ControlValueAccessor, ImpdcFormFieldControl<string | null>, ICanUpdateErrorState, IHasErrorState, DoCheck, OnChanges, OnDestroy {
+    private readonly _changeDetector;
+    protected _toggleButtonRef: ElementRef<HTMLButtonElement>;
+    protected readonly filteredOptions$: Observable<string[]>;
+    protected readonly searchControl: FormControl<string | null>;
+    protected readonly _uid: string;
+    protected _dropdownOpen: boolean;
+    private readonly _iconOptionsSubject;
+    private _previousControl?;
+    private _cvaOnChange;
+    private _cvaOnTouched;
+    /**
+     * Set whether or not an input field will appear for searching and
+     * filtering icon options.
+     * @default true
+     */
+    allowSearch: boolean;
+    get iconOptions(): string[];
+    /**
+     * Set to override the default set of FontAwesome icon options.
+     */
+    set iconOptions(iconOptions: string[]);
+    /**
+     * Set whether or not to show the icon names as labels for icon options.
+     * @default true
+     */
+    showText: boolean;
+    /**
+     * Set whether or not to show the name of the selected icon inside the control.
+     * @default true
+     */
+    showSelectedText: boolean;
+    /**
+     * The placeholder text that will be displayed when no selection has been made.
+     *
+     * @default \- Select -
+     */
+    get placeholder(): string;
+    set placeholder(value: string);
+    private _placeholder;
+    errorStateMatcher: ErrorStateMatcher;
+    /** Events fire when selection has been changed by the user. */
+    readonly selectionChange: EventEmitter<ImpdcSelectIconChange>;
+    /**
+     * Events fire when raw value of select changes. Mainly exists to handle
+     * two-way binding of `value` input property.
+     * @ignore
+     */
+    readonly valueChange: EventEmitter<string | null>;
+    constructor(_changeDetector: ChangeDetectorRef, _defaultErrorStateMatcher: ErrorStateMatcher, _formRoot: ImpdcFormRoot, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, ngControl: NgControl);
+    get empty(): boolean;
+    /** @ignore */
+    focus(options?: FocusOptions): void;
+    /** @ignore */
+    ngDoCheck(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    writeValue(value: string): void;
+    /** @ignore */
+    registerOnChange(fn: (value: any) => void): void;
+    /** @ignore */
+    registerOnTouched(fn: () => {}): void;
+    /** @ignore */
+    setDisabledState?(isDisabled: boolean): void;
+    get value(): string | null;
+    set value(value: string | null);
+    private _value;
+    get id(): string;
+    set id(value: string);
+    protected _id: string;
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required(): boolean;
+    set required(value: BooleanInput);
+    private _required;
+    get focused(): boolean;
+    protected _focused: boolean;
+    readonly controlType: string;
+    readonly supportsAffixes: boolean;
+    protected handleOpenChange(isOpen: boolean): void;
+    protected selectIcon(iconName: string): void;
+    protected _onFocus(): void;
+    /**
+     * Calls the CVA touched callback only if the dropdown is closed.
+     */
+    protected _onBlur(): void;
+    private _buildChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectIconComponent, [null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectIconComponent, "impdc-select-icon", never, { "disabled": { "alias": "disabled"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "allowSearch": { "alias": "allowSearch"; "required": false; }; "iconOptions": { "alias": "iconOptions"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "showSelectedText": { "alias": "showSelectedText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; }; "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "selectionChange": "selectionChange"; "valueChange": "valueChange"; }, never, never, false, never>;
+}
+
+declare class SelectIconModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectIconModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectIconModule, [typeof SelectIconComponent], [typeof i2.CommonModule, typeof ImpdcFormsModule, typeof IconModule, typeof i18.NgbTypeaheadModule, typeof i18.NgbDropdownModule, typeof i4.ReactiveFormsModule], [typeof SelectIconComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectIconModule>;
+}
+
+/**
+ * The `CardHeadingComponent` (`<impdc-data-card` or `<any impdc-data-card`) is to display data snapshots with support for
+ * previous values and differences.
+ *
+ * To use, import `DataCardModule` or another module that imports and exports that module from `@impartner/design-components`.
+ *
+ * An icon may be displayed in the card via Angular content projection and the `icon` attribute.
+ */
+declare class DataCardComponent {
+    protected readonly BadgeTheme: typeof ComponentTheme;
+    protected iconContentElementRef: ElementRef<HTMLElement>;
+    /**
+     * The subject text for the Data Card.
+     */
+    title: string;
+    /**
+     * The current data value. Any number/currency format is supported.
+     */
+    current: string;
+    /**
+     * The previous data value. Any number/currency format is supported.
+     * Only displayed when an icon is not provided via Angular content projection.
+     */
+    previous: string;
+    /**
+     * The difference between the current and previous values. A numerical or percentage value is preferred,
+     * but any number/currency format is supported.
+     */
+    difference: string;
+    /**
+     * Text for the link at the bottom of the Data Card. If provided, enables the `linkClicked` event to be emitted.
+     */
+    linkText: string;
+    /**
+     * When stacking multiple Data Card elements together, it's common to combine their borders.
+     */
+    sharedBorders: boolean;
+    /**
+     * Changes the color of the icon.
+     */
+    iconColor: string;
+    /**
+     * Changes the color of the icon's background.
+     */
+    iconBgColor: string;
+    /**
+     * Emitted when the link text is clicked.
+     */
+    linkClicked: EventEmitter<Event | MouseEvent>;
+    /**
+     * Emitted when the corner content is clicked.
+     */
+    cornerClicked: EventEmitter<Event | MouseEvent>;
+    private get classDataCard();
+    private get classDataCardSharedBorders();
+    get differenceNumber(): number;
+    get differenceNegative(): boolean;
+    get differencePositive(): boolean;
+    get differenceDisplay(): string;
+    protected get hasIcon(): boolean;
+    protected handleLinkClick(event: MouseEvent | Event): void;
+    protected handleCornerClick(event: MouseEvent | Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataCardComponent, "impdc-data-card, [impdc-data-card]", never, { "title": { "alias": "title"; "required": false; }; "current": { "alias": "current"; "required": false; }; "previous": { "alias": "previous"; "required": false; }; "difference": { "alias": "difference"; "required": false; }; "linkText": { "alias": "linkText"; "required": false; }; "sharedBorders": { "alias": "sharedBorders"; "required": false; }; "iconColor": { "alias": "iconColor"; "required": false; }; "iconBgColor": { "alias": "iconBgColor"; "required": false; }; }, { "linkClicked": "linkClicked"; "cornerClicked": "cornerClicked"; }, never, ["[icon]", "*", "[corner]", "[footer]"], false, never>;
+}
+
+declare class DataCardModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataCardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DataCardModule, [typeof DataCardComponent], [typeof i2.CommonModule, typeof IconModule, typeof BadgeModule], [typeof IconModule, typeof DataCardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DataCardModule>;
+}
+
+declare function IMPDC_DATETIME_PICKER_FORMATTER_FACTORY(): ImpdcDatetimeISOFormatter;
+declare abstract class ImpdcDatetimeFormatter {
+    abstract format(date: NgbDateStruct, time?: NgbTimeStruct | null | {
+        value: NgbTimeStruct | null;
+        withSeconds: boolean;
+    }): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpdcDatetimeFormatter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImpdcDatetimeFormatter>;
+}
+declare class ImpdcDatetimeISOFormatter extends ImpdcDatetimeFormatter {
+    format(date: NgbDateStruct, time?: NgbTimeStruct | null | {
+        value: NgbTimeStruct | null;
+        withSeconds: boolean;
+    }): string;
+    private _padNumberString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpdcDatetimeISOFormatter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImpdcDatetimeISOFormatter>;
+}
+
+type NgbDatepickerViewModel = NgbDatepicker['model'];
+declare enum NgbNavigationEvent {
+    PREV = 0,
+    NEXT = 1
+}
+declare class DatepickerNavComponent implements OnInit, AfterViewChecked {
+    private readonly _cd;
+    private readonly _destroyRef$;
+    protected readonly monthControl: FormControl<number | null>;
+    protected readonly yearControl: FormControl<number | null>;
+    protected readonly datepickerI18n: NgbDatepickerI18n;
+    date: NgbDate;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _disabled;
+    prevDisabled: boolean;
+    nextDisabled: boolean;
+    selectBoxes: NgbDatepickerViewModel['selectBoxes'];
+    navigate: EventEmitter<NgbNavigationEvent>;
+    selected: EventEmitter<NgbDate>;
+    onClickGoPrevious(event: MouseEvent): void;
+    onClickGoNext(event: MouseEvent): void;
+    changeMonth(month: number): void;
+    changeYear(year: number): void;
+    ngOnInit(): void;
+    ngAfterViewChecked(): void;
+    private _applyDateToControls;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerNavComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerNavComponent, "impdc-datepicker-nav", never, { "date": { "alias": "date"; "required": true; }; "disabled": { "alias": "disabled"; "required": true; }; "prevDisabled": { "alias": "prevDisabled"; "required": true; }; "nextDisabled": { "alias": "nextDisabled"; "required": true; }; "selectBoxes": { "alias": "selectBoxes"; "required": true; }; }, { "navigate": "navigate"; "selected": "selected"; }, never, never, true, never>;
+}
+
+interface ContentTemplateContext {
+    /**
+     * The datepicker that corresponds to the template.
+     *
+     * Can be used for convenience as a default template key, ex. `let-d`.
+     */
+    $implicit: NgbDatepicker;
+}
+declare class DatepickerTemplateHostComponent {
+    private readonly _calendar;
+    readonly isWeekend: (date: NgbDate) => boolean;
+    readonly isToday: (date: NgbDate) => boolean;
+    dayTemplateRef: TemplateRef<DayTemplateContext>;
+    contentTemplateRef: TemplateRef<ContentTemplateContext>;
+    protected getMonthTrackByKey(ngbDate: NgbDate): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatepickerTemplateHostComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatepickerTemplateHostComponent, "impdc-datepicker-template-host", never, {}, {}, never, never, true, never>;
+}
+
+declare class DatetimePickerInputFooterComponent implements OnInit {
+    private readonly _cd;
+    private readonly _destroyRef;
+    protected readonly datetimePickerFormControl: FormControl<IDatetimePickerValue<any, any> | null>;
+    datetimePicker: DatetimePickerComponent;
+    initialValue: IDatetimePickerValue<any, any> | null;
+    cancelLabel: string;
+    clearLabel: string;
+    saveLabel: string;
+    readonly datetimeSelected: EventEmitter<IDatetimePickerValue<any, any> | null>;
+    readonly closeRequested: EventEmitter<void>;
+    ngOnInit(): void;
+    allowSave(): boolean;
+    clearAndClose(): void;
+    saveAndClose(): void;
+    closePicker(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimePickerInputFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimePickerInputFooterComponent, "impdc-datetime-picker-input-footer", never, { "datetimePicker": { "alias": "datetimePicker"; "required": true; }; "initialValue": { "alias": "initialValue"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "clearLabel": { "alias": "clearLabel"; "required": false; }; "saveLabel": { "alias": "saveLabel"; "required": false; }; }, { "datetimeSelected": "datetimeSelected"; "closeRequested": "closeRequested"; }, never, never, true, never>;
+}
+
+export { AlertComponent, AlertModule, AvatarComponent, AvatarGroupComponent, AvatarGroupModule, AvatarModule, BackdropComponent, BackdropModule, BadgeComponent, BadgeModule, BadgeSize, BadgeSizesArr, BrandedDirective, BrandingModule, BreadcrumbComponent, BreadcrumbItemComponent, BreadcrumbModule, ButtonComponent, ButtonGroupComponent, ButtonGroupModule, ButtonModule, CardHeadingComponent, CardHeadingModule, CheckboxChangeEvent, CheckboxComponent, CheckboxGroupChangeEvent, CheckboxGroupComponent, CheckboxGroupModule, CheckboxItemChangeEvent, CheckboxItemComponent, CheckboxModule, ColumnHeadingComponent, ComponentSize, ComponentTheme, ComponentThemesArr, CornerActionComponent, CornerHintComponent, DataCardComponent, DataCardModule, DatepickerNavComponent, DatepickerTemplateHostComponent, DatetimePickerComponent, DatetimePickerInputComponent, DatetimePickerInputFooterComponent, DatetimePickerModule, DesignComponentsModule, DropdownComponent, DropdownItemComponent, DropdownModule, ErrorComponent, ErrorStateMatcher, FORM_FIELD_FEEDBACK_COMPONENTS, FORM_FIELD_SUBCOMPONENTS, FeedbackTextCounterComponent, FileDropDirective, FileUploadComponent, FileUploadModule, FloatingFeedbackComponent, FontAwesomeFreeRegularIcons, FontAwesomeFreeSolidIcons, FontAwesomeIconThemes, FontAwesomeIcons, FormFieldComponent, FormFieldModule, HintComponent, HumanReadableByteSizePipe, IMPDC_DATETIME_PICKER_FORMATTER_FACTORY, IMPDC_ERROR, IMPDC_FORM_FIELD, IMPDC_FORM_ROOT, IMPDC_PREFIX, IMPDC_SELECT_OPTION_PARENT_COMPONENT, IMPDC_SELECT_VALUE_BADGES_PARENT_COMPONENT, IMPDC_SUFFIX, IconComponent, IconModule, ImpdcDatetimeFormatter, ImpdcDatetimeISOFormatter, ImpdcFormFieldControl, ImpdcFormsModule, ImpdcSelectIconChange, InputDirective, InteractionService, LabelComponent, ModalComponent, ModalComponentSizesArr, ModalLayoutComponent, ModalModule, ModalTheme, ModalThemesArr, PaginationComponent, PaginationModule, PrefixDirective, ProgressBarComponent, ProgressBarModule, RadioButtonComponent, RadioChangeEvent, RadioGroupComponent, RadioModule, RootFormGroupDirective, RootNgFormDirective, RowActionsComponent, ScrollableComponent, ScrollableModule, SelectChangeEvent, SelectComponent, SelectIconComponent, SelectIconModule, SelectModel, SelectModule, SelectOptionComponent, SelectOptionDisplayComponent, SelectOptionGroupComponent, SelectOptionSelectionChangeEvent, SelectValueTagsDisplayComponent, ShowOnDirtyErrorStateMatcher, SizeDetectionModule, SizeDetectorDirective, SpinnerComponent, SpinnerModule, SubLabelComponent, SuffixDirective, TableBulkActionsComponent, TableColumnType, TableComponent, TableDirective, TableInjectComponentDirective, TableModule, TableThemeHelper, TagComponent, TagSelectComponent, TextHighlightComponent, TextHighlightModule, UniqueSelectionDispatcher, getImpdcCheckboxGroupNonArrayValueError, getImpdcFormFieldMissingControlError, mixinDisabled, mixinErrorState, mixinTabIndex, provideImpdcModalAppInitializer };
+export type { AbstractConstructor, AlertTheme, BadgeIcon, BadgeSizes, ButtonTheme, CanDisable, ComponentThemes, Constructor, DropdownPosition, FontAwesomeIcon, FontAwesomeIconTheme, HasTabIndex, IBackdropComponent, ICanUpdateErrorState, ICellRenderer, ICheckboxItem, ICollapsibleRowContentContext, ICustomCellRendererComponents, IDatetimePickerValue, IElementSize, IHasErrorState, IIdentifiable, IInteractableComponent, IRadioButton, ISelectOption, ISelectOptionParentComponent, ISelectValueBadgesParentComponent, ISortByPayload, ITableActionsColumnDef, ITableCellOption, ITableColumnDef, ITableEventPayload, ITableRowAction, ITableRowActionDivider, ITableRowActionPayload, ITableRowCollapseChange, ITableRowItem, ITableRowItemValue, ITableRowItemValueTypes, ImpdcFormRoot, ModalComponentSizes, ModalThemes, PrimaryComponentSizes, SecondaryComponentSizes, SelectChange, TableColumnDef, TagTheme, UniqueSelectionDispatcherListener };