pm-fuel 20.0.1

package/index.d.ts

@@ -0,0 +1,3356 @@
+import { FormControl, FormGroupDirective, ValidatorFn, AbstractControl, ControlValueAccessor, FormGroup } from '@angular/forms';
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnChanges, SimpleChanges, PipeTransform, OnDestroy, InjectionToken, EventEmitter, Type, ElementRef, ViewContainerRef, Renderer2, NgZone, TemplateRef, AfterContentInit, AfterContentChecked, QueryList } from '@angular/core';
+import { CurrencyPipe } from '@angular/common';
+import { Router } from '@angular/router';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { Subject, Observable, BehaviorSubject } from 'rxjs';
+import { SafeUrl } from '@angular/platform-browser';
+import { ComponentType } from '@angular/cdk/portal';
+import * as pm_fuel from 'pm-fuel';
+import { AnimationEvent, AnimationTriggerMetadata } from '@angular/animations';
+import { HttpClient } from '@angular/common/http';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+
+declare class PmdsDirectiveDecimalNumberFormat {
+    private el;
+    control: FormControl;
+    onKeyDown(): void;
+    private run;
+    private restoreValue;
+    private isValid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveDecimalNumberFormat, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveDecimalNumberFormat, "[pmdsDecimalNumberFormat]", never, { "control": { "alias": "control"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface INumberFormatOptions {
+    maxLengthInt: number;
+    maxLengthDec: number;
+    formControlName: string;
+}
+
+declare class PmdsDirectiveNumberFormat implements OnInit {
+    private readonly currencyPipe;
+    private formGroupDirective;
+    pmdsNumberOptions: Partial<INumberFormatOptions>;
+    private inputValue;
+    formControl: FormControl;
+    private regExp;
+    constructor(currencyPipe: CurrencyPipe, formGroupDirective: FormGroupDirective);
+    ngOnInit(): void;
+    private regexCurrency;
+    private formatCurrency;
+    private isValidCurrency;
+    private cleanValue;
+    private saveInputValue;
+    onInput(input: HTMLInputElement): void;
+    onFocusOut(_event: FocusEvent): void;
+    onFocusIn(_event: FocusEvent): void;
+    onKeyPress(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveNumberFormat, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveNumberFormat, "[pmdsNumberFormat]", never, { "pmdsNumberOptions": { "alias": "pmdsNumberOptions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsDirectiveTitle implements AfterViewInit, OnChanges {
+    forceLabel: string;
+    forceTitle: boolean;
+    multipleLine: boolean;
+    disabledEllipsis: boolean;
+    private domElement;
+    private readonly elementRef;
+    private readonly renderer;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    setTooltip(): void;
+    onHover(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveTitle, "[pmdsTitle]", never, { "forceLabel": { "alias": "forceLabel"; "required": false; }; "forceTitle": { "alias": "forceTitle"; "required": false; }; "multipleLine": { "alias": "multipleLine"; "required": false; }; "disabledEllipsis": { "alias": "disabledEllipsis"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsDirectiveTitleClasses {
+    'text-overflow': string;
+    overflow: string;
+    'white-space': string;
+}
+
+type TPmdsDirectiveTooltipPosition = 'top-left' | 'top-center' | 'top-right' | 'middle-left' | 'middle-center' | 'middle-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+
+declare class PmdsDirectiveTooltip implements OnChanges {
+    pmdsTooltipTitle: string | null;
+    pmdsTooltipActivate: boolean;
+    tooltipContent: string | null;
+    pmdsTooltipPosition: TPmdsDirectiveTooltipPosition;
+    delay: '0' | '75' | '100' | '150' | '200' | '300' | '500' | '700' | '1000';
+    private tooltip;
+    private contentTooltip;
+    private triangleTooltip;
+    private timer;
+    private defaultTime;
+    private elementRef;
+    private renderer;
+    onMouseEnter(): void;
+    onMouseClick(event: Event): void;
+    onMouseLeave(): void;
+    onWindowScroll(): void;
+    onKeyDown(): void;
+    onGlobalClick(event: Element): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private show;
+    private hide;
+    private create;
+    private setPosition;
+    private loadedTooltip;
+    private isMobile;
+    private generateContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveTooltip, "[pmdsTooltip]", never, { "pmdsTooltipTitle": { "alias": "pmdsTooltipTitle"; "required": false; }; "pmdsTooltipActivate": { "alias": "pmdsTooltipActivate"; "required": false; }; "tooltipContent": { "alias": "pmdsTooltip"; "required": false; }; "pmdsTooltipPosition": { "alias": "pmdsTooltipPosition"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsPipeAccountFormat implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeAccountFormat, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeAccountFormat, "pmdsAccountFormat", true>;
+}
+
+declare class PmdsPipeAccountHidden implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeAccountHidden, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeAccountHidden, "pmdsAccountHidden", true>;
+}
+
+declare class PmdsPipeAmountFormat implements PipeTransform {
+    transform(value: string | number | undefined, showDecimals?: boolean, locale?: string, numberDecimals?: number, numberFormat?: string, currency?: string): string;
+    private getFormattedValueByCurrency;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeAmountFormat, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeAmountFormat, "pmdsAmountFormat", true>;
+}
+
+declare class PmdsPipeCamelcaseToSnakecaseUppercase implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeCamelcaseToSnakecaseUppercase, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeCamelcaseToSnakecaseUppercase, "pmdsCamelcaseToSnakecaseUppercase", true>;
+}
+
+declare class PmdsPipeDateTime implements PipeTransform {
+    private datePipe;
+    transform(value: number | string | undefined | null, dateFormat?: string, timeFormat?: string, timezone?: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeDateTime, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeDateTime, "pmdsDateTime", true>;
+}
+
+declare class PmdsPipeOnlyDecimals implements PipeTransform {
+    transform(value: number | string | undefined | null, separator?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeOnlyDecimals, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeOnlyDecimals, "pmdsOnlyDecimals", true>;
+}
+
+type TPmdsRelationshipFormatType = 'identifier' | 'text';
+
+interface IPmdsRelationshipLiterals {
+    father: string;
+    mother: string;
+    selfPayed: string;
+}
+
+declare class PmdsPipeRelationshipFormat implements PipeTransform {
+    private formats;
+    transform(value: string | number | undefined | null, type: TPmdsRelationshipFormatType | undefined, literals: IPmdsRelationshipLiterals): string;
+    private getLiterals;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeRelationshipFormat, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeRelationshipFormat, "pmdsRelationshipFormat", true>;
+}
+
+declare class PmdsPipeSalesforceNumberFormat implements PipeTransform {
+    transform(value: number | string | undefined | null, mask?: string, noDecimals?: boolean, separator?: string): string;
+    private getDecimals;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeSalesforceNumberFormat, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeSalesforceNumberFormat, "pmdsSalesforceNumberFormat", true>;
+}
+
+declare class PmdsPipeTransactionReference implements PipeTransform {
+    private referenceStatus;
+    transform(value: string, text?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeTransactionReference, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeTransactionReference, "pmdsTransactionReference", true>;
+}
+
+declare class PmdsPipeTruncateEllipsis implements PipeTransform {
+    transform(value: string, max?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeTruncateEllipsis, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeTruncateEllipsis, "pmdsTruncateEllipsis", true>;
+}
+
+declare class PmdsUtilHistoryRouting {
+    private router;
+    history: string[];
+    private isNavigatePrevious;
+    constructor(router: Router);
+    initHistory(): Promise<unknown>;
+    navigatePrevious(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsUtilHistoryRouting, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsUtilHistoryRouting>;
+}
+
+declare class PmdsUtilImgFlags {
+}
+
+declare class PmdsUtilStyles {
+}
+
+declare class PmdsUtilValidators {
+    static validChars: string;
+    static minTime(min: string): ValidatorFn;
+    static maxTime(max: string): ValidatorFn;
+    static min(min: number, locale?: string): ValidatorFn;
+    static max(max: number, locale?: string): ValidatorFn;
+    static nameRegex(control: AbstractControl): {
+        [key: string]: unknown;
+    } | null;
+    static emailRegex(control: AbstractControl): {
+        [key: string]: unknown;
+    } | null;
+    static noSpaces(control: AbstractControl): {
+        [key: string]: unknown;
+    } | null;
+    static noWhitespace(control: AbstractControl): {
+        [key: string]: unknown;
+    } | null;
+    static isEmptyValue(value?: unknown): boolean;
+    static studentId(control: AbstractControl): {
+        [key: string]: any;
+    } | null;
+    static minLengthArray(min: number): ValidatorFn;
+    static maxAmount(max: number, decimalCharacter?: ',' | '.'): ValidatorFn;
+}
+
+declare class PmdsUtilImgSvgs {
+}
+
+declare class PmdsPipeTypeOf implements PipeTransform {
+    transform(value: unknown): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeTypeOf, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeTypeOf, "pmdsTypeOf", true>;
+}
+
+declare class PmdsDirectiveMaskAmountInput {
+    pmdsMAIDecimalCharacter: string;
+    pmdsMAIMaxIntLength: number;
+    onInput(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveMaskAmountInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveMaskAmountInput, "[pmdsMaskAmountInput]", never, { "pmdsMAIDecimalCharacter": { "alias": "pmdsMAIDecimalCharacter"; "required": false; }; "pmdsMAIMaxIntLength": { "alias": "pmdsMAIMaxIntLength"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsDirectiveNoLeadingSpacesInput {
+    onInput(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveNoLeadingSpacesInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveNoLeadingSpacesInput, "[pmdsNoLeadingSpacesInput]", never, {}, {}, never, never, true, never>;
+}
+
+declare class PmdsDirectiveViewportOverflow {
+    options: {
+        height: number;
+        translateY: number;
+    };
+    private domElement;
+    private elementRef;
+    private renderer;
+    private changed;
+    onScroll(): void;
+    checkPostion(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsDirectiveViewportOverflow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PmdsDirectiveViewportOverflow, "[pmdsViewportOverflow]", never, { "options": { "alias": "pmdsViewportOverflow"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsPipeExchangeDecimals implements PipeTransform {
+    transform(value: string, format: 'xx.xxXXxx' | 'xx.XXxxxx' | 'xx.xxxxXX', bigFont: string): string;
+    calculateSizeOfRate(value: string, format: string, bigFont: string): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsPipeExchangeDecimals, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PmdsPipeExchangeDecimals, "pmdsExchangeDecimals", true>;
+}
+
+interface PmdsCoreICachedElement {
+    id: string;
+    value: any;
+}
+
+declare class PmdsCoreCacheService {
+    private cachedCollection;
+    private maxCachedElements;
+    addCachedElement(id: string, value: any, expiration?: number | null): void;
+    getCachedElement(id: string): any;
+    private addElementToCollection;
+    private removeExpiredItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCoreCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsCoreCacheService>;
+}
+
+declare class PmdsCoreStorageService {
+    signOut(): void;
+    setLocalStorageItem(tokenKey: string, token: any): void;
+    getLocalStorageItem(tokenKey: string): any;
+    deleteLocalStorageItem(tokenKey: string): void;
+    setSessionStorageItem(tokenKey: string, token: any): void;
+    getSessionStorageItem(tokenKey: string): any;
+    deleteSessionStorageItem(tokenKey: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCoreStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsCoreStorageService>;
+}
+
+interface IPmdsCdkActionBarConfig {
+    actionBarButtons?: IPmdsCdkActionBarButton[];
+    clearBarButton?: {
+        label: string;
+    };
+    secondaryBarButton?: IPmdsCdkActionBarButton;
+    dataQA?: string;
+}
+interface IPmdsCdkActionBarButton {
+    action: (button?: unknown) => void;
+    label?: string;
+}
+
+declare class PmdsCdkActionBarComponent implements OnInit {
+    actionBarButtons: IPmdsCdkActionBarButton[];
+    moreActionBarButtons: IPmdsCdkActionBarButton[];
+    clearBarButton: Partial<IPmdsCdkActionBarButton>;
+    secondaryBarButton: IPmdsCdkActionBarButton;
+    componentSelector: string;
+    dataQA: string;
+    maxActionBarButtons: number;
+    showMoreActions: boolean;
+    moreOptionsOffset: string;
+    private readonly actionBarConfig;
+    private readonly overlayRef;
+    get showMenuActionBarButtons(): boolean;
+    ngOnInit(): void;
+    clear(): void;
+    close(): void;
+    toggleShowMore(): void;
+    getMoreOptionsOffset(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkActionBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkActionBarComponent, "pmds-cdk-action-bar", never, {}, {}, never, never, true, never>;
+}
+
+declare class PmdsCdkActionBarRef {
+    private readonly overlayRef;
+    events: Subject<{
+        action: "clear";
+    }>;
+    constructor(overlayRef: OverlayRef);
+    close(): void;
+}
+
+declare class PmdsCdkActionBarService {
+    dialogRef: PmdsCdkActionBarRef;
+    private readonly injector;
+    private readonly overlay;
+    private readonly overlayContainer;
+    open(config: IPmdsCdkActionBarConfig): PmdsCdkActionBarRef;
+    private attachModalContainer;
+    private createInjector;
+    private createOverlay;
+    private getOverlayConfig;
+    private setOverlayContainerClassList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkActionBarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsCdkActionBarService>;
+}
+
+interface IPmdsCdkActionRowBar {
+    action: () => void;
+    label: string;
+}
+
+declare class PmdsCdkActionRowBarComponent implements OnInit, OnDestroy {
+    actionBarButtons: IPmdsCdkActionRowBar[];
+    disabled: boolean;
+    dataQA: string;
+    showActions: boolean;
+    componentSelector: string;
+    private wasInside;
+    private readonly actionRowBarSrv;
+    private readonly destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onDataChangeReceived(): void;
+    clickInside(): void;
+    clickOut(): void;
+    openActionRowBar(event: Event): void;
+    noAction(event: Event): void;
+    buttonAction(event: Event, indexButton: number): void;
+    closeAction(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkActionRowBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkActionRowBarComponent, "pmds-cdk-action-row-bar", never, { "actionBarButtons": { "alias": "actionBarButtons"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkAlertLiterals {
+    action?: string;
+    subject?: string;
+    subjectContent?: string;
+    message?: string;
+    messageContent?: string;
+}
+
+interface IPmdsCdkAlertData {
+    actionFn?: () => void;
+    actionIcon?: string;
+    cancelAutoClose?: boolean;
+    closeFn?: () => void;
+    content?: string;
+    hideClose?: boolean;
+    literals?: IPmdsCdkAlertLiterals;
+    title?: string;
+    type?: TPmdsCdkAlertType;
+}
+type TPmdsCdkAlertType = 'warning' | 'info' | 'success' | 'error';
+declare const PMDS_CDK_ALERT_DATA_TOKEN: InjectionToken<IPmdsCdkAlertData>;
+
+declare class PmdsCdkAlertComponent {
+    data: IPmdsCdkAlertData;
+    dataQA: string;
+    closeEmit: EventEmitter<void>;
+    componentSelector: string;
+    styleByType: {
+        success: string;
+        warning: string;
+        info: string;
+        error: string;
+    };
+    iconByType: {
+        success: string;
+        warning: string;
+        info: string;
+        error: string;
+    };
+    actionByType: {
+        success: string;
+        warning: string;
+        info: string;
+        error: string;
+    };
+    action(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkAlertComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkAlertComponent, "pmds-cdk-alert", never, { "data": { "alias": "data"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; }, { "closeEmit": "closeEmit"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkAutocompleteTableConfig {
+    rowComponent?: IPmdsCdkAutocompleteDynamicRowComponentConfig;
+    error?: {
+        title: string;
+        body?: string;
+    };
+    button?: {
+        label: string;
+        show: boolean;
+        action: () => void;
+    };
+    customHeight?: string;
+    loadingLiterals?: string;
+    noResultsLiterals?: {
+        title: string;
+        msg: string;
+    };
+}
+interface IPmdsCdkAutocompleteDynamicRowComponentConfig {
+    component: Type<unknown>;
+    cardComponent?: Type<unknown>;
+    styles?: string;
+    selectRowAction?: (row: unknown) => void;
+}
+interface IPmdsCdkAutocompleteRowConfigParam<T> {
+    data: T;
+    rowIndex: number;
+    stylesConfig?: string;
+}
+
+interface IPmdsCdkAutocompleteConfig {
+    customWidth?: string;
+    input?: IPmdsCdkAutompleteInputConfig;
+    table: IPmdsCdkAutocompleteTableConfig;
+}
+interface IPmdsCdkAutompleteInputConfig {
+    customWidth?: string;
+    icon?: string;
+    labelComponent?: IPmdsCdkAutocompleteDynamicLabelComponentConfig;
+    placeholder?: string;
+    type?: string;
+}
+interface IPmdsCdkAutocompleteStates {
+    isError?: boolean;
+    isLoading?: boolean;
+}
+interface IPmdsCdkAutocompleteSuggestions {
+    search: string;
+    total?: number;
+}
+interface IPmdsCdkAutocompleteDynamicLabelComponentConfig {
+    component: Type<unknown>;
+}
+interface IPmdsCdkAutocompleteLabelConfigParam<T> {
+    data: Observable<T>;
+}
+declare const PMDS_CDK_AUTOCOMPLETE_DEFAULT_THROTTLE_TIME = 500;
+declare const PMDS_CDK_AUTOCOMPLETE_DEFAULT_DEBOUNCE_TIME = 250;
+
+interface IPmdsCdkFormErrorMessage<T> {
+    (name: string, error: string, value?: T, label?: string): string;
+}
+
+declare class PmdsCdkAutocompleteComponent implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor {
+    inputForm: ElementRef;
+    private _config;
+    get config(): IPmdsCdkAutocompleteConfig;
+    set config(value: IPmdsCdkAutocompleteConfig);
+    data: unknown[];
+    dataQA: string;
+    formControlName: string;
+    isDisabled: boolean;
+    label: unknown;
+    labelError: string;
+    labelErrorNotSelected: string;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    paginationInfo: {
+        total: number;
+        actualPage: number;
+        itemsPage: number;
+    };
+    propValue: string;
+    states: IPmdsCdkAutocompleteStates;
+    skeleton: boolean;
+    suggestions: string;
+    byTyping: EventEmitter<IPmdsCdkAutocompleteSuggestions>;
+    keyEnter: EventEmitter<IPmdsCdkAutocompleteSuggestions>;
+    focusIn: EventEmitter<undefined>;
+    focusOut: EventEmitter<string>;
+    scrollEnd: EventEmitter<IPmdsCdkAutocompleteSuggestions>;
+    componentSelector: string;
+    control: AbstractControl;
+    focusin: boolean;
+    inputFocused: boolean;
+    omitFocusOut: boolean;
+    omitClose: boolean;
+    showError: boolean;
+    value: string;
+    lastValue: string;
+    valueSelected: any;
+    private controlContainer;
+    private debouncerKeyEnter$;
+    private debouncerScrollEnd$;
+    private debouncerTyping$;
+    private destroy$;
+    private renderer;
+    private unlistener;
+    onChange: (_: unknown) => void;
+    onTouched: () => undefined;
+    get formError(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    onInput(event?: Event): void;
+    onEnter(): void;
+    onSetInput(event: any): void;
+    onSelectRow(event: any): void;
+    updateClearButtonOnFocus(focusedOnInput: boolean): void;
+    compareStudentId(selectedId: any): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => undefined): void;
+    onFocusOut(): void;
+    onFocusIn(): void;
+    onScrollEnd(): void;
+    onClear(omitFocus?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkAutocompleteComponent, "pmds-cdk-autocomplete", never, { "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelError": { "alias": "labelError"; "required": false; }; "labelErrorNotSelected": { "alias": "labelErrorNotSelected"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "paginationInfo": { "alias": "paginationInfo"; "required": false; }; "propValue": { "alias": "propValue"; "required": false; }; "states": { "alias": "states"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "suggestions": { "alias": "suggestions"; "required": false; }; }, { "byTyping": "byTyping"; "keyEnter": "keyEnter"; "focusIn": "focusIn"; "focusOut": "focusOut"; "scrollEnd": "scrollEnd"; }, never, never, true, never>;
+}
+
+type PmdsCdkButtonType = 'primary' | 'secondary' | 'tertiary';
+type PmdsCdkButtonSize = 'small' | 'medium';
+declare const PMDS_CDK_BUTTON_PRIMARY: {
+    HOVER: string;
+    ACTIVE: string;
+    DISABLED: string;
+};
+declare const PMDS_CDK_BUTTON_SECONDARY: {
+    HOVER: string;
+    ACTIVE: string;
+    DISABLED: string;
+};
+declare const PMDS_CDK_BUTTON_TERTIARY: {
+    HOVER: string;
+    ACTIVE: string;
+    DISABLED: string;
+};
+
+declare class PmdsCdkButtonComponent {
+    buttonSize: PmdsCdkButtonSize;
+    buttonSizeMobile: PmdsCdkButtonSize;
+    buttonType: PmdsCdkButtonType;
+    customIconStyle: string;
+    customStyle: string;
+    dataQA: string;
+    disabled: boolean;
+    fullWidth: boolean;
+    smallFit: boolean;
+    hideLabelMobile: boolean;
+    icon: string;
+    iconPosition: 'left' | 'right';
+    label: string;
+    type: 'button' | 'submit';
+    buttonClick: EventEmitter<Event>;
+    buttonTypes: Map<PmdsCdkButtonType, string>;
+    buttonSizes: Map<PmdsCdkButtonSize, string>;
+    buttonSizesMobile: Map<PmdsCdkButtonSize, string>;
+    componentSelector: string;
+    onButtonClick(event: Event): void;
+    getClass(): string;
+    getIconClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkButtonComponent, "pmds-cdk-button", never, { "buttonSize": { "alias": "buttonSize"; "required": false; }; "buttonSizeMobile": { "alias": "buttonSizeMobile"; "required": false; }; "buttonType": { "alias": "buttonType"; "required": false; }; "customIconStyle": { "alias": "customIconStyle"; "required": false; }; "customStyle": { "alias": "customStyle"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "smallFit": { "alias": "smallFit"; "required": false; }; "hideLabelMobile": { "alias": "hideLabelMobile"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "label": { "alias": "label"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkCardsAccountActionComponent {
+    dataQA: string;
+    icon: string;
+    label: string;
+    skeleton: boolean;
+    clickCard: EventEmitter<void>;
+    componentSelector: string;
+    emitClickCard(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCardsAccountActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCardsAccountActionComponent, "pmds-cdk-cards-account-action", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "clickCard": "clickCard"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkCheckboxComponent implements OnInit, ControlValueAccessor {
+    formControlName: string;
+    isDisabled: boolean;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    skeleton: boolean;
+    dataQA: string;
+    label: string;
+    valueChanges: EventEmitter<boolean>;
+    formControl: AbstractControl;
+    showError: boolean;
+    value: undefined | null | boolean;
+    componentSelector: string;
+    private formGroupDirective;
+    ngOnInit(): void;
+    onChange: (_: unknown) => void;
+    onTouch: () => undefined;
+    toggleValue(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => undefined): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCheckboxComponent, "pmds-cdk-checkbox", never, { "formControlName": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, { "valueChanges": "valueChanges"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkDividerComponent {
+    dataQA: string;
+    styles: string;
+    componentSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDividerComponent, "pmds-cdk-divider", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "styles": { "alias": "styles"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkStoreIdApp {
+    id: string;
+    name: string;
+    imageBase64: string;
+    url: string;
+    width?: number;
+    height?: number;
+}
+
+declare class PmdsCdkDownloadIdAppButtonsComponent implements OnInit {
+    dataQA: string;
+    direction: 'row' | 'col';
+    height: number;
+    width: number;
+    componentSelector: string;
+    storeIdApps: IPmdsCdkStoreIdApp[];
+    private domSanitizer;
+    ngOnInit(): void;
+    sanitizedUrl(url: string): SafeUrl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDownloadIdAppButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDownloadIdAppButtonsComponent, "pmds-cdk-download-id-app-buttons", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type IPmdsCdkDatepickerLiterals = {
+    month: [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+    weekDay: [string, string, string, string, string, string, string];
+    today: string;
+    formatHelp?: string;
+};
+
+type TPmdsCdkDatepickerDateFormat = 'DD/MM/YYYY' | 'MM/DD/YYYY' | 'YYYY/MM/DD' | 'DD-MM-YYYY' | 'MM-DD-YYYY' | 'YYYY-MM-DD' | 'DD MM YYYY' | 'MM DD YYYY' | 'YYYY MM DD';
+
+interface IPmdsDropdownRangeSelect {
+    to: string | Date;
+    from: string | Date;
+}
+
+interface IPmdsCdkDropdownRangeLiterals {
+    apply: string;
+    clearAll: string;
+    to: string;
+    from: string;
+    datepickerLiterals?: IPmdsCdkDatepickerLiterals;
+}
+
+declare class PmdsCdkDropdownRangeComponent implements OnInit, OnDestroy, AfterViewInit {
+    selectFilterView: ElementRef;
+    dataQA: string;
+    decimalCharacter: '.' | ',';
+    fromFormControlName: string;
+    isDisabled: boolean;
+    literals: IPmdsCdkDropdownRangeLiterals;
+    max: Date;
+    maxDecLength: number;
+    maxIntLength: number;
+    maxNumber: number;
+    min: Date;
+    minNumber: number;
+    mode: 'date' | 'number';
+    pattern: TPmdsCdkDatepickerDateFormat;
+    placeholder: string;
+    skeleton: boolean;
+    toFormControlName: string;
+    selectChange: EventEmitter<IPmdsDropdownRangeSelect>;
+    disabledApply: boolean;
+    componentSelector: string;
+    fromControl: FormControl | null;
+    omitEvent: boolean;
+    provisionalValue: IPmdsDropdownRangeSelect;
+    showOptions: boolean;
+    toControl: FormControl | null;
+    private formGroupDirective;
+    private renderer;
+    private destroy$;
+    private unlistener;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    get datepickerLiterals(): IPmdsCdkDatepickerLiterals;
+    toggleShowOption(): void;
+    setSelection(): void;
+    clear(): void;
+    private checkDisableButton;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDropdownRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDropdownRangeComponent, "pmds-cdk-dropdown-range", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "decimalCharacter": { "alias": "decimalCharacter"; "required": false; }; "fromFormControlName": { "alias": "fromFormControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "max": { "alias": "max"; "required": false; }; "maxDecLength": { "alias": "maxDecLength"; "required": false; }; "maxIntLength": { "alias": "maxIntLength"; "required": false; }; "maxNumber": { "alias": "maxNumber"; "required": false; }; "min": { "alias": "min"; "required": false; }; "minNumber": { "alias": "minNumber"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "toFormControlName": { "alias": "toFormControlName"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkFileDownloaderInfoLiterals {
+    download?: string;
+    failedTo?: string;
+    subTitle?: string;
+    processing?: string;
+    cancel?: string;
+    showErrors?: string;
+}
+
+interface IPmdsCdkFileDownloaderInfoFile {
+    createdAt: string;
+    fileName: string;
+    id: string;
+    status: TPmdsCdkFileDownloaderInfoStatus;
+    url?: string;
+}
+interface IPmdsCdkFileDownloaderInfoButtons {
+    label: string;
+    icon: string;
+    actionFn: (file?: any) => void;
+}
+type TPmdsCdkFileDownloaderInfoStatus = 'COMPLETED' | 'FAILURE' | 'PROCESSING' | 'PENDING' | 'WAITING_VIRTUAL_ACCOUNTS' | '';
+
+declare class PmdsCdkFileDownloaderInfoComponent {
+    dataQA: string;
+    file: IPmdsCdkFileDownloaderInfoFile;
+    literals: IPmdsCdkFileDownloaderInfoLiterals;
+    buttons: IPmdsCdkFileDownloaderInfoButtons[];
+    errorIncluded: boolean;
+    skeleton: boolean;
+    cancelClick: EventEmitter<IPmdsCdkFileDownloaderInfoFile>;
+    errorsDisplayed: boolean;
+    componentSelector: string;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkFileDownloaderInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkFileDownloaderInfoComponent, "pmds-cdk-file-downloader-info", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "file": { "alias": "file"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "errorIncluded": { "alias": "errorIncluded"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "cancelClick": "cancelClick"; }, never, ["*"], true, never>;
+}
+
+declare class PmdsCdkFormErrorMessageComponent implements OnInit, OnDestroy, OnChanges {
+    control: FormControl | AbstractControl;
+    controlName: string;
+    label: string;
+    dataQA: string;
+    hideError: boolean;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    errorLiterals$: BehaviorSubject<string[]>;
+    componentSelector: string;
+    private destroy$;
+    get formError(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    private evaluateErrors;
+    private lowerCaseFirstLetter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkFormErrorMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkFormErrorMessageComponent, "pmds-cdk-form-error-message", never, { "control": { "alias": "control"; "required": false; }; "controlName": { "alias": "controlName"; "required": false; }; "label": { "alias": "label"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "hideError": { "alias": "hideError"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkOptionDropdown {
+    icon?: string;
+    label: string;
+    sublabel?: string;
+    sublabelIcon?: string;
+    flagCode?: string;
+    category?: string;
+    showCategory?: boolean;
+    value: string;
+}
+
+declare class PmdsCdkPageHeaderComponent implements OnInit, OnChanges {
+    back: string;
+    dataQA: string;
+    dropdownDefaultOption: IPmdsCdkOptionDropdown;
+    dropdownOptions: IPmdsCdkOptionDropdown[];
+    dropdownPlaceholder: string;
+    firstLevel: boolean;
+    iconSubtitle: string;
+    showBackButton: boolean;
+    showCloseButton: boolean;
+    showDivider: boolean;
+    skeleton: boolean;
+    subtitle: string;
+    title: string;
+    clickBackButton: EventEmitter<void>;
+    clickCloseButton: EventEmitter<void>;
+    selectOption: EventEmitter<string>;
+    componentSelector: string;
+    dropdownForm: FormGroup;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setDropdownIfHasOnlyOneValue(): void;
+    setDropdownIfHasDefaultValue(): void;
+    emitBackButton(): void;
+    emitCloseButton(): void;
+    onSelectOption(selection: string[] | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkPageHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkPageHeaderComponent, "pmds-cdk-page-header", never, { "back": { "alias": "back"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "dropdownDefaultOption": { "alias": "dropdownDefaultOption"; "required": false; }; "dropdownOptions": { "alias": "dropdownOptions"; "required": false; }; "dropdownPlaceholder": { "alias": "dropdownPlaceholder"; "required": false; }; "firstLevel": { "alias": "firstLevel"; "required": false; }; "iconSubtitle": { "alias": "iconSubtitle"; "required": false; }; "showBackButton": { "alias": "showBackButton"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; "showDivider": { "alias": "showDivider"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, { "clickBackButton": "clickBackButton"; "clickCloseButton": "clickCloseButton"; "selectOption": "selectOption"; }, never, ["*", "*"], true, never>;
+}
+
+declare class PmdsCdkLoaderComponent implements AfterViewInit {
+    bgClass?: string;
+    dataQA: string;
+    isPrimary: boolean;
+    isFullscreen: boolean;
+    subtitle?: string;
+    title?: string;
+    customStyles: string;
+    embedBody: boolean;
+    componentSelector: string;
+    private renderer;
+    private el;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkLoaderComponent, "pmds-cdk-loader", never, { "bgClass": { "alias": "bgClass"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "isPrimary": { "alias": "isPrimary"; "required": false; }; "isFullscreen": { "alias": "isFullscreen"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "title": { "alias": "title"; "required": false; }; "customStyles": { "alias": "customStyles"; "required": false; }; "embedBody": { "alias": "embedBody"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkModalData<T> {
+    body?: string;
+    data?: T;
+    title?: string;
+}
+interface IPmdsCdkModalConfig {
+    buttons?: IPmdsCdkModalButtons;
+    dataQA?: string;
+    disabledConfirmButton?: boolean;
+    hasBackdropClick?: boolean;
+    hiddenFooter?: boolean;
+    hideBackButton?: boolean;
+    isFullScreenMobile?: boolean;
+    isSidebar?: boolean;
+    modalSize?: TPmdsCdkModalSize;
+    sidebarButtons?: IPmdsCdkModalSidebarButtons[];
+}
+interface IPmdsCdkModalButtons {
+    closeLabel?: string;
+    confirmLabel?: string;
+    backLabel?: string;
+}
+interface IPmdsCdkModalSidebarButtons {
+    label: string;
+    icon: string;
+    actionFn: () => void;
+}
+type TPmdsCdkModalAction = 'confirm' | 'close' | 'cancel' | 'back';
+type TPmdsCdkModalSize = 'small' | 'medium' | 'large';
+declare const PMDS_CDK_MODAL_DATA_TOKEN: InjectionToken<IPmdsCdkModalData<unknown>>;
+
+declare class PmdsCdkModalComponent implements OnInit {
+    hideBackButton: boolean;
+    loading: boolean;
+    componentSelector: string;
+    readonly config: IPmdsCdkModalConfig;
+    readonly data: IPmdsCdkModalData<unknown>;
+    private actualView;
+    private initialIsSidebar;
+    private overlayRef;
+    onResize(): void;
+    ngOnInit(): void;
+    action(action: TPmdsCdkModalAction, close?: boolean): void;
+    get title(): string;
+    get body(): string;
+    get modalSize(): TPmdsCdkModalSize;
+    get sidebarButtons(): IPmdsCdkModalSidebarButtons[] | undefined;
+    get buttonConfirmLabel(): string;
+    get buttonCloseLabel(): string;
+    get buttonBackLabel(): string;
+    get dataQA(): string;
+    get isSidebar(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkModalComponent, "pmds-cdk-modal", never, { "hideBackButton": { "alias": "hideBackButton"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[body]", "[footer]"], true, never>;
+}
+
+declare class PmdsCdkModalRef {
+    private readonly overlayRef;
+    events: Subject<{
+        action: TPmdsCdkModalAction;
+        data?: IPmdsCdkModalData<unknown>;
+    }>;
+    constructor(overlayRef: OverlayRef);
+    close(): void;
+    private removeScrollBlockClassList;
+}
+
+declare class PmdsCdkModalService {
+    dialogRef: PmdsCdkModalRef;
+    private injector;
+    private modalConfig;
+    private overlay;
+    private overlayContainer;
+    open<T>(component: ComponentType<T> | null, config?: IPmdsCdkModalConfig, data?: IPmdsCdkModalData<unknown>): PmdsCdkModalRef;
+    close(): void;
+    private attachModalContainer;
+    private createInjector;
+    private createOverlay;
+    private getOverlayConfig;
+    private setOverlayContainerClassList;
+    private setScrollBlockClassList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsCdkModalService>;
+}
+
+declare const PMDS_CDK_MODAL_DEFAULT_CONFIG: IPmdsCdkModalConfig;
+declare const PMDS_CDK_MODAL_CONFIG_TOKEN: InjectionToken<IPmdsCdkModalConfig>;
+
+interface IPmdsCdkOptionButtons {
+    id: string;
+    label?: string;
+    active?: boolean;
+    icon?: string;
+}
+
+declare class PmdsCdkOptionButtonsComponent implements OnInit {
+    likeDislike: boolean;
+    noSelectionByDefault: boolean;
+    dataQA: string;
+    labels: IPmdsCdkOptionButtons[];
+    selectedOption?: string | null;
+    size: 'small' | 'large';
+    skeleton: boolean;
+    optionSelected: EventEmitter<string>;
+    componentSelector: string;
+    options: IPmdsCdkOptionButtons[];
+    private likeDislikeOptions;
+    ngOnInit(): void;
+    onChange: (_: unknown) => void;
+    onTouch: () => void;
+    selectOption(optionId: string): void;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkOptionButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkOptionButtonsComponent, "pmds-cdk-option-buttons", never, { "likeDislike": { "alias": "likeDislike"; "required": false; }; "noSelectionByDefault": { "alias": "noSelectionByDefault"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "selectedOption": { "alias": "selectedOption"; "required": false; }; "size": { "alias": "size"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "optionSelected": "optionSelected"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkPageControllerComponent {
+    actualItem: number;
+    dataQA: string;
+    onlyDots: boolean;
+    skeleton: boolean;
+    totalItems: number;
+    changePage: EventEmitter<number>;
+    componentSelector: string;
+    changePageEmit(page: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkPageControllerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkPageControllerComponent, "pmds-cdk-page-controller", never, { "actualItem": { "alias": "actualItem"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "onlyDots": { "alias": "onlyDots"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "totalItems": { "alias": "totalItems"; "required": false; }; }, { "changePage": "changePage"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkPaginatorLiterals {
+    items: string;
+    item: string;
+    itemsDisplayed: string;
+    jumpTo: string;
+    labelOf: string;
+    next: string;
+    prev: string;
+    to: string;
+}
+
+interface IPmdsCdkPaginationInfo {
+    actualPage: number;
+    itemsPage: number;
+    total: number;
+}
+
+declare class PmdsCdkPaginatorComponent implements OnInit, OnChanges {
+    dataQA: string;
+    itemsPage: number[];
+    literals: IPmdsCdkPaginatorLiterals | undefined;
+    skeleton: boolean;
+    forceTabletView: boolean;
+    paginationInfo: IPmdsCdkPaginationInfo;
+    changePage: EventEmitter<number>;
+    itemChangedPerPage: EventEmitter<number>;
+    componentSelector: string;
+    arrayPages: number[];
+    jumpToOpen: boolean;
+    lastPage: number;
+    numericalPage: number[];
+    selectValue: number;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    calculateLastPage(): void;
+    calculateNumericalPage(page: number): void;
+    changeInitialNumberPage(): void;
+    changePageEmit(page: number, next?: boolean): void;
+    jumpToPage(value: number): void;
+    changeItemPerPage(value: number): void;
+    private checkLimitsPage;
+    private recalculateInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkPaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkPaginatorComponent, "pmds-cdk-paginator", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "itemsPage": { "alias": "itemsPage"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "forceTabletView": { "alias": "forceTabletView"; "required": false; }; "paginationInfo": { "alias": "paginationInfo"; "required": false; }; }, { "changePage": "changePage"; "itemChangedPerPage": "itemChangedPerPage"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkSelectPaginatorComponent implements OnInit, AfterViewInit, OnDestroy {
+    dataQA: string;
+    initialValue: number;
+    options: number[];
+    selectedItem: number;
+    search: boolean;
+    valueClick: EventEmitter<number>;
+    componentSelector: string;
+    displayValues: boolean;
+    omitEvent: boolean;
+    filterValues: number[];
+    private renderer;
+    private unlistener;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onValueClick(page: number): void;
+    valueFilter(ev: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkSelectPaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkSelectPaginatorComponent, "pmds-cdk-select-paginator", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "options": { "alias": "options"; "required": false; }; "selectedItem": { "alias": "selectedItem"; "required": false; }; "search": { "alias": "search"; "required": false; }; }, { "valueClick": "valueClick"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkProcessHeaderLiterals {
+    title: string;
+    stepTitle: string;
+    stepSubtitle?: string;
+    stepIndex?: number;
+}
+
+interface IPmdsCdkProcessHeaderActions {
+    actionFn: () => void;
+    actionIcon: string;
+    actionLabel: string;
+}
+
+type TPmdsCdkProcessHeaderMaxDesktopWidth = 'max-w-[808px]' | 'max-w-[704px]' | 'max-w-[1016px]';
+
+declare class PmdsCdkProcessHeaderComponent {
+    literals: IPmdsCdkProcessHeaderLiterals;
+    dataQA: string;
+    titleImg: string | null;
+    progress: number;
+    subtitleStyles: string;
+    centerSubtitle: boolean;
+    maxDesktopWidth: TPmdsCdkProcessHeaderMaxDesktopWidth;
+    actions: IPmdsCdkProcessHeaderActions[];
+    backButton: IPmdsCdkProcessHeaderActions;
+    componentSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkProcessHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkProcessHeaderComponent, "pmds-cdk-process-header", never, { "literals": { "alias": "literals"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "titleImg": { "alias": "titleImg"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "subtitleStyles": { "alias": "subtitleStyles"; "required": false; }; "centerSubtitle": { "alias": "centerSubtitle"; "required": false; }; "maxDesktopWidth": { "alias": "maxDesktopWidth"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "backButton": { "alias": "backButton"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type TPmdsCdkToastAnimationState = 'default' | 'closing';
+
+interface IPmdsCdkToastConfig {
+    animation?: {
+        fadeOut: number;
+        fadeIn: number;
+    };
+    dataQA?: string;
+    floating?: boolean;
+    panelClass?: string | string[];
+    position?: {
+        top: number;
+    };
+    timeInterval?: number;
+}
+
+declare class PmdsCdkToastRef {
+    private overlay;
+    constructor(overlay: OverlayRef);
+    close(): void;
+    isVisible(): HTMLElement;
+    getPosition(): DOMRect;
+}
+
+declare class PmdsCdkToastComponent implements OnInit, OnDestroy {
+    actionFnData: () => void;
+    animationState: TPmdsCdkToastAnimationState;
+    componentSelector: string;
+    dataQA: string;
+    readonly config: pm_fuel.IPmdsCdkToastConfig;
+    readonly data: IPmdsCdkAlertData;
+    readonly ref: PmdsCdkToastRef;
+    private intervalId;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    close(): void;
+    action(): void;
+    onFadeFinished(event: AnimationEvent): void;
+    private autoCloseActionFn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkToastComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkToastComponent, "pmds-cdk-toast", never, {}, {}, never, never, true, never>;
+}
+
+declare const PMDS_CDK_TOAST_ANIMATIONS: {
+    readonly fadeToast: AnimationTriggerMetadata;
+};
+
+declare const PMDS_CDK_TOAST_DEFAULT_CONFIG: IPmdsCdkToastConfig;
+declare const PMDS_CDK_TOAST_CONFIG_TOKEN: InjectionToken<IPmdsCdkToastConfig>;
+
+declare class PmdsCdkToastService {
+    lastToast: PmdsCdkToastRef;
+    toastRefs: PmdsCdkToastRef[];
+    private readonly injector;
+    private readonly overlay;
+    private readonly overlayContainer;
+    private readonly toastConfig;
+    show(data: IPmdsCdkAlertData, config?: IPmdsCdkToastConfig): PmdsCdkToastRef;
+    closeAll(): void;
+    private getPositionStrategy;
+    private getInjector;
+    private getToastConfig;
+    private setOverlayContainerClassList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsCdkToastService>;
+}
+
+interface IPmdsCdkDynamicRowComponentConfig {
+    component: Type<any>;
+    cardComponent: Type<any>;
+    styles?: string;
+    selectRowAction?: (row: Type<any>) => void;
+    selectCardAction?: (card: Type<any>) => void;
+    stylesCard?: string;
+    selectedRows?: (rows: Type<any>) => void;
+}
+
+interface IPmdsCdkHeaderConfig {
+    label: string;
+    styles?: string;
+    order?: 'ASC' | 'DES' | undefined;
+    action?: () => void;
+    tooltip?: string;
+    tooltipTitle?: string;
+    tooltipPosition?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+}
+
+interface IPmdsCdkTableConfig {
+    headerColumns: IPmdsCdkHeaderConfig[];
+    rowComponent: IPmdsCdkDynamicRowComponentConfig;
+    fixedColumns?: 'first' | 'first-second';
+    emptyStateLiterals?: {
+        contentWithFilters: string;
+        contentWithoutFilters: string;
+        title: string;
+        buttonText: string;
+        icon?: string;
+    };
+}
+interface IPmdsCdkTablePaginationInfo {
+    actualPage: number;
+    itemsPage: number;
+    total: number;
+}
+interface IPmdsCdkTableEmptyStateData {
+    content: string;
+    title: string;
+    buttonText: string;
+    icon: string;
+}
+
+declare class PmdsCdkTableComponent implements OnInit, OnDestroy, AfterViewInit, OnChanges {
+    infinityScroll: ElementRef;
+    content: ElementRef<HTMLElement> | null;
+    tableContainer: ElementRef<HTMLElement> | null;
+    dataQA: string;
+    showOnlyHeader: boolean;
+    itemsPerPage: number;
+    paginationInfo: IPmdsCdkTablePaginationInfo;
+    showSelectRow: boolean;
+    tableConfig: IPmdsCdkTableConfig;
+    tableData: any[];
+    filteredFields: string[];
+    showBottomBorder: boolean;
+    scrollEnd: EventEmitter<void>;
+    changeView: EventEmitter<'card' | 'table'>;
+    clearFilters: EventEmitter<void>;
+    componentSelector: string;
+    form: FormGroup | undefined;
+    headerColumnsConfig: IPmdsCdkHeaderConfig[];
+    infinityScrollLoading: boolean;
+    headerHoverIndex: number | undefined;
+    noMoreData: boolean;
+    dataCurrentPage: any[];
+    rowComponentConfig: IPmdsCdkDynamicRowComponentConfig;
+    vcRef: ViewContainerRef;
+    render: Renderer2;
+    zone: NgZone;
+    actualView: 'card' | 'table';
+    private destroy$;
+    onResize(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    renderContents(isIntersecting: boolean): void;
+    onHeadClicked(action: (() => void) | undefined, index: number): void;
+    onClicked(item: any): void;
+    onCardClicked(item: Type<unknown>): void;
+    getSelectedRows(): void;
+    ngContentIsEmpty(): boolean;
+    onHeaderMouseEnter(index: number): void;
+    onHeaderMouseOut(): void;
+    private updateStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTableComponent, "pmds-cdk-table", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "showOnlyHeader": { "alias": "showOnlyHeader"; "required": false; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; }; "paginationInfo": { "alias": "paginationInfo"; "required": false; }; "showSelectRow": { "alias": "showSelectRow"; "required": false; }; "tableConfig": { "alias": "tableConfig"; "required": false; }; "tableData": { "alias": "tableData"; "required": false; }; "filteredFields": { "alias": "filteredFields"; "required": false; }; "showBottomBorder": { "alias": "showBottomBorder"; "required": false; }; }, { "scrollEnd": "scrollEnd"; "changeView": "changeView"; "clearFilters": "clearFilters"; }, never, ["*"], true, never>;
+}
+
+declare class PmdsCdkDynamicCardComponent implements OnInit {
+    cardTemplate: ViewContainerRef;
+    data: any[];
+    dynamicCardComponent: Type<any>;
+    rowIndex: number;
+    stylesConfig?: string;
+    ngOnInit(): void;
+    loadComponent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDynamicCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDynamicCardComponent, "pmds-cdk-dynamic-card", never, { "data": { "alias": "data"; "required": false; }; "dynamicCardComponent": { "alias": "dynamicCardComponent"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; "stylesConfig": { "alias": "stylesConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsCdkDynamicRowComponent implements OnInit, OnChanges {
+    rowTemplate: ViewContainerRef;
+    data: any;
+    dynamicRowComponent: Type<any>;
+    rowIndex: number;
+    rowSelected: boolean;
+    showSelectRow?: boolean;
+    stylesConfig?: string;
+    selectRow: EventEmitter<unknown>;
+    form: any;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    loadComponent(): void;
+    loadForm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDynamicRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDynamicRowComponent, "[pmds-cdk-dynamic-row]", never, { "data": { "alias": "data"; "required": false; }; "dynamicRowComponent": { "alias": "dynamicRowComponent"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; "rowSelected": { "alias": "rowSelected"; "required": false; }; "showSelectRow": { "alias": "showSelectRow"; "required": false; }; "stylesConfig": { "alias": "stylesConfig"; "required": false; }; }, { "selectRow": "selectRow"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkRowConfigParam<T> {
+    data: T;
+    rowIndex: number;
+    stylesConfig?: string;
+}
+
+declare enum EPmdsCdkTableRowTypeStyle {
+    tableStyle = "contents [&>td]:align-middle [&>td]:h-[64px] first:[&>td]:pl-4 last:[&>td]:pr-4 last:[&>td]:text-right",
+    tableStyleCheckbox = "contents [&>td]:align-middle [&>td]:h-[64px] last:[&>td]:pr-4 last:[&>td]:text-right"
+}
+
+interface IPmdsCdkTableHeaderInfo {
+    literals: {
+        displaying: string;
+        items: string;
+        item: string;
+        searchedBy: string;
+    };
+    actions?: {
+        actionIcon: string;
+        actionLabel: string;
+        actionFn: () => void;
+    }[];
+}
+
+interface IPmdsCdkRadioButtons {
+    label: string;
+    value: string | number;
+    checked?: boolean;
+}
+
+declare class PmdsCdkRadioButtonsComponent implements OnInit {
+    dataQA: string;
+    forceVertical: boolean;
+    formControlName: string;
+    groupLabel: string;
+    hideLabel: boolean;
+    isDisabled: boolean;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    optional: boolean;
+    options: IPmdsCdkRadioButtons[];
+    skeleton: boolean;
+    checkOption: EventEmitter<string | number>;
+    formControl: AbstractControl;
+    showError: boolean;
+    componentSelector: string;
+    private formGroupDirective;
+    private destroy$;
+    onChange: (_: unknown) => void;
+    onTouch: () => void;
+    ngOnInit(): void;
+    onChecked(value: string | number, index: number): void;
+    writeValue(value: string | number): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkRadioButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkRadioButtonsComponent, "pmds-cdk-radio-buttons", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "forceVertical": { "alias": "forceVertical"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "groupLabel": { "alias": "groupLabel"; "required": false; }; "hideLabel": { "alias": "hideLabel"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "optional": { "alias": "optional"; "required": false; }; "options": { "alias": "options"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "checkOption": "checkOption"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkTabsConfig {
+    isDisabled?: boolean;
+    skipLocationChange?: boolean;
+}
+
+declare class PmdsCdkTabComponent {
+    tabContent: TemplateRef<unknown>;
+    componentPath: string;
+    isActive: boolean;
+    isDisabled: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTabComponent, "pmds-cdk-tab", never, { "componentPath": { "alias": "componentPath"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class PmdsCdkTabsComponent implements AfterContentInit, AfterContentChecked {
+    tabs: QueryList<PmdsCdkTabComponent>;
+    componentPathSelected: string;
+    config: IPmdsCdkTabsConfig;
+    dataQA: string;
+    skeleton: boolean;
+    activeTab: PmdsCdkTabComponent;
+    componentSelector: string;
+    tabs$: Observable<PmdsCdkTabComponent[]>;
+    private readonly activatedRoute;
+    private readonly router;
+    ngAfterContentInit(): void;
+    ngAfterContentChecked(): void;
+    selectTab(tab: PmdsCdkTabComponent): void;
+    private navigateTab;
+    private setActiveTab;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTabsComponent, "pmds-cdk-tabs", never, { "componentPathSelected": { "alias": "componentPathSelected"; "required": false; }; "config": { "alias": "config"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, ["tabs"], never, true, never>;
+}
+
+interface IPmdsCdkTextInputTagCategoryData {
+    assetsFolder?: string;
+    flagCode?: string;
+    label?: string;
+    showIcon?: boolean;
+    tooltip?: string;
+    tooltipPosition?: TPmdsDirectiveTooltipPosition;
+}
+
+type IPmdsCdkTextInputType = 'text' | 'password' | 'number';
+
+type IPmdsCdkTextInputMode = 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
+
+declare class PmdsCdkTextInputComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    input: ElementRef;
+    charactersLeftText: string;
+    dataQA: string;
+    decimalCharacter: '.' | ',';
+    formControlName: string;
+    helperText: string | undefined;
+    icon: string;
+    iconPosition: 'left' | 'right';
+    isDisabled: boolean;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    max: number;
+    maxDecLength: number;
+    maxIntLength: number;
+    maxlength: number;
+    min: number;
+    minlength: number;
+    placeholder: string;
+    showClear: boolean;
+    styles: string;
+    skeleton: boolean;
+    suffix: string;
+    tagCategoryData: IPmdsCdkTextInputTagCategoryData;
+    tooltip: string;
+    tooltipTitle: string;
+    type: IPmdsCdkTextInputType;
+    inputmode: IPmdsCdkTextInputMode;
+    inputChange: EventEmitter<string>;
+    inputFocus: EventEmitter<void>;
+    inputFocusOut: EventEmitter<void>;
+    componentSelector: string;
+    formControl: AbstractControl;
+    inputFocused: boolean;
+    omitClearClick: boolean;
+    showError: boolean;
+    showValueFormatted: boolean;
+    value: string;
+    valueFormatted: string;
+    get inputNgClass(): {
+        'border-color-border-default text-color-text-primary focus:border-color-border-focus': boolean;
+        'border-color-border-error text-color-text-primary focus:border-color-border-error': boolean;
+        '!border-color-border-disabled !text-color-text-disabled !bg-color-surface-disabled pointer-event pointer-events-none': boolean;
+        'text-transparent': boolean;
+        'pr-10': boolean;
+        'pr-4': boolean;
+        '!pl-12': boolean | "";
+        '!pr-[6.25rem]': boolean | "";
+        '!pr-[4.75rem]': boolean | "";
+        '!pr-[5rem]': boolean;
+        '!pr-[5.25rem]': boolean | "";
+        '!pr-14': boolean | "";
+        '!pr-20': boolean | "";
+        '!pr-[3.25rem]': boolean | "";
+        '!pr-28': string | false;
+        'pt-7': string | boolean;
+    };
+    get placeholderNgClass(): {
+        'text-color-text-tertiary': boolean;
+        'text-color-text-disabled pointer-event pointer-events-none': boolean;
+        'left-3': boolean;
+        'left-0': string | false;
+        'pr-10': boolean;
+        'pr-6': boolean;
+        '!pl-12': boolean | "";
+        '!pr-[6.25rem]': boolean | "";
+        '!pr-[5rem]': boolean | "";
+        '!pr-[5.50rem]': boolean;
+        '!pr-[5.5rem]': boolean | "";
+        '!pr-[4.5rem]': boolean | "";
+        '!pr-20': boolean | "";
+        '!pr-[3.50rem]': boolean | "";
+        '!pr-28': string | false;
+    };
+    get clearButtonNgClass(): {
+        'right-[4rem]': string | false;
+        '!right-20': IPmdsCdkTextInputTagCategoryData;
+        '!right-16': string;
+        'right-5': boolean;
+        'right-[3.5rem]': boolean | "";
+        'right-28': string | false;
+        'right-1': boolean | "";
+        'transition-all opacity-100': boolean | "";
+        'opacity-0': boolean;
+        'cursor-text': boolean;
+    };
+    get iconNgClass(): {
+        'pointer-events-none': boolean;
+        'right-[4.75rem]': boolean;
+        'right-5': boolean;
+        'left-3': boolean;
+    };
+    private formGroupDirective;
+    private destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onChange(_: unknown): void;
+    onTouch(): void;
+    onFocusOut(): void;
+    onFocus(): void;
+    updateClearButtonOnFocus(focusedOnInput: boolean): void;
+    checkOmitClick(event: Event): void;
+    clearClick(): void;
+    onInput(event?: Event): void;
+    writeValue(value: string): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    maskInput(event: KeyboardEvent): void;
+    private showFormatValue;
+    private setValueFormatted;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTextInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTextInputComponent, "pmds-cdk-text-input", never, { "charactersLeftText": { "alias": "charactersLeftText"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "decimalCharacter": { "alias": "decimalCharacter"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "max": { "alias": "max"; "required": false; }; "maxDecLength": { "alias": "maxDecLength"; "required": false; }; "maxIntLength": { "alias": "maxIntLength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "min": { "alias": "min"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "styles": { "alias": "styles"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "tagCategoryData": { "alias": "tagCategoryData"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "tooltipTitle": { "alias": "tooltipTitle"; "required": false; }; "type": { "alias": "type"; "required": false; }; "inputmode": { "alias": "inputmode"; "required": false; }; }, { "inputChange": "inputChange"; "inputFocus": "inputFocus"; "inputFocusOut": "inputFocusOut"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkOptionDropdownLiterals {
+    accept?: string;
+    filterBy?: string;
+    cancel?: string;
+    clear?: string;
+    searchPlaceholder?: string;
+    all?: string;
+    showCategory?: string;
+    category?: string;
+}
+
+declare class PmdsCdkDropdownComponent implements OnInit, OnDestroy, AfterViewInit, ControlValueAccessor, OnChanges {
+    selectFilterView: ElementRef;
+    dropdownOptions: ElementRef;
+    inputSearchElement: ElementRef;
+    optionsElement: ElementRef;
+    inputSearch: ElementRef;
+    container: ElementRef;
+    assetsFolder: string;
+    categoryOrder: string[];
+    dataQA: string;
+    disabledShowToTop: boolean;
+    enableSearch: boolean;
+    formControlName: string;
+    isDisabled: boolean;
+    isFilter: boolean;
+    isTitle: boolean;
+    keepValue: boolean;
+    label: string;
+    literals: IPmdsCdkOptionDropdownLiterals;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    multi: boolean;
+    openDefault: boolean;
+    options: IPmdsCdkOptionDropdown[];
+    optionsMinWidth: string;
+    placeholder: string;
+    positionRight: boolean;
+    positionTop: boolean;
+    showCategory: boolean;
+    skeleton: boolean;
+    tooltip: string;
+    tooltipPosition: TPmdsDirectiveTooltipPosition;
+    tooltipTitle: string | null;
+    warningText: string;
+    selectChange: EventEmitter<string[] | string | null>;
+    componentSelector: string;
+    currentFilter: string;
+    filteredOptions: IPmdsCdkOptionDropdown[];
+    footerHeight: number;
+    formControl: AbstractControl;
+    height: number;
+    isPositionTop: boolean;
+    itemHeight: number;
+    labelMulti: string;
+    maxElementsOnHeight: number;
+    omitEvent: boolean;
+    optionMinWidth: string;
+    provisionalSelectedValues: IPmdsCdkOptionDropdown[];
+    searchHeight: number;
+    selectedValues: IPmdsCdkOptionDropdown[];
+    showErrors: boolean;
+    showOptions: boolean;
+    top: number;
+    value: string[] | string | null;
+    private formGroupDirective;
+    private renderer;
+    private destroy$;
+    private unlistener;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    updateShowErrors(): void;
+    ngAfterViewInit(): void;
+    onChange(value: string[] | string | null): void;
+    onTouch: () => undefined;
+    preventClose(evt: Event): void;
+    toggleShowOption(forceClose?: boolean, omitEvent?: boolean): void;
+    cancel(): void;
+    clear(): void;
+    getFilteredOptions(): void;
+    selectOption(option: IPmdsCdkOptionDropdown, event?: Event): void;
+    onSelect(): void;
+    writeValue(value: string[] | string | null): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => undefined): void;
+    setDisabledState(isDisabled: boolean): void;
+    checkOptionSelected(options: IPmdsCdkOptionDropdown[], option: IPmdsCdkOptionDropdown): boolean;
+    private calculateDimensions;
+    private recalculateMultipleSelection;
+    private getTrimmedAndLowerCaseString;
+    private setCategoryShow;
+    private scrollOption;
+    private updateMultiPlaceholder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDropdownComponent, "pmds-cdk-dropdown", never, { "assetsFolder": { "alias": "assetsFolder"; "required": false; }; "categoryOrder": { "alias": "categoryOrder"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "disabledShowToTop": { "alias": "disabledShowToTop"; "required": false; }; "enableSearch": { "alias": "enableSearch"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isFilter": { "alias": "isFilter"; "required": false; }; "isTitle": { "alias": "isTitle"; "required": false; }; "keepValue": { "alias": "keepValue"; "required": false; }; "label": { "alias": "label"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "multi": { "alias": "multi"; "required": false; }; "openDefault": { "alias": "openDefault"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionsMinWidth": { "alias": "optionsMinWidth"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "positionRight": { "alias": "positionRight"; "required": false; }; "positionTop": { "alias": "positionTop"; "required": false; }; "showCategory": { "alias": "showCategory"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipTitle": { "alias": "tooltipTitle"; "required": false; }; "warningText": { "alias": "warningText"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkDatepickerDateInfo {
+    date: Date;
+    label: string;
+}
+
+declare class PmdsCdkDatepickerCalendarComponent implements OnInit, OnChanges {
+    customStyles: string | null;
+    dataQA: string;
+    dateInfo: IPmdsCdkDatepickerDateInfo[];
+    enabledToday: boolean;
+    format: TPmdsCdkDatepickerDateFormat;
+    literals: IPmdsCdkDatepickerLiterals;
+    max: Date | string;
+    min: Date | string;
+    positionRight: boolean;
+    selectableDates: Date[] | string[];
+    setDate: Date | undefined;
+    closeCalendar: EventEmitter<void>;
+    selectDayChange: EventEmitter<Date>;
+    daysArray: number[];
+    disabledNext: boolean;
+    disabledPrev: boolean;
+    disabledNextYear: boolean;
+    disabledPrevYear: boolean;
+    disabledToday: boolean;
+    displayDate: Date;
+    displayMonth: number;
+    displayYear: number;
+    componentSelector: string;
+    firstDayOfMonthWeekday: number;
+    selectedDate: Date | undefined;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    fillCalendardisplayMonth(year: number, month: number): void;
+    changeMonth(increment: number): void;
+    changeYear(year: number): void;
+    setToday(): void;
+    selectDay(day: number, emit?: boolean): void;
+    clickDay(day: number): void;
+    changeSetDate(): void;
+    private setDisplayCalendar;
+    private setDisplayDate;
+    private checkDisplayDate;
+    private checkStringDate;
+    private checkDisabled;
+    private getMinDate;
+    private getMaxDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDatepickerCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDatepickerCalendarComponent, "pmds-cdk-datepicker-calendar", never, { "customStyles": { "alias": "customStyles"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "dateInfo": { "alias": "dateInfo"; "required": false; }; "enabledToday": { "alias": "enabledToday"; "required": false; }; "format": { "alias": "format"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "positionRight": { "alias": "positionRight"; "required": false; }; "selectableDates": { "alias": "selectableDates"; "required": false; }; "setDate": { "alias": "setDate"; "required": false; }; }, { "closeCalendar": "closeCalendar"; "selectDayChange": "selectDayChange"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkDatepickerComponent implements OnInit, OnDestroy, OnChanges, AfterViewInit {
+    datepickerInput: ElementRef | undefined;
+    datepickerCalendar: PmdsCdkDatepickerCalendarComponent | undefined;
+    dataQA: string;
+    dateInfo: IPmdsCdkDatepickerDateInfo[];
+    enabledToday: boolean;
+    formControlName: string;
+    format: TPmdsCdkDatepickerDateFormat;
+    isDisabled: boolean;
+    literals: IPmdsCdkDatepickerLiterals;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    max: Date | string;
+    min: Date | string;
+    placeholder: string;
+    positionRight: boolean;
+    selectableDates: Date[] | string[];
+    skeleton: boolean;
+    currentValue: string;
+    componentSelector: string;
+    omitEvent: boolean;
+    setDate: Date | undefined;
+    show: boolean;
+    showCalendar: boolean;
+    calendarWidthStyle: string | null;
+    private formGroupDirective;
+    private renderer;
+    private destroy$;
+    private unlistener;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    checkValidDate(value?: string, isFocusOut?: boolean, closeOption?: boolean): void;
+    updateSeparator(): any;
+    selectDayChange(date: Date): void;
+    writeValue(value: string): void;
+    onOpenCalendar(): void;
+    private resetValue;
+    private checkLimitDates;
+    private changeDate;
+    private checkStringDate;
+    private getFormatBrowser;
+    private getMinDate;
+    private getMaxDate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkDatepickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkDatepickerComponent, "pmds-cdk-datepicker", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "dateInfo": { "alias": "dateInfo"; "required": false; }; "enabledToday": { "alias": "enabledToday"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "format": { "alias": "format"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "positionRight": { "alias": "positionRight"; "required": false; }; "selectableDates": { "alias": "selectableDates"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPmdsCdkToggleSwitchSize = 'small' | 'medium' | 'large';
+
+declare class PmdsCdkToggleSwitchComponent implements ControlValueAccessor {
+    dataQA: string;
+    label: string;
+    isDisabled: boolean;
+    compact: boolean;
+    size: TPmdsCdkToggleSwitchSize;
+    switchChange: EventEmitter<boolean>;
+    componentSelector: string;
+    value: boolean;
+    sizeClass: Map<TPmdsCdkToggleSwitchSize, string>;
+    private onChangeCallback;
+    private onTouchCallback;
+    setValue(event: Event): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (_: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkToggleSwitchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkToggleSwitchComponent, "pmds-cdk-toggle-switch", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "label": { "alias": "label"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "switchChange": "switchChange"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkTimeInputComponent implements OnInit, OnDestroy, AfterViewInit, ControlValueAccessor {
+    input: ElementRef;
+    optionsContent: ElementRef;
+    dropdownOptions: ElementRef;
+    assetsFolder: string;
+    helperText: string | undefined;
+    isDisabled: boolean;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    placeholder: string;
+    dataQA: string;
+    formControlName: string;
+    options: IPmdsCdkOptionDropdown[];
+    showClear: boolean;
+    skeleton: boolean;
+    showCategory: boolean;
+    inputChange: EventEmitter<string | null>;
+    provisionalSelectedValues: IPmdsCdkOptionDropdown[];
+    componentSelector: string;
+    optionMinWidth: string;
+    formControl: AbstractControl;
+    omitClearClick: boolean;
+    inputFocused: boolean;
+    showError: boolean;
+    showValueFormatted: boolean;
+    value: string | null;
+    showOptions: boolean;
+    omitEvent: boolean;
+    private unlistener;
+    private formGroupDirective;
+    private destroy$;
+    private renderer;
+    get inputType(): "text" | "time";
+    get inputNgClass(): {
+        'border-color-border-default text-color-text-primary focus:border-color-border-focus': boolean;
+        'border-color-border-error text-color-text-primary focus:border-color-border-error': boolean;
+        'border-color-border-disabled text-color-text-disabled bg-color-surface-disabled pointer-event pointer-events-none': boolean;
+        'text-transparent': boolean;
+        'pt-5 !pb-1 !pr-20': string | boolean;
+    };
+    get clockIconNgClass(): {
+        'text-color-icon-error': boolean;
+        'text-color-icon-default': boolean;
+        'text-color-icon-disabled': boolean;
+    };
+    get clearButtonNgClass(): {
+        'transition-all opacity-100': boolean | "" | null;
+        'opacity-0': boolean;
+        'cursor-text': boolean;
+        '!cursor-pointer': boolean;
+        '!cursor-default': boolean;
+    };
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    cancel(): void;
+    onChange(_: unknown): void;
+    onTouch(): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    onPlaceholderClick(): void;
+    checkOmitClick(): void;
+    clearClick(): void;
+    updateClearButtonOnFocus(focusedOnInput: boolean): void;
+    onFocusOut(): void;
+    onInput(event?: Event): void;
+    writeValue(value: string): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnTouched(fn: () => unknown): void;
+    preventClose(evt: Event): void;
+    toggleShowOption(forceClose?: boolean, omitEvent?: boolean, $event?: Event): void;
+    selectOption(option: IPmdsCdkOptionDropdown, event?: Event): void;
+    private updateShowErrors;
+    private setCategoryShow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTimeInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTimeInputComponent, "pmds-cdk-time-input", never, { "assetsFolder": { "alias": "assetsFolder"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "options": { "alias": "options"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "showCategory": { "alias": "showCategory"; "required": false; }; }, { "inputChange": "inputChange"; }, never, never, true, never>;
+}
+
+type TPmdsCdkTagLabelColor = 'red' | 'green' | 'yellow' | 'grey' | 'blue';
+
+declare class PmdsCdkTagLabelComponent {
+    color: TPmdsCdkTagLabelColor;
+    label: string;
+    dataQA: string;
+    skeleton: boolean;
+    componentSelector: string;
+    colorSet: {
+        red: string;
+        green: string;
+        blue: string;
+        grey: string;
+        yellow: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTagLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTagLabelComponent, "pmds-cdk-tag-label", never, { "color": { "alias": "color"; "required": false; }; "label": { "alias": "label"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkSteps {
+    title: string;
+    status: IPmdsCdkStepStatus;
+    observations?: IPmdsCdkStepObservation[];
+    subSteps?: IPmdsCdkSteps[];
+    alert?: IPmdsCdkStepAlert;
+    colorCode?: colorCode;
+}
+declare enum IPmdsCdkStepStatus {
+    Completed = "completed",
+    Current = "current",
+    UpComing = "up-coming",
+    LastComplete = "last-complete",
+    Error = "error"
+}
+type colorCode = 'red' | 'grey' | 'green' | 'blue' | 'yellow';
+interface IPmdsCdkStepObservation {
+    date?: Date | string;
+    message?: string;
+    agent?: string;
+}
+interface IPmdsCdkStepAlert {
+    alertTitle?: string;
+    alertSubtitle?: string;
+}
+interface IPmdsCdkStepAttributes {
+    alertType?: TPmdsCdkAlertType;
+    readMore: boolean;
+    readContent: string;
+    collapse: boolean;
+}
+
+declare class PmdsCdkTimelineTrackingComponent implements OnInit {
+    collapseIconAnimation?: boolean;
+    dataQA: string;
+    dateLocale: string;
+    readLessContent: string;
+    readMoreContent: string;
+    steps: IPmdsCdkSteps[];
+    skeleton: boolean;
+    attributesList: IPmdsCdkStepAttributes[];
+    colorSet: {
+        red: string;
+        green: string;
+        grey: string;
+        blue: string;
+        yellow: string;
+    };
+    componentSelector: string;
+    isReady: boolean;
+    subAttributesList: IPmdsCdkStepAttributes[];
+    readonly stepStatus: typeof IPmdsCdkStepStatus;
+    ngOnInit(): void;
+    generateAttributes(step: IPmdsCdkSteps, attributesList: IPmdsCdkStepAttributes[]): void;
+    generateAlertTypes(step: IPmdsCdkSteps, attributes: IPmdsCdkStepAttributes): void;
+    readChange(isStep: boolean, stepIndex: number): void;
+    collapseAction(stepAttributes: IPmdsCdkStepAttributes): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTimelineTrackingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTimelineTrackingComponent, "pmds-cdk-timeline-tracking", never, { "collapseIconAnimation": { "alias": "collapseIconAnimation"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "dateLocale": { "alias": "dateLocale"; "required": false; }; "readLessContent": { "alias": "readLessContent"; "required": false; }; "readMoreContent": { "alias": "readMoreContent"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPmdsCdkCardsFileUploadStates = 'initial' | 'loading' | 'error';
+
+interface IPmdsCdkCardsFileUploadLiterals {
+    chooseFileTitle: string;
+    chooseFileSubtitle: string;
+    loadingTitle: string;
+    loadingSubtitle: string;
+    button: string;
+    errorText: string;
+    errorMultipleText?: string;
+    errorTypeText?: string;
+    errorFileMax?: string;
+    errorMaxSize?: string;
+}
+
+declare class PmdsCdkCardsFileUploadComponent implements OnChanges {
+    selectFilesInput: ElementRef;
+    accept: string;
+    dataQA: string;
+    literals: IPmdsCdkCardsFileUploadLiterals;
+    multiFiles: boolean;
+    maxFiles: number;
+    maxSize: number;
+    disabledLoading: boolean;
+    skeleton: boolean;
+    state: TPmdsCdkCardsFileUploadStates;
+    fileSelected: EventEmitter<File | FileList>;
+    stateChange: EventEmitter<TPmdsCdkCardsFileUploadStates>;
+    componentSelector: string;
+    errorText: string;
+    isDragover: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    onDrop(event: DragEvent): void;
+    selectFile(event: Event): void;
+    onDragOver(event: DragEvent): void;
+    private checkAcceptFiles;
+    private checkSizeFiles;
+    private updateValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCardsFileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCardsFileUploadComponent, "pmds-cdk-cards-file-upload", never, { "accept": { "alias": "accept"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "multiFiles": { "alias": "multiFiles"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "disabledLoading": { "alias": "disabledLoading"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "fileSelected": "fileSelected"; "stateChange": "stateChange"; }, never, never, true, never>;
+}
+
+type TPmdsCdkCountryLabelSize = 'small' | 'large';
+
+declare class PmdsCdkCountryLabelComponent implements OnInit, OnChanges {
+    assetsFolder: string;
+    codeCountry: string;
+    dataQA: string;
+    label: string;
+    showLabel: boolean;
+    size: TPmdsCdkCountryLabelSize;
+    skeleton: boolean;
+    componentSelector: string;
+    src: string;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    updateUrl(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCountryLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCountryLabelComponent, "pmds-cdk-country-label", never, { "assetsFolder": { "alias": "assetsFolder"; "required": false; }; "codeCountry": { "alias": "codeCountry"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "label": { "alias": "label"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "size": { "alias": "size"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsCdkTagCategoryComponent implements OnInit, OnChanges {
+    assetsFolder: string;
+    dataQA: string;
+    flagCode: string;
+    isDisabled: boolean;
+    label: string;
+    tooltip: string;
+    skeleton: boolean;
+    showIcon: boolean;
+    tooltipPosition: TPmdsDirectiveTooltipPosition;
+    src: string;
+    componentSelector: string;
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    setSrc(): void;
+    updateUrl(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTagCategoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTagCategoryComponent, "pmds-cdk-tag-category", never, { "assetsFolder": { "alias": "assetsFolder"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "flagCode": { "alias": "flagCode"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkExpansionPanelActions {
+    icon: string;
+    label: string;
+    actionFn: (data?: any) => void;
+}
+
+declare class PmdsCdkExpansionPanelComponent implements OnInit {
+    optionsContent: ElementRef;
+    actions: IPmdsCdkExpansionPanelActions[];
+    dataQA: string;
+    openByDefault: boolean;
+    title: string;
+    tooltip: string;
+    skeleton: boolean;
+    skeletonOpen: boolean;
+    open: boolean;
+    showOptions: boolean;
+    omitEvent: boolean;
+    componentSelector: string;
+    private renderer;
+    private unlistener;
+    ngAfterViewInit(): void;
+    ngOnInit(): void;
+    toggleExpansionPanelState(): void;
+    showContent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkExpansionPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkExpansionPanelComponent, "pmds-cdk-expansion-panel", never, { "actions": { "alias": "actions"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "openByDefault": { "alias": "openByDefault"; "required": false; }; "title": { "alias": "title"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "skeletonOpen": { "alias": "skeletonOpen"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class PmdsCdkButtonFloatingComponent {
+    isDisabled: boolean;
+    icon: string;
+    dataQA: string;
+    buttonClick: EventEmitter<void>;
+    componentSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkButtonFloatingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkButtonFloatingComponent, "pmds-cdk-button-floating", never, { "isDisabled": { "alias": "isDisabled"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+type TPmdsCdkBadgetNumbersSize = 'small' | 'medium' | 'large';
+
+declare class PmdsCdkBadgetNumbersComponent {
+    label: number;
+    size: TPmdsCdkBadgetNumbersSize;
+    isActive: boolean;
+    dataQA: string;
+    hasBackground: boolean;
+    componentSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkBadgetNumbersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkBadgetNumbersComponent, "pmds-cdk-badget-numbers", never, { "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "hasBackground": { "alias": "hasBackground"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsCdkSkeletonComponent implements AfterViewInit {
+    line: ElementRef;
+    content: ElementRef;
+    dataQA: string;
+    style: string;
+    componentSelector: string;
+    showLine: boolean;
+    top: string;
+    left: string;
+    height: string;
+    onResize(): void;
+    ngAfterViewInit(): void;
+    private setSizes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkSkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkSkeletonComponent, "pmds-cdk-skeleton", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkAccordionLiterals {
+    title: string;
+    elements?: string;
+}
+
+interface IPmdsCdkAccordionTags {
+    label: string;
+    flagCode?: string;
+    assetsFolder?: string;
+}
+
+declare class PmdsCdkAccordionComponent {
+    content: string[];
+    dataQA: string;
+    hideBottomBorder: boolean;
+    literals: IPmdsCdkAccordionLiterals;
+    open: boolean;
+    skeleton: boolean;
+    skeletonOpen: boolean;
+    tags: IPmdsCdkAccordionTags[];
+    componentSelector: string;
+    toggleAccordion(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkAccordionComponent, "pmds-cdk-accordion", never, { "content": { "alias": "content"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "hideBottomBorder": { "alias": "hideBottomBorder"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "open": { "alias": "open"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "skeletonOpen": { "alias": "skeletonOpen"; "required": false; }; "tags": { "alias": "tags"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IPmdsCdkErrorPageLiterals {
+    401?: IPmdsCdkErrorPageLiteralsError;
+    403?: IPmdsCdkErrorPageLiteralsError;
+    404?: IPmdsCdkErrorPageLiteralsError;
+    500?: IPmdsCdkErrorPageLiteralsError;
+    503?: IPmdsCdkErrorPageLiteralsError;
+}
+interface IPmdsCdkErrorPageLiteralsError {
+    error: string;
+    title: string;
+    paragraph: string;
+    buttons?: [IPmdsCdkErrorPageButtons] | [IPmdsCdkErrorPageButtons, IPmdsCdkErrorPageButtons];
+}
+interface IPmdsCdkErrorPageButtons {
+    label: string;
+    type: 'primary' | 'secondary';
+    disabled?: boolean;
+    action: () => void;
+}
+
+type TPmdsCdkErrorPageType = '401' | '403' | '404' | '500' | '503';
+
+declare class PmdsCdkErrorPageComponent implements OnInit {
+    dataQA: string;
+    errorCode: TPmdsCdkErrorPageType;
+    literals: IPmdsCdkErrorPageLiterals;
+    isModule: boolean;
+    buttons: IPmdsCdkErrorPageButtons[] | undefined;
+    componentSelector: string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkErrorPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkErrorPageComponent, "pmds-cdk-error-page", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "errorCode": { "alias": "errorCode"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "isModule": { "alias": "isModule"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkButtonModalButton {
+    type: PmdsCdkButtonType;
+    label: string;
+    action?: () => void;
+    icon?: string;
+    iconPosition?: 'left' | 'right';
+    disabled?: boolean;
+    dropdownButtons?: IPmdsCdkButtonModalButton[];
+}
+
+declare class PmdsCdkButtonModalComponent implements OnInit, OnDestroy, AfterViewInit {
+    buttons: IPmdsCdkButtonModalButton[];
+    hasBackdropClick: boolean;
+    dataQA: string;
+    backLiteral: string;
+    show: boolean | undefined;
+    showChange: EventEmitter<boolean>;
+    componentSelector: string;
+    buttonShowed: IPmdsCdkButtonModalButton[];
+    showBackbutton: boolean;
+    private renderer;
+    private el;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    buttonClick(button: IPmdsCdkButtonModalButton): void;
+    backClick(): void;
+    updateShow(value: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkButtonModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkButtonModalComponent, "pmds-cdk-button-modal", never, { "buttons": { "alias": "buttons"; "required": false; }; "hasBackdropClick": { "alias": "hasBackdropClick"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "backLiteral": { "alias": "backLiteral"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, { "showChange": "showChange"; }, never, never, true, never>;
+}
+
+type TPmdsCdkCopyClipboardIconPosition = 'left' | 'right';
+
+declare class PmdsCdkCopyClipboardComponent {
+    textToCopy: string;
+    dataQA: string;
+    hideLabelMobile: boolean;
+    literal: string;
+    literalCopied: string;
+    iconPosition: TPmdsCdkCopyClipboardIconPosition;
+    copyClick: EventEmitter<void>;
+    componentSelector: string;
+    showCopied: boolean;
+    private clipboard;
+    copyTextToClipboard(event: MouseEvent): void;
+    private initCopiedTimer;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCopyClipboardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCopyClipboardComponent, "pmds-cdk-copy-clipboard", never, { "textToCopy": { "alias": "textToCopy"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "hideLabelMobile": { "alias": "hideLabelMobile"; "required": false; }; "literal": { "alias": "literal"; "required": false; }; "literalCopied": { "alias": "literalCopied"; "required": false; }; "iconPosition": { "alias": "iconPosition"; "required": false; }; }, { "copyClick": "copyClick"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkNotificationsPopoverNotification {
+    id: string;
+    date: string;
+    action?: () => void;
+    title: string;
+    seen: boolean;
+    info: string;
+}
+interface IPmdsCdkNotificationsPopoverLiterals {
+    notifications: string;
+}
+interface IPmdsCdkNotificationsPopoverButton {
+    label: string;
+    action: () => void;
+    icon?: string;
+}
+
+declare class PmdsCdkNotificationsPopoverComponent {
+    dataQA: string;
+    notifications: IPmdsCdkNotificationsPopoverNotification[];
+    literals: IPmdsCdkNotificationsPopoverLiterals;
+    button: IPmdsCdkNotificationsPopoverButton;
+    checkedNotifications: EventEmitter<string>;
+    buttonClick: EventEmitter<void>;
+    componentSelector: string;
+    notificationClicked(index: number, id: string): void;
+    onButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkNotificationsPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkNotificationsPopoverComponent, "pmds-cdk-notifications-popover", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "notifications": { "alias": "notifications"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "button": { "alias": "button"; "required": false; }; }, { "checkedNotifications": "checkedNotifications"; "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkMessage {
+    id: string;
+    literals: IPmdsCdkMessageLiterals;
+    typeUser: TPmdsCdkUserType;
+}
+interface IPmdsCdkMessageLiterals {
+    published?: string;
+    profileLabel?: string;
+    title: string;
+    content: string;
+    date: string;
+}
+type TPmdsCdkUserType = 'otherMessage' | 'myMessage';
+type TPmdsCdkMessageType = 'comment' | 'chat';
+
+declare class PmdsCdkMessageComponent {
+    dataQA: string;
+    messages: IPmdsCdkMessage[];
+    literals: IPmdsCdkMessageLiterals;
+    messageType: TPmdsCdkMessageType;
+    userType: TPmdsCdkUserType;
+    componentSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkMessageComponent, "pmds-cdk-message", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "messages": { "alias": "messages"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "messageType": { "alias": "messageType"; "required": false; }; "userType": { "alias": "userType"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkStickyButtonBarButton {
+    type: PmdsCdkButtonType;
+    label: string;
+    action?: () => void;
+    icon?: string;
+    iconPosition?: 'left' | 'right';
+    disabled?: boolean;
+    dropdownButtons?: IPmdsCdkStickyButtonBarButton[];
+}
+
+declare class PmdsCdkStickyButtonBarComponent implements OnInit, AfterViewInit, OnDestroy, OnChanges {
+    elem: ElementRef;
+    buttons: IPmdsCdkStickyButtonBarButton[];
+    dataQA: string;
+    position: 'fixed' | 'bottom';
+    floatingButton: boolean;
+    showDesktop: boolean;
+    show: boolean;
+    showChange: EventEmitter<boolean>;
+    close: EventEmitter<void>;
+    private renderer;
+    private el;
+    buttonShowed: IPmdsCdkStickyButtonBarButton[];
+    componentSelector: string;
+    showBackButton: boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    buttonClick(button: IPmdsCdkStickyButtonBarButton): void;
+    goToFirstLevel(): void;
+    closeMenu(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkStickyButtonBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkStickyButtonBarComponent, "pmds-cdk-sticky-button-bar", never, { "buttons": { "alias": "buttons"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "position": { "alias": "position"; "required": false; }; "floatingButton": { "alias": "floatingButton"; "required": false; }; "showDesktop": { "alias": "showDesktop"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, { "showChange": "showChange"; "close": "close"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkCardsInformationLiterals {
+    icon: string;
+    title: string;
+    subtitle: string;
+}
+interface IPmdsCdkCardsInformationAction {
+    label: string;
+    icon: string;
+    actionFn: () => void;
+}
+
+declare class PmdsCdkCardsInformationComponent implements OnInit {
+    dataQA: string;
+    disabled: boolean;
+    toggle: boolean;
+    literals: IPmdsCdkCardsInformationLiterals;
+    actions: IPmdsCdkCardsInformationAction[];
+    create: IPmdsCdkCardsInformationAction;
+    skeleton: boolean;
+    enabledChange: EventEmitter<boolean>;
+    selected: boolean;
+    toggleForm: FormGroup;
+    componentSelector: string;
+    ngOnInit(): void;
+    toggleClicked(selected: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCardsInformationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCardsInformationComponent, "pmds-cdk-cards-information", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "actions": { "alias": "actions"; "required": false; }; "create": { "alias": "create"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "enabledChange": "enabledChange"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkStepperComponent {
+    dataQA: string;
+    steps: string[];
+    current: number;
+    skeleton: boolean;
+    componentSelector: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkStepperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkStepperComponent, "pmds-cdk-stepper", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "current": { "alias": "current"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PmdsCdkTextareaComponent implements OnInit {
+    dataQA: string;
+    charactersLeftText: string;
+    formControlName: string;
+    isDisabled: boolean;
+    maxlength: number;
+    placeholder: string;
+    skeleton: boolean;
+    helperText: string;
+    tooltip: string;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    formControl: AbstractControl;
+    isFocus: boolean;
+    showError: boolean;
+    value: string;
+    componentSelector: string;
+    private formGroupDirective;
+    ngOnInit(): void;
+    onChange(_: unknown): void;
+    onTouch(): void;
+    onFocusOut(): void;
+    onInput(event?: Event): void;
+    checkOmitClick(event: Event): void;
+    clickOnClear(event?: Event): void;
+    writeValue(value: string): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTextareaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTextareaComponent, "pmds-cdk-textarea", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "charactersLeftText": { "alias": "charactersLeftText"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type IPmdsCdkTextFieldType = 'two-line-bold' | 'two-line-tag' | 'two-line-country' | 'two-line-regular' | 'list' | 'two-line-link' | 'two-line-figure-bold' | 'inline-bold' | 'inline-regular' | 'inline-figure-bold' | 'inline-figure-regular';
+
+interface IPmdsCdkTextField {
+    label: string;
+    value: string | string[];
+    tagColor?: TPmdsCdkTagLabelColor;
+    assetsFolder?: string;
+    flagCode?: string;
+    tooltip?: string;
+    copyValue?: string;
+    actionFn?: () => void;
+}
+
+declare class PmdsCdkTextFieldComponent implements OnInit, OnChanges {
+    dataQA: string;
+    field: IPmdsCdkTextField;
+    iconValue: string;
+    skeleton: boolean;
+    type: IPmdsCdkTextFieldType;
+    typeMobile: IPmdsCdkTextFieldType;
+    disabledEllipsis: boolean;
+    actualView: 'mobile' | 'screen';
+    componentSelector: string;
+    listValues: string[];
+    value: string;
+    typeShow: IPmdsCdkTextFieldType;
+    inlineTypes: string[];
+    flexTypes: string[];
+    onResize(): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private parseValues;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTextFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTextFieldComponent, "pmds-cdk-text-field", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "field": { "alias": "field"; "required": false; }; "iconValue": { "alias": "iconValue"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "type": { "alias": "type"; "required": false; }; "typeMobile": { "alias": "typeMobile"; "required": false; }; "disabledEllipsis": { "alias": "disabledEllipsis"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface IPmdsCdkTableCompleteResponseModel<T> {
+    total: number;
+    registers: T[];
+}
+
+declare abstract class PmdsCdkTableCompleteDataAbstractService {
+    abstract dataCollectionHasChanged: Subject<IPmdsCdkTableCompleteResponseModel<any>>;
+    abstract loading: Subject<boolean>;
+    abstract errorLoadingData: Subject<boolean>;
+    abstract filterHasChanged: Subject<void>;
+    abstract httpClient: HttpClient;
+    abstract limit: number;
+    abstract offset: number;
+    abstract filter: any;
+    abstract setLimit(limit: number): void;
+    abstract setOffset(offset: number): void;
+    abstract setFilter<T>(filter: T): void;
+    abstract getData(sortFields?: {
+        field: string;
+        order: 'DES' | 'ASC';
+    }[]): void;
+}
+
+interface IPmdsCdkTableCompleteConfig {
+    showSelectRow?: boolean;
+    tableConfig: IPmdsCdkBasicTableConfig;
+    resService: PmdsCdkTableCompleteDataAbstractService;
+    paginatorLiterals?: IPmdsCdkPaginatorLiterals;
+    tableInfoHeader?: IPmdsCdkTableHeaderInfo;
+}
+interface IPmdsCdkBasicTableConfig {
+    headerColumns: IPmdsCdkHeaderCompleteConfig[];
+    rowComponent: IPmdsCdkDynamicRowDefaultComponentConfig;
+    fixedColumns?: 'first' | 'first-second';
+    emptyStateLiterals?: {
+        contentWithFilters: string;
+        contentWithoutFilters: string;
+        title: string;
+        buttonText: string;
+    };
+}
+interface IPmdsCdkHeaderCompleteConfig {
+    label: string;
+    sortableField?: string;
+    order?: 'ASC' | 'DES' | undefined;
+    styles?: string;
+    tooltip?: string;
+    tooltipTitle?: string;
+    tooltipPosition?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+}
+interface IPmdsCdkDynamicRowDefaultComponentConfig {
+    component?: Type<any>;
+    cardComponent?: Type<any>;
+    selectRowAction?: (row: Type<any>) => void;
+    selectCardAction?: (card: Type<any>) => void;
+    selectedRows?: (rows: Type<any>) => void;
+}
+
+declare class PmdsCdkTableCompleteComponent implements OnInit, OnDestroy, OnChanges {
+    tableConfiguration: IPmdsCdkTableCompleteConfig;
+    dataQA: string;
+    sortOneColumnAtATime: boolean;
+    filteredFields: string[];
+    cardItemsPerLoad: number;
+    skeleton: boolean;
+    itemsPage: number[];
+    forceTabletView: boolean;
+    initialPaginationInfo: Partial<IPmdsCdkPaginationInfo>;
+    changePage: EventEmitter<number>;
+    changeView: EventEmitter<'card' | 'table'>;
+    clearFilters: EventEmitter<void>;
+    itemChangedPerPage: EventEmitter<number>;
+    actualView: 'card' | 'table';
+    componentSelector: string;
+    data: never[];
+    initialLoading: boolean;
+    loadingOnFilterChange: boolean;
+    loadingOnViewChange: boolean;
+    paginationInfo: IPmdsCdkPaginationInfo;
+    sortableFields: {
+        field: string;
+        order: 'DES' | 'ASC';
+    }[];
+    tableConfig: IPmdsCdkTableConfig | null;
+    private destroy$;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    get filteredFieldsString(): string;
+    get infoHeaderActions(): {
+        actionIcon: string;
+        actionLabel: string;
+        actionFn: () => void;
+    }[];
+    get showPagination(): boolean | undefined;
+    onItemChangedPerPage(itemsPage: number): void;
+    onChangePage(page: number): void;
+    tableScrollEnd(): void;
+    tableChangeView(ev: 'card' | 'table'): void;
+    sortByField(field: string): void;
+    private getData;
+    private setDefaultComponentsIfNecessary;
+    private setInitialSortFields;
+    private parseTableConfig;
+    private getParsedHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTableCompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTableCompleteComponent, "pmds-cdk-table-complete", never, { "tableConfiguration": { "alias": "tableConfiguration"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "sortOneColumnAtATime": { "alias": "sortOneColumnAtATime"; "required": false; }; "filteredFields": { "alias": "filteredFields"; "required": false; }; "cardItemsPerLoad": { "alias": "cardItemsPerLoad"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "itemsPage": { "alias": "itemsPage"; "required": false; }; "forceTabletView": { "alias": "forceTabletView"; "required": false; }; "initialPaginationInfo": { "alias": "initialPaginationInfo"; "required": false; }; }, { "changePage": "changePage"; "changeView": "changeView"; "clearFilters": "clearFilters"; "itemChangedPerPage": "itemChangedPerPage"; }, never, ["*"], true, never>;
+}
+
+declare class PmdsCdkTableCompleteDataService implements PmdsCdkTableCompleteDataAbstractService {
+    dataCollectionHasChanged: Subject<IPmdsCdkTableCompleteResponseModel<any>>;
+    loading: BehaviorSubject<boolean>;
+    errorLoadingData: BehaviorSubject<boolean>;
+    filterHasChanged: Subject<void>;
+    httpClient: HttpClient;
+    offset: number;
+    limit: number;
+    filter: any;
+    setFilter<T>(filter: T): void;
+    setLimit(limit: number): void;
+    setOffset(offset: number): void;
+    getData(sortFields?: {
+        field: string;
+        order: 'DES' | 'ASC';
+    }[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTableCompleteDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PmdsCdkTableCompleteDataService>;
+}
+
+interface IPmdsCdkButtonsDropdownOption {
+    label: string;
+    actionFn: () => void;
+}
+type TPmdsCdkButtonModalSize = 'large' | 'small';
+type TPmdsCdkButtonModalType = 'double' | 'single' | 'tertiary' | 'double-secondary' | 'single-secondary';
+
+declare class PmdsCdkButtonDropdownComponent implements AfterViewInit, OnDestroy {
+    optionsContent: ElementRef;
+    buttonLabel: string;
+    dataQA: string;
+    openLeft: boolean;
+    options: IPmdsCdkButtonsDropdownOption[];
+    size: TPmdsCdkButtonModalSize;
+    smallFit: boolean;
+    type: TPmdsCdkButtonModalType;
+    doubleAction: EventEmitter<void>;
+    showOptions: boolean;
+    omitEvent: boolean;
+    componentSelector: string;
+    private renderer;
+    private unlistener;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    showContent(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkButtonDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkButtonDropdownComponent, "pmds-cdk-button-dropdown", never, { "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "openLeft": { "alias": "openLeft"; "required": false; }; "options": { "alias": "options"; "required": false; }; "size": { "alias": "size"; "required": false; }; "smallFit": { "alias": "smallFit"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "doubleAction": "doubleAction"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkFooterLiterals {
+    bannerText?: string;
+    simpleLink?: string;
+    simpleText?: string;
+}
+
+interface IPmdsCdkFooterLink {
+    label: string;
+    actionFn: () => void;
+}
+
+interface IPmdsCdkFooterAction {
+    icon: string;
+    tittle: string;
+    message: string;
+    actionFn: () => void;
+    tagLabel?: string;
+    tagColor?: TPmdsCdkTagLabelColor;
+}
+
+type TPmdsCdkFooterLayout = 'simple' | 'contact' | 'banner';
+
+declare class PmdsCdkFooterComponent {
+    dataQA: string;
+    type: TPmdsCdkFooterLayout;
+    contactItems: IPmdsCdkFooterAction[];
+    linkItems: IPmdsCdkFooterLink[];
+    literals: IPmdsCdkFooterLiterals;
+    selectorComponent: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkFooterComponent, "pmds-cdk-footer", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "type": { "alias": "type"; "required": false; }; "contactItems": { "alias": "contactItems"; "required": false; }; "linkItems": { "alias": "linkItems"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPmdsCdkHeaderLayout = 'operational' | 'backoffice';
+
+interface IPmdsCdkHeaderLiterals {
+    backofficeLabel?: string;
+    modalTitle?: string;
+}
+
+interface IPmdsCdkMenuOptions {
+    label: string;
+    action?: () => void;
+    icon?: string;
+    children?: {
+        label: string;
+        action: () => void;
+    }[];
+}
+
+interface IPmdsCdkHeaderMobileFooterActionModel {
+    label: string;
+    action?: () => void;
+    icon?: string;
+}
+
+declare class PmdsCdkHeaderComponent implements OnInit, AfterViewInit, OnDestroy {
+    optionsContent: ElementRef;
+    companies: IPmdsCdkOptionDropdown[];
+    dataQA: string;
+    initialCompany: IPmdsCdkOptionDropdown;
+    literals: IPmdsCdkHeaderLiterals;
+    notifications: number;
+    notificationsInfo: IPmdsCdkNotificationsPopoverNotification[];
+    titleNotifications: IPmdsCdkNotificationsPopoverLiterals;
+    buttonNotification: IPmdsCdkNotificationsPopoverButton;
+    photoSrc: string;
+    type: TPmdsCdkHeaderLayout;
+    menuConfig: {
+        menuOptions: IPmdsCdkMenuOptions[];
+    };
+    menuFooterAction: IPmdsCdkHeaderMobileFooterActionModel;
+    changeCompany: EventEmitter<IPmdsCdkOptionDropdown>;
+    notificationSelected: EventEmitter<void>;
+    openMenuClick: EventEmitter<void>;
+    showNotification: boolean;
+    omitEvent: boolean;
+    selectedCompany: string;
+    selectedCompanyLabel: string;
+    selectorComponent: string;
+    isMobile: boolean;
+    showMenu: boolean;
+    documentHeight: number;
+    documentWidth: number;
+    private modalSrv;
+    private unlistener;
+    private renderer;
+    private destroy$;
+    onResize(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    setCompany(companiesValue: string | string[]): void;
+    openModal(): void;
+    toggleMenu(): void;
+    toggleShowOption(forceClose?: boolean, omitEvent?: boolean): void;
+    close(): void;
+    onTouch: () => undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkHeaderComponent, "pmds-cdk-header", never, { "companies": { "alias": "companies"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "initialCompany": { "alias": "initialCompany"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "notifications": { "alias": "notifications"; "required": false; }; "notificationsInfo": { "alias": "notificationsInfo"; "required": false; }; "titleNotifications": { "alias": "titleNotifications"; "required": false; }; "buttonNotification": { "alias": "buttonNotification"; "required": false; }; "photoSrc": { "alias": "photoSrc"; "required": false; }; "type": { "alias": "type"; "required": false; }; "menuConfig": { "alias": "menuConfig"; "required": false; }; "menuFooterAction": { "alias": "menuFooterAction"; "required": false; }; }, { "changeCompany": "changeCompany"; "notificationSelected": "notificationSelected"; "openMenuClick": "openMenuClick"; }, never, never, true, never>;
+}
+
+declare class PmdsCdkButtonAllFiltersComponent {
+    dataQA: string;
+    disabled: boolean;
+    open: boolean;
+    label: string;
+    buttonClick: EventEmitter<void>;
+    componentSelector: string;
+    onButtonClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkButtonAllFiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkButtonAllFiltersComponent, "pmds-cdk-button-all-filters", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "open": { "alias": "open"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkShortcutItem {
+    label: string;
+    icon: string;
+    isDisabled?: boolean;
+    actionFn: () => void;
+}
+
+declare class PmdsCdkShortcutComponent {
+    scrollSection: ElementRef;
+    dataQA: string;
+    flexWidth: boolean;
+    shortcutItems: IPmdsCdkShortcutItem[];
+    skeleton: boolean;
+    componentSelector: string;
+    scrollSectionAction(toEnd: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkShortcutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkShortcutComponent, "pmds-cdk-shortcut", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "flexWidth": { "alias": "flexWidth"; "required": false; }; "shortcutItems": { "alias": "shortcutItems"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPmdsCdkProfilePhotoLayout = 'label' | 'photo';
+
+declare class PmdsCdkProfilePhotoComponent implements OnInit {
+    dataQA: string;
+    label: string;
+    photo: string;
+    type: TPmdsCdkProfilePhotoLayout;
+    componentSelector: string;
+    parseLabel: string;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkProfilePhotoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkProfilePhotoComponent, "pmds-cdk-profile-photo", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "label": { "alias": "label"; "required": false; }; "photo": { "alias": "photo"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPmdsCdkCalendarEventType = 'CONFIRMED' | 'PENDING' | 'SETTLED' | 'CUSTOM';
+
+interface IPmdsCdkCalendarEvent {
+    eventTitle: string;
+    eventSubtitle: string;
+    eventDate: Date;
+    eventType: TPmdsCdkCalendarEventType;
+}
+
+interface IPmdsCdkCalendarLiterals {
+    addEvent: string;
+    today: string;
+    title: string;
+    withoutEvents: string;
+    suffixDays: {
+        fisrt: string;
+        second: string;
+        third: string;
+        others: string;
+    };
+    month: [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+    weekDay: [string, string, string, string, string, string, string];
+}
+
+interface IPmdsCdkCalendarEventShow {
+    [day: number]: {
+        title: string;
+        events: IPmdsCdkCalendarEvent[];
+    };
+}
+
+declare class PmdsCdkCalendarComponent implements OnInit {
+    dataQA: string;
+    events: IPmdsCdkCalendarEvent[];
+    literals: IPmdsCdkCalendarLiterals;
+    showEvents: boolean;
+    isMultiple: boolean;
+    skeleton: boolean;
+    addEvent: EventEmitter<void>;
+    selectEvent: EventEmitter<IPmdsCdkCalendarEvent>;
+    changeMonth: EventEmitter<Date>;
+    componentSelector: string;
+    daySelected: number;
+    daysArray: {
+        day: number;
+        events: IPmdsCdkCalendarEvent[];
+    }[];
+    eventsShow: IPmdsCdkCalendarEventShow | null;
+    firstDayOfMonthWeekday: number;
+    monthSelected: number;
+    selectedDates: Date[];
+    yearSelected: number;
+    ngOnInit(): void;
+    changeMonthClick(change: number): void;
+    selectDay(day: number): void;
+    selectToday(): void;
+    private fillCalendardisplayMonth;
+    private getEvents;
+    private getEventShow;
+    private groupEvent;
+    private getGroupTitle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCalendarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCalendarComponent, "pmds-cdk-calendar", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "events": { "alias": "events"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "showEvents": { "alias": "showEvents"; "required": false; }; "isMultiple": { "alias": "isMultiple"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "addEvent": "addEvent"; "selectEvent": "selectEvent"; "changeMonth": "changeMonth"; }, never, never, true, never>;
+}
+
+type TPmdsCdkTextType = 'module-title' | 'section-title' | 'description' | 'category';
+
+declare class PmdsCdkTextComponent {
+    dataQA: string;
+    type: TPmdsCdkTextType;
+    text: string;
+    componentSelector: string;
+    typeSet: {
+        'section-title': string;
+        'module-title': string;
+        category: string;
+        description: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkTextComponent, "pmds-cdk-text", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "type": { "alias": "type"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type TPmdsCdkMenuSubmenuType = 'OPERATIONAL' | 'ADMIN';
+
+declare class PmdsCdkMenuAndSubmenuComponent implements AfterViewInit, OnDestroy, OnChanges {
+    dataQA: string;
+    selectMenu: string;
+    selectSubmenu: string;
+    menuOptions: IPmdsCdkMenuOptions[];
+    type: TPmdsCdkMenuSubmenuType;
+    selectedMenuItemChange: EventEmitter<{
+        menuItem: string;
+        submenuItem: string;
+    }>;
+    menuComponent: ElementRef;
+    componentSelector: string;
+    selectedMenuItem: string;
+    selectedSubmenuItem: string;
+    openMenu: string;
+    private renderer;
+    private unlistener;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    setMenuItem(menuItem: string): void;
+    openOnHover(menuItem: IPmdsCdkMenuOptions): void;
+    setSubmenuItem(menuItem: string, submenuItem: string): void;
+    selectMenuButton(menuItem: IPmdsCdkMenuOptions, $event: MouseEvent): void;
+    private closeSubmenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkMenuAndSubmenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkMenuAndSubmenuComponent, "pmds-cdk-menu-and-submenu", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "selectMenu": { "alias": "selectMenu"; "required": false; }; "selectSubmenu": { "alias": "selectSubmenu"; "required": false; }; "menuOptions": { "alias": "menuOptions"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "selectedMenuItemChange": "selectedMenuItemChange"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkPendingTaskLiterals {
+    title: string;
+    view: string;
+    viewAll: string;
+    noTasksTitle: string;
+    noTasksMsg: string;
+}
+
+interface IPmdsCdkPendingTaskGroup {
+    label: string;
+    tasks: number;
+}
+
+declare class PmdsCdkPendingTaskComponent implements OnInit {
+    dataQA: string;
+    groupTasks: IPmdsCdkPendingTaskGroup[];
+    literals: IPmdsCdkPendingTaskLiterals;
+    skeleton: boolean;
+    viewAll: EventEmitter<void>;
+    viewGroup: EventEmitter<IPmdsCdkPendingTaskGroup>;
+    componentSelector: string;
+    totalTask: number;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkPendingTaskComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkPendingTaskComponent, "pmds-cdk-pending-task", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "groupTasks": { "alias": "groupTasks"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "viewAll": "viewAll"; "viewGroup": "viewGroup"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkCardsSelectorOptionLiterals {
+    label: string;
+    helperText?: string;
+    value?: string;
+    helperValue?: string;
+    icon?: string;
+}
+interface IPmdsCdkCardsSelectorImages {
+    images?: string[];
+    widthStyle?: string;
+    heightStyle?: string;
+}
+interface IPmdsCdkCardsSelectorTooltip {
+    title?: string;
+    content: string;
+    position?: TPmdsDirectiveTooltipPosition;
+}
+
+declare class PmdsCdkCardsSelectorComponent {
+    dataQA: string;
+    disabled: boolean;
+    id: string;
+    isSelected: boolean;
+    labelImages: IPmdsCdkCardsSelectorImages;
+    literals: IPmdsCdkCardsSelectorOptionLiterals;
+    skeleton: boolean;
+    skeletonAdditionalContent: boolean;
+    tooltip: IPmdsCdkCardsSelectorTooltip | undefined;
+    selected: EventEmitter<string>;
+    componentSelector: string;
+    clicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCardsSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCardsSelectorComponent, "pmds-cdk-cards-selector", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "labelImages": { "alias": "labelImages"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "skeletonAdditionalContent": { "alias": "skeletonAdditionalContent"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
+}
+
+interface IPmdsCdkCardsSettingsItem {
+    tagLabel?: {
+        color: TPmdsCdkTagLabelColor;
+        label: string;
+    };
+    field?: IPmdsCdkTextField;
+    value?: string;
+    checkBoxValue?: boolean;
+    switchValue?: boolean;
+}
+
+type TPmdsCdkCardsSettingsType = 'moveDelete' | 'toggle';
+
+declare class PmdsCdkCardsSettingsComponent {
+    dataQA: string;
+    settingsItems: IPmdsCdkCardsSettingsItem[];
+    showCheckbox: boolean;
+    showDeleteAction: boolean;
+    showEditAction: boolean;
+    skeleton: boolean;
+    type: TPmdsCdkCardsSettingsType;
+    editedItem: EventEmitter<IPmdsCdkCardsSettingsItem>;
+    checkedItem: EventEmitter<IPmdsCdkCardsSettingsItem>;
+    toggledItem: EventEmitter<IPmdsCdkCardsSettingsItem>;
+    deletedItem: EventEmitter<IPmdsCdkCardsSettingsItem>;
+    componentSelector: string;
+    drop(event: CdkDragDrop<IPmdsCdkCardsSettingsItem[]>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkCardsSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkCardsSettingsComponent, "pmds-cdk-cards-settings", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "settingsItems": { "alias": "settingsItems"; "required": false; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; "showDeleteAction": { "alias": "showDeleteAction"; "required": false; }; "showEditAction": { "alias": "showEditAction"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "editedItem": "editedItem"; "checkedItem": "checkedItem"; "toggledItem": "toggledItem"; "deletedItem": "deletedItem"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkPhoneCountryOptionDropdown {
+    codeCountry: string;
+    country: string;
+    label: string;
+    value: string;
+}
+
+interface IPmdsCdkPhoneInputLiterals {
+    placeholder: string;
+    searchPlaceholder: string;
+    emptyStateTitle: string;
+    emptyStateContent: string;
+    helperText?: string;
+}
+
+declare class PmdsCdkPhoneInputComponent implements OnInit, OnDestroy, AfterViewInit, OnChanges {
+    optionsContent: ElementRef;
+    optionsDropdown: ElementRef;
+    optionsDropdownContainer: ElementRef;
+    assetsFolder: string;
+    dataQA: string;
+    formControlName: string;
+    isDisabled: boolean;
+    skeleton: boolean;
+    literals: IPmdsCdkPhoneInputLiterals;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    options: IPmdsCdkPhoneCountryOptionDropdown[];
+    initialValue: IPmdsCdkPhoneCountryOptionDropdown | undefined;
+    currencySelected: EventEmitter<IPmdsCdkPhoneCountryOptionDropdown>;
+    componentSelector: string;
+    control: AbstractControl;
+    currentFilter: string;
+    enableSearch: boolean;
+    error: boolean;
+    filteredOptions: IPmdsCdkPhoneCountryOptionDropdown[];
+    inputFocused: boolean;
+    omitEvent: boolean;
+    selectedValue: IPmdsCdkPhoneCountryOptionDropdown | null;
+    showOptions: boolean;
+    searchInputHasFocus: boolean;
+    value: string;
+    showDropdownOnTop: boolean;
+    private controlContainer;
+    private destroy$;
+    private renderer;
+    private unlistener;
+    get dropdownNgClass(): {
+        'bg-color-surface-disabled border-color-border-disabled text-color-text-disabled pointer-events-none': boolean;
+        'bg-color-surface-primary text-color-text-primary border-color-border-default': boolean;
+        '!border-color-border-focus': boolean;
+        'border-r-transparent': boolean;
+    };
+    get inputNgClass(): {
+        'border-color-border-default text-color-text-primary': boolean;
+        'border-color-border-error': boolean;
+        'border-color-border-disabled bg-color-surface-disabled text-color-text-disabled': boolean;
+        'pointer-events-none': boolean;
+    };
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    searchInputFocusChange(focus: boolean): void;
+    getFilteredOptions(): void;
+    selectOption(option: IPmdsCdkPhoneCountryOptionDropdown, event?: Event): void;
+    updateClearButtonOnFocus(focusedOnInput: boolean): void;
+    sortOptions(options: IPmdsCdkPhoneCountryOptionDropdown[]): IPmdsCdkPhoneCountryOptionDropdown[];
+    toggleShowOption(forceClose?: boolean, omitEvent?: boolean): void;
+    preventClose(evt: Event): void;
+    onInput(event?: Event): void;
+    onPaste(event: Event): void;
+    checkErrors(): void;
+    cancel(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => undefined): void;
+    onChange: (_: unknown) => void;
+    onTouch: () => undefined;
+    private getTrimmedAndLowerCaseString;
+    private scrollOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkPhoneInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkPhoneInputComponent, "pmds-cdk-phone-input", never, { "assetsFolder": { "alias": "assetsFolder"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; "literals": { "alias": "literals"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "options": { "alias": "options"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; }, { "currencySelected": "currencySelected"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkGraphsLineChartConfig {
+    height?: number;
+    lines?: number;
+    subtitle?: string;
+    title?: string;
+    onlyChart?: boolean;
+    yLabel?: (value: number) => string;
+    noData?: {
+        title: string;
+        content: string;
+        buttonText?: string;
+        icon?: string;
+        disabledButton?: boolean;
+        buttonClick?: () => void;
+    };
+}
+
+interface IPmdsCdkGraphsLineChartData {
+    value: string[];
+    valueSecondLine?: string[];
+    valueMobile?: string[];
+    lines: {
+        value: number[];
+        label: string;
+        tooltip?: (value: number, label: string, xValue: string) => string;
+    }[];
+}
+
+interface IPmdsCdkGraphsLineChartYLines {
+    y: number;
+    value: number;
+    label: string;
+}
+interface IPmdsCdkGraphsLineChartLines {
+    d: string;
+    color: string;
+}
+interface IPmdsCdkGraphsLineChartPoints {
+    x: number;
+    y: number;
+    tooltip: string;
+    color: string;
+}
+interface IPmdsCdkGraphsLineChartGraphicLegend {
+    label: string;
+    color: string;
+}
+interface IPmdsCdkGraphsLineChartXLabels {
+    x: number;
+    label: string;
+    labelSecondLine?: string;
+    labelMobile: string;
+}
+
+declare class PmdsCdkGraphsLineChartComponent implements AfterViewInit, OnInit, AfterViewInit {
+    graphSVG: ElementRef;
+    dataQA: string;
+    data: IPmdsCdkGraphsLineChartData;
+    config: IPmdsCdkGraphsLineChartConfig;
+    isLoading: boolean;
+    lines: IPmdsCdkGraphsLineChartLines[];
+    points: IPmdsCdkGraphsLineChartPoints[][];
+    graphicLegend: IPmdsCdkGraphsLineChartGraphicLegend[];
+    testLine: string;
+    lineActive: boolean[];
+    lineShow: boolean[][];
+    coefY: number;
+    graphHeight: number;
+    offsetWidth: number;
+    paddingBottom: number;
+    viewBox: string;
+    xLabels: IPmdsCdkGraphsLineChartXLabels[];
+    y0Axis: number;
+    yLabelsWidth: number;
+    yLastAxis: number;
+    yLines: IPmdsCdkGraphsLineChartYLines[];
+    private elementRef;
+    onResize(): void;
+    onGlobalClick(event: Element): void;
+    private elem;
+    componentSelector: string;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectLine(isHover: boolean, lineIndex?: number, pointIndex?: number): void;
+    private calculateYAxis;
+    private roundNumber;
+    private parseRefencesValues;
+    private calculateYLabelsWidth;
+    private calculateLines;
+    private calculateXLabels;
+    private calculateGraphicLegend;
+    private getBgColor;
+    private getStrokeColor;
+    private widthCheck;
+    private initData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkGraphsLineChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkGraphsLineChartComponent, "pmds-cdk-graphs-line-chart", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "data": { "alias": "data"; "required": false; }; "config": { "alias": "config"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IPmdsCdkGraphsSequentialBarChartConfig {
+    height?: number;
+    lines?: number;
+    source?: string;
+    subtitle?: string;
+    title?: string;
+    onlyChart?: boolean;
+    yLabel?: (value: number) => string;
+    noData?: {
+        title: string;
+        content: string;
+        buttonText?: string;
+        icon?: string;
+        disabledButton?: boolean;
+        buttonClick?: () => void;
+    };
+}
+
+interface IPmdsCdkGraphsSequentialBarChartData {
+    value: number;
+    label: string;
+    labelSecondLine?: string;
+    labelMobile?: string;
+    tooltip?: (value: number) => string;
+}
+
+interface IPmdsCdkGraphsSequentialBarChartYLines {
+    y: number;
+    value: number;
+    label: string;
+}
+interface IPmdsCdkGraphsSequentialBarChartBars {
+    x: number;
+    y: number;
+    d: string;
+    tooltip: string;
+}
+interface IPmdsCdkGraphsSequentialBarChartXLabels {
+    x: number;
+    label: string;
+    labelSecondLine?: string;
+    labelMobile: string;
+}
+
+declare class PmdsCdkGraphsSequentialBarChartComponent implements AfterViewInit, OnChanges {
+    graphSVG: ElementRef;
+    dataQA: string;
+    data: IPmdsCdkGraphsSequentialBarChartData[];
+    config: IPmdsCdkGraphsSequentialBarChartConfig;
+    isLoading: boolean;
+    bars: IPmdsCdkGraphsSequentialBarChartBars[];
+    barsActive: boolean[];
+    barsShow: boolean[];
+    barsWidth: number;
+    coefY: number;
+    graphHeight: number;
+    offsetWidth: number;
+    paddingBottom: number;
+    viewBox: string;
+    xLabels: IPmdsCdkGraphsSequentialBarChartXLabels[];
+    y0Axis: number;
+    yLabelsWidth: number;
+    yLastAxis: number;
+    yLines: IPmdsCdkGraphsSequentialBarChartYLines[];
+    private elementRef;
+    onResize(): void;
+    onGlobalClick(event: Element): void;
+    private elem;
+    componentSelector: string;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectBar(isHover: boolean, index?: number): void;
+    private calculateBarsWidth;
+    private calculateYAxis;
+    private roundNumber;
+    private parseRefencesValues;
+    private calculateYLabelsWidth;
+    private calculateBars;
+    private calculateDValue;
+    private calculateXLabels;
+    private widthCheck;
+    private initData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkGraphsSequentialBarChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkGraphsSequentialBarChartComponent, "pmds-cdk-graphs-sequential-bar-chart", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "data": { "alias": "data"; "required": false; }; "config": { "alias": "config"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IPmdsCdkGraphsPieChartConfig {
+    height?: number;
+    subtitle?: string;
+    title?: string;
+    onlyChart?: boolean;
+    noData?: {
+        title: string;
+        content: string;
+        buttonText?: string;
+        icon?: string;
+        disabledButton?: boolean;
+        buttonClick?: () => void;
+    };
+}
+
+interface IPmdsCdkGraphsPieChartData {
+    label: string;
+    tooltip?: (percent: number, value: number, label: string) => string;
+    value: number;
+}
+
+interface IPmdsCdkGraphsPieChartGraphicLegend {
+    label: string;
+    color: string;
+}
+
+declare class PmdsCdkGraphsPieChartComponent implements OnInit, OnChanges {
+    dataQA: string;
+    config: IPmdsCdkGraphsPieChartConfig;
+    data: IPmdsCdkGraphsPieChartData[];
+    isLoading: boolean;
+    componentSelector: string;
+    graphicLegend: IPmdsCdkGraphsPieChartGraphicLegend[];
+    pieActive: boolean[];
+    pieShow: boolean[];
+    pies: any;
+    radio: number;
+    private elementRef;
+    onGlobalClick(event: Element): void;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    selectPie(isHover: boolean, index?: number): void;
+    private generatePieChart;
+    private calculateGraphicLegend;
+    private getBgColor;
+    private getFillColor;
+    private initData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkGraphsPieChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkGraphsPieChartComponent, "pmds-cdk-graphs-pie-chart", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "config": { "alias": "config"; "required": false; }; "data": { "alias": "data"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+interface IPmdsCdkAutocompleteMultidestinataryItem {
+    id: string;
+    label: string;
+}
+
+interface IPmdsCdkAutocompleteMultidestinataryStates {
+    isNoResults?: boolean;
+    isLoading?: boolean;
+}
+
+interface IPmdsCdkAutocompleteMultidestinataryConfig {
+    customHeight?: string;
+    placeholder: string;
+    icon: string;
+    iconResults: string;
+    loadingLiteral: string;
+    more10Literal: string;
+    noResultsLiterals: {
+        noResult: string;
+        instructions: string;
+    };
+    helperText: string;
+}
+
+declare const PMDS_CDK_AUTOCOMPLETE_MULTIDESTINATARY_DEFAULT_DEBOUNCE_TIME = 500;
+declare class PmdsCdkAutocompleteMultidestinataryComponent implements OnInit, ControlValueAccessor, OnDestroy {
+    config: IPmdsCdkAutocompleteMultidestinataryConfig;
+    dataQA: string;
+    formControlName: string;
+    isDisabled: boolean;
+    literalsErrorFn: IPmdsCdkFormErrorMessage<unknown>;
+    results: IPmdsCdkAutocompleteMultidestinataryItem[];
+    states: IPmdsCdkAutocompleteMultidestinataryStates;
+    suggestionsLabel: string;
+    skeleton: boolean;
+    byTyping: EventEmitter<string>;
+    changeValues: EventEmitter<IPmdsCdkAutocompleteMultidestinataryItem[]>;
+    selectValue: EventEmitter<IPmdsCdkAutocompleteMultidestinataryItem>;
+    componentSelector: string;
+    formControl: AbstractControl;
+    omitClose: boolean;
+    showError: boolean;
+    showResults: boolean;
+    show10Results: boolean;
+    showValues: boolean;
+    value: IPmdsCdkAutocompleteMultidestinataryItem[];
+    data: IPmdsCdkAutocompleteMultidestinataryItem[];
+    private debounceTyping$;
+    private destroy$;
+    private formGroupDirective;
+    private renderer;
+    private unlistener;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    searchValue(value: string): void;
+    selectResult(value: IPmdsCdkAutocompleteMultidestinataryItem): void;
+    removeValue(valueToRemove: IPmdsCdkAutocompleteMultidestinataryItem): void;
+    selectedValue(event: Event, valueSelected: IPmdsCdkAutocompleteMultidestinataryItem): void;
+    onChange: (_: unknown) => void;
+    onTouched: () => undefined;
+    onFocus(): void;
+    onFocusOut(): void;
+    writeValue(value: IPmdsCdkAutocompleteMultidestinataryItem[]): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => undefined): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkAutocompleteMultidestinataryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkAutocompleteMultidestinataryComponent, "pmds-cdk-autocomplete-multidestinatary", never, { "config": { "alias": "config"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "literalsErrorFn": { "alias": "literalsErrorFn"; "required": false; }; "results": { "alias": "results"; "required": false; }; "states": { "alias": "states"; "required": false; }; "suggestionsLabel": { "alias": "suggestionsLabel"; "required": false; }; "skeleton": { "alias": "skeleton"; "required": false; }; }, { "byTyping": "byTyping"; "changeValues": "changeValues"; "selectValue": "selectValue"; }, never, never, true, never>;
+}
+
+interface IPmdsCdkSidebarEmbeddedConfig {
+    sidebarTitle: string;
+    backButton: {
+        action: () => void;
+        label: string;
+    };
+    footerButtons: IPmdsCdkStickyButtonBarButton[];
+    loaderLiterals: {
+        title: string;
+        subtitle: string;
+    };
+    headerButton: {
+        actionButton1: () => void;
+        actionButton2: () => void;
+        iconButton1: string;
+        iconButton2: string;
+        labelButton1: string;
+        labelButton2: string;
+    };
+}
+
+declare class PmdsCdkSidebarEmbeddedComponent implements AfterViewInit {
+    section: ElementRef;
+    sidebarTemplate: ViewContainerRef;
+    dataQA: string;
+    config: IPmdsCdkSidebarEmbeddedConfig;
+    loading: boolean;
+    showSidebar: boolean;
+    sidebarComponent: Type<any>;
+    showSidebarChange: EventEmitter<boolean>;
+    componentSelector: string;
+    sidebarHeight: string;
+    onResize(): void;
+    ngOnInit(): void;
+    loadComponent(): void;
+    ngAfterViewInit(): void;
+    private setFullHeight;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkSidebarEmbeddedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkSidebarEmbeddedComponent, "pmds-cdk-sidebar-embedded", never, { "dataQA": { "alias": "dataQA"; "required": false; }; "config": { "alias": "config"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showSidebar": { "alias": "showSidebar"; "required": false; }; "sidebarComponent": { "alias": "sidebarComponent"; "required": false; }; }, { "showSidebarChange": "showSidebarChange"; }, never, ["*"], true, never>;
+}
+
+type TPmdsCdkEditableContentPosition = 'left' | 'right' | 'center';
+
+interface IPmdsCdkEditableContentConfirmValue {
+    newValue: string;
+    oldValue: string;
+}
+
+declare class PmdsCdkEditableContentComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    inputValue: ElementRef;
+    contentPosition: TPmdsCdkEditableContentPosition;
+    dataQA: string;
+    formControl: AbstractControl;
+    formControlName: string;
+    hideOnTablet: boolean;
+    isDisabled: boolean;
+    noEditClass: string;
+    noEditIcon: string;
+    noEditValue: string;
+    placeholder: string;
+    tooltipPosition: TPmdsCdkEditableContentPosition;
+    tooltipValue: string;
+    typeInput: 'text' | 'number';
+    noEditValueChange: EventEmitter<string>;
+    valueChange: EventEmitter<IPmdsCdkEditableContentConfirmValue>;
+    componentSelector: string;
+    isEditing: boolean;
+    omitEvent: boolean;
+    showError: boolean;
+    value: string;
+    private unlistener;
+    private formGroupDirective;
+    private destroy$;
+    private renderer;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    changeValue(ev: Event): void;
+    resetValue(): void;
+    initEdit(): void;
+    onChange(_: unknown): void;
+    onTouch(): void;
+    writeValue(value: string): void;
+    setDisabledState(isDisabled: boolean): void;
+    registerOnChange(fn: (_: unknown) => void): void;
+    registerOnTouched(fn: () => unknown): void;
+    clickSection(event: Event): void;
+    updateValue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PmdsCdkEditableContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PmdsCdkEditableContentComponent, "pmds-cdk-editable-content", never, { "contentPosition": { "alias": "contentPosition"; "required": false; }; "dataQA": { "alias": "dataQA"; "required": false; }; "formControl": { "alias": "formControl"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "hideOnTablet": { "alias": "hideOnTablet"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "noEditClass": { "alias": "noEditClass"; "required": false; }; "noEditIcon": { "alias": "noEditIcon"; "required": false; }; "noEditValue": { "alias": "noEditValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipValue": { "alias": "tooltipValue"; "required": false; }; "typeInput": { "alias": "typeInput"; "required": false; }; }, { "noEditValueChange": "noEditValueChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { EPmdsCdkTableRowTypeStyle, IPmdsCdkStepStatus, PMDS_CDK_ALERT_DATA_TOKEN, PMDS_CDK_AUTOCOMPLETE_DEFAULT_DEBOUNCE_TIME, PMDS_CDK_AUTOCOMPLETE_DEFAULT_THROTTLE_TIME, PMDS_CDK_AUTOCOMPLETE_MULTIDESTINATARY_DEFAULT_DEBOUNCE_TIME, PMDS_CDK_BUTTON_PRIMARY, PMDS_CDK_BUTTON_SECONDARY, PMDS_CDK_BUTTON_TERTIARY, PMDS_CDK_MODAL_CONFIG_TOKEN, PMDS_CDK_MODAL_DATA_TOKEN, PMDS_CDK_MODAL_DEFAULT_CONFIG, PMDS_CDK_TOAST_ANIMATIONS, PMDS_CDK_TOAST_CONFIG_TOKEN, PMDS_CDK_TOAST_DEFAULT_CONFIG, PmdsCdkAccordionComponent, PmdsCdkActionBarComponent, PmdsCdkActionBarRef, PmdsCdkActionBarService, PmdsCdkActionRowBarComponent, PmdsCdkAlertComponent, PmdsCdkAutocompleteComponent, PmdsCdkAutocompleteMultidestinataryComponent, PmdsCdkBadgetNumbersComponent, PmdsCdkButtonAllFiltersComponent, PmdsCdkButtonComponent, PmdsCdkButtonDropdownComponent, PmdsCdkButtonFloatingComponent, PmdsCdkButtonModalComponent, PmdsCdkCalendarComponent, PmdsCdkCardsAccountActionComponent, PmdsCdkCardsFileUploadComponent, PmdsCdkCardsInformationComponent, PmdsCdkCardsSelectorComponent, PmdsCdkCardsSettingsComponent, PmdsCdkCheckboxComponent, PmdsCdkCopyClipboardComponent, PmdsCdkCountryLabelComponent, PmdsCdkDatepickerCalendarComponent, PmdsCdkDatepickerComponent, PmdsCdkDividerComponent, PmdsCdkDownloadIdAppButtonsComponent, PmdsCdkDropdownComponent, PmdsCdkDropdownRangeComponent, PmdsCdkDynamicCardComponent, PmdsCdkDynamicRowComponent, PmdsCdkEditableContentComponent, PmdsCdkErrorPageComponent, PmdsCdkExpansionPanelComponent, PmdsCdkFileDownloaderInfoComponent, PmdsCdkFooterComponent, PmdsCdkFormErrorMessageComponent, PmdsCdkGraphsLineChartComponent, PmdsCdkGraphsPieChartComponent, PmdsCdkGraphsSequentialBarChartComponent, PmdsCdkHeaderComponent, PmdsCdkLoaderComponent, PmdsCdkMenuAndSubmenuComponent, PmdsCdkMessageComponent, PmdsCdkModalComponent, PmdsCdkModalRef, PmdsCdkModalService, PmdsCdkNotificationsPopoverComponent, PmdsCdkOptionButtonsComponent, PmdsCdkPageControllerComponent, PmdsCdkPageHeaderComponent, PmdsCdkPaginatorComponent, PmdsCdkPendingTaskComponent, PmdsCdkPhoneInputComponent, PmdsCdkProcessHeaderComponent, PmdsCdkProfilePhotoComponent, PmdsCdkRadioButtonsComponent, PmdsCdkSelectPaginatorComponent, PmdsCdkShortcutComponent, PmdsCdkSidebarEmbeddedComponent, PmdsCdkSkeletonComponent, PmdsCdkStepperComponent, PmdsCdkStickyButtonBarComponent, PmdsCdkTabComponent, PmdsCdkTableCompleteComponent, PmdsCdkTableCompleteDataAbstractService, PmdsCdkTableCompleteDataService, PmdsCdkTableComponent, PmdsCdkTabsComponent, PmdsCdkTagCategoryComponent, PmdsCdkTagLabelComponent, PmdsCdkTextComponent, PmdsCdkTextFieldComponent, PmdsCdkTextInputComponent, PmdsCdkTextareaComponent, PmdsCdkTimeInputComponent, PmdsCdkTimelineTrackingComponent, PmdsCdkToastComponent, PmdsCdkToastRef, PmdsCdkToastService, PmdsCdkToggleSwitchComponent, PmdsCoreCacheService, PmdsCoreStorageService, PmdsDirectiveDecimalNumberFormat, PmdsDirectiveMaskAmountInput, PmdsDirectiveNoLeadingSpacesInput, PmdsDirectiveNumberFormat, PmdsDirectiveTitle, PmdsDirectiveTooltip, PmdsDirectiveViewportOverflow, PmdsPipeAccountFormat, PmdsPipeAccountHidden, PmdsPipeAmountFormat, PmdsPipeCamelcaseToSnakecaseUppercase, PmdsPipeDateTime, PmdsPipeExchangeDecimals, PmdsPipeOnlyDecimals, PmdsPipeRelationshipFormat, PmdsPipeSalesforceNumberFormat, PmdsPipeTransactionReference, PmdsPipeTruncateEllipsis, PmdsPipeTypeOf, PmdsUtilHistoryRouting, PmdsUtilImgFlags, PmdsUtilImgSvgs, PmdsUtilStyles, PmdsUtilValidators };
+export type { IPmdsCdkAccordionLiterals, IPmdsCdkActionBarButton, IPmdsCdkActionBarConfig, IPmdsCdkActionRowBar, IPmdsCdkAlertData, IPmdsCdkAlertLiterals, IPmdsCdkAutocompleteConfig, IPmdsCdkAutocompleteDynamicLabelComponentConfig, IPmdsCdkAutocompleteDynamicRowComponentConfig, IPmdsCdkAutocompleteLabelConfigParam, IPmdsCdkAutocompleteMultidestinataryConfig, IPmdsCdkAutocompleteMultidestinataryItem, IPmdsCdkAutocompleteMultidestinataryStates, IPmdsCdkAutocompleteRowConfigParam, IPmdsCdkAutocompleteStates, IPmdsCdkAutocompleteSuggestions, IPmdsCdkAutocompleteTableConfig, IPmdsCdkAutompleteInputConfig, IPmdsCdkBasicTableConfig, IPmdsCdkButtonModalButton, IPmdsCdkButtonsDropdownOption, IPmdsCdkCalendarEvent, IPmdsCdkCalendarEventShow, IPmdsCdkCalendarLiterals, IPmdsCdkCardsFileUploadLiterals, IPmdsCdkCardsInformationAction, IPmdsCdkCardsInformationLiterals, IPmdsCdkCardsSelectorImages, IPmdsCdkCardsSelectorOptionLiterals, IPmdsCdkCardsSelectorTooltip, IPmdsCdkCardsSettingsItem, IPmdsCdkDatepickerDateInfo, IPmdsCdkDatepickerLiterals, IPmdsCdkDropdownRangeLiterals, IPmdsCdkDynamicRowComponentConfig, IPmdsCdkDynamicRowDefaultComponentConfig, IPmdsCdkEditableContentConfirmValue, IPmdsCdkErrorPageButtons, IPmdsCdkErrorPageLiterals, IPmdsCdkErrorPageLiteralsError, IPmdsCdkExpansionPanelActions, IPmdsCdkFileDownloaderInfoButtons, IPmdsCdkFileDownloaderInfoFile, IPmdsCdkFileDownloaderInfoLiterals, IPmdsCdkFooterAction, IPmdsCdkFooterLink, IPmdsCdkFooterLiterals, IPmdsCdkFormErrorMessage, IPmdsCdkGraphsLineChartConfig, IPmdsCdkGraphsLineChartData, IPmdsCdkGraphsPieChartConfig, IPmdsCdkGraphsPieChartData, IPmdsCdkGraphsSequentialBarChartConfig, IPmdsCdkGraphsSequentialBarChartData, IPmdsCdkHeaderCompleteConfig, IPmdsCdkHeaderConfig, IPmdsCdkHeaderLiterals, IPmdsCdkHeaderMobileFooterActionModel, IPmdsCdkMenuOptions, IPmdsCdkMessage, IPmdsCdkMessageLiterals, IPmdsCdkModalButtons, IPmdsCdkModalConfig, IPmdsCdkModalData, IPmdsCdkModalSidebarButtons, IPmdsCdkNotificationsPopoverButton, IPmdsCdkNotificationsPopoverLiterals, IPmdsCdkNotificationsPopoverNotification, IPmdsCdkOptionButtons, IPmdsCdkOptionDropdown, IPmdsCdkOptionDropdownLiterals, IPmdsCdkPaginationInfo, IPmdsCdkPaginatorLiterals, IPmdsCdkPendingTaskGroup, IPmdsCdkPendingTaskLiterals, IPmdsCdkPhoneCountryOptionDropdown, IPmdsCdkPhoneInputLiterals, IPmdsCdkProcessHeaderActions, IPmdsCdkProcessHeaderLiterals, IPmdsCdkRadioButtons, IPmdsCdkRowConfigParam, IPmdsCdkShortcutItem, IPmdsCdkSidebarEmbeddedConfig, IPmdsCdkStepAlert, IPmdsCdkStepAttributes, IPmdsCdkStepObservation, IPmdsCdkSteps, IPmdsCdkStickyButtonBarButton, IPmdsCdkTableCompleteConfig, IPmdsCdkTableCompleteResponseModel, IPmdsCdkTableConfig, IPmdsCdkTableEmptyStateData, IPmdsCdkTableHeaderInfo, IPmdsCdkTablePaginationInfo, IPmdsCdkTabsConfig, IPmdsCdkTextField, IPmdsCdkTextFieldType, IPmdsCdkTextInputTagCategoryData, IPmdsCdkTextInputType, IPmdsCdkToastConfig, IPmdsCdkAlertData as IPmdsCdkToastData, IPmdsDirectiveTitleClasses, IPmdsDropdownRangeSelect, PmdsCdkButtonSize, PmdsCdkButtonType, PmdsCoreICachedElement, TPmdsCdkAlertType, TPmdsCdkButtonModalSize, TPmdsCdkButtonModalType, TPmdsCdkCalendarEventType, TPmdsCdkCardsFileUploadStates, TPmdsCdkCardsSettingsType, TPmdsCdkCopyClipboardIconPosition, TPmdsCdkCountryLabelSize, TPmdsCdkDatepickerDateFormat, TPmdsCdkEditableContentPosition, TPmdsCdkErrorPageType, TPmdsCdkFileDownloaderInfoStatus, TPmdsCdkFooterLayout, TPmdsCdkHeaderLayout, TPmdsCdkMenuSubmenuType, TPmdsCdkMessageType, TPmdsCdkModalAction, TPmdsCdkModalSize, TPmdsCdkProcessHeaderMaxDesktopWidth, TPmdsCdkTagLabelColor, TPmdsCdkTextType, TPmdsCdkToastAnimationState, TPmdsCdkUserType, TPmdsDirectiveTooltipPosition, colorCode };