@qualcomm-ui/angular-core 1.0.2 → 1.0.4

package/presence/index.d.ts

@@ -1,5 +1,97 @@
-export * from "./core-presence.directive";
-export * from "./presence-context.service";
-export * from "./render-strategy-context.service";
-export * from "./use-presence-renderer";
-//# sourceMappingURL=index.d.ts.map
+import * as _angular_core from '@angular/core';
+import { Signal, Provider, ElementRef, InjectOptions, EffectRef } from '@angular/core';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import { PresenceApiProps, PresenceApi, RenderStrategyApi } from '@qualcomm-ui/core/presence';
+import { Booleanish } from '@qualcomm-ui/utils/coercion';
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+
+declare class CorePresenceDirective implements SignalifyInput<PresenceApiProps> {
+    /**
+     * Whether to synchronize the present change immediately or defer it to the next
+     * frame.
+     *
+     * @default false
+     */
+    readonly immediate: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * When true, the component will not be rendered in the DOM until it becomes
+     * visible or active.
+     *
+     * @default false
+     */
+    readonly lazyMount: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * The controlled presence of the node.
+     */
+    readonly present: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Whether to allow the initial presence animation.
+     *
+     * @default false
+     */
+    readonly skipAnimationOnMount: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * When true, the component will be completely removed from the DOM when it
+     * becomes inactive or hidden, rather than just being hidden with CSS.
+     *
+     * @default false
+     */
+    readonly unmountOnExit: _angular_core.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Function called when the animation ends in the closed state
+     */
+    exitCompleted: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CorePresenceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CorePresenceDirective, never, never, { "immediate": { "alias": "immediate"; "required": false; "isSignal": true; }; "lazyMount": { "alias": "lazyMount"; "required": false; "isSignal": true; }; "present": { "alias": "present"; "required": false; "isSignal": true; }; "skipAnimationOnMount": { "alias": "skipAnimationOnMount"; "required": false; "isSignal": true; }; "unmountOnExit": { "alias": "unmountOnExit"; "required": false; "isSignal": true; }; }, { "exitCompleted": "exitCompleted"; }, never, never, true, never>;
+}
+
+declare class PresenceContextService {
+    readonly initialized: _angular_core.WritableSignal<boolean>;
+    protected get context(): Signal<PresenceApi>;
+    private _context;
+    init(computedApi: Signal<PresenceApi>): void;
+    setNode(node: HTMLElement | null): void;
+    immediatePresent: boolean | undefined;
+    private _wasEverPresent;
+    readonly wasEverPresent: Signal<boolean>;
+    readonly unmounted: Signal<boolean | undefined>;
+    readonly getPresenceBindings: Signal<{
+        "data-state": string | undefined;
+        hidden: boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresenceContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PresenceContextService>;
+}
+declare function providePresenceContext(): Provider[];
+
+declare class RenderStrategyContextService extends BaseApiContextService<RenderStrategyApi> {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RenderStrategyContextService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RenderStrategyContextService>;
+}
+declare const RENDER_STRATEGY_CONTEXT: _angular_core.InjectionToken<() => RenderStrategyApi>;
+declare const useRenderStrategyContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => RenderStrategyApi) | null : () => RenderStrategyApi;
+declare const provideRenderStrategyContext: () => _angular_core.Provider[];
+
+interface UsePresenceRendererOptions {
+    /**
+     * Element to manage. Defaults to injected ElementRef
+     */
+    elementRef?: ElementRef;
+    /**
+     * Injection options for PresenceContextService
+     */
+    injectOptions?: InjectOptions;
+}
+/**
+ * Removes the host element from the DOM when the presence context is unmounted,
+ * and re-appends it when remounted. Useful for components that need to preserve
+ * their lifecycle while being hidden from the DOM tree.
+ *
+ * @returns Effect reference that can be destroyed manually if needed
+ */
+declare function usePresenceRenderer(options?: UsePresenceRendererOptions): EffectRef;
+
+export { CorePresenceDirective, PresenceContextService, RENDER_STRATEGY_CONTEXT, RenderStrategyContextService, providePresenceContext, provideRenderStrategyContext, usePresenceRenderer, useRenderStrategyContext };
+export type { UsePresenceRendererOptions };
+//# sourceMappingURL=index.d.ts.map

package/presence/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/presence/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,mCAAmC,CAAA;AACjD,cAAc,yBAAyB,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/presence/core-presence.directive.ts","../../src/presence/presence-context.service.ts","../../src/presence/render-strategy-context.service.ts","../../src/presence/use-presence-renderer.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;;;;;AASA;AAEE;;;;;AAKG;;AAKH;;;;;AAKG;;AAKH;;AAEG;;AAGH;;;;AAIG;;AAMH;;;;;AAKG;;AAKH;;AAEG;AACH;;;AACD;;AC/CD;;;;;AAoBE;AAIA;;;;AAuBA;;;AAUE;;;AACH;AAED;;AC7DA;;;AAC6F;AAE7F;AACyB;AACC;;;ACFxB;;AAEG;;AAGH;;AAEG;;AAEJ;AAED;;;;;;AAMG;AACH;;;"}

package/progress/index.d.ts

@@ -1,10 +1,166 @@
-export * from "./core-base-progress.directive";
-export * from "./core-progress-bar.directive";
-export * from "./core-progress-error-text.directive";
-export * from "./core-progress-hint.directive";
-export * from "./core-progress-label.directive";
-export * from "./core-progress-root.directive";
-export * from "./core-progress-track.directive";
-export * from "./core-progress-value-text.directive";
-export * from "./progress-context.service";
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { OnInit, Injector } from '@angular/core';
+import { SignalifyInput } from '@qualcomm-ui/angular-core/signals';
+import * as _qualcomm_ui_core_progress from '@qualcomm-ui/core/progress';
+import { ProgressApiProps, ProgressApi } from '@qualcomm-ui/core/progress';
+import { NumberInput, Booleanish } from '@qualcomm-ui/utils/coercion';
+import { Direction } from '@qualcomm-ui/utils/direction';
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+
+declare class CoreBaseProgressDirective implements SignalifyInput<Omit<ProgressApiProps, "ids">> {
+    /**
+     * The initial value of the progress when it is first rendered. Use when you do
+     * not need to control the state of the progress.
+     */
+    readonly defaultValue: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * The document's text/writing direction.
+     *
+     * @default "ltr"
+     */
+    readonly dir: i0.InputSignal<Direction | undefined>;
+    /**
+     * If `true`, the progress is marked as invalid.
+     */
+    readonly invalid: i0.InputSignalWithTransform<boolean | undefined, Booleanish>;
+    /**
+     * Maximum value
+     *
+     * @default 100
+     */
+    readonly max: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Minimum value
+     *
+     * @default 0
+     */
+    readonly min: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Current progress value (0-100)
+     */
+    readonly value: i0.InputSignalWithTransform<number | undefined, NumberInput>;
+    /**
+     * Callback fired when the value changes.
+     */
+    readonly valueChanged: i0.OutputEmitterRef<number | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreBaseProgressDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreBaseProgressDirective, never, never, { "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
+}
+
+declare class CoreProgressBarDirective implements OnInit {
+    protected readonly progressContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressBarDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreProgressErrorTextDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressErrorTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressErrorTextDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreProgressHintDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly onDestroy: (callback: () => void) => void;
+    private readonly hostId;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressHintDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressHintDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreProgressLabelDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressLabelDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ProgressContextService extends BaseApiContextService<ProgressApi> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressContextService>;
+}
+declare const PROGRESS_CONTEXT: i0.InjectionToken<() => ProgressApi>;
+declare const useProgressContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => ProgressApi) | null : () => ProgressApi;
+declare const provideProgressContext: () => i0.Provider[];
+
+declare class CoreProgressRootDirective extends CoreBaseProgressDirective implements OnInit {
+    readonly injector: Injector;
+    protected readonly progressContext: ProgressContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRootDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreProgressTrackDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    protected readonly hostId: i0.Signal<string>;
+    protected readonly onDestroy: (callback: () => void) => void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressTrackDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressTrackDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreProgressValueTextDirective implements OnInit {
+    protected readonly progressContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressValueTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressValueTextDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+export { CoreBaseProgressDirective, CoreProgressBarDirective, CoreProgressErrorTextDirective, CoreProgressHintDirective, CoreProgressLabelDirective, CoreProgressRootDirective, CoreProgressTrackDirective, CoreProgressValueTextDirective, PROGRESS_CONTEXT, ProgressContextService, provideProgressContext, useProgressContext };
+//# sourceMappingURL=index.d.ts.map

package/progress/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/progress/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,sCAAsC,CAAA;AACpD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,4BAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/progress/core-base-progress.directive.ts","../../src/progress/core-progress-bar.directive.ts","../../src/progress/core-progress-error-text.directive.ts","../../src/progress/core-progress-hint.directive.ts","../../src/progress/core-progress-label.directive.ts","../../src/progress/progress-context.service.ts","../../src/progress/core-progress-root.directive.ts","../../src/progress/core-progress-track.directive.ts","../../src/progress/core-progress-value-text.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null],"names":["_angular_core"],"mappings":";;;;;;;;;;AAWA,cAAA,yBAAA,YAAA,cAAA,CAAA,IAAA,CAAA,gBAAA;AAIE;;;AAGG;2BACkBA,EAAA,CAAA,wBAAA,qBAAA,WAAA;AAIrB;;;;AAIG;kBACSA,EAAA,CAAA,WAAA,CAAA,SAAA;AAEZ;;AAEG;sBACaA,EAAA,CAAA,wBAAA,sBAAA,UAAA;AAIhB;;;;AAIG;kBACSA,EAAA,CAAA,wBAAA,qBAAA,WAAA;AAIZ;;;;AAIG;kBACSA,EAAA,CAAA,wBAAA,qBAAA,WAAA;AAIZ;;AAEG;oBACWA,EAAA,CAAA,wBAAA,qBAAA,WAAA;AAId;;AAEG;2BACkBA,EAAA,CAAA,gBAAA;;;AACtB;;ACzDD,cAAA,wBAAA,YAAA,MAAA;AAEE,8CAAkC,0BAAA,CAAA,WAAA;+CAEF,iCAAA,CAAA,mBAAA;;;AAE/B;;;;AAKF;;ACVD,cAAA,8BAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,8CAAkC,0BAAA,CAAA,WAAA;+CAEF,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACxBD,cAAA,yBAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,8CAAkC,0BAAA,CAAA,WAAA;+CAEF,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACxBD,cAAA,0BAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,8CAAkC,0BAAA,CAAA,WAAA;+CAEF,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACtBD,cAAA,sBAAA,SAAA,qBAAA,CAAA,WAAA;;;AACiF;AAEjF,cAAA,gBAAA,EACkBA,EAAA,CAAA,cAAA,OAAA,WAAA;AAAA,cAChB,8DAAkB,iCAAA,CAAA,cAAA,0DAAA,WAAA,iBAAA,WAAA;AAAA,cAClB;;ACEF,cAAA,yBAAA,SAAA,yBAAA,YAAA,MAAA;;AAOE,wCAAA,sBAAA;+CAEgC,iCAAA,CAAA,mBAAA;;;AAE/B;;;;AAwBF;;AC7CD,cAAA,0BAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,8CAAkC,0BAAA,CAAA,WAAA;+CAEF,iCAAA,CAAA,mBAAA;;;AAK/B;AAED,+BAAyBA,EAAA,CAAA,MAAA;AAEzB;;;;AAKD;;ACzBD,cAAA,8BAAA,YAAA,MAAA;AAEE,8CAAkC,0BAAA,CAAA,WAAA;+CAEF,iCAAA,CAAA,mBAAA;;;AAE/B;;;;AAKF;;;;"}

package/progress-ring/index.d.ts

@@ -1,9 +1,117 @@
-export * from "./core-progress-ring-bar.directive";
-export * from "./core-progress-ring-circle.directive";
-export * from "./core-progress-ring-error-text.directive";
-export * from "./core-progress-ring-label.directive";
-export * from "./core-progress-ring-root.directive";
-export * from "./core-progress-ring-track.directive";
-export * from "./core-progress-ring-value-text.directive";
-export * from "./progress-ring-context.service";
-//# sourceMappingURL=index.d.ts.map
+import * as _qualcomm_ui_angular_core_machine from '@qualcomm-ui/angular-core/machine';
+import { BaseApiContextService } from '@qualcomm-ui/angular-core/machine';
+import * as _qualcomm_ui_core_progress from '@qualcomm-ui/core/progress';
+import { ProgressApi } from '@qualcomm-ui/core/progress';
+import * as i0 from '@angular/core';
+import { OnInit, Injector } from '@angular/core';
+import { CoreBaseProgressDirective } from '@qualcomm-ui/angular-core/progress';
+
+declare class CoreProgressRingBarDirective implements OnInit {
+    protected readonly progressRingContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingBarDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingBarDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreProgressRingCircleDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressRingContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingCircleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingCircleDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreProgressRingErrorTextDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressRingContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingErrorTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingErrorTextDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CoreProgressRingLabelDirective implements OnInit {
+    /**
+     * {@link https://www.w3schools.com/html/html_id.asp id attribute}. If
+     * omitted, a unique identifier will be generated for accessibility.
+     */
+    readonly id: i0.InputSignal<string | undefined>;
+    protected readonly progressRingContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    private readonly hostId;
+    private readonly onDestroy;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingLabelDirective, never, never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ProgressRingContextService extends BaseApiContextService<ProgressApi> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressRingContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProgressRingContextService>;
+}
+declare const PROGRESS_RING_CONTEXT: i0.InjectionToken<() => ProgressApi>;
+declare const useProgressRingContext: <Optional extends boolean = false>(opts?: _qualcomm_ui_angular_core_machine.UseContextOpts<Optional> | undefined) => Optional extends true ? (() => ProgressApi) | null : () => ProgressApi;
+declare const provideProgressRingContext: () => i0.Provider[];
+
+declare class CoreProgressRingRootDirective extends CoreBaseProgressDirective implements OnInit {
+    readonly injector: Injector;
+    protected readonly progressRingContext: ProgressRingContextService;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingRootDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingRootDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreProgressRingTrackDirective implements OnInit {
+    protected readonly progressRingContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingTrackDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingTrackDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class CoreProgressRingValueTextDirective implements OnInit {
+    protected readonly progressRingContext: () => _qualcomm_ui_core_progress.ProgressApi;
+    protected readonly trackBindings: ((opts?: _qualcomm_ui_angular_core_machine.TrackBindingsConfig) => void) & {
+        extendWith: (computedProps: () => _qualcomm_ui_angular_core_machine.Dict) => void;
+        setDisabled: (disabled: boolean) => void;
+    };
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CoreProgressRingValueTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CoreProgressRingValueTextDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+export { CoreProgressRingBarDirective, CoreProgressRingCircleDirective, CoreProgressRingErrorTextDirective, CoreProgressRingLabelDirective, CoreProgressRingRootDirective, CoreProgressRingTrackDirective, CoreProgressRingValueTextDirective, PROGRESS_RING_CONTEXT, ProgressRingContextService, provideProgressRingContext, useProgressRingContext };
+//# sourceMappingURL=index.d.ts.map

package/progress-ring/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/progress-ring/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAA;AAClD,cAAc,uCAAuC,CAAA;AACrD,cAAc,2CAA2C,CAAA;AACzD,cAAc,sCAAsC,CAAA;AACpD,cAAc,qCAAqC,CAAA;AACnD,cAAc,sCAAsC,CAAA;AACpD,cAAc,2CAA2C,CAAA;AACzD,cAAc,iCAAiC,CAAA"}
+{"version":3,"file":"index.d.ts","sources":["../../src/progress-ring/core-progress-ring-bar.directive.ts","../../src/progress-ring/core-progress-ring-circle.directive.ts","../../src/progress-ring/core-progress-ring-error-text.directive.ts","../../src/progress-ring/core-progress-ring-label.directive.ts","../../src/progress-ring/progress-ring-context.service.ts","../../src/progress-ring/core-progress-ring-root.directive.ts","../../src/progress-ring/core-progress-ring-track.directive.ts","../../src/progress-ring/core-progress-ring-value-text.directive.ts"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":["_angular_core"],"mappings":";;;;;;;;AASA,cAAA,4BAAA,YAAA,MAAA;AAEE,kDAAsC,0BAAA,CAAA,WAAA;+CAEN,iCAAA,CAAA,mBAAA;;;AAE9B;;;;AAKH;;ACVD,cAAA,+BAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,kDAAsC,0BAAA,CAAA,WAAA;+CAEN,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACxBD,cAAA,kCAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,kDAAsC,0BAAA,CAAA,WAAA;+CAEN,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACxBD,cAAA,8BAAA,YAAA,MAAA;AAEE;;;AAGG;iBACQA,EAAA,CAAA,WAAA;AAEX,kDAAsC,0BAAA,CAAA,WAAA;+CAEN,iCAAA,CAAA,mBAAA;;;AAK9B;AAEF;AAEA;;;;AAKD;;ACtBD,cAAA,0BAAA,SAAA,qBAAA,CAAA,WAAA;;;AACqF;AAErF,cAAA,qBAAA,EACuBA,EAAA,CAAA,cAAA,OAAA,WAAA;AAAA,cACrB,kEAAsB,iCAAA,CAAA,cAAA,0DAAA,WAAA,iBAAA,WAAA;AAAA,cACtB;;ACEF,cAAA,6BAAA,SAAA,yBAAA,YAAA,MAAA;;AAOE,4CAAA,0BAAA;+CAEgC,iCAAA,CAAA,mBAAA;;;AAE/B;;;;AAwBF;;AC9CD,cAAA,8BAAA,YAAA,MAAA;AAEE,kDAAsC,0BAAA,CAAA,WAAA;+CAEN,iCAAA,CAAA,mBAAA;;;AAE9B;;;;AAKH;;ACXD,cAAA,kCAAA,YAAA,MAAA;AAEE,kDAAsC,0BAAA,CAAA,WAAA;+CAEN,iCAAA,CAAA,mBAAA;;;AAE9B;;;;AAKH;;;;"}