@energinet/watt 4.2.13 → 4.2.15-alpha.0

package/{query-params/watt-query-params.directive.d.ts → types/energinet-watt-query-params.d.ts}

@@ -1,5 +1,6 @@
-import * as i0 from "@angular/core";
-export declare class WattQueryParamsDirective {
+import * as i0 from '@angular/core';
+
+declare class WattQueryParamsDirective {
     private router;
     private route;
     private formGroup;
@@ -7,3 +8,5 @@ export declare class WattQueryParamsDirective {
     static ɵfac: i0.ɵɵFactoryDeclaration<WattQueryParamsDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<WattQueryParamsDirective, "[formGroup][wattQueryParams]", never, {}, {}, never, never, true, never>;
 }
+
+export { WattQueryParamsDirective };

package/types/energinet-watt-radio.d.ts

@@ -0,0 +1,71 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+
+declare class WattRadioComponent<T> implements ControlValueAccessor {
+    /** The name of the radio button. Prefer using `<watt-radio-group>` over this. */
+    group: _angular_core.InputSignal<string | undefined>;
+    name: _angular_core.WritableSignal<string | undefined>;
+    /** Value of the radio button. */
+    value: _angular_core.InputSignal<T>;
+    /** Whether the radio is disabled. */
+    disabled: _angular_core.ModelSignal<boolean>;
+    /** Whether the radio is checked. */
+    checked: _angular_core.ModelSignal<boolean>;
+    /** Emits only when the radio is checked. Never emits when unchecked. */
+    isChecked: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the radio is touched. */
+    touched: _angular_core.OutputEmitterRef<void>;
+    writeValue: (value: T | null | undefined) => void;
+    setDisabledState: (isDisabled: boolean) => void;
+    registerOnTouched: (fn: () => void) => _angular_core.OutputRefSubscription;
+    registerOnChange: (fn: (value: T | null | undefined) => void) => _angular_core.OutputRefSubscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattRadioComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattRadioComponent<any>, "watt-radio", never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "checked": "checkedChange"; "isChecked": "isChecked"; "touched": "touched"; }, never, ["*"], true, never>;
+}
+
+declare class WattRadioGroupComponent<T> implements ControlValueAccessor {
+    /**
+     * The field label.
+     */
+    label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The value of the radio button group.
+     */
+    value: _angular_core.ModelSignal<T | null | undefined>;
+    /**
+     * Optional input for setting the name of the radio buttons.
+     * If no name is provided, the name will be auto-generated.
+     */
+    name: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the radio button group is readonly.
+     */
+    readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the radio button group is disabled.
+     */
+    disabled: _angular_core.ModelSignal<boolean>;
+    /**
+     * Emits when the radio button group is touched.
+     */
+    touched: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Tracks the FormControl instance bound to the directive.
+     */
+    formControl: _angular_core.InputSignal<FormControl<any> | null>;
+    private static instance;
+    private instance;
+    private group;
+    private radios;
+    protected inheritPropertiesEffect: _angular_core.EffectRef;
+    constructor();
+    writeValue: (value: T | null | undefined) => void;
+    setDisabledState: (isDisabled: boolean) => void;
+    registerOnTouched: (fn: () => void) => _angular_core.OutputRefSubscription;
+    registerOnChange: (fn: (value: T | null | undefined) => void) => _angular_core.OutputRefSubscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattRadioGroupComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattRadioGroupComponent<any>, "watt-radio-group", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "formControl": { "alias": "formControl"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; "touched": "touched"; }, ["radios"], ["*"], true, never>;
+}
+declare const WATT_RADIO: readonly [typeof WattRadioGroupComponent, typeof WattRadioComponent];
+
+export { WATT_RADIO, WattRadioComponent, WattRadioGroupComponent };

package/types/energinet-watt-search.d.ts

@@ -0,0 +1,47 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { WattIconSize } from '@energinet/watt/icon';
+
+declare class WattSearchComponent {
+    /**
+     * @ignore
+     */
+    input: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    /**
+     * @ignore
+     */
+    label: _angular_core.InputSignal<string>;
+    /**
+     * @ignore
+     */
+    debounceTime: _angular_core.InputSignal<number>;
+    /**
+     * If true, trims whitespace from the search value before emitting.
+     */
+    trim: _angular_core.InputSignal<boolean>;
+    /**
+     * @ignore
+     */
+    search$: BehaviorSubject<string>;
+    /**
+     * @ignore
+     */
+    search: _angular_core.OutputRef<string>;
+    /**
+     * @ignore
+     */
+    size: _angular_core.InputSignal<WattIconSize>;
+    /**
+     * Handles input event, optionally trimming the value.
+     */
+    onInput(value: string): void;
+    /**
+     * @ignore
+     */
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattSearchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattSearchComponent, "watt-search", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "debounceTime": { "alias": "debounceTime"; "required": false; "isSignal": true; }; "trim": { "alias": "trim"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, { "search": "search"; }, never, never, true, never>;
+}
+
+export { WattSearchComponent };

package/types/energinet-watt-segmented-buttons.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class WattSegmentedButtonComponent {
+    templateRef: _angular_core.Signal<TemplateRef<unknown>>;
+    value: _angular_core.InputSignal<string | undefined>;
+    link: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattSegmentedButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattSegmentedButtonComponent, "watt-segmented-button", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "link": { "alias": "link"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Segmented buttons.
+ */
+declare class WattSegmentedButtonsComponent implements ControlValueAccessor {
+    private element;
+    segmentedButtonElements: _angular_core.Signal<readonly WattSegmentedButtonComponent[]>;
+    selected: _angular_core.ModelSignal<string>;
+    disabled: _angular_core.WritableSignal<boolean>;
+    writeValue(selected: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: (value: boolean) => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattSegmentedButtonsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattSegmentedButtonsComponent, "watt-segmented-buttons", never, { "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; }, ["segmentedButtonElements"], never, true, never>;
+}
+
+/**
+ * @license
+ * Copyright 2020 Energinet DataHub A/S
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License2");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare const WATT_SEGMENTED_BUTTONS: readonly [typeof WattSegmentedButtonsComponent, typeof WattSegmentedButtonComponent];
+
+export { WATT_SEGMENTED_BUTTONS, WattSegmentedButtonComponent, WattSegmentedButtonsComponent };

package/types/energinet-watt-shell.d.ts

@@ -0,0 +1,47 @@
+import * as _angular_core from '@angular/core';
+
+declare class WattShellComponent {
+    private breakpointObserver;
+    private router;
+    private readonly sidenav;
+    /**
+     * @ignore
+     */
+    private onNavigationEnd$;
+    /**
+     * @ignore
+     */
+    isHandset: _angular_core.Signal<boolean | undefined>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattShellComponent, "watt-shell", never, {}, {}, never, ["[watt-shell-sidenav]", "[watt-shell-toolbar]", "*"], true, never>;
+}
+
+declare class WattNavListItemComponent {
+    link: _angular_core.InputSignal<string>;
+    target: _angular_core.InputSignal<"_self" | "_blank" | "_parent" | "_top">;
+    isActive: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * @ignore
+     */
+    isExternalLink: _angular_core.Signal<boolean>;
+    /**
+     * @ignore
+     */
+    onRouterLinkActive(isActive: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattNavListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattNavListItemComponent, "watt-nav-list-item", never, { "link": { "alias": "link"; "required": true; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, { "isActive": "isActive"; }, never, ["*"], true, never>;
+}
+
+declare class WattNavListComponent {
+    /**
+     * @ignore
+     */
+    navListItemComponents: _angular_core.Signal<readonly WattNavListItemComponent[]>;
+    expandable: _angular_core.InputSignal<boolean>;
+    title: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattNavListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattNavListComponent, "watt-nav-list", never, { "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, ["navListItemComponents"], ["*"], true, never>;
+}
+
+export { WattNavListComponent, WattNavListItemComponent, WattShellComponent };

package/types/energinet-watt-slide-toggle.d.ts

@@ -0,0 +1,20 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * Slide toggle
+ */
+declare class WattSlideToggleComponent implements ControlValueAccessor {
+    private element;
+    checked: _angular_core.ModelSignal<boolean>;
+    isDisabled: _angular_core.WritableSignal<boolean>;
+    required: _angular_core.InputSignal<boolean>;
+    writeValue(checked: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: (value: boolean) => void): void;
+    setDisabledState?(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattSlideToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattSlideToggleComponent, "watt-slide-toggle", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+export { WattSlideToggleComponent };

package/types/energinet-watt-slider.d.ts

@@ -0,0 +1,35 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+interface WattSliderValue {
+    min: number;
+    max: number;
+}
+/**
+ * Slider for providing a range of values.
+ */
+declare class WattSliderComponent {
+    private readonly colorService;
+    private readonly destroyRef;
+    /** The lowest permitted value. */
+    readonly min: _angular_core.InputSignal<number>;
+    /** The highest permitted value. */
+    readonly max: _angular_core.InputSignal<number>;
+    /** Step between each value. */
+    readonly step: _angular_core.InputSignal<number>;
+    /** The currently selected range value. */
+    readonly value: _angular_core.InputSignal<WattSliderValue | undefined>;
+    readonly currentValue: _angular_core.Signal<WattSliderValue>;
+    readonly maxRange: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly minRange: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    readonly valueChange: _angular_core.OutputEmitterRef<WattSliderValue>;
+    readonly sliderColor: string;
+    readonly rangeColor: string;
+    constructor();
+    private updateRange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattSliderComponent, "watt-slider", never, { "min": { "alias": "min"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": true; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+export { WattSliderComponent };
+export type { WattSliderValue };

package/types/energinet-watt-spinner.d.ts

@@ -0,0 +1,18 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Usage:
+ * `import { WattSpinnerComponent } from '@energinet/watt/spinner';`
+ */
+declare class WattSpinnerComponent {
+    /**
+     * @ignore
+     */
+    diameterSize: _angular_core.Signal<string>;
+    diameter: _angular_core.InputSignal<number>;
+    strokeWidth: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattSpinnerComponent, "watt-spinner", never, { "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WattSpinnerComponent };

package/types/energinet-watt-stepper.d.ts

@@ -0,0 +1,59 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, AfterViewInit, EventEmitter, QueryList } from '@angular/core';
+import { CdkStep, StepperSelectionEvent } from '@angular/cdk/stepper';
+export { CdkStep as WattStep } from '@angular/cdk/stepper';
+import { MatStep, MatStepper } from '@angular/material/stepper';
+import { Observable } from 'rxjs';
+
+declare class WattStepperStepComponent extends MatStep {
+    readonly templateRef: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    nextButtonLabel: _angular_core.InputSignal<string | undefined>;
+    disableNextButton: _angular_core.InputSignal<boolean>;
+    loadingNextButton: _angular_core.InputSignal<boolean>;
+    previousButtonLabel: _angular_core.InputSignal<string | undefined>;
+    enabled: _angular_core.InputSignal<boolean>;
+    disablePreviousButton: _angular_core.InputSignal<boolean>;
+    entering: _angular_core.OutputEmitterRef<CdkStep>;
+    leaving: _angular_core.OutputEmitterRef<CdkStep>;
+    next: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattStepperStepComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattStepperStepComponent, "watt-stepper-step", never, { "nextButtonLabel": { "alias": "nextButtonLabel"; "required": false; "isSignal": true; }; "disableNextButton": { "alias": "disableNextButton"; "required": false; "isSignal": true; }; "loadingNextButton": { "alias": "loadingNextButton"; "required": false; "isSignal": true; }; "previousButtonLabel": { "alias": "previousButtonLabel"; "required": false; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "disablePreviousButton": { "alias": "disablePreviousButton"; "required": false; "isSignal": true; }; }, { "entering": "entering"; "leaving": "leaving"; "next": "next"; }, never, ["*"], true, never>;
+}
+
+/**
+ * @license
+ * Copyright 2020 Energinet DataHub A/S
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License2");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+declare class WattStepperComponent extends MatStepper implements AfterViewInit {
+    completed: EventEmitter<void>;
+    isCompleting: boolean;
+    _steps: QueryList<WattStepperStepComponent>;
+    stepper: MatStepper;
+    selectedIndexChanged$: Observable<StepperSelectionEvent>;
+    onFirstStep$: Observable<boolean>;
+    onLastStep$: Observable<boolean>;
+    private destroyRef;
+    reset(): void;
+    ngAfterViewInit(): void;
+    nextStep(step: WattStepperStepComponent): void;
+    previousStep(): void;
+    complete(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattStepperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattStepperComponent, "watt-stepper", never, { "isCompleting": { "alias": "isCompleting"; "required": false; }; }, { "completed": "completed"; }, ["_steps"], never, true, never>;
+}
+declare const WATT_STEPPER: (typeof WattStepperStepComponent | typeof WattStepperComponent)[];
+
+export { WATT_STEPPER, WattStepperComponent, WattStepperStepComponent };

package/{table/watt-table.component.d.ts → types/energinet-watt-table.d.ts}

@@ -1,3 +1,12 @@
+import { DataSource } from '@angular/cdk/collections';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort, SortDirection, Sort } from '@angular/material/sort';
+import { MatTableDataSource } from '@angular/material/table';
+import * as _angular_core from '@angular/core';
+import { Signal, TrackByFunction, TemplateRef, ElementRef } from '@angular/core';
+import { KeyValue } from '@angular/common';
+import { Subject } from 'rxjs';
+
 /**
  * @license
  * Copyright 2020 Energinet DataHub A/S
@@ -14,16 +23,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { KeyValue } from '@angular/common';
-import { ElementRef, TemplateRef } from '@angular/core';
-import type { Signal, TrackByFunction } from '@angular/core';
-import { MatSort, Sort, SortDirection } from '@angular/material/sort';
-import { Subject } from 'rxjs';
-import { IWattTableDataSource } from './watt-table-data-source';
-import * as i0 from "@angular/core";
-/** Class name for expandable cells. */
-export declare const EXPANDABLE_CLASS = "watt-table-cell--expandable";
-export interface WattTableColumn<T> {
+
+interface IWattTableDataSource<T> extends DataSource<T> {
+    data: T[];
+    filter: string;
+    filteredData: T[];
+    paginator: MatPaginator | null | undefined;
+    sort: MatSort | null | undefined;
+    totalCount: number;
+}
+/**
+ * @see https://material.angular.dev/components/table/api#MatTableDataSource
+ */
+declare class WattTableDataSource<T> extends MatTableDataSource<T> implements IWattTableDataSource<T> {
+    constructor(initialData?: T[], config?: {
+        disableClientSideSort: boolean;
+    });
+    get totalCount(): number;
+}
+/** Convenience method for creating a data source from reactive input. */
+declare const dataSource: <T>(computation: () => T[]) => WattTableDataSource<T>;
+
+interface WattTableColumn<T> {
     /**
      * The data that this column should be bound to, either as a property of `T`
      * or derived from each row of `T` using an accessor function.  Use `null`
@@ -98,7 +119,7 @@ export interface WattTableColumn<T> {
 /**
  * Configuration for the footer cell of a column.
  */
-export interface WattTableColumnFooter {
+interface WattTableColumnFooter {
     /**
      * The value that will be displayed in the footer cell.
      */
@@ -111,7 +132,7 @@ export interface WattTableColumnFooter {
 /**
  * Record for defining columns with keys used as column identifiers.
  */
-export type WattTableColumnDef<T> = Record<string, WattTableColumn<T>>;
+type WattTableColumnDef<T> = Record<string, WattTableColumn<T>>;
 interface WattTableCellContext<T> {
     $implicit: T;
     index: number;
@@ -119,102 +140,102 @@ interface WattTableCellContext<T> {
 interface WattTableToolbarContext<T> {
     $implicit: T;
 }
-export declare class WattTableCellDirective<T> {
+declare class WattTableCellDirective<T> {
     templateRef: TemplateRef<any>;
     /**
      * The WattTableColumn this template applies to.
      */
-    readonly column: import("@angular/core").InputSignal<WattTableColumn<T>>;
+    readonly column: _angular_core.InputSignal<WattTableColumn<T>>;
     /**
      * Optional header text for the column.
      */
-    readonly header: import("@angular/core").InputSignal<string | undefined>;
+    readonly header: _angular_core.InputSignal<string | undefined>;
     static ngTemplateContextGuard<T>(_directive: WattTableCellDirective<T>, context: unknown): context is WattTableCellContext<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WattTableCellDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<WattTableCellDirective<any>, "[wattTableCell]", never, { "column": { "alias": "wattTableCell"; "required": true; "isSignal": true; }; "header": { "alias": "wattTableCellHeader"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattTableCellDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WattTableCellDirective<any>, "[wattTableCell]", never, { "column": { "alias": "wattTableCell"; "required": true; "isSignal": true; }; "header": { "alias": "wattTableCellHeader"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
-export declare class WattTableToolbarDirective<T> {
+declare class WattTableToolbarDirective<T> {
     templateRef: TemplateRef<any>;
     static ngTemplateContextGuard<T>(_directive: WattTableToolbarDirective<T>, context: unknown): context is WattTableToolbarContext<T[]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WattTableToolbarDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<WattTableToolbarDirective<any>, "[wattTableToolbar]", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattTableToolbarDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WattTableToolbarDirective<any>, "[wattTableToolbar]", never, {}, {}, never, never, true, never>;
 }
 /**
  * Usage:
  * `import { WATT_TABLE } from '@energinet/watt/table';`
  */
-export declare class WattTableComponent<T> {
+declare class WattTableComponent<T> {
     /**
      * The table's source of data. Property should not be changed after
      * initialization, instead update the data on the instance itself.
      */
-    readonly dataSource: import("@angular/core").InputSignal<IWattTableDataSource<T>>;
+    readonly dataSource: _angular_core.InputSignal<IWattTableDataSource<T>>;
     /**
      * Column definition record with keys representing the column identifiers
      * and values being the column configuration. The order of the columns
      * is determined by the property order, but can be overruled by the
      * `displayedColumns` input.
      */
-    readonly columns: import("@angular/core").InputSignal<WattTableColumnDef<T>>;
+    readonly columns: _angular_core.InputSignal<WattTableColumnDef<T>>;
     /**
      * Used for hiding or reordering columns defined in the `columns` input.
      */
-    readonly displayedColumns: import("@angular/core").InputSignal<string[] | undefined>;
+    readonly displayedColumns: _angular_core.InputSignal<string[] | undefined>;
     /**
      * Used for disabling the table. This will disable all user interaction
      */
-    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
     /**
      * Provide a description of the table for visually impaired users.
      */
-    readonly description: import("@angular/core").InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
     /**
      * If set to `true`, the table will show a loading indicator
      * when there is no data.
      */
-    readonly loading: import("@angular/core").InputSignal<boolean>;
+    readonly loading: _angular_core.InputSignal<boolean>;
     /**
      * If true the footer will be sticky
      */
-    readonly stickyFooter: import("@angular/core").InputSignal<boolean>;
+    readonly stickyFooter: _angular_core.InputSignal<boolean>;
     /**
      * Optional callback for determining header text for columns that
      * do not have a static header text set in the column definition.
      * Useful for providing translations of column headers.
      */
-    readonly resolveHeader: import("@angular/core").InputSignal<((key: string) => string) | undefined>;
+    readonly resolveHeader: _angular_core.InputSignal<((key: string) => string) | undefined>;
     /**
      * Identifier for column that should be sorted initially.
      */
-    readonly sortBy: import("@angular/core").InputSignal<string>;
+    readonly sortBy: _angular_core.InputSignal<string>;
     /**
      * The sort direction of the initially sorted column.
      */
-    readonly sortDirection: import("@angular/core").InputSignal<SortDirection>;
+    readonly sortDirection: _angular_core.InputSignal<SortDirection>;
     /**
      * Whether to allow the user to clear the sort. Defaults to `true`.
      */
-    readonly sortClear: import("@angular/core").InputSignal<boolean>;
+    readonly sortClear: _angular_core.InputSignal<boolean>;
     /**
      * Optional function to determine CSS class(es) for each row.
      */
-    readonly rowClass: import("@angular/core").InputSignal<((row: T) => string | string[]) | undefined>;
+    readonly rowClass: _angular_core.InputSignal<((row: T) => string | string[]) | undefined>;
     /**
      * Whether the table should include a checkbox column for row selection.
      */
-    readonly selectable: import("@angular/core").InputSignal<boolean>;
+    readonly selectable: _angular_core.InputSignal<boolean>;
     /**
      * Sets the selected rows. Only applicable when selectable is `true`.
      */
-    readonly selection: import("@angular/core").ModelSignal<T[]>;
+    readonly selection: _angular_core.ModelSignal<T[]>;
     /**
      * Set to true to disable row hover highlight.
      */
-    readonly suppressRowHoverHighlight: import("@angular/core").InputSignal<boolean>;
+    readonly suppressRowHoverHighlight: _angular_core.InputSignal<boolean>;
     /**
      * Highlights the currently active row.
      */
-    readonly activeRow: import("@angular/core").InputSignal<T | undefined>;
+    readonly activeRow: _angular_core.InputSignal<T | undefined>;
     /**
      * Custom comparator function to determine if two rows are equal.
      *
@@ -224,23 +245,23 @@ export declare class WattTableComponent<T> {
      * as long as the instances remain the same, which may not be the case
      * if row data is recreated or rebuilt from serialization.
      */
-    readonly activeRowComparator: import("@angular/core").InputSignal<((currentRow: T, activeRow: T) => boolean) | undefined>;
+    readonly activeRowComparator: _angular_core.InputSignal<((currentRow: T, activeRow: T) => boolean) | undefined>;
     /**
      * If set to `true`, the column headers will not be shown. Default is `false`.
      */
-    readonly hideColumnHeaders: import("@angular/core").InputSignal<boolean>;
+    readonly hideColumnHeaders: _angular_core.InputSignal<boolean>;
     /**
      * Choose from a predefined set of display variants.
      */
-    readonly variant: import("@angular/core").InputSignal<"zebra" | undefined>;
+    readonly variant: _angular_core.InputSignal<"zebra" | undefined>;
     /**
      * Array of rows that are currently expanded.
      */
-    readonly expanded: import("@angular/core").ModelSignal<T[]>;
+    readonly expanded: _angular_core.ModelSignal<T[]>;
     /**
      * Optional function for uniquely identifying rows.
      */
-    readonly trackBy: import("@angular/core").InputSignal<TrackByFunction<T> | keyof T | undefined>;
+    readonly trackBy: _angular_core.InputSignal<TrackByFunction<T> | keyof T | undefined>;
     /**
      * @ignore
      * The `observed` boolean from the `Subject` is used to determine if a row is
@@ -251,16 +272,16 @@ export declare class WattTableComponent<T> {
     /**
      * Emits whenever a row is clicked.
      */
-    readonly rowClick: import("@angular/core").OutputRef<T>;
+    readonly rowClick: _angular_core.OutputRef<T>;
     /**
      * Event emitted when the user changes the active sort or sort direction.
      */
-    readonly sortChange: import("@angular/core").OutputEmitterRef<Sort>;
+    readonly sortChange: _angular_core.OutputEmitterRef<Sort>;
     protected cells: Signal<readonly WattTableCellDirective<T>[]>;
     protected toolbar: Signal<WattTableToolbarDirective<any> | undefined>;
     protected sort: Signal<MatSort | undefined>;
     protected tableCellElements: Signal<readonly ElementRef<HTMLTableCellElement>[]>;
-    protected animationEffect: import("@angular/core").AfterRenderRef;
+    protected animationEffect: _angular_core.AfterRenderRef;
     protected filterSelectionBy: (rows: T[]) => T[];
     protected getSelectionState: () => boolean | null;
     protected checkboxColumn: string;
@@ -287,8 +308,10 @@ export declare class WattTableComponent<T> {
      * Toggles the selection of a row.
      */
     toggleSelection: (row: T) => void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WattTableComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WattTableComponent<any>, "watt-table", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "stickyFooter": { "alias": "stickyFooter"; "required": false; "isSignal": true; }; "resolveHeader": { "alias": "resolveHeader"; "required": false; "isSignal": true; }; "sortBy": { "alias": "sortBy"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; "sortClear": { "alias": "sortClear"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "suppressRowHoverHighlight": { "alias": "suppressRowHoverHighlight"; "required": false; "isSignal": true; }; "activeRow": { "alias": "activeRow"; "required": false; "isSignal": true; }; "activeRowComparator": { "alias": "activeRowComparator"; "required": false; "isSignal": true; }; "hideColumnHeaders": { "alias": "hideColumnHeaders"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "expanded": "expandedChange"; "rowClick": "rowClick"; "sortChange": "sortChange"; }, ["cells", "toolbar"], never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WattTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WattTableComponent<any>, "watt-table", never, { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "stickyFooter": { "alias": "stickyFooter"; "required": false; "isSignal": true; }; "resolveHeader": { "alias": "resolveHeader"; "required": false; "isSignal": true; }; "sortBy": { "alias": "sortBy"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; "sortClear": { "alias": "sortClear"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "suppressRowHoverHighlight": { "alias": "suppressRowHoverHighlight"; "required": false; "isSignal": true; }; "activeRow": { "alias": "activeRow"; "required": false; "isSignal": true; }; "activeRowComparator": { "alias": "activeRowComparator"; "required": false; "isSignal": true; }; "hideColumnHeaders": { "alias": "hideColumnHeaders"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "expanded": "expandedChange"; "rowClick": "rowClick"; "sortChange": "sortChange"; }, ["cells", "toolbar"], never, true, never>;
 }
-export declare const WATT_TABLE: (typeof WattTableToolbarDirective | typeof WattTableComponent)[];
-export {};
+declare const WATT_TABLE: (typeof WattTableToolbarDirective | typeof WattTableComponent)[];
+
+export { WATT_TABLE, WattTableCellDirective, WattTableComponent, WattTableDataSource, WattTableToolbarDirective, dataSource };
+export type { IWattTableDataSource, WattTableColumn, WattTableColumnDef };