@ops-prime/primeng 0.0.0-stage → 21.1.11

package/types/primeng-autofocus.d.ts

@@ -0,0 +1,31 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { BaseComponent } from 'primeng/basecomponent';
+
+/**
+ * AutoFocus manages focus on focusable element on load.
+ * @group Components
+ */
+declare class AutoFocus extends BaseComponent {
+    /**
+     * When present, it specifies that the component should automatically get focus on load.
+     * @group Props
+     */
+    autofocus: boolean;
+    focused: boolean;
+    platformId: Object;
+    document: Document;
+    host: ElementRef;
+    onAfterContentChecked(): void;
+    onAfterViewChecked(): void;
+    autoFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocus, "[pAutoFocus]", never, { "autofocus": { "alias": "pAutoFocus"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class AutoFocusModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AutoFocusModule, never, [typeof AutoFocus], [typeof AutoFocus]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AutoFocusModule>;
+}
+
+export { AutoFocus, AutoFocusModule };

package/types/primeng-avatar.d.ts

@@ -0,0 +1,140 @@
+import { AvatarPassThrough } from 'primeng/types/avatar';
+export * from 'primeng/types/avatar';
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primeng/base';
+import * as i2 from 'primeng/api';
+
+/**
+ *
+ * Avatar represents people using icons, labels and images.
+ *
+ * - [Live Demo](https://primeng.org/avatar)
+ *
+ * @module avatarstyle
+ *
+ */
+declare enum AvatarClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-avatar",
+    /**
+     * Class name of the label element
+     */
+    label = "p-avatar-label",
+    /**
+     * Class name of the icon element
+     */
+    icon = "p-avatar-icon",
+    /**
+     * Container element in image mode
+     */
+    image = "p-avatar-image",
+    /**
+     * Container element with a circle shape
+     */
+    circle = "p-avatar-circle",
+    /**
+     *  Container element with a large size
+     */
+    large = "p-avatar-lg",
+    /**
+     *  Container element with an xlarge size
+     */
+    xlarge = "p-avatar-xl"
+}
+declare class AvatarStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-avatar-image': boolean;
+            'p-avatar-circle': boolean;
+            'p-avatar-lg': boolean;
+            'p-avatar-xl': boolean;
+        })[];
+        label: string;
+        icon: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AvatarStyle>;
+}
+interface AvatarStyle extends BaseStyle {
+}
+
+/**
+ * Avatar represents people using icons, labels and images.
+ * @group Components
+ */
+declare class Avatar extends BaseComponent<AvatarPassThrough> {
+    componentName: string;
+    $pcAvatar: Avatar | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Defines the text to display.
+     * @group Props
+     */
+    label: string | undefined;
+    /**
+     * Defines the icon to display.
+     * @group Props
+     */
+    icon: string | undefined;
+    /**
+     * Defines the image to display.
+     * @group Props
+     */
+    image: string | undefined;
+    /**
+     * Size of the element.
+     * @group Props
+     */
+    size: 'normal' | 'large' | 'xlarge' | undefined;
+    /**
+     * Shape of the element.
+     * @group Props
+     */
+    shape: 'square' | 'circle' | undefined;
+    /**
+     * Class of the element.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Establishes a string value that labels the component.
+     * @group Props
+     */
+    ariaLabel: string | undefined;
+    /**
+     * Establishes relationships between the component and label(s) where its value should be one or more element IDs.
+     * @group Props
+     */
+    ariaLabelledBy: string | undefined;
+    /**
+     * This event is triggered if an error occurs while loading an image file.
+     * @param {Event} event - Browser event.
+     * @group Emits
+     */
+    onImageError: EventEmitter<Event>;
+    _componentStyle: AvatarStyle;
+    imageError(event: Event): void;
+    get dataP(): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Avatar, "p-avatar", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "image": { "alias": "image"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "styleClass": { "alias": "styleClass"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; }, { "onImageError": "onImageError"; }, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class AvatarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarModule, never, [typeof Avatar, typeof i2.SharedModule], [typeof Avatar, typeof i2.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AvatarModule>;
+}
+
+export { Avatar, AvatarClasses, AvatarModule, AvatarStyle };

package/types/primeng-avatargroup.d.ts

@@ -0,0 +1,66 @@
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import { AvatarGroupPassThrough } from 'primeng/types/avatargroup';
+import { BaseStyle } from 'primeng/base';
+import * as i0 from '@angular/core';
+import * as i2 from 'primeng/api';
+
+/**
+ *
+ * A set of Avatars can be displayed together using the AvatarGroup component.
+ *
+ * [Live Demo](https://www.primeng.org/avatar/)
+ *
+ * @module avatargroupstyle
+ *
+ */
+declare enum AvatarGroupClasses {
+    root = "p-avatar-group"
+}
+declare class AvatarGroupStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AvatarGroupStyle>;
+}
+interface AvatarGroupStyle extends BaseStyle {
+}
+
+/**
+ * AvatarGroup is a helper component for Avatar.
+ * @group Components
+ */
+declare class AvatarGroup extends BaseComponent<AvatarGroupPassThrough> {
+    componentName: string;
+    $pcAvatarGroup: AvatarGroup | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Style class of the component
+     * @group Props
+     */
+    styleClass: string | undefined;
+    /**
+     * Inline style of the component.
+     * @group Props
+     */
+    style: {
+        [klass: string]: any;
+    } | null | undefined;
+    get hostStyle(): {
+        [klass: string]: any;
+    } | null | undefined;
+    _componentStyle: AvatarGroupStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarGroup, "p-avatarGroup, p-avatar-group, p-avatargroup", never, { "styleClass": { "alias": "styleClass"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class AvatarGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarGroupModule, never, [typeof AvatarGroup, typeof i2.SharedModule], [typeof AvatarGroup, typeof i2.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AvatarGroupModule>;
+}
+
+export { AvatarGroup, AvatarGroupClasses, AvatarGroupModule, AvatarGroupStyle };

package/types/primeng-badge.d.ts

@@ -0,0 +1,184 @@
+import * as _angular_core from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { BaseComponent } from 'primeng/basecomponent';
+import * as i1 from 'primeng/bind';
+import { Bind } from 'primeng/bind';
+import { BadgePassThrough } from 'primeng/types/badge';
+import { BaseStyle } from 'primeng/base';
+import * as i2 from 'primeng/api';
+
+/**
+ *
+ * Badge represents people using icons, labels and images.
+ *
+ * [Live Demo](https://www.primeng.org/badge)
+ *
+ * @module badgestyle
+ *
+ */
+declare enum BadgeClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-badge"
+}
+declare class BadgeStyle extends BaseStyle {
+    name: string;
+    style: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-badge-circle': boolean;
+            'p-badge-dot': boolean;
+            'p-badge-sm': boolean;
+            'p-badge-lg': boolean;
+            'p-badge-xl': boolean;
+            'p-badge-info': boolean;
+            'p-badge-success': boolean;
+            'p-badge-warn': boolean;
+            'p-badge-danger': boolean;
+            'p-badge-secondary': boolean;
+            'p-badge-contrast': boolean;
+        })[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BadgeStyle>;
+}
+interface BadgeStyle extends BaseStyle {
+}
+
+/**
+ * Badge Directive is directive usage of badge component.
+ * @group Components
+ */
+declare class BadgeDirective extends BaseComponent {
+    $pcBadgeDirective: BadgeDirective | undefined;
+    /**
+     * Used to pass attributes to DOM elements inside the Badge component.
+     * @defaultValue undefined
+     * @deprecated use pBadgePT instead.
+     * @group Props
+     */
+    ptBadgeDirective: _angular_core.InputSignal<BadgePassThrough>;
+    /**
+     * Used to pass attributes to DOM elements inside the Badge component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pBadgePT: _angular_core.InputSignal<BadgePassThrough>;
+    /**
+     * Indicates whether the component should be rendered without styles.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pBadgeUnstyled: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * When specified, disables the component.
+     * @group Props
+     */
+    disabled: boolean;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     */
+    badgeSize: 'large' | 'xlarge' | 'small' | null | undefined;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     * @deprecated use badgeSize instead.
+     */
+    set size(value: 'large' | 'xlarge' | 'small' | null | undefined);
+    get size(): "large" | "xlarge" | "small" | null | undefined;
+    _size: 'large' | 'xlarge' | 'small' | null | undefined;
+    /**
+     * Severity type of the badge.
+     * @group Props
+     */
+    severity: 'secondary' | 'info' | 'success' | 'warn' | 'danger' | 'contrast' | null | undefined;
+    /**
+     * Value to display inside the badge.
+     * @group Props
+     */
+    value: string | number;
+    /**
+     * Inline style of the element.
+     * @group Props
+     */
+    badgeStyle: {
+        [klass: string]: any;
+    } | null | undefined;
+    /**
+     * Class of the element.
+     * @group Props
+     */
+    badgeStyleClass: string;
+    private id;
+    badgeEl: HTMLElement;
+    _componentStyle: BadgeStyle;
+    private get activeElement();
+    private get canUpdateBadge();
+    constructor();
+    onChanges(changes: SimpleChanges): void;
+    onAfterViewInit(): void;
+    private setValue;
+    private setSizeClasses;
+    private renderBadgeContent;
+    private applyStyles;
+    private setSeverity;
+    private toggleDisableState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BadgeDirective, "[pBadge]", never, { "ptBadgeDirective": { "alias": "ptBadgeDirective"; "required": false; "isSignal": true; }; "pBadgePT": { "alias": "pBadgePT"; "required": false; "isSignal": true; }; "pBadgeUnstyled": { "alias": "pBadgeUnstyled"; "required": false; "isSignal": true; }; "disabled": { "alias": "badgeDisabled"; "required": false; }; "badgeSize": { "alias": "badgeSize"; "required": false; }; "size": { "alias": "size"; "required": false; }; "severity": { "alias": "severity"; "required": false; }; "value": { "alias": "value"; "required": false; }; "badgeStyle": { "alias": "badgeStyle"; "required": false; }; "badgeStyleClass": { "alias": "badgeStyleClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Badge is a small status indicator for another element.
+ * @group Components
+ */
+declare class Badge extends BaseComponent<BadgePassThrough> {
+    componentName: string;
+    $pcBadge: Badge | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Class of the element.
+     * @deprecated since v20.0.0, use `class` instead.
+     * @group Props
+     */
+    styleClass: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     */
+    badgeSize: _angular_core.InputSignal<"small" | "large" | "xlarge" | null | undefined>;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     */
+    size: _angular_core.InputSignal<"small" | "large" | "xlarge" | null | undefined>;
+    /**
+     * Severity type of the badge.
+     * @group Props
+     */
+    severity: _angular_core.InputSignal<"info" | "success" | "warn" | "danger" | "secondary" | "contrast" | null | undefined>;
+    /**
+     * Value to display inside the badge.
+     * @group Props
+     */
+    value: _angular_core.InputSignal<string | number | null | undefined>;
+    /**
+     * When specified, disables the component.
+     * @group Props
+     */
+    badgeDisabled: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    _componentStyle: BadgeStyle;
+    get dataP(): string | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "p-badge", never, { "styleClass": { "alias": "styleClass"; "required": false; "isSignal": true; }; "badgeSize": { "alias": "badgeSize"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "badgeDisabled": { "alias": "badgeDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class BadgeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BadgeModule, never, [typeof Badge, typeof BadgeDirective, typeof i2.SharedModule], [typeof Badge, typeof BadgeDirective, typeof i2.SharedModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BadgeModule>;
+}
+
+export { Badge, BadgeClasses, BadgeDirective, BadgeModule, BadgeStyle };

package/types/primeng-base.d.ts

@@ -0,0 +1,58 @@
+import { UseStyle } from 'primeng/usestyle';
+import * as i0 from '@angular/core';
+
+declare const _default: {
+    _loadedStyleNames: Set<unknown>;
+    getLoadedStyleNames(): any;
+    isStyleNameLoaded(name: any): any;
+    setLoadedStyleName(name: any): void;
+    deleteLoadedStyleName(name: any): void;
+    clearLoadedStyleNames(): void;
+};
+
+declare class BaseStyle {
+    name: string;
+    useStyle: UseStyle;
+    css: string | undefined;
+    style: any;
+    classes: {};
+    inlineStyles: {};
+    load: (style: any, options?: {}, transform?: (cs: any) => any) => {} | undefined;
+    loadCSS: (options?: {}) => {} | undefined;
+    loadStyle: (options?: any, style?: string) => {} | undefined;
+    loadBaseCSS: (options?: {}) => {} | undefined;
+    loadBaseStyle: (options?: any, style?: string) => {} | undefined;
+    getCommonTheme: (params?: any) => {
+        primitive: {
+            css: string | undefined;
+            tokens: any;
+        };
+        semantic: {
+            css: string | undefined;
+            tokens: any[] | undefined;
+        };
+        global: {
+            css: string | undefined;
+            tokens: any[] | undefined;
+        };
+        style: string | undefined;
+    };
+    getComponentTheme: (params: any) => {
+        css: string | undefined;
+        tokens: any[] | undefined;
+        style: string | undefined;
+    };
+    getPresetTheme: (preset: any, selector: any, params: any) => {
+        css: string | undefined;
+        tokens: any[] | undefined;
+        style: string | undefined;
+    };
+    getLayerOrderThemeCSS: () => string;
+    getStyleSheet: (extendedCSS?: string, props?: {}) => string;
+    getCommonThemeStyleSheet: (params: any, props?: {}) => any;
+    getThemeStyleSheet: (params: any, props?: {}) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseStyle>;
+}
+
+export { _default as Base, BaseStyle };

package/types/primeng-basecomponent.d.ts

@@ -0,0 +1,175 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, Injector, ChangeDetectorRef, Renderer2, SimpleChanges, InjectionToken } from '@angular/core';
+import { cn } from '@primeuix/utils';
+import { Lifecycle, PassThroughOptions } from 'primeng/api';
+import { BaseStyle } from 'primeng/base';
+import { PrimeNG } from 'primeng/config';
+
+declare class BaseComponentStyle extends BaseStyle {
+    name: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponentStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseComponentStyle>;
+}
+
+declare const PARENT_INSTANCE: InjectionToken<BaseComponent<any>>;
+declare class BaseComponent<PT = any> implements Lifecycle {
+    document: Document;
+    platformId: any;
+    el: ElementRef;
+    readonly injector: Injector;
+    readonly cd: ChangeDetectorRef;
+    renderer: Renderer2;
+    config: PrimeNG;
+    $parentInstance: BaseComponent | undefined;
+    baseComponentStyle: BaseComponentStyle;
+    baseStyle: BaseStyle;
+    scopedStyleEl: any;
+    parent: {
+        instance: any;
+    };
+    protected readonly cn: typeof cn;
+    private _themeScopedListener;
+    private themeChangeListenerMap;
+    /******************** Inputs ********************/
+    /**
+     * Defines scoped design tokens of the component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    dt: _angular_core.InputSignal<Object | undefined>;
+    /**
+     * Indicates whether the component should be rendered without styles.
+     * @defaultValue undefined
+     * @group Props
+     */
+    unstyled: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Used to pass attributes to DOM elements inside the component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pt: _angular_core.InputSignal<PT | undefined>;
+    /**
+     * Used to configure passthrough(pt) options of the component.
+     * @group Props
+     * @defaultValue undefined
+     */
+    ptOptions: _angular_core.InputSignal<PassThroughOptions | undefined>;
+    /******************** Computed ********************/
+    $attrSelector: string;
+    get $name(): any;
+    private get $hostName();
+    get $el(): any;
+    directivePT: _angular_core.WritableSignal<any>;
+    directiveUnstyled: _angular_core.WritableSignal<boolean | undefined>;
+    $unstyled: _angular_core.Signal<boolean>;
+    $pt: _angular_core.Signal<any>;
+    get $globalPT(): any;
+    get $defaultPT(): any;
+    get $style(): any;
+    get $styleOptions(): {
+        nonce: string | undefined;
+    };
+    get $params(): {
+        instance: any;
+        parent: {
+            instance: any;
+        };
+    };
+    /******************** Lifecycle Hooks ********************/
+    onInit(): void;
+    onChanges(changes: SimpleChanges): void;
+    onDoCheck(): void;
+    onAfterContentInit(): void;
+    onAfterContentChecked(): void;
+    onAfterViewInit(): void;
+    onAfterViewChecked(): void;
+    onDestroy(): void;
+    /******************** Angular Lifecycle Hooks ********************/
+    constructor();
+    /**
+     * ⚠ Do not override ngOnInit!
+     *
+     * Use 'onInit()' in subclasses instead.
+     */
+    ngOnInit(): void;
+    /**
+     * ⚠ Do not override ngOnChanges!
+     *
+     * Use 'onChanges(changes: SimpleChanges)' in subclasses instead.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * ⚠ Do not override ngDoCheck!
+     *
+     * Use 'onDoCheck()' in subclasses instead.
+     */
+    ngDoCheck(): void;
+    /**
+     * ⚠ Do not override ngAfterContentInit!
+     *
+     * Use 'onAfterContentInit()' in subclasses instead.
+     */
+    ngAfterContentInit(): void;
+    /**
+     * ⚠ Do not override ngAfterContentChecked!
+     *
+     * Use 'onAfterContentChecked()' in subclasses instead.
+     */
+    ngAfterContentChecked(): void;
+    /**
+     * ⚠ Do not override ngAfterViewInit!
+     *
+     * Use 'onAfterViewInit()' in subclasses instead.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * ⚠ Do not override ngAfterViewChecked!
+     *
+     * Use 'onAfterViewChecked()' in subclasses instead.
+     */
+    ngAfterViewChecked(): void;
+    /**
+     * ⚠ Do not override ngOnDestroy!
+     *
+     * Use 'onDestroy()' in subclasses instead.
+     */
+    ngOnDestroy(): void;
+    /******************** Methods ********************/
+    private _mergeProps;
+    private _getHostInstance;
+    private _getPropValue;
+    private _getOptionValue;
+    private _hook;
+    /********** Load Styles **********/
+    private _load;
+    private _loadStyles;
+    private _loadGlobalStyles;
+    private _loadCoreStyles;
+    private _loadThemeStyles;
+    private _loadScopedThemeStyles;
+    private _unloadScopedThemeStyles;
+    private _themeChangeListener;
+    private _removeThemeListeners;
+    private _offThemeChangeListener;
+    /********** Passthrough **********/
+    private _getPTValue;
+    private _getPTDatasets;
+    private _getPTClassValue;
+    private _getPT;
+    private _usePT;
+    private _useGlobalPT;
+    private _useDefaultPT;
+    /******************** Exposed API ********************/
+    ptm(key?: string, params?: {}): any;
+    ptms(keys: string[], params?: {}): {};
+    ptmo(obj?: {}, key?: string, params?: {}): any;
+    cx(key: string, params?: {}): string | undefined;
+    sx(key?: string, when?: boolean, params?: {}): {
+        [x: string]: any;
+    } | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseComponent<any>, never, never, { "dt": { "alias": "dt"; "required": false; "isSignal": true; }; "unstyled": { "alias": "unstyled"; "required": false; "isSignal": true; }; "pt": { "alias": "pt"; "required": false; "isSignal": true; }; "ptOptions": { "alias": "ptOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BaseComponent, BaseComponentStyle, PARENT_INSTANCE };