@oslokommune/punkt-elements 16.8.2 → 16.9.1

package/dist/components/datepicker/date-tags.d.ts

@@ -0,0 +1,20 @@
+import { PktElement } from '../../base-elements/element';
+type TYear = `${number}${number}${number}${number}`;
+type TMonth = `${number}${number}`;
+type TDay = `${number}${number}`;
+export type TISODate = `${TYear}-${TMonth}-${TDay}`;
+/**
+ * OBS! `dateformat` er standard formatteringsstreng for visning av datoer.
+ * Denne brukes for å sette "menneskeleselig" format på datoene i tags.
+ *
+ * Følger denne unicode-standarden:
+ * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+ */
+export declare class PktDateTags extends PktElement {
+    dates: TISODate[];
+    dateformat: string;
+    className: string;
+    idBase: string;
+    render(): import('lit-html').TemplateResult<1>;
+}
+export {};

package/dist/components/datepicker/date-tags.test.d.ts

@@ -0,0 +1,12 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { PktDateTags } from './date-tags';
+export interface IDateTagsTest extends BaseTestConfig {
+    dates?: string[];
+    idBase?: string;
+    className?: string;
+    dateformat?: string;
+}
+export declare const createDateTagsTest: (config?: IDateTagsTest) => Promise<{
+    container: HTMLElement;
+    dateTags: PktDateTags;
+}>;

package/dist/components/datepicker/datepicker-base.d.ts

@@ -0,0 +1,39 @@
+import { TemplateResult } from 'lit';
+import { Ref } from 'lit/directives/ref.js';
+import { PktElement } from '../../base-elements/element';
+import { IDatepickerStrings } from './datepicker-types';
+/**
+ * Abstract base class for datepicker input components
+ *
+ * Consolidates shared properties, methods, and event dispatchers
+ * used by all three datepicker input types (single, multiple, range).
+ *
+ * Subclasses must implement:
+ * - `strings` property with component-specific defaults
+ * - `render()` method with component-specific template
+ */
+export declare abstract class PktDatepickerBase extends PktElement {
+    inputType: string;
+    id: string;
+    min?: string;
+    max?: string;
+    placeholder?: string;
+    readonly: boolean;
+    disabled: boolean;
+    inputClasses: Record<string, boolean>;
+    internals?: ElementInternals;
+    abstract strings: IDatepickerStrings;
+    inputRef: Ref<HTMLInputElement>;
+    btnRef: Ref<HTMLButtonElement>;
+    get inputElement(): HTMLInputElement | undefined;
+    get buttonElement(): HTMLButtonElement | undefined;
+    get isInputReadonly(): boolean;
+    protected dispatchToggleCalendar(e: Event): void;
+    protected dispatchInput(e: Event): void;
+    protected dispatchFocus(): void;
+    protected dispatchBlur(e: FocusEvent): void;
+    protected dispatchChange(e: Event): void;
+    protected renderCalendarButton(): TemplateResult;
+    createRenderRoot(): this;
+    abstract render(): TemplateResult;
+}

package/dist/components/datepicker/datepicker-multiple.d.ts

@@ -0,0 +1,10 @@
+import { PktDatepickerBase } from './datepicker-base';
+import { IDatepickerStrings } from './datepicker-types';
+export declare class PktDatepickerMultiple extends PktDatepickerBase {
+    value: string[];
+    maxlength?: number;
+    strings: IDatepickerStrings;
+    get isInputDisabled(): boolean;
+    private dispatchAddToSelected;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/datepicker/datepicker-popup.d.ts

@@ -0,0 +1,34 @@
+import { PropertyValues } from 'lit';
+import { PktElement } from '../../base-elements/element';
+import { Ref } from 'lit/directives/ref.js';
+export declare class PktDatepickerPopup extends PktElement {
+    open: boolean;
+    multiple: boolean;
+    range: boolean;
+    weeknumbers: boolean;
+    withcontrols: boolean;
+    maxMultiple: number | null;
+    selected: string[];
+    earliest: string | null;
+    latest: string | null;
+    excludedates: string[];
+    excludeweekdays: string[];
+    currentmonth: string | null;
+    today: string | null;
+    private _hasBeenOpened;
+    popupRef: Ref<HTMLElement>;
+    calendarRef: Ref<HTMLElement>;
+    firstUpdated(): void;
+    updated(changedProperties: PropertyValues): void;
+    disconnectedCallback(): void;
+    handleDocumentClick: (e: MouseEvent) => void;
+    handleDocumentKeydown: (e: KeyboardEvent) => void;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    contains(node: Node | null): boolean;
+    focusOnCurrentDate(): void;
+    addToSelected(e: Event, min?: string | null, max?: string | null): void;
+    handleDateSelect(date: Date): Promise<void> | undefined;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/datepicker/datepicker-popup.test.d.ts

@@ -0,0 +1,4 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+export interface IDatepickerPopupTest extends BaseTestConfig {
+    open?: boolean;
+}

package/dist/components/datepicker/datepicker-range.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'lit/directives/ref.js';
+import { PktDatepickerBase } from './datepicker-base';
+import { IDatepickerStrings } from './datepicker-types';
+export declare class PktDatepickerRange extends PktDatepickerBase {
+    value: string[];
+    label: string;
+    showRangeLabels: boolean;
+    strings: IDatepickerStrings;
+    inputRefTo: Ref<HTMLInputElement>;
+    get inputElementTo(): HTMLInputElement | undefined;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/datepicker/datepicker-single.d.ts

@@ -0,0 +1,8 @@
+import { PktDatepickerBase } from './datepicker-base';
+import { IDatepickerStrings } from './datepicker-types';
+export declare class PktDatepickerSingle extends PktDatepickerBase {
+    value: string;
+    strings: IDatepickerStrings;
+    private dispatchManageValidity;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/datepicker/datepicker-types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type definitions for the datepicker component family.
+ * Re-exports from shared-types for backward compatibility.
+ */
+export type { IDatepickerStrings } from '../../shared-types/datepicker';
+export { defaultSingleStrings, defaultRangeStrings } from '../../shared-types/datepicker';

package/dist/components/datepicker/datepicker-utils.d.ts

@@ -0,0 +1,77 @@
+import { Ref } from 'lit/directives/ref.js';
+import { PktCalendar } from '../calendar/calendar';
+/**
+ * Utility functions for PktDatepicker component
+ *
+ * This module provides helper functions organized by concern.
+ * Framework-agnostic functions are delegated to shared-utils/datepicker-utils.
+ * Lit-specific functions (using Ref, ElementInternals, PktCalendar) stay here.
+ */
+/**
+ * Value parsing and validation utilities
+ * Delegates to shared-utils/datepicker-utils
+ */
+export declare const valueUtils: {
+    validateRangeOrder: (values: string[]) => boolean;
+    sortDates: (dates: string[]) => string[];
+    filterSelectableDates: (dates: string[], min?: string | null, max?: string | null, excludedDates?: string[], excludedWeekdays?: string[]) => string[];
+};
+/**
+ * Input type detection utilities
+ * Delegates to shared-utils/datepicker-utils
+ */
+export declare const inputTypeUtils: {
+    getInputType: () => string;
+};
+/**
+ * Form and validation utilities (Lit-specific — uses ElementInternals)
+ */
+export declare const formUtils: {
+    submitForm(element: HTMLElement): void;
+    submitFormOrFallback(internals: any, fallbackAction: () => void): void;
+    validateDateInput(input: HTMLInputElement, internals: any, min?: string | null, max?: string | null, strings?: any): void;
+};
+/**
+ * Calendar interaction utilities
+ * handleCalendarPosition delegates to shared-utils (with Lit ref unwrapping).
+ * addToSelected stays Lit-specific (uses Ref<PktCalendar>).
+ */
+export declare const calendarUtils: {
+    addToSelected(event: Event | KeyboardEvent, calendarRef: Ref<PktCalendar>, min?: string | null, max?: string | null): void;
+    handleCalendarPosition(popupRef: Ref<HTMLDivElement>, inputRef: Ref<HTMLInputElement>, hasCounter?: boolean): void;
+};
+/**
+ * Event handling utilities (Lit-specific — uses Lit Ref types)
+ */
+export declare const eventUtils: {
+    createDocumentClickListener(inputRef: Ref<HTMLInputElement>, inputRefTo: Ref<HTMLInputElement> | null, btnRef: Ref<HTMLButtonElement>, getCalendarOpen: () => boolean, onBlur: () => void, hideCalendar: () => void): (e: MouseEvent) => void;
+    createDocumentKeydownListener(getCalendarOpen: () => boolean, hideCalendar: () => void): (e: KeyboardEvent) => void;
+    handleFocusOut(event: FocusEvent, element: HTMLElement, onBlur: () => void, hideCalendar: () => void): void;
+};
+/**
+ * CSS class utilities
+ * Delegates to shared-utils/datepicker-utils
+ */
+export declare const cssUtils: {
+    getInputClasses: (fullwidth: boolean, showRangeLabels: boolean, multiple: boolean, range: boolean, readonly?: boolean, inputType?: string) => Record<string, boolean>;
+    getButtonClasses: () => Record<string, boolean>;
+    getRangeLabelClasses: (showRangeLabels: boolean) => Record<string, boolean>;
+};
+/**
+ * Date value processing utilities
+ * processDateSelection delegates to shared-utils.
+ * updateInputValues and processRangeBlur stay Lit-specific (use Lit Ref).
+ */
+export declare const dateProcessingUtils: {
+    processDateSelection: (detail: string | string[], multiple: boolean, range: boolean) => string;
+    updateInputValues(inputRef: Ref<HTMLInputElement>, inputRefTo: Ref<HTMLInputElement> | null, values: string[], range: boolean, multiple: boolean, manageValidity: (input: HTMLInputElement) => void): void;
+    processRangeBlur(event: Event, values: string[], calendarRef: Ref<PktCalendar>, clearInputValue: () => void, manageValidity: (input: HTMLInputElement) => void): void;
+};
+/**
+ * Keyboard navigation utilities
+ * Delegates to shared-utils/datepicker-utils
+ */
+export declare const keyboardUtils: {
+    handleInputKeydown: (event: KeyboardEvent, toggleCalendar: (e: Event) => void, submitForm?: () => void, focusNextInput?: () => void, blurInput?: () => void, commaHandler?: (e: KeyboardEvent) => void) => void;
+    handleButtonKeydown: (event: KeyboardEvent, toggleCalendar: (e: Event) => void) => void;
+};

package/dist/components/datepicker/datepicker-utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/datepicker/datepicker.d.ts

@@ -0,0 +1,83 @@
+import { PropertyValues } from 'lit';
+import { PktCalendar } from '../calendar/calendar';
+import { PktInputElement } from '../../base-elements/input-element';
+import { Ref } from 'lit/directives/ref.js';
+import { PktDatepickerPopup } from './datepicker-popup';
+import { PktDatepickerSingle } from './datepicker-single';
+import { PktDatepickerRange } from './datepicker-range';
+import { PktDatepickerMultiple } from './datepicker-multiple';
+import { ElementProps } from '../../types/typeUtils';
+type Props = ElementProps<PktDatepicker, 'label' | 'dateformat' | 'multiple' | 'maxlength' | 'range' | 'showRangeLabels' | 'min' | 'max' | 'weeknumbers' | 'withcontrols' | 'excludedates' | 'excludeweekdays' | 'currentmonth' | 'calendarOpen' | 'timezone'>;
+export declare class PktDatepicker extends PktInputElement<Props> {
+    /**
+     * Element attributes and properties
+     */
+    private _valueProperty;
+    private _valueProcessing;
+    datepickerPopupRef: Ref<PktDatepickerPopup>;
+    get value(): string;
+    set value(newValue: string | string[]);
+    _value: string[];
+    label: string;
+    dateformat: string;
+    multiple: boolean;
+    maxlength: number | null;
+    range: boolean;
+    showRangeLabels: boolean;
+    min: string | null;
+    max: string | null;
+    weeknumbers: boolean;
+    withcontrols: boolean;
+    excludedates: string[];
+    excludeweekdays: string[];
+    currentmonth: string | null;
+    today: string | null;
+    calendarOpen: boolean;
+    timezone: string;
+    inputClasses: {};
+    /**
+     * Computed properties
+     */
+    get inputType(): string;
+    /**
+     * Housekeeping / lifecycle methods
+     */
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    onInput(): void;
+    valueChanged(newValue: string | null, oldValue: string | null): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    updated(changedProperties: PropertyValues): void;
+    /**
+     * Element references
+     */
+    get inputRef(): Ref<HTMLInputElement>;
+    get inputRefTo(): Ref<HTMLInputElement>;
+    calRef: Ref<PktCalendar>;
+    popupRef: Ref<HTMLDivElement>;
+    singleInputRef: Ref<PktDatepickerSingle>;
+    rangeInputRef: Ref<PktDatepickerRange>;
+    multipleInputRef: Ref<PktDatepickerMultiple>;
+    get currentInputElement(): HTMLInputElement | undefined;
+    get currentInputElementTo(): HTMLInputElement | undefined;
+    get currentButtonElement(): HTMLButtonElement | undefined;
+    get btnRef(): Ref<HTMLButtonElement>;
+    /**
+     * Rendering
+     */
+    renderInput(): import('lit-html').TemplateResult<1>;
+    renderRangeInput(): import('lit-html').TemplateResult<1>;
+    renderMultipleInput(): import('lit-html').TemplateResult<1>;
+    renderCalendar(): import('lit-html').TemplateResult<1>;
+    render(): import('lit-html').TemplateResult<1>;
+    /**
+     * Handlers
+     */
+    handleCalendarPosition(): void;
+    addToSelected: (e: Event | KeyboardEvent) => void;
+    showCalendar(): Promise<void>;
+    hideCalendar(): void;
+    toggleCalendar(e: Event): Promise<void>;
+    clearInputValue(): void;
+}
+export {};

package/dist/components/datepicker/index.d.ts

@@ -0,0 +1,6 @@
+import { PktDatepicker } from './datepicker';
+import { PktDatepickerSingle } from './datepicker-single';
+import { PktDatepickerRange } from './datepicker-range';
+import { PktDatepickerMultiple } from './datepicker-multiple';
+export { PktDatepicker, PktDatepickerSingle, PktDatepickerRange, PktDatepickerMultiple };
+export default PktDatepicker;

package/dist/components/header/header-service.d.ts

@@ -0,0 +1,86 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+import { PropertyValues, TemplateResult } from 'lit';
+import { User, Representing, UserMenuItem, THeaderMenu, TLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior, TSlotMenuVariant, IPktHeader, Booleanish } from './types';
+export declare class PktHeaderService extends PktElementWithSlot<IPktHeader> implements IPktHeader {
+    serviceName?: string;
+    serviceLink?: string;
+    logoLink?: string;
+    searchPlaceholder: string;
+    searchValue: string;
+    mobileBreakpoint: number;
+    tabletBreakpoint: number;
+    openedMenu: THeaderMenu;
+    logOutButtonPlacement: TLogOutButtonPlacement;
+    position: THeaderPosition;
+    scrollBehavior: THeaderScrollBehavior;
+    slotMenuVariant: TSlotMenuVariant;
+    slotMenuText: string;
+    hideLogo: Booleanish;
+    compact: Booleanish;
+    showSearch: Booleanish;
+    canChangeRepresentation: Booleanish;
+    hasLogOut: Booleanish;
+    user?: User;
+    userMenu?: UserMenuItem[];
+    representing?: Representing;
+    private isMobile;
+    private isTablet;
+    private openMenu;
+    private isHidden;
+    private componentWidth;
+    private alignSlotRight;
+    private alignSearchRight;
+    private headerRef;
+    private userContainerRef;
+    private slotContainerRef;
+    private searchContainerRef;
+    private slotContentRef;
+    private searchMenuRef;
+    private resizeObserver?;
+    private lastScrollPosition;
+    private savedScrollY;
+    private lastFocusedElement;
+    private shouldRestoreFocus;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    firstUpdated(): void;
+    updated(changedProperties: PropertyValues): void;
+    private setupResizeObserver;
+    private updateIsMobile;
+    private updateIsTablet;
+    private updateScrollLock;
+    private lockScroll;
+    private unlockScroll;
+    private setupScrollListener;
+    private handleScroll;
+    private handleClickOutside;
+    private handleFocusOut;
+    private handleEscapeKey;
+    private restoreFocus;
+    private checkDropdownAlignment;
+    private handleMenuToggle;
+    private handleLogoClick;
+    private handleServiceClick;
+    private handleLogout;
+    private handleSearch;
+    private handleSearchChange;
+    private handleSearchInputChange;
+    private handleSearchKeyDown;
+    private get formattedLastLoggedIn();
+    private get isFixed();
+    private get shouldHideOnScroll();
+    private get showLogoutInHeader();
+    private get showLogoutInUserMenu();
+    private renderLogo;
+    private renderServiceName;
+    private renderSlotContainer;
+    private renderSearch;
+    private renderUserButton;
+    private renderHeader;
+    render(): TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'pkt-header-service': PktHeaderService;
+    }
+}

package/dist/components/header/header-service.test.d.ts

@@ -0,0 +1,18 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+export interface HeaderServiceTestConfig extends BaseTestConfig {
+    'service-name'?: string;
+    'service-link'?: string;
+    'logo-link'?: string;
+    compact?: boolean;
+    'hide-logo'?: boolean;
+    position?: 'fixed' | 'relative';
+    'scroll-behavior'?: 'hide' | 'none';
+    'show-search'?: boolean;
+    'search-placeholder'?: string;
+    'search-value'?: string;
+    'log-out-button-placement'?: 'userMenu' | 'header' | 'both' | 'none';
+    'can-change-representation'?: boolean;
+    'opened-menu'?: 'none' | 'slot' | 'search' | 'user';
+    'mobile-breakpoint'?: number;
+    'tablet-breakpoint'?: number;
+}

package/dist/components/header/header-user-menu.d.ts

@@ -0,0 +1,29 @@
+import { PktElement } from '../../base-elements/element';
+import { User, Representing, UserMenuItem, Booleanish } from './types';
+export interface IPktHeaderUserMenu {
+    user: User;
+    formattedLastLoggedIn?: string;
+    representing?: Representing;
+    userMenu?: UserMenuItem[];
+    canChangeRepresentation?: Booleanish;
+    logoutOnClick?: Booleanish;
+}
+export declare class PktHeaderUserMenu extends PktElement<IPktHeaderUserMenu> implements IPktHeaderUserMenu {
+    user: User;
+    formattedLastLoggedIn?: string;
+    representing?: Representing;
+    userMenu?: UserMenuItem[];
+    canChangeRepresentation: Booleanish;
+    logoutOnClick: Booleanish;
+    private handleChangeRepresentation;
+    private handleLogout;
+    private handleMenuItemClick;
+    private renderLinkOrButton;
+    private renderLinkSection;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'pkt-header-user-menu': PktHeaderUserMenu;
+    }
+}

package/dist/components/header/header-utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Format a Date or ISO string to a readable Norwegian date format
+ * @param date - Date object or ISO date string
+ * @returns Formatted date string like "22. januar 2026, 14:30"
+ */
+export declare const formatLastLoggedIn: (date: Date | string | undefined) => string | undefined;

package/dist/components/header/header.d.ts

@@ -0,0 +1,52 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+import { PropertyValues } from 'lit';
+import { User, Representing, UserMenuItem, THeaderMenu, TLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior, TSlotMenuVariant, IPktHeader, Booleanish } from './types';
+/**
+ * PktHeader - Main header component for Oslo kommune services
+ *
+ * This component provides a complete header solution with:
+ * - Logo and service name
+ * - User menu with login/logout functionality
+ * - Search functionality
+ * - Responsive mobile menu
+ * - Fixed positioning with scroll-to-hide
+ *
+ * TODO: Add `type` prop to switch between `service` and `global` header types
+ */
+export declare class PktHeader extends PktElementWithSlot<IPktHeader> implements IPktHeader {
+    serviceName?: string;
+    serviceLink?: string;
+    logoLink?: string;
+    searchPlaceholder: string;
+    searchValue: string;
+    mobileBreakpoint: number;
+    tabletBreakpoint: number;
+    openedMenu: THeaderMenu;
+    logOutButtonPlacement: TLogOutButtonPlacement;
+    position: THeaderPosition;
+    scrollBehavior: THeaderScrollBehavior;
+    slotMenuVariant: TSlotMenuVariant;
+    slotMenuText: string;
+    hideLogo: Booleanish;
+    compact: Booleanish;
+    showSearch: Booleanish;
+    canChangeRepresentation: Booleanish;
+    hasLogOut: Booleanish;
+    user?: User;
+    userMenu?: UserMenuItem[];
+    representing?: Representing;
+    userMenuFooter?: UserMenuItem[];
+    userOptions?: UserMenuItem[];
+    firstUpdated(changedProperties: PropertyValues): void;
+    private emitDeprecationWarnings;
+    /**
+     * Convert deprecated props to new props
+     */
+    private get effectiveUserMenu();
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'pkt-header': PktHeader;
+    }
+}

package/dist/components/header/index.d.ts

@@ -0,0 +1,5 @@
+export { PktHeader } from './header';
+export { PktHeaderService } from './header-service';
+export { PktHeaderUserMenu } from './header-user-menu';
+export type { User, Representing, UserMenuItem, TInternalMenuItem, THeaderMenu, TLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior, TSlotMenuVariant, IPktHeader, } from './types';
+export { formatLastLoggedIn } from './header-utils';

package/dist/components/header/types.d.ts

@@ -0,0 +1,59 @@
+import { PktIconName } from '@oslokommune/punkt-assets/dist/icons/icon';
+import { booleanishConverter, Booleanish, User as SharedUser, Representing as SharedRepresenting, UserMenuItem as SharedUserMenuItem, TInternalMenuItem as SharedTInternalMenuItem, TSlotMenuVariant, THeaderMenu, TLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior } from '../../shared-types';
+export type { Booleanish, TSlotMenuVariant, THeaderMenu, TLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior, };
+export { booleanishConverter };
+export type User = SharedUser;
+export type Representing = SharedRepresenting;
+export type UserMenuItem = SharedUserMenuItem<PktIconName>;
+export type TInternalMenuItem = SharedTInternalMenuItem<PktIconName>;
+/**
+ * Helper to convert UserMenuItem (with target) to internal format
+ */
+export declare const convertUserMenuItem: (item: UserMenuItem) => TInternalMenuItem;
+/**
+ * Interface for the Header component props
+ */
+export interface IPktHeader {
+    /** Hide the Oslo logo */
+    hideLogo?: Booleanish;
+    /** Logo link URL */
+    logoLink?: string;
+    /** Service name displayed in the header */
+    serviceName?: string;
+    /** Service link URL */
+    serviceLink?: string;
+    /** Use compact header height */
+    compact?: Booleanish;
+    /** Header position. 'fixed' fixes to top of viewport, 'relative' follows document flow. Default: 'fixed' */
+    position?: THeaderPosition;
+    /** Scroll behavior. 'hide' hides header on scroll down, 'none' keeps it visible. Default: 'hide' */
+    scrollBehavior?: THeaderScrollBehavior;
+    /** User object for logged-in user */
+    user?: User;
+    /** User menu items */
+    userMenu?: UserMenuItem[];
+    /** Representation object */
+    representing?: Representing;
+    /** Allow user to change representation */
+    canChangeRepresentation?: Booleanish;
+    /** Logout button placement */
+    logOutButtonPlacement?: TLogOutButtonPlacement;
+    /** Whether there's a logout handler attached (required for logout button to show) */
+    hasLogOut?: Booleanish;
+    /** Show search field */
+    showSearch?: Booleanish;
+    /** Search field placeholder */
+    searchPlaceholder?: string;
+    /** Controlled search value */
+    searchValue?: string;
+    /** Custom breakpoint for responsive behavior in pixels. Default: 1024 */
+    mobileBreakpoint?: number;
+    /** Custom breakpoint for tablet responsive behavior in pixels. Default: 1280 */
+    tabletBreakpoint?: number;
+    /** Which menu is initially open */
+    openedMenu?: THeaderMenu;
+    /** Variant for the slot menu button. Default: 'icon-only' */
+    slotMenuVariant?: TSlotMenuVariant;
+    /** Text for the slot menu button. Default: 'Meny' */
+    slotMenuText?: string;
+}

package/dist/components/heading/heading.d.ts

@@ -0,0 +1,28 @@
+import { PktShadowElement } from '../../base-elements/element';
+import { PropertyValues } from 'lit';
+import { THeadingLevel, THeadingSize, THeadingWeight } from '../../shared-types';
+export type TPktHeadingLevel = THeadingLevel;
+export type TPktHeadingSize = THeadingSize;
+export type TPktHeadingWeight = THeadingWeight;
+export interface IPktHeading {
+    size?: TPktHeadingSize;
+    level?: TPktHeadingLevel;
+    weight?: TPktHeadingWeight;
+    visuallyHidden?: boolean;
+    align?: 'start' | 'center' | 'end';
+}
+export declare class PktHeading extends PktShadowElement<IPktHeading> implements IPktHeading {
+    size: TPktHeadingSize | undefined;
+    level: TPktHeadingLevel;
+    weight: TPktHeadingWeight | undefined;
+    visuallyHidden: boolean;
+    align: 'start' | 'center' | 'end' | undefined;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    protected updated(_changedProperties: PropertyValues): void;
+    private setLevel;
+    private get defaultSizeForLevel();
+    private get defaultWeightForLevel();
+    private updateHostClasses;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/heading/index.d.ts

@@ -0,0 +1,4 @@
+import { PktHeading, IPktHeading, TPktHeadingSize, TPktHeadingLevel, TPktHeadingWeight } from './heading';
+export { PktHeading };
+export type { IPktHeading, TPktHeadingSize, TPktHeadingLevel, TPktHeadingWeight };
+export default PktHeading;

package/dist/components/helptext/helptext.d.ts

@@ -0,0 +1,9 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+export declare class PktHelptext extends PktElementWithSlot {
+    forId: string;
+    helptext: string;
+    helptextDropdown: string;
+    helptextDropdownButton: string;
+    isHelpTextOpen: boolean;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/helptext/index.d.ts

@@ -0,0 +1,3 @@
+import { PktHelptext } from './helptext';
+export { PktHelptext };
+export default PktHelptext;