@oslokommune/punkt-elements 16.8.2 → 16.9.1

package/dist/components/icon/icon.d.ts

@@ -0,0 +1,22 @@
+import { PktElement } from '../../base-elements/element';
+import { ElementProps } from '../../types/typeUtils';
+import { PktIconName } from '@oslokommune/punkt-assets/dist/icons/icon';
+import { PropertyValues } from 'lit';
+type Props = ElementProps<PktIcon, 'path' | 'name'>;
+export declare class PktIcon extends PktElement<Props> {
+    path: string | undefined;
+    name: PktIconName;
+    private icon;
+    private _updatedProps;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): Promise<void>;
+    protected updated(_changedProperties: PropertyValues): Promise<void>;
+    protected getIcon(name?: PktIconName): Promise<void>;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'pkt-icon': PktIcon;
+    }
+}
+export {};

package/dist/components/icon/icon.test.d.ts

@@ -0,0 +1,10 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { PktIcon } from './icon';
+export interface IconTestConfig extends BaseTestConfig {
+    name?: string;
+    path?: string;
+}
+export declare const createIconTest: (config?: IconTestConfig) => Promise<{
+    container: HTMLElement;
+    icon: PktIcon;
+}>;

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

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

package/dist/components/index.d.ts

@@ -0,0 +1,45 @@
+export { PktAlert } from './alert';
+export { PktAccordion, PktAccordionItem } from './accordion';
+export { PktBackLink } from './backlink';
+export { PktBreadcrumbs } from './breadcrumbs';
+export { PktButton } from './button';
+export { PktCalendar } from './calendar';
+export { PktCard } from './card';
+export { PktCombobox } from './combobox';
+export { PktConsent } from './consent';
+export { PktCheckbox } from './checkbox';
+export { PktDateTags } from './datepicker/date-tags.js';
+export { PktDatepicker } from './datepicker/datepicker.js';
+export { PktHeader, PktHeaderService, PktHeaderUserMenu } from './header';
+export { PktHelptext } from './helptext';
+export { PktHeading } from './heading';
+export { PktIcon } from './icon';
+export { PktInputWrapper } from './input-wrapper';
+export { PktLink } from './link';
+export { PktLinkCard } from './linkcard';
+export { PktLoader } from './loader';
+export { PktMessagebox } from './messagebox';
+export { PktModal } from './modal';
+export { PktProgressbar } from './progressbar';
+export { PktRadioButton } from './radiobutton';
+export { PktRadioButton as PktRadiobutton } from './radiobutton';
+export { PktTag } from './tag';
+export { PktTabs, PktTabItem } from './tabs';
+export { PktTextarea } from './textarea';
+export { PktTextinput } from './textinput';
+export { PktSelect } from './select';
+export { PktTimepicker } from './timepicker';
+export type { IPktAccordion, IPktAccordionItem, TPktAccordionSkin } from './accordion';
+export type { IPktButton, TPktButtonMode, TPktButtonSize, TPktButtonColor, TPktButtonSkin, TPktButtonVariant, TPktButtonState, TPktButtonType, } from './button';
+export type { User as IPktHeaderUser, Representing as IPktHeaderRepresenting, UserMenuItem as IPktHeaderUserMenuItem, THeaderMenu, TLogOutButtonPlacement as TPktHeaderLogOutButtonPlacement, THeaderPosition, THeaderScrollBehavior, TSlotMenuVariant, IPktHeader, } from './header';
+export type { IPktProgressbar, TProgressbarRole, TProgressbarSkin, TProgressbarStatusPlacement, TProgressbarStatusType, TProgressbarTitlePosition, } from './progressbar';
+export type { IPktCombobox, IPktComboboxOption, TPktComboboxTagPlacement, } from './combobox';
+export type { IPktHeading, TPktHeadingSize, TPktHeadingLevel } from './heading';
+export type { TTagSkin, TTagType } from './tag';
+export type { IPktTabs, IPktTabItem, TSkin as TTabItemSkin } from './tabs';
+export type { TSelectOption } from './select';
+export type { IPktBackLink } from './backlink';
+export type { IPktBreadcrumbs, IBreadcrumbItem } from './breadcrumbs';
+export type { IPktLoader, TPktLoaderVariant } from './loader';
+export type { IPktConsent } from './consent';
+export type { IPktTimepicker } from './timepicker';

package/dist/components/input-wrapper/index.d.ts

@@ -0,0 +1,3 @@
+import { PktInputWrapper } from './input-wrapper';
+export { PktInputWrapper };
+export default PktInputWrapper;

package/dist/components/input-wrapper/input-wrapper.d.ts

@@ -0,0 +1,39 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+import { PropertyValues } from 'lit';
+import { ElementProps } from '../../types/typeUtils';
+import { Booleanish } from '../../shared-types';
+type TCounterPosition = 'top' | 'bottom';
+type Props = ElementProps<PktInputWrapper, 'forId' | 'label' | 'helptext' | 'helptextDropdown' | 'helptextDropdownButton' | 'counter' | 'counterCurrent' | 'counterMaxLength' | 'optionalTag' | 'optionalText' | 'requiredTag' | 'requiredText' | 'tagText' | 'hasError' | 'errorMessage' | 'disabled' | 'inline' | 'ariaDescribedby' | 'hasFieldset' | 'useWrapper' | 'role'>;
+export declare class PktInputWrapper extends PktElementWithSlot<Props> {
+    /**
+     * Element attributes
+     */
+    forId: string;
+    label: string;
+    helptext: string | null;
+    helptextDropdown: string | null;
+    helptextDropdownButton: string | null;
+    counter: boolean;
+    counterCurrent: number;
+    counterMaxLength: number;
+    counterError: string | null;
+    counterPosition: TCounterPosition;
+    optionalTag: boolean;
+    optionalText: string;
+    requiredTag: boolean;
+    requiredText: string;
+    tagText: string | null;
+    hasError: boolean;
+    errorMessage: string;
+    disabled: boolean;
+    inline: boolean;
+    ariaDescribedby: string | undefined;
+    hasFieldset: boolean;
+    role: string | null;
+    useWrapper: Booleanish;
+    protected updated(changedProperties: PropertyValues): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private toggleDropdown;
+    private handleLabelClick;
+}
+export {};

package/dist/components/input-wrapper/input-wrapper.test.d.ts

@@ -0,0 +1,31 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+export interface InputWrapperTestConfig extends BaseTestConfig {
+    label?: string;
+    helptext?: string;
+    errorMessage?: string;
+    hasError?: boolean;
+    counter?: boolean;
+    counterCurrent?: number;
+    counterMaxLength?: number;
+    counterError?: boolean;
+    inline?: boolean;
+    useWrapper?: boolean;
+    disabled?: boolean;
+    optionalTag?: boolean;
+    requiredTag?: boolean;
+    hasFieldset?: boolean;
+    inFieldset?: boolean;
+    readonly?: boolean;
+    forId?: string;
+    ariaDescribedBy?: string;
+    helptextDropdown?: string;
+    helptextDropdownButton?: string;
+    optionalText?: string;
+    requiredText?: string;
+    tagText?: string;
+    role?: string;
+}
+export declare const createInputWrapperTest: (config?: InputWrapperTestConfig) => Promise<{
+    container: HTMLElement;
+    wrapper: import('./input-wrapper').PktInputWrapper;
+}>;

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

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

package/dist/components/link/link.d.ts

@@ -0,0 +1,12 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+export declare class PktLink extends PktElementWithSlot {
+    /**
+     * Element attributes
+     */
+    href: string;
+    iconName: string | undefined;
+    iconPosition: string | undefined;
+    external: boolean;
+    target: string | null;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/link/link.test.d.ts

@@ -0,0 +1,15 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+export interface LinkTestConfig extends BaseTestConfig {
+    href?: string;
+    target?: string;
+    skin?: string;
+    variant?: string;
+    iconName?: string;
+    iconPosition?: string;
+    openInNewTab?: boolean;
+    external?: boolean;
+}
+export declare const createLinkTest: (config?: LinkTestConfig) => Promise<{
+    container: HTMLElement;
+    link: import('./link').PktLink;
+}>;

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

@@ -0,0 +1,4 @@
+import { PktLinkCard } from './linkcard';
+export { PktLinkCard } from './linkcard';
+export type { IPktLinkCard, TLinkCardSkin } from './linkcard';
+export default PktLinkCard;

package/dist/components/linkcard/linkcard.d.ts

@@ -0,0 +1,19 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+export type TLinkCardSkin = 'normal' | 'no-padding' | 'blue' | 'beige' | 'green' | 'gray' | 'beige-outline' | 'gray-outline';
+export interface IPktLinkCard {
+    title?: string;
+    href?: string;
+    iconName?: string;
+    external?: boolean;
+    openInNewTab?: boolean;
+    skin?: TLinkCardSkin;
+}
+export declare class PktLinkCard extends PktElementWithSlot implements IPktLinkCard {
+    title: string;
+    href: string;
+    iconName: string;
+    external: boolean;
+    openInNewTab: boolean;
+    skin: TLinkCardSkin;
+    render(): import('lit-html').TemplateResult<1>;
+}

package/dist/components/linkcard/linkcard.test.d.ts

@@ -0,0 +1,9 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { PktLinkCard, IPktLinkCard } from './linkcard';
+export interface LinkCardTestConfig extends IPktLinkCard, BaseTestConfig {
+}
+export declare const createLinkCardTest: (config?: LinkCardTestConfig) => Promise<{
+    container: HTMLElement;
+    linkCard: PktLinkCard;
+    link: HTMLAnchorElement;
+}>;

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

@@ -0,0 +1,4 @@
+import { PktListbox } from './listbox';
+export type { IPktListbox } from './listbox';
+export { PktListbox };
+export default PktListbox;

package/dist/components/listbox/listbox.d.ts

@@ -0,0 +1,64 @@
+import { PropertyValues } from 'lit';
+import { PktElement } from '../../base-elements/element';
+import { IPktComboboxOption } from '../../shared-types/combobox';
+declare global {
+    interface HTMLElementTagNameMap {
+        'pkt-listbox': PktListbox;
+    }
+}
+export interface IPktListbox {
+    options: IPktComboboxOption[];
+    isOpen: boolean;
+    disabled: boolean;
+    includeSearch: boolean;
+    isMultiSelect: boolean;
+    allowUserInput: boolean;
+    maxIsReached: boolean;
+    customUserInput: string | null;
+    searchPlaceholder: string | null;
+    searchValue: string | null;
+    maxLength: number;
+    userMessage: string | null;
+}
+export declare class PktListbox extends PktElement implements IPktListbox {
+    id: string;
+    label: string | null;
+    options: IPktComboboxOption[];
+    isOpen: boolean;
+    disabled: boolean;
+    includeSearch: boolean;
+    isMultiSelect: boolean;
+    allowUserInput: boolean;
+    maxIsReached: boolean;
+    customUserInput: string | null;
+    searchPlaceholder: string | null;
+    searchValue: string | null;
+    maxLength: number;
+    userMessage: string | null;
+    private _selectedOptions;
+    private typeahead;
+    private _filteredOptions;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProperties: PropertyValues): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private get _hasOptions();
+    render(): import('lit-html').TemplateResult<1>;
+    private renderCheckboxOrCheckIcon;
+    private renderEmptyMessage;
+    private renderList;
+    private renderNewOptionBanner;
+    private renderMaximumReachedBanner;
+    private renderUserMessage;
+    private renderSearch;
+    private handleSearchInput;
+    private handleSearchKeydown;
+    private handleOptionKeydown;
+    focusFirstOrSelectedOption(): void;
+    private toggleOption;
+    private selectAll;
+    private closeOptions;
+    private tabClose;
+    filterOptions(): void;
+    private handleTypeAhead;
+}

package/dist/components/listbox/listbox.interaction.test.d.ts

@@ -0,0 +1,10 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { IPktListbox } from './listbox';
+export interface ListboxTestConfig extends Partial<IPktListbox>, BaseTestConfig {
+    label?: string;
+    id?: string;
+}
+export declare const createListboxTest: (config?: ListboxTestConfig) => Promise<{
+    container: HTMLElement;
+    listbox: import('./listbox').PktListbox;
+}>;

package/dist/components/listbox/listbox.test.d.ts

@@ -0,0 +1,10 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { IPktListbox } from './listbox';
+export interface ListboxTestConfig extends Partial<IPktListbox>, BaseTestConfig {
+    label?: string;
+    id?: string;
+}
+export declare const createListboxTest: (config?: ListboxTestConfig) => Promise<{
+    container: HTMLElement;
+    listbox: import('./listbox').PktListbox;
+}>;

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

@@ -0,0 +1,4 @@
+import { PktLoader } from './loader';
+export { PktLoader } from './loader';
+export default PktLoader;
+export type { IPktLoader, TPktLoaderVariant } from './loader';

package/dist/components/loader/loader.d.ts

@@ -0,0 +1,53 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+import { TPktSize } from '../../types/size';
+export type TPktLoaderVariant = 'blue' | 'rainbow' | 'shapes';
+export interface IPktLoader {
+    /**
+     * The `delay` prop controls how much time the loading should be given before the loader is displayed.
+     * This is handy for situations where the load time might be so short that loader is not necessary.
+     * Delay time is in milliseconds.
+     */
+    delay?: number;
+    /**
+     * The `inline` prop decides whether the loader should be displayed inline or not.
+     */
+    inline?: boolean;
+    /**
+     * The boolean 'isLoading' decides whether the loader or the children will be displayed.
+     * If set to false, the children will be displayed.
+     */
+    isLoading?: boolean;
+    /**
+     * The message to display when the loader is loading.
+     */
+    message?: string | null;
+    /**
+     * The size of the loader. Default is "medium".
+     */
+    size?: TPktSize;
+    /**
+     * The variant of the loader. Default is "shapes" which is the OSLO wave loader.
+     * Other variants are "blue" and "rainbow" which are spinner variants.
+     */
+    variant?: TPktLoaderVariant;
+    /**
+     * Override path to loading animations.
+     */
+    loadingAnimationPath?: string;
+}
+export declare class PktLoader extends PktElementWithSlot implements IPktLoader {
+    delay: number;
+    inline: boolean;
+    isLoading: boolean;
+    message: string | null;
+    size: TPktSize;
+    variant: TPktLoaderVariant;
+    loadingAnimationPath: string | undefined;
+    private _shouldDisplayLoader;
+    connectedCallback(): void;
+    updated(changedProperties: Map<string, unknown>): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private getVariant;
+    private setupLoader;
+}
+export default PktLoader;

package/dist/components/loader/loader.test.d.ts

@@ -0,0 +1,8 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { IPktLoader } from './loader';
+export interface LoaderTestConfig extends Partial<IPktLoader>, BaseTestConfig {
+}
+export declare const createLoaderTest: (config?: LoaderTestConfig) => Promise<{
+    container: HTMLElement;
+    loader: import('./loader').PktLoader;
+}>;

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

@@ -0,0 +1,4 @@
+import { PktMessagebox } from './messagebox';
+export { PktMessagebox } from './messagebox';
+export type { IPktMessagebox, TMessageboxSkin } from './messagebox';
+export default PktMessagebox;

package/dist/components/messagebox/messagebox.d.ts

@@ -0,0 +1,21 @@
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+import { PropertyValues } from 'lit';
+import { TMessageboxSkin } from '../../shared-types';
+export type { TMessageboxSkin };
+export interface IPktMessagebox {
+    skin?: TMessageboxSkin;
+    title?: string;
+    compact?: boolean;
+    closable?: boolean;
+}
+export declare class PktMessagebox extends PktElementWithSlot implements IPktMessagebox {
+    constructor();
+    closable: boolean;
+    compact: boolean;
+    title: string;
+    skin: TMessageboxSkin;
+    _isClosed: boolean;
+    protected updated(_changedProperties: PropertyValues): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private close;
+}

package/dist/components/messagebox/messagebox.test.d.ts

@@ -0,0 +1,8 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { IPktMessagebox } from './messagebox';
+export interface MessageboxTestConfig extends Partial<IPktMessagebox>, BaseTestConfig {
+}
+export declare const createMessageboxTest: (config?: MessageboxTestConfig) => Promise<{
+    container: HTMLElement;
+    messagebox: import('./messagebox').PktMessagebox;
+}>;

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

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

package/dist/components/modal/modal.d.ts

@@ -0,0 +1,41 @@
+import { PropertyValues } from 'lit';
+import { PktElementWithSlot } from '../../base-elements/element-with-slot';
+import { Ref } from 'lit/directives/ref.js';
+import { TPktSize } from '../../types/size';
+export interface IPktModal {
+    open?: boolean;
+    headingText?: string;
+    removePadding?: boolean;
+    hideCloseButton?: boolean;
+    closeOnBackdropClick?: boolean;
+    closeButtonSkin?: 'blue' | 'yellow-filled';
+    size?: TPktSize;
+    variant?: 'dialog' | 'drawer';
+    drawerPosition?: 'left' | 'right';
+    transparentBackdrop?: boolean;
+}
+export declare class PktModal extends PktElementWithSlot implements IPktModal {
+    open?: boolean;
+    headingText?: string;
+    removePadding?: boolean;
+    hideCloseButton?: boolean;
+    closeOnBackdropClick?: boolean;
+    closeButtonSkin?: 'blue' | 'yellow-filled';
+    size?: TPktSize;
+    variant?: 'dialog' | 'drawer';
+    drawerPosition?: 'left' | 'right';
+    transparentBackdrop?: boolean;
+    dialogRef: Ref<HTMLDialogElement>;
+    _isOpen: boolean;
+    constructor();
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): void;
+    protected updated(changedProperties: PropertyValues): void;
+    protected firstUpdated(_changedProperties: PropertyValues): Promise<void>;
+    private handleKeyDown;
+    private handleBackdropClick;
+    private isElementInViewport;
+    close: (event: Event, bypassNativeClose?: boolean) => void;
+    showModal: (event?: Event | null) => void;
+    render(): import('lit-html').TemplateResult<1>;
+}

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

@@ -0,0 +1,4 @@
+import { default as PktProgressbar } from './progressbar';
+export { PktProgressbar } from './progressbar';
+export type { IPktProgressbar, TProgressbarRole, TProgressbarSkin, TProgressbarStatusPlacement, TProgressbarStatusType, TProgressbarTitlePosition, } from './progressbar';
+export default PktProgressbar;

package/dist/components/progressbar/progressbar.d.ts

@@ -0,0 +1,49 @@
+import { PktElement } from '../../base-elements/element';
+import { TAriaLive, TProgressbarRole, TProgressbarSkin, TProgressbarStatusPlacement, TProgressbarStatusType, TProgressbarTitlePosition } from '../../shared-types';
+export type { TProgressbarRole, TProgressbarSkin, TProgressbarStatusPlacement, TProgressbarStatusType, TProgressbarTitlePosition };
+export interface IPktProgressbar {
+    ariaLabel?: string | null;
+    ariaLabelledby?: string | null;
+    ariaLive?: TAriaLive | null;
+    ariaValueText?: string | null;
+    id?: string | null;
+    role?: TProgressbarRole;
+    skin?: TProgressbarSkin;
+    statusPlacement?: TProgressbarStatusPlacement;
+    statusType?: TProgressbarStatusType;
+    title?: string | null;
+    titlePosition?: TProgressbarTitlePosition;
+    valueCurrent: number;
+    valueMax?: number;
+    valueMin?: number;
+}
+export declare class PktProgressbar extends PktElement implements IPktProgressbar {
+    constructor();
+    ariaLabel: string | null;
+    ariaLabelledby: string | null;
+    ariaValueText: string | null;
+    ariaLive: TAriaLive;
+    id: string;
+    role: TProgressbarRole;
+    skin: TProgressbarSkin;
+    statusPlacement: TProgressbarStatusPlacement;
+    statusType: TProgressbarStatusType;
+    title: string;
+    titlePosition: TProgressbarTitlePosition;
+    valueCurrent: number;
+    valueMax: number;
+    valueMin: number;
+    private labelWidth;
+    private progressbarId;
+    private computedAriaLabelledby;
+    private computedAriaValueText;
+    private labelRef;
+    private progressBarRef;
+    firstUpdated(changedProperties: Map<string | number | symbol, unknown>): void;
+    updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private setComputedValues;
+    private syncAttributes;
+    private _handleAttribute;
+}
+export default PktProgressbar;

package/dist/components/progressbar/progressbar.test.d.ts

@@ -0,0 +1,8 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+import { IPktProgressbar } from './progressbar';
+export interface ProgressbarTestConfig extends Partial<IPktProgressbar>, BaseTestConfig {
+}
+export declare const createProgressbarTest: (config?: ProgressbarTestConfig) => Promise<{
+    container: HTMLElement;
+    progressbar: import('./progressbar').PktProgressbar;
+}>;

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

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

package/dist/components/radiobutton/radiobutton.d.ts

@@ -0,0 +1,24 @@
+import { PktInputElement } from '../../base-elements/input-element';
+import { Ref } from 'lit/directives/ref.js';
+import { ElementProps } from '../../types/typeUtils';
+type Props = ElementProps<PktRadioButton, 'checkHelptext' | 'defaultChecked' | 'hasTile' | 'tagText' | 'optionalTag' | 'optionalText' | 'requiredTag' | 'requiredText'>;
+export declare class PktRadioButton extends PktInputElement<Props> {
+    inputRef: Ref<HTMLInputElement>;
+    value: string;
+    checkHelptext: string | null;
+    defaultChecked: boolean;
+    hasTile: boolean;
+    checked: boolean | string | null;
+    type: string;
+    tagText: string | null;
+    optionalTag: boolean;
+    optionalText: string;
+    requiredTag: boolean;
+    requiredText: string;
+    _checked: boolean;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    render(): import('lit-html').TemplateResult<1>;
+    private toggleChecked;
+}
+export {};

package/dist/components/radiobutton/radiobutton.test.d.ts

@@ -0,0 +1,28 @@
+import { BaseTestConfig } from '../../tests/test-framework';
+export interface RadioButtonTestConfig extends BaseTestConfig {
+    value?: string;
+    checkHelptext?: string | null;
+    defaultChecked?: boolean;
+    hasTile?: boolean;
+    checked?: boolean | string | null;
+    type?: string;
+    tagText?: string | null;
+    optionalTag?: boolean;
+    optionalText?: string;
+    requiredTag?: boolean;
+    requiredText?: string;
+    id?: string;
+    name?: string;
+    label?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    hasError?: boolean;
+    inline?: boolean;
+    ariaDescribedBy?: string | null;
+    ariaLabelledby?: string | null;
+}
+export declare const createRadioButtonTest: (config?: RadioButtonTestConfig) => Promise<{
+    container: HTMLElement;
+    radiobutton: import('./radiobutton').PktRadioButton;
+}>;

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

@@ -0,0 +1,4 @@
+import { PktSelect } from './select';
+export { PktSelect } from './select';
+export type { TSelectOption } from './select';
+export default PktSelect;