@danske/sapphire-angular 1.12.4

package/lib/select/src/common/select-component-base.d.ts

@@ -0,0 +1,109 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ListboxChild, ListboxComponent, OptionComponent } from '../../../listbox/public_api';
+import { ControlValueAccessor } from '@angular/forms';
+import { AfterContentInit, ElementRef, EventEmitter, OnDestroy, QueryList } from '@angular/core';
+import { FocusOrigin, ListKeyManager, ListKeyManagerOption } from '@angular/cdk/a11y';
+import { PopoverTriggerDirective } from '../../../popover/src/popover-trigger.directive';
+import { SelectValueHolder } from './select-value-holder';
+import { SelectionTextDirective } from '../select/selection-text.directive';
+import * as i0 from "@angular/core";
+export declare abstract class SelectComponentBase implements ControlValueAccessor, AfterContentInit, OnDestroy {
+    protected valueHolder: SelectValueHolder;
+    /**
+     * Whether the component is disabled.
+     */
+    disabled: BooleanInput;
+    /** A unique id for the select. If none is supplied, it will be auto-generated. */
+    id: string;
+    /** The name of the input, used when submitting an HTML form. */
+    name?: string;
+    /**
+     * Placeholder to be shown if no value has been selected.
+     */
+    placeholder?: string;
+    /**
+     * Emitted when the popover is opened
+     */
+    readonly opened: EventEmitter<void>;
+    /**
+     * Emitted when the popover is closed
+     */
+    readonly closed: EventEmitter<void>;
+    options: QueryList<OptionComponent>;
+    listboxChildren: QueryList<ListboxChild>;
+    /**
+     * Manages keyboard events for options in the panel.
+     */
+    protected keyManager: ListKeyManager<{
+        value: string;
+    } & ListKeyManagerOption> | undefined;
+    /**
+     * Emits whenever the dropdown is closed as a result of an option (already
+     * selected or not) being selected.
+     */
+    selected: EventEmitter<any>;
+    ariaLabel: string | null;
+    ariaLabelledby?: string | null;
+    selectionText?: SelectionTextDirective;
+    /**
+     * Used to work around ExpressionChangedAfterItHasBeenCheckedError error thrown from HiddenSelect,
+     * when the select component is rendered from a template (e.g. with *ngIf). It's set to true
+     * asynchronously after content is initialized, to delay rendering of things that depend on
+     * options. It's not clear why the issue happens, and it only happens when select is used with
+     * *ngIf, or generally in a template.
+     */
+    _initialized: boolean;
+    set listboxValue(value: readonly string[]);
+    get listboxValue(): readonly string[];
+    get selectedOptions(): OptionComponent[];
+    private changeDetectorRef;
+    constructor(valueHolder: SelectValueHolder);
+    protected abstract triggerRef: PopoverTriggerDirective | undefined;
+    protected abstract triggerElementRef: ElementRef<HTMLElement> | undefined;
+    protected abstract listbox: ListboxComponent | undefined;
+    abstract focus(focusOrigin: FocusOrigin): void;
+    abstract isFocused(): boolean;
+    handleKeyDown($event: KeyboardEvent): void;
+    getSelectionText(): string;
+    /**
+     * Whether multiple selection is allowed.
+     */
+    get multiple(): boolean;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Called when an item in the listbox is selected.
+     */
+    _handleSelected(): void;
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    protected getFieldLabel?(): string;
+    getLabelText(): string | undefined;
+    protected controlValueAccessorChangeFn: (value: any) => void;
+    onTouched: () => any;
+    _onOpen(): void;
+    _onClose(): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    registerOnChange(fn: any): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    registerOnTouched(fn: any): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value: unknown): void;
+    protected getNextEnabledOptionValue(direction?: 'left' | 'right'): string | undefined;
+    protected initKeyManager(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponentBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectComponentBase, never, never, { "disabled": "disabled"; "id": "id"; "name": "name"; "placeholder": "placeholder"; "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; }, { "opened": "opened"; "closed": "closed"; "selected": "selected"; }, ["selectionText", "options", "listboxChildren"], never, false, never>;
+}

package/lib/select/src/common/select-value-holder.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A common base class to handle value for single and multiple selection.
+ * {@link MultiSelectDirectiveBase} and {@link SingleSelectDirectiveBase} implement and
+ * provide this interface. Note that the main purpose for such design is **not**
+ * to abstract out selection behavior. But to have accurate `value` and `valueChange`
+ * type for single and multiple selection mode. It would be possible to fully abstract out
+ * the selection behavior, and have Select component not know anything about selection being
+ * multiple or not, but it doesn't seem such a clear abstraction, and also not worth the additional
+ * complexity.
+ *
+ * At least one directive has to be defined for each select component to provide SelectValueHolder,
+ * extending either {@link MultiSelectDirectiveBase} or {@link SingleSelectDirectiveBase}
+ */
+export declare abstract class SelectValueHolder<T = unknown> {
+    abstract value: T;
+    abstract valueChange: EventEmitter<T>;
+    abstract setFromListboxValue(value: readonly string[]): void;
+    abstract getListboxValue(): readonly string[];
+}
+/**
+ * Enables multiple selection. When present, `value` will be of type `string[]`, and `valueChange`
+ * will emit `string[]`.
+ *
+ * Each select component can define a directive with the right selector (usually based on
+ * the presence of `multiple` attribute) to enable multiple selection.
+ */
+export declare class MultiSelectDirectiveBase extends SelectValueHolder<string[]> {
+    value: string[];
+    valueChange: EventEmitter<string[]>;
+    setFromListboxValue(value: string[]): void;
+    getListboxValue(): readonly string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectDirectiveBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSelectDirectiveBase, never, never, { "value": "value"; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}
+/**
+ * Enables single selection, the default behavior of select.
+ * When present, `value` will be of type `string`, and `valueChange` will emit `string`.
+ *
+ * Each select component has to define a directive with the right selector (usually based on
+ * the absence of `multiple` attribute) to enable single selection.
+ */
+export declare class SingleSelectDirectiveBase extends SelectValueHolder<string> {
+    get value(): string;
+    set value(value: string);
+    private _value;
+    private values;
+    valueChange: EventEmitter<string>;
+    setFromListboxValue(value: string[]): void;
+    getListboxValue(): readonly string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSelectDirectiveBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SingleSelectDirectiveBase, never, never, { "value": "value"; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}

package/lib/select/src/select/searchable-select.directive.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ListboxChild } from '../../../listbox/src/listbox-child';
+import { OptionComponent } from '../../../listbox/src/option.component';
+import * as i0 from "@angular/core";
+/**
+ * Marks sp-select as searchable. When used, a search input is rendered inside select trigger
+ * which allows filtering options, in a more convenient way than the default typeahead search.
+ * By default, rendered `sp-option`s are filtered based on the search value, but `searchValue`
+ * and `searchValueChange` can be used to control the search value and filter the `sp-options`
+ * upfront.
+ */
+export declare class SearchableSelectDirective {
+    get searchValue(): string | undefined;
+    set searchValue(value: string | undefined);
+    private _searchValue;
+    /**
+     * Filtering function to be applied on each item. The default filter function
+     * does a case-insensitive search on optionComponent.label.
+     * The built-in filtering can be disabled by passing `null`. That's useful
+     * when filtering is fully controlled by filtering input sp-options based on
+     * {@property searchValue}.
+     */
+    filter?: null | ((optionComponent: OptionComponent, searchQuery: string) => boolean);
+    selectTextOnOpen?: BooleanInput;
+    searchValueChange: EventEmitter<string>;
+    filterListboxItems(items: Iterable<ListboxChild>, filter: (option: OptionComponent) => boolean): {
+        filteredChildren: ListboxChild[];
+        filteredOutOptions: OptionComponent[];
+    };
+    /**
+     * Used when search value is updated via UI, and searchValueChange output should be emitted.
+     * @internal
+     */
+    setSearchValue(searchValue: string): void;
+    defaultFilter(optionComponent: OptionComponent, searchQuery: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchableSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SearchableSelectDirective, "sp-select[searchable]", never, { "searchValue": "searchValue"; "filter": "filter"; "selectTextOnOpen": "selectTextOnOpen"; }, { "searchValueChange": "searchValueChange"; }, never, never, false, never>;
+}
+export declare const notNull: <T>(item: T | null | undefined) => item is NonNullable<T>;

package/lib/select/src/select/select.component.d.ts

@@ -0,0 +1,80 @@
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import { FocusMonitor, FocusOrigin, InputModalityDetector } from '@angular/cdk/a11y';
+import { Observable } from 'rxjs';
+import { PopoverTriggerDirective } from '../../../popover/src/popover-trigger.directive';
+import { ListboxChild, ListboxComponent } from '../../../listbox/public_api';
+import { FieldComponent, FieldControl } from '../../../field/public_api';
+import { SelectComponentBase } from '../common/select-component-base';
+import { MultiSelectDirectiveBase, SelectValueHolder, SingleSelectDirectiveBase } from '../common/select-value-holder';
+import { SearchableSelectDirective } from './searchable-select.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../common/sapphire-view-encapsulation";
+/**
+ * Enables multiple selection. When present, `value` will be of type `string[]`, and `valueChange`
+ * will emit `string[]`.
+ */
+export declare class MultiSelectDirective extends MultiSelectDirectiveBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultiSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MultiSelectDirective, "sp-select[multiple]", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Enables single selection, the default behavior of Select.
+ * When present, `value` will be of type `string`, and `valueChange` will emit `string`.
+ */
+export declare class SingleSelectDirective extends SingleSelectDirectiveBase {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SingleSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SingleSelectDirective, "sp-select:not([multiple])", never, {}, {}, never, never, false, never>;
+}
+/**
+ * Allows user to select a single option from a list, similar to native select
+ * component.
+ *
+ * Example:
+ * ```tsx
+ * <sp-field>
+ *   <sp-field-label>Label text</sp-field-label>
+ *   <sp-select placeholder="Select an option">
+ *     <sp-option value="option1">First Option</sp-option>
+ *     <sp-option value="option2">Second Option</sp-option>
+ *     <sp-option value="option3">Third Option</sp-option>
+ *   </sp-select>
+ * </sp-field>
+ * ```
+ */
+export declare class SelectComponent extends SelectComponentBase implements FieldControl, AfterViewInit, OnDestroy {
+    private focusMonitor;
+    private inputModality;
+    _field?: FieldComponent | undefined;
+    _searchableSelectDirective?: SearchableSelectDirective | undefined;
+    private focusOrigin;
+    filteredChildren$: Observable<ListboxChild[]>;
+    protected triggerRef: PopoverTriggerDirective | undefined;
+    protected triggerElementRef: ElementRef | undefined;
+    protected listbox: ListboxComponent | undefined;
+    private searchInput?;
+    get searchable(): boolean;
+    /**
+     * id of trigger value area, which will contain either the selected value or the placeholder.
+     */
+    _valueContainerId: string;
+    private destroyed;
+    constructor(valueHolder: SelectValueHolder, focusMonitor: FocusMonitor, inputModality: InputModalityDetector, _field?: FieldComponent | undefined, _searchableSelectDirective?: SearchableSelectDirective | undefined);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _getAriaLabelledBy(): string | undefined;
+    isFocused(): boolean;
+    isFocusVisible(): boolean;
+    focus(focusOrigin?: FocusOrigin): void;
+    _onFocusChange(focusOrigin: FocusOrigin): void;
+    _onFocus(): void;
+    _isInputVisible(): boolean;
+    _onOpen(): void;
+    _onClose(): void;
+    protected getFieldLabel?(): string;
+    _onInputKeydown(event: KeyboardEvent): void;
+    _onSearchInput(event: Event): void;
+    _handleSelected(): void;
+    isDisabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, [null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "sp-select", ["spSelect"], {}, {}, never, ["sp-selection-text"], false, [{ directive: typeof i1.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

package/lib/select/src/select/select.module.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./select.component";
+import * as i2 from "./selection-text.directive";
+import * as i3 from "../basic-select/basic-select.component";
+import * as i4 from "../common/hidden-select.component";
+import * as i5 from "./searchable-select.directive";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/forms";
+import * as i8 from "../../../icon/src/icon.module";
+import * as i9 from "../../../listbox/src/listbox.module";
+import * as i10 from "../../../popover/src/popover.module";
+import * as i11 from "@angular/cdk/listbox";
+import * as i12 from "@angular/cdk/a11y";
+import * as i13 from "@angular/cdk/portal";
+import * as i14 from "../../../common/visually-hidden.directive";
+import * as i15 from "../../../field/src/field-label.directive";
+import * as i16 from "../../../field/src/field-error.directive";
+import * as i17 from "../../../field/src/field-note.directive";
+import * as i18 from "../../../button/src/button.module";
+import * as i19 from "../../../label/src/label.component";
+import * as i20 from "../../../common/sapphire-view-encapsulation";
+export declare class SapphireSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireSelectModule, [typeof i1.SelectComponent, typeof i1.MultiSelectDirective, typeof i1.SingleSelectDirective, typeof i2.SelectionTextDirective, typeof i3.BasicSelectComponent, typeof i3.BasicSingleSelectDirective, typeof i4.HiddenSelectComponent, typeof i5.SearchableSelectDirective], [typeof i6.CommonModule, typeof i7.FormsModule, typeof i8.SapphireIconModule, typeof i9.SapphireListboxModule, typeof i10.SapphirePopoverModule, typeof i11.CdkListboxModule, typeof i12.A11yModule, typeof i13.PortalModule, typeof i14.VisuallyHiddenDirective, typeof i15.FieldLabelDirective, typeof i16.FieldErrorDirective, typeof i17.FieldNoteDirective, typeof i18.SapphireButtonModule, typeof i19.LabelComponent, typeof i20.UseComponentStyles], [typeof i9.SapphireListboxModule, typeof i1.SelectComponent, typeof i1.MultiSelectDirective, typeof i1.SingleSelectDirective, typeof i2.SelectionTextDirective, typeof i3.BasicSelectComponent, typeof i3.BasicSingleSelectDirective, typeof i5.SearchableSelectDirective, typeof i15.FieldLabelDirective, typeof i16.FieldErrorDirective, typeof i17.FieldNoteDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireSelectModule>;
+}

package/lib/select/src/select/selection-text.directive.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+/**
+ * Used to customize what is shown in select's trigger when selection is non-empty.
+ * By default, the (primary) text of the selected option is shown in single selection mode,
+ * and a short text indicating the number of selected items is shown in multiple selection mode,
+ * if more than 1 item is selected.
+ */
+export declare class SelectionTextDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectionTextDirective, "sp-selection-text", never, {}, {}, never, never, false, never>;
+}

package/lib/skeleton/public_api.d.ts

@@ -0,0 +1,5 @@
+export * from './src/skeleton-text.directive';
+export * from './src/skeleton.component';
+export * from './src/skeleton-circle.directive';
+export * from './src/skeleton-block.directive';
+export * from './src/skeleton.module';

package/lib/skeleton/src/skeleton-block.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SkeletonBlockDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkeletonBlockDirective, "sp-skeleton-block", never, {}, {}, never, never, false, never>;
+}

package/lib/skeleton/src/skeleton-circle.directive.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SkeletonCircleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonCircleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkeletonCircleDirective, "sp-skeleton-circle", never, {}, {}, never, never, false, never>;
+}

package/lib/skeleton/src/skeleton-text.directive.d.ts

@@ -0,0 +1,13 @@
+import { AfterContentInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class SkeletonTextDirective implements AfterContentInit {
+    width?: string;
+    minWidth?: number;
+    maxWidth?: number;
+    widthType?: 'randomPct' | 'randomPx' | 'fixed';
+    _calculatedWidth: string;
+    private calculateWidth;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonTextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SkeletonTextDirective, "sp-skeleton-text", never, { "width": "width"; "minWidth": "minWidth"; "maxWidth": "maxWidth"; "widthType": "widthType"; }, {}, never, never, false, never>;
+}

package/lib/skeleton/src/skeleton.component.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+import * as i2 from "../../common/sapphire-view-encapsulation";
+export declare class SkeletonComponent {
+    /**
+     * The index of this element in the container that renders skeleton pieces.
+     * Used to harmonize the background animation across the skeleton pieces.
+     */
+    index?: number;
+    _getAnimationDelay: (order?: number | undefined) => string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SkeletonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SkeletonComponent, "sp-skeleton-block, sp-skeleton-circle, sp-skeleton-text", never, { "index": "index"; }, {}, never, never, false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

package/lib/skeleton/src/skeleton.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./skeleton.component";
+import * as i2 from "./skeleton-text.directive";
+import * as i3 from "./skeleton-circle.directive";
+import * as i4 from "./skeleton-block.directive";
+import * as i5 from "@angular/common";
+export declare class SapphireSkeletonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireSkeletonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireSkeletonModule, [typeof i1.SkeletonComponent, typeof i2.SkeletonTextDirective, typeof i3.SkeletonCircleDirective, typeof i4.SkeletonBlockDirective], [typeof i5.CommonModule], [typeof i1.SkeletonComponent, typeof i2.SkeletonTextDirective, typeof i3.SkeletonCircleDirective, typeof i4.SkeletonBlockDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireSkeletonModule>;
+}

package/lib/skeleton/src/util.d.ts

@@ -0,0 +1 @@
+export declare const getAnimationDelay: (order?: number) => string | undefined;

package/lib/surface/public_api.d.ts

@@ -0,0 +1,2 @@
+export * from './src/surface.component';
+export * from './src/surface.module';

package/lib/surface/src/surface.component.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+/**
+ * This is a container for all other components which comes with the theme's
+ * primary surface background color, text color and font family.
+ */
+export declare class SurfaceComponent {
+    variant?: 'primary' | 'secondary';
+    static ɵfac: i0.ɵɵFactoryDeclaration<SurfaceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SurfaceComponent, "sp-surface", never, { "variant": "variant"; }, {}, never, ["*"], true, [{ directive: typeof i1.UseComponentStylesOnHost; inputs: {}; outputs: {}; }]>;
+}

package/lib/surface/src/surface.module.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./surface.component";
+export declare class SapphireSurfaceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireSurfaceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireSurfaceModule, never, [typeof i1.SurfaceComponent], [typeof i1.SurfaceComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireSurfaceModule>;
+}

package/lib/switch/public_api.d.ts

@@ -0,0 +1,3 @@
+export * from './src/switch.component';
+export * from './src/switch.module';
+export * from './src/switch-required-validator';

package/lib/switch/src/switch-required-validator.d.ts

@@ -0,0 +1,10 @@
+import { CheckboxRequiredValidator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Validator for Sapphire switch's required attribute in template-driven checkbox.
+ */
+export declare class SapphireSwitchRequiredValidator extends CheckboxRequiredValidator {
+    required: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireSwitchRequiredValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SapphireSwitchRequiredValidator, "sp-switch[required][formControlName],             sp-switch[required][formControl], sp-switch[required][ngModel]", never, { "required": "required"; }, {}, never, never, false, never>;
+}

package/lib/switch/src/switch.component.d.ts

@@ -0,0 +1,91 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { FocusableOption } from '@angular/cdk/a11y';
+import { HasTabIndex } from '../../common/tabindex';
+import { CanDisable } from '../../common/disabled';
+import * as i0 from "@angular/core";
+import * as i1 from "../../theme/src/theme-check.directive";
+/** Change event object emitted by switch. */
+export declare class SapphireSwitchChange {
+    /** The new `selected` value of the switch. */
+    readonly selected: boolean;
+    /** The source switch of the event. */
+    readonly source: SwitchComponent;
+    constructor(
+    /** The new `selected` value of the switch. */
+    selected: boolean, 
+    /** The source switch of the event. */
+    source: SwitchComponent);
+}
+declare const _SwitchMixinBase: import("../../common/constructor").Constructor<HasTabIndex> & import("../../common/constructor").AbstractConstructor<HasTabIndex> & import("../../common/constructor").Constructor<CanDisable> & import("../../common/constructor").AbstractConstructor<CanDisable> & {
+    new (_elementRef: ElementRef): {
+        _elementRef: ElementRef;
+    };
+};
+export declare class SwitchComponent extends _SwitchMixinBase implements ControlValueAccessor, CanDisable, HasTabIndex, FocusableOption {
+    private changeDetectorRef;
+    /**
+     * Attached to the aria-label attribute of the host element. In most cases, aria-labelledby will
+     * take precedence so this may be omitted.
+     */
+    ariaLabel: string;
+    /**
+     * Users can specify the `aria-labelledby` attribute which will be forwarded to the input element
+     */
+    ariaLabelledby: string | null;
+    /** The 'aria-describedby' attribute is read after the element's label and field type. */
+    ariaDescribedby: string;
+    /** Name value will be applied to the input element if present */
+    name: string | null;
+    /** @default "large" */
+    size?: 'large' | 'medium';
+    /** A unique id for the switch input. If none is supplied, it will be auto-generated. */
+    id: string;
+    /** Returns the unique id for the visual hidden input. */
+    get inputId(): string;
+    /** Event emitted when the switch's `selected` value changes. */
+    readonly change: EventEmitter<SapphireSwitchChange>;
+    /** The value attribute of the native input element */
+    value: string | undefined;
+    /** Whether the switch is required. */
+    required: BooleanInput;
+    /** Whether the switch is selected. */
+    get selected(): boolean;
+    set selected(value: BooleanInput);
+    private _selected;
+    /**
+     * Whether the switch is disabled. This fully overrides the implementation provided by
+     * mixinDisabled, but the mixin is still required because mixinTabIndex requires it.
+     */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    /**
+     * Whether the switch is readonly.
+     */
+    readonly: BooleanInput;
+    /**
+     * Called when the switch is blurred. Needed to properly implement ControlValueAccessor.
+     * @docs-private
+     */
+    private onTouched;
+    private controlValueAccessorChangeFn;
+    /** The native `<input type="checkbox">` element */
+    _inputElement: ElementRef<HTMLInputElement>;
+    constructor(elementRef: ElementRef<HTMLElement>, changeDetectorRef: ChangeDetectorRef, tabIndex: string);
+    writeValue(value: any): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(disabled: boolean): void;
+    /** Toggles the `selected` state of the switch. */
+    toggle(): void;
+    focus(): void;
+    _onInputClick($event: Event): void;
+    _onInteractionEvent(event: Event): void;
+    _onBlur(): void;
+    private emitChangeEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchComponent, [null, null, { attribute: "tabindex"; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchComponent, "sp-switch", never, { "ariaLabel": "aria-label"; "ariaLabelledby": "aria-labelledby"; "ariaDescribedby": "aria-describedby"; "name": "name"; "size": "size"; "id": "id"; "value": "value"; "required": "required"; "selected": "selected"; "disabled": "disabled"; "readonly": "readonly"; }, { "change": "change"; }, never, ["*"], false, [{ directive: typeof i1.ThemeCheckDirective; inputs: {}; outputs: {}; }]>;
+}
+export {};

package/lib/switch/src/switch.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./switch.component";
+import * as i2 from "./switch-required-validator";
+import * as i3 from "@angular/common";
+export declare class SapphireSwitchModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SapphireSwitchModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SapphireSwitchModule, [typeof i1.SwitchComponent, typeof i2.SapphireSwitchRequiredValidator], [typeof i3.CommonModule], [typeof i1.SwitchComponent, typeof i2.SapphireSwitchRequiredValidator]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SapphireSwitchModule>;
+}

package/lib/table/public_api.d.ts

@@ -0,0 +1,10 @@
+export * from './src/table.component';
+export * from './src/table.directive';
+export * from './src/table-row.directive';
+export * from './src/table-cell.directive';
+export * from './src/table-body.directive';
+export * from './src/table-head-cell.component';
+export * from './src/table-head.directive';
+export * from './src/table-sort.directive';
+export * from './src/table-sort-header.directive';
+export * from './src/table.module';

package/lib/table/src/table-body.directive.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+export declare class TableBodyDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableBodyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableBodyDirective, "tbody[sp-table-tbody]", never, {}, {}, never, never, false, [{ directive: typeof i1.UseComponentStyles; inputs: {}; outputs: {}; }]>;
+}

package/lib/table/src/table-cell.directive.d.ts

@@ -0,0 +1,30 @@
+import { AfterContentChecked } from '@angular/core';
+import { TableRowDirective } from './table-row.directive';
+import { TableComponent } from './table.component';
+import { TruncatedWithTooltipDirective } from '../../tooltip/public_api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../tooltip/src/truncated-with-tooltip.directive";
+import * as i2 from "../../common/sapphire-view-encapsulation";
+type CellAlignment = 'left' | 'center' | 'right';
+export declare class TableCellDirective implements AfterContentChecked {
+    private table;
+    private truncatedWithTooltipDirective;
+    private tableRow;
+    get role(): "rowheader" | "cell";
+    /**
+     * Horizontal alignment of content in the cell.
+     *
+     * @default 'left'
+     */
+    get align(): CellAlignment;
+    set align(value: CellAlignment);
+    _align: CellAlignment | undefined;
+    get width(): string | import("@danske/sapphire-angular").TableSortHeaderDirective | undefined;
+    get minWidth(): string | import("@danske/sapphire-angular").TableSortHeaderDirective | undefined;
+    get maxWidth(): string | import("@danske/sapphire-angular").TableSortHeaderDirective | undefined;
+    constructor(table: TableComponent, truncatedWithTooltipDirective: TruncatedWithTooltipDirective, tableRow: TableRowDirective);
+    ngAfterContentChecked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableCellDirective, "td[sp-table-td]", never, { "align": "align"; }, {}, never, never, false, [{ directive: typeof i1.TruncatedWithTooltipDirective; inputs: {}; outputs: {}; }, { directive: typeof i2.UseComponentStyles; inputs: {}; outputs: {}; }]>;
+}
+export {};

package/lib/table/src/table-head-cell.component.d.ts

@@ -0,0 +1,19 @@
+import { TableSortHeaderDirective } from './table-sort-header.directive';
+import { TableComponent } from './table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+export declare class TableHeadCellComponent {
+    private table;
+    tableSortHeader?: TableSortHeaderDirective | undefined;
+    /**
+     * Horizontal alignment of content in the cell.
+     */
+    align?: 'left' | 'center' | 'right';
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    get cellOverflow(): "wrap" | "truncate";
+    constructor(table: TableComponent, tableSortHeader?: TableSortHeaderDirective | undefined);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeadCellComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableHeadCellComponent, "th[sp-table-th]", never, { "align": "align"; "width": "width"; "minWidth": "minWidth"; "maxWidth": "maxWidth"; }, {}, never, ["*"], false, [{ directive: typeof i1.UseComponentStyles; inputs: {}; outputs: {}; }]>;
+}

package/lib/table/src/table-head.directive.d.ts

@@ -0,0 +1,10 @@
+import { TableComponent } from './table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/sapphire-view-encapsulation";
+export declare class TableHeadDirective {
+    table: TableComponent;
+    private get classNames();
+    constructor(table: TableComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableHeadDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableHeadDirective, "thead[sp-table-thead]", never, {}, {}, never, never, false, [{ directive: typeof i1.UseComponentStyles; inputs: {}; outputs: {}; }]>;
+}