@oslokommune/punkt-react 16.25.1 → 16.26.3

package/CHANGELOG.md

@@ -5,6 +5,34 @@ og skriver commits ca etter [Conventional Commits](https://conventionalcommits.o
 
 ---
 
+## [16.25.3](https://github.com/oslokommune/punkt/compare/16.25.2...16.25.3) (2026-06-18)
+
+### ⚠ BREAKING CHANGES
+Ingen
+
+### Features
+Ingen
+
+### Bug Fixes
+* Massiv oppdatering av avhengigheter, pluss følgende fikser (#3519). - Testing utils bruker nå vitest, akkurat som alle andre
+  - Docs har nå fungerende prettier og linting
+  - Bruker Astro 7 beta, fordi versjon 6 ikke støtter Vite 8
+  - Fjernet onInput i Timepicker. Denne var uansett ikke dokumentert og funket ikke
+  - Oppdatert node-krav (kjører 24 i build, krever 22 i konsum av pakker)
+  - Fjernet absolutt alle sikkerhetsvarsler
+  - Fikset en del feil syntaks i docs
+  - Fikset bygging av typescript
+  - npm run build gir ikke lenger noen advarsler
+  
+  Et lite aber, som er verdt å nevne men som ikke kommer fra denne PR: Playwright rapporterer en del feil. Og man må kjøre en npm playwright install for å oppdatere browser. Men det er forventet og urelatert. Kommer fra andre endringer og fra oppdatering av Playwright-avhengighet.
+
+
+### Chores
+Ingen
+
+---
+
+
 ## [16.25.1](https://github.com/oslokommune/punkt/compare/16.25.0...16.25.1) (2026-06-16)
 
 ### ⚠ BREAKING CHANGES

package/CONTRIBUTING.md

@@ -8,7 +8,7 @@ er at vi høflig ber deg endre på noe. **Vi setter pris på alle hyggelige bidr
 
 ## 📝 Forutsetninger
 
-- nodejs 20.19.1
+- nodejs 24.16.0
 - Kunnskap om [Sass (SCSS)](https://sass-lang.com/) og [CSS](https://developer.mozilla.org/en-US/docs/Web/CSS).
 - Forståelse av [BEM-navnekonvensjoner](http://getbem.com/) som designsystemet følger.
 - Noen skal ha designet komponenten i [Figma](https://www.figma.com/file/Eej5jm3jIUjeMfzLE0aOTB/Punkt---Origo-designsystem?node-id=0%3A1&t=VDbEaltk80wYiYn3-0) (Krever innlogging og tilgang).

package/README.md

@@ -8,7 +8,7 @@ Dette repoet inneholder Punkt sine UI-komponenter for React. Komponentene er lag
 
 Peer dependencies:
 
-- nodejs `20.19.1`
+- nodejs `24.16.0`
 - react `>= 18`
 - @oslokommune/punkt-assets `*`
 - @oslokommune/punkt-css `*`

package/dist/components/accordion/Accordion.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { TAccordionSkin } from '../../shared-types';
+export type TPktAccordionSkin = TAccordionSkin;
+export interface IPktAccordion {
+    compact?: boolean;
+    /**
+     * @default skin: "borderless"
+     */
+    skin?: TPktAccordionSkin;
+    /**
+     * @description A unique identifier to connect the accordion with a heading
+     */
+    ariaLabelledBy?: string;
+    children?: ReactNode;
+    name?: string;
+    className?: string;
+}
+export declare const useAccordionContext: () => {
+    name?: string;
+};
+export declare const PktAccordion: import('react').ForwardRefExoticComponent<IPktAccordion & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/accordion/AccordionItem.d.ts

@@ -0,0 +1,17 @@
+import { MouseEvent, ReactNode, SyntheticEvent } from 'react';
+import { TAccordionSkin } from '../../shared-types';
+export type TPktAccordionSkin = TAccordionSkin;
+export interface IPktAccordionItem {
+    defaultOpen?: boolean;
+    id: string;
+    title: string | ReactNode;
+    skin?: TPktAccordionSkin;
+    compact?: boolean;
+    isOpen?: boolean;
+    children?: ReactNode;
+    name?: string;
+    className?: string;
+    onClick?: (e: MouseEvent<HTMLDetailsElement>) => void;
+    onToggle?: (e: SyntheticEvent<HTMLDetailsElement>) => void;
+}
+export declare const PktAccordionItem: import('react').ForwardRefExoticComponent<IPktAccordionItem & import('react').RefAttributes<HTMLDetailsElement>>;

package/dist/components/alert/Alert.d.ts

@@ -0,0 +1,14 @@
+import { FC, HTMLAttributes, ReactNode } from 'react';
+import { TAlertRole, TAlertSkin, TAriaLive } from '../../shared-types';
+export interface IPktAlert extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    skin?: TAlertSkin;
+    closeAlert?: boolean;
+    title?: ReactNode;
+    date?: string;
+    ariaLive?: TAriaLive;
+    compact?: boolean;
+    role?: TAlertRole;
+    onClose?: (e: CustomEvent) => void;
+}
+export type { TAlertSkin };
+export declare const PktAlert: FC<IPktAlert>;

package/dist/components/backlink/BackLink.d.ts

@@ -0,0 +1,14 @@
+import { AnchorHTMLAttributes, ReactNode, Ref } from 'react';
+export interface IPktBackLink extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+    href?: string;
+    text?: string;
+    ariaLabel?: string;
+    renderLink?: (args: {
+        href: string;
+        className: string;
+        children: ReactNode;
+        props: AnchorHTMLAttributes<HTMLAnchorElement>;
+    }) => ReactNode;
+    ref?: Ref<HTMLElement>;
+}
+export declare const PktBackLink: import('react').ForwardRefExoticComponent<Omit<IPktBackLink, "ref"> & import('react').RefAttributes<HTMLElement>>;

package/dist/components/breadcrumbs/Breadcrumbs.d.ts

@@ -0,0 +1,16 @@
+import { AnchorHTMLAttributes, ReactNode } from 'react';
+export interface IBreadcrumbs {
+    text: string;
+    href: string;
+}
+export interface IPktBreadcrumbs extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    breadcrumbs: IBreadcrumbs[];
+    navigationType?: 'router' | 'anchor';
+    renderLink?: (args: {
+        href: string;
+        className: string;
+        children: ReactNode;
+        props: AnchorHTMLAttributes<HTMLAnchorElement>;
+    }) => ReactNode;
+}
+export declare const PktBreadcrumbs: import('react').ForwardRefExoticComponent<IPktBreadcrumbs & import('react').RefAttributes<HTMLAnchorElement>>;

package/dist/components/breadcrumbs/Breadcrumbs.test.d.ts

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

package/dist/components/button/Button.d.ts

@@ -0,0 +1,24 @@
+import { ButtonHTMLAttributes } from 'react';
+declare global {
+    interface Window {
+        pktAnimationPath?: string;
+    }
+}
+export interface IPktButton extends ButtonHTMLAttributes<HTMLButtonElement> {
+    iconName?: string;
+    secondIconName?: string;
+    iconPath?: string;
+    secondIconPath?: string;
+    mode?: 'light' | 'dark';
+    size?: 'small' | 'medium' | 'large';
+    fullWidth?: boolean;
+    fullWidthOnMobile?: boolean;
+    color?: 'blue' | 'blue-outline' | 'green' | 'green-outline' | 'green-dark' | 'green-dark-outline' | 'beige-light' | 'beige-dark-outline' | 'yellow' | 'yellow-outline' | 'red' | 'red-outline';
+    skin?: 'primary' | 'secondary' | 'tertiary';
+    variant?: 'label-only' | 'icon-left' | 'icon-right' | 'icon-only' | 'icons-right-and-left';
+    state?: 'normal' | 'focus' | 'hover' | 'active';
+    type?: 'button' | 'submit' | 'reset';
+    isLoading?: boolean;
+    loadingAnimationPath?: string;
+}
+export declare const PktButton: import('react').ForwardRefExoticComponent<IPktButton & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/calendar/Calendar.d.ts

@@ -0,0 +1,3 @@
+import { IPktCalendar, PktCalendarHandle } from './types';
+export type { IPktCalendar, IPktCalendarStrings, PktCalendarHandle } from './types';
+export declare const PktCalendar: import('react').ForwardRefExoticComponent<IPktCalendar & import('react').RefAttributes<PktCalendarHandle>>;

package/dist/components/calendar/CalendarGrid.d.ts

@@ -0,0 +1,4 @@
+import { ICalendarState } from './types';
+export declare const CalendarGrid: ({ state }: {
+    state: ICalendarState;
+}) => import("react").JSX.Element;

package/dist/components/calendar/CalendarNav.d.ts

@@ -0,0 +1,2 @@
+import { ICalendarNavProps } from './types';
+export declare const CalendarNav: ({ componentId, strings, year, month, earliest, latest, withcontrols, prevMonth, nextMonth, changeMonth, }: ICalendarNavProps) => import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+import { TDateRangeMap } from '../../shared-types/calendar';
+import { TDayViewData } from './types';
+export interface IDayViewContext {
+    year: number;
+    month: number;
+    activeSelected: string[];
+    focusedDate: string | null;
+    tabIndexSetRef: React.MutableRefObject<number>;
+    isDayDisabled: (date: Date, isSelected: boolean) => boolean;
+}
+export interface IDayCellClassContext {
+    range: boolean;
+    activeSelected: string[];
+    rangeHovered: Date | null;
+    inRange: TDateRangeMap;
+    isExcluded: (date: Date) => boolean;
+}
+export declare function getDayViewData(dayCounter: number, today: Date, ctx: IDayViewContext): TDayViewData;
+export declare function getDayCellClasses(data: TDayViewData, ctx: IDayCellClassContext): string;
+export declare function getDayButtonClasses(data: TDayViewData, ctx: IDayCellClassContext): string;

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

@@ -0,0 +1,104 @@
+import { IDateConstraints, TDateRangeMap } from '../../shared-types/calendar';
+export declare const DEFAULT_STRINGS: Required<IPktCalendarStrings>;
+export interface IPktCalendarStrings {
+    month?: string;
+    year?: string;
+    days?: string[];
+    daysShort?: string[];
+    months?: string[];
+    week?: string;
+    prevMonth?: string;
+    nextMonth?: string;
+}
+export interface PktCalendarHandle {
+    handleDateSelect: (selectedDate: Date | null) => void;
+    addToSelected: (selectedDate: Date) => void;
+    removeFromSelected: (selectedDate: Date) => void;
+    toggleSelected: (selectedDate: Date) => void;
+    focusOnCurrentDate: () => void;
+    close: () => void;
+}
+export interface IPktCalendar {
+    selected?: string[];
+    multiple?: boolean;
+    maxMultiple?: number;
+    range?: boolean;
+    earliest?: string | null;
+    latest?: string | null;
+    excludedates?: Date[] | string[];
+    excludeweekdays?: string[];
+    weeknumbers?: boolean;
+    withcontrols?: boolean;
+    currentmonth?: Date | string | null;
+    today?: string;
+    strings?: IPktCalendarStrings;
+    onDateSelected?: (selected: string[]) => void;
+    onClose?: () => void;
+    id?: string;
+    className?: string;
+}
+export type TDayViewData = {
+    currentDate: Date;
+    currentDateISO: string;
+    isToday: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+    ariaLabel: string;
+    tabindex: string;
+};
+export interface ICalendarState {
+    componentId: string;
+    strings: Required<IPktCalendarStrings>;
+    year: number;
+    month: number;
+    activeSelected: string[];
+    _selected: Date[];
+    inRange: TDateRangeMap;
+    rangeHovered: Date | null;
+    focusedDate: string | null;
+    todayDate: Date;
+    range: boolean;
+    multiple: boolean;
+    weeknumbers: boolean;
+    withcontrols: boolean;
+    earliest: string | null;
+    latest: string | null;
+    excludedates: Date[];
+    excludeweekdays: string[];
+    className?: string;
+    dateConstraints: IDateConstraints;
+    calendarRef: React.RefObject<HTMLDivElement | null>;
+    selectableDatesRef: React.MutableRefObject<{
+        currentDateISO: string;
+        isDisabled: boolean;
+        tabindex: string;
+    }[]>;
+    tabIndexSetRef: React.MutableRefObject<number>;
+    prevMonth: () => void;
+    nextMonth: () => void;
+    changeMonth: (newYear: number, newMonth: number) => void;
+    handleDateSelect: (selectedDate: Date | null) => void;
+    addToSelected: (selectedDate: Date) => void;
+    removeFromSelected: (selectedDate: Date) => void;
+    toggleSelectedDate: (selectedDate: Date) => void;
+    handleRangeHover: (date: Date) => void;
+    isExcluded: (date: Date) => boolean;
+    isDayDisabled: (date: Date, isSelected: boolean) => boolean;
+    focusOnCurrentDate: () => void;
+    handleKeydown: (e: React.KeyboardEvent) => void;
+    handleFocusOut: (e: React.FocusEvent) => void;
+    close: () => void;
+    setFocusedDate: (date: string | null) => void;
+}
+export interface ICalendarNavProps {
+    componentId: string;
+    strings: Required<IPktCalendarStrings>;
+    year: number;
+    month: number;
+    earliest: string | null;
+    latest: string | null;
+    withcontrols: boolean;
+    prevMonth: () => void;
+    nextMonth: () => void;
+    changeMonth: (newYear: number, newMonth: number) => void;
+}

package/dist/components/calendar/useCalendarState.d.ts

@@ -0,0 +1,2 @@
+import { IPktCalendar, ICalendarState } from './types';
+export declare function useCalendarState(props: IPktCalendar): ICalendarState;

package/dist/components/card/Card.d.ts

@@ -0,0 +1,37 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+import { TCardSkin, TLayout, TTagSkin } from '../../shared-types';
+export type { TCardSkin, TLayout };
+type TCardPadding = 'none' | 'default';
+type TCardImageShape = 'square' | 'round';
+type TCardTagPosition = 'top' | 'bottom';
+type THeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+interface ICardTag {
+    skin?: TTagSkin;
+    iconName?: string;
+    ariaLabel?: string;
+    text: string;
+}
+export interface IPktCard extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    ariaLabel?: string;
+    metaLead?: string | null;
+    borderOnHover?: boolean;
+    metaTrail?: string | null;
+    layout?: TLayout;
+    heading?: string;
+    headingLevel?: THeadingLevel;
+    image?: {
+        src: string;
+        alt: string;
+    };
+    imageShape?: TCardImageShape;
+    clickCardLink?: string | null;
+    padding?: TCardPadding;
+    openLinkInNewTab?: boolean;
+    skin?: TCardSkin;
+    subheading?: string;
+    tagPosition?: TCardTagPosition;
+    tags?: ICardTag[];
+    children?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const PktCard: import('react').ForwardRefExoticComponent<Omit<IPktCard, "ref"> & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/checkbox/Checkbox.d.ts

@@ -0,0 +1,23 @@
+import { ChangeEventHandler, InputHTMLAttributes, ReactNode } from 'react';
+export interface IPktCheckbox extends InputHTMLAttributes<HTMLInputElement> {
+    id: string;
+    hasTile?: boolean;
+    disabled?: boolean;
+    label?: string;
+    checkHelptext?: ReactNode | ReactNode[] | string;
+    hasError?: boolean;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    indeterminate?: boolean;
+    value?: string;
+    isSwitch?: boolean;
+    hideLabel?: boolean;
+    labelPosition?: 'right' | 'left';
+    optionalTag?: boolean;
+    optionalText?: string;
+    requiredTag?: boolean;
+    requiredText?: string;
+    tagText?: string | null;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+}
+export declare const PktCheckbox: import('react').ForwardRefExoticComponent<IPktCheckbox & import('react').RefAttributes<HTMLInputElement>>;

package/dist/components/combobox/Combobox.d.ts

@@ -0,0 +1,3 @@
+import { IPktCombobox } from './types';
+export type { IPktCombobox } from './types';
+export declare const PktCombobox: import('react').ForwardRefExoticComponent<IPktCombobox & import('react').RefAttributes<HTMLDivElement>>;

package/dist/components/combobox/ComboboxInput.d.ts

@@ -0,0 +1,6 @@
+import { IComboboxState } from './types';
+interface IComboboxInputProps {
+    state: IComboboxState;
+}
+export declare const ComboboxInput: ({ state }: IComboboxInputProps) => import("react").JSX.Element;
+export {};

package/dist/components/combobox/ComboboxTags.d.ts

@@ -0,0 +1,11 @@
+import { IComboboxState } from './types';
+interface IComboboxTagsProps {
+    state: IComboboxState;
+    outside?: boolean;
+}
+export declare const ComboboxTags: ({ state, outside }: IComboboxTagsProps) => import("react").JSX.Element | null;
+interface ISingleValueDisplayProps {
+    state: IComboboxState;
+}
+export declare const SingleValueDisplay: ({ state }: ISingleValueDisplayProps) => import("react").JSX.Element | null;
+export {};

package/dist/components/combobox/Listbox.d.ts

@@ -0,0 +1,6 @@
+import { IComboboxState } from './types';
+interface IListboxProps {
+    state: IComboboxState;
+}
+export declare const Listbox: ({ state }: IListboxProps) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,104 @@
+import { ChangeEvent, ChangeEventHandler, FocusEvent, KeyboardEvent, MouseEvent as ReactMouseEvent, KeyboardEvent as ReactKeyboardEvent, ReactNode, RefObject } from 'react';
+import { IPktComboboxOption, TPktComboboxDisplayValue, TPktComboboxTagPlacement } from '../../shared-types/combobox';
+export interface IPktCombobox {
+    value?: string | string[];
+    defaultValue?: string | string[];
+    options?: IPktComboboxOption[];
+    defaultOptions?: IPktComboboxOption[];
+    multiple?: boolean;
+    maxlength?: number;
+    typeahead?: boolean;
+    includeSearch?: boolean;
+    allowUserInput?: boolean;
+    displayValueAs?: TPktComboboxDisplayValue;
+    tagPlacement?: TPktComboboxTagPlacement;
+    searchPlaceholder?: string;
+    name?: string;
+    id?: string;
+    disabled?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    label?: string;
+    helptext?: string | ReactNode;
+    helptextDropdown?: string | ReactNode;
+    helptextDropdownButton?: string;
+    hasError?: boolean;
+    errorMessage?: string | ReactNode;
+    fullwidth?: boolean;
+    requiredTag?: boolean;
+    requiredText?: string;
+    optionalTag?: boolean;
+    optionalText?: string;
+    tagText?: string;
+    useWrapper?: boolean;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    onValueChange?: (values: string[]) => void;
+    className?: string;
+    children?: ReactNode;
+}
+export interface IComboboxState {
+    id: string;
+    inputId: string;
+    listboxId: string;
+    values: string[];
+    inputValue: string;
+    searchValue: string;
+    options: IPktComboboxOption[];
+    filteredOptions: IPktComboboxOption[];
+    isOpen: boolean;
+    userInfoMessage: string;
+    addValueText: string | null;
+    maxIsReached: boolean;
+    editingSingleValue: boolean;
+    inputFocus: boolean;
+    focusedTagIndex: number;
+    label?: string;
+    multiple: boolean;
+    maxlength?: number;
+    typeahead: boolean;
+    includeSearch: boolean;
+    allowUserInput: boolean;
+    displayValueAs: TPktComboboxDisplayValue;
+    tagPlacement?: TPktComboboxTagPlacement;
+    searchPlaceholder?: string;
+    placeholder?: string;
+    disabled: boolean;
+    required: boolean;
+    fullwidth: boolean;
+    hasError: boolean;
+    errorMessage?: string | ReactNode;
+    helptext?: string | ReactNode;
+    helptextDropdown?: string | ReactNode;
+    helptextDropdownButton?: string;
+    optionalTag: boolean;
+    optionalText?: string;
+    requiredTag: boolean;
+    requiredText?: string;
+    tagText?: string;
+    useWrapper: boolean;
+    name?: string;
+    className?: string;
+    hasCounter: boolean;
+    inputRef: RefObject<HTMLInputElement | null>;
+    changeInputRef: RefObject<HTMLInputElement | null>;
+    triggerRef: RefObject<HTMLDivElement | null>;
+    listboxRef: RefObject<HTMLDivElement | null>;
+    wrapperRef: RefObject<HTMLDivElement | null>;
+    handleInputChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleInputKeydown: (e: KeyboardEvent<HTMLInputElement>) => void;
+    handleInputFocus: () => void;
+    handleInputBlur: () => void;
+    handleFocusOut: (e: FocusEvent) => void;
+    handleInputClick: (e: ReactMouseEvent) => void;
+    handlePlaceholderClick: (e: ReactMouseEvent) => void;
+    handleSelectOnlyKeydown: (e: ReactKeyboardEvent) => void;
+    handleOptionClick: (value: string) => void;
+    handleOptionKeydown: (e: KeyboardEvent<HTMLLIElement>, value: string) => void;
+    handleTagRemove: (value: string) => void;
+    handleTagKeydown: (e: ReactKeyboardEvent, index: number) => void;
+    handleSearchInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    handleSearchKeydown: (e: KeyboardEvent<HTMLInputElement>) => void;
+    handleNewOptionClick: (value: string) => void;
+    handleNewOptionKeydown: (e: KeyboardEvent<HTMLDivElement>) => void;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+}

package/dist/components/combobox/useComboboxState.d.ts

@@ -0,0 +1,2 @@
+import { IPktCombobox, IComboboxState } from './types';
+export declare function useComboboxState(props: IPktCombobox, ref: React.ForwardedRef<HTMLDivElement>): IComboboxState;

package/dist/components/consent/Consent.d.ts

@@ -0,0 +1,51 @@
+import { HTMLAttributes } from 'react';
+interface ConsentItem {
+    name: string;
+    consent: boolean;
+}
+interface ConsentValue {
+    items: ConsentItem[];
+}
+interface CookieConsentEvent {
+    value: string | ConsentValue;
+}
+type ConsentDetailsMap = Record<string, boolean>;
+type CookieEventHandler = (consent: CookieConsentEvent) => void;
+interface CookieEvents {
+    on(eventName: string, handler: CookieEventHandler): void;
+    off(eventName: string, handler: CookieEventHandler): void;
+}
+interface CookieBannerApi {
+    cookieConsent: {
+        validateConsentCookie(): Promise<boolean>;
+        getConsentCookie(): string | ConsentValue;
+    };
+    openCookieModal(): void;
+}
+declare global {
+    interface Window {
+        cookieBanner_devMode?: boolean;
+        cookieBanner_cookieDomain?: string | null;
+        cookieBanner_cookieSecure?: string | null;
+        cookieBanner_cookieExpiryDays?: string | null;
+        cookieBanner_googleAnalyticsId?: string | null;
+        cookieBanner_hotjarId?: string | null;
+        cookieBanner?: CookieBannerApi;
+        __cookieEvents?: CookieEvents;
+    }
+}
+export type TPktConsentTriggerType = 'button' | 'link' | 'footerlink' | 'icon';
+export interface IPktConsent extends HTMLAttributes<HTMLElement> {
+    devMode?: boolean;
+    cookieDomain?: string | null;
+    cookieSecure?: string | null;
+    cookieExpiryDays?: string | null;
+    hotjarId?: string | null;
+    googleAnalyticsId?: string | null;
+    i18nLanguage?: string;
+    triggerType?: TPktConsentTriggerType | null;
+    triggerText?: string | null;
+    onToggleConsent?: (e: CustomEvent<ConsentDetailsMap>) => void;
+}
+export declare const PktConsent: import('react').ForwardRefExoticComponent<IPktConsent & import('react').RefAttributes<HTMLElement>>;
+export {};