@fremtind/jokul 0.22.1 → 0.22.3

package/build/components/menu/Menu.d.ts

@@ -0,0 +1,39 @@
+import { Placement } from '@floating-ui/react';
+import { default as React, ButtonHTMLAttributes, ReactNode } from 'react';
+import { DataTestAutoId, WithChildren } from '../..';
+export interface MenuProps extends DataTestAutoId, WithChildren, Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    className?: string;
+    /**
+     * Initiell plassering av menyen. Dersom det ikke er plass på skjermen der du
+     * angir at den skal åpnes vil den slyttes automatisk.
+     * @default "bottom-start" på toppnivå, "right-start" for undermenyer
+     * */
+    initialPlacement?: Placement;
+    /**
+     * Angir om menyen skal åpnes ved hover (uten å måtte klikke)
+     * @default false
+     */
+    openOnHover?: boolean;
+    /**
+     * Angir om menyen skal holdes åpen når man klikker utenfor menyen
+     * @default false
+     */
+    keepOpenOnClickOutside?: boolean;
+    /**
+     * Elementet som fungerer som trigger for menyen. Dersom elementet ikke er en `<button>`
+     * eller en `forwardRef<HTMLButtonElement>` vil det bli lagt inne i en knapp
+     * med forhåndsdefinert stil. For å komme raskt i gang kan du bruke komponenten
+     * `MenuTriggerButton` fra denne pakken.
+     */
+    triggerElement: ReactNode;
+    /**
+     * Kan brukes til å styre utenfra om menyen skal være åpen eller ikke.
+     * @default false
+     */
+    isOpen?: boolean;
+    /**
+     * Callback som kalles når menyen åpnes eller lukkes.
+     */
+    onToggle?: (isOpen: boolean) => void;
+}
+export declare const Menu: React.ForwardRefExoticComponent<MenuProps & React.RefAttributes<HTMLButtonElement>>;

package/build/components/menu/MenuDivider.d.ts

@@ -0,0 +1,2 @@
+import { HTMLAttributes, FC } from 'react';
+export declare const MenuDivider: FC<HTMLAttributes<HTMLHRElement>>;

package/build/components/menu/MenuItem.d.ts

@@ -0,0 +1,25 @@
+import { default as React, ReactNode } from 'react';
+import { PolymorphicPropsWithRef } from '../../utilities/polymorphism/polymorphism';
+export type MenuItemProps<ElementType extends React.ElementType> = PolymorphicPropsWithRef<ElementType, {
+    /**
+     * Et ikon som vises før innholdet i menypunktet
+     */
+    icon?: ReactNode;
+} & ({
+    expandable?: never;
+    /**
+     * Indikerer at menypunktet åpner noe i et nytt vindu eller tab
+     * @default false
+     */
+    external?: boolean;
+} | {
+    external?: never;
+    /**
+     * Indikerer at menypunktet er utvidbart ved å vise en chevron
+     * @default false
+     */
+    expandable?: boolean;
+})>;
+type MenuItemComponent = <ElementType extends React.ElementType = "button">(props: MenuItemProps<ElementType>) => React.ReactElement | null;
+export declare const MenuItem: MenuItemComponent;
+export {};

package/build/components/menu/MenuItemCheckbox.d.ts

@@ -0,0 +1,11 @@
+import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { SwipeChangeHandler } from '../../hooks';
+export interface MenuItemCheckboxProps extends Omit<HTMLAttributes<HTMLDivElement>, "aria-checked" | "onChange"> {
+    "aria-checked": boolean;
+    /**
+     * Et ikon som vises før innholdet i menypunktet
+     */
+    icon?: ReactNode;
+    onChange?: SwipeChangeHandler<HTMLDivElement> & ((event: React.KeyboardEvent<HTMLDivElement> | React.PointerEvent<HTMLDivElement>, pressed: boolean) => void);
+}
+export declare const MenuItemCheckbox: React.ForwardRefExoticComponent<MenuItemCheckboxProps & React.RefAttributes<HTMLDivElement>>;

package/build/components/menu/index.d.ts

@@ -0,0 +1,4 @@
+export { Menu, type MenuProps } from './Menu';
+export { MenuItem, type MenuItemProps } from './MenuItem';
+export { MenuItemCheckbox, type MenuItemCheckboxProps } from './MenuItemCheckbox';
+export { MenuDivider } from './MenuDivider';

package/build/components/menu/useMenuWideEvents.d.ts

@@ -0,0 +1,6 @@
+import { FloatingTreeType } from '@floating-ui/react';
+export declare const useMenuWideEvents: (tree: FloatingTreeType | null, nodeId: string, parentId: string | null) => {
+    allowHover: boolean;
+    isOpen: boolean;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+};

package/build/components/message/DismissButton.d.ts

@@ -0,0 +1,5 @@
+import { default as React, ButtonHTMLAttributes } from 'react';
+export interface DismissButtonProps extends Exclude<ButtonHTMLAttributes<HTMLButtonElement>, "disabled"> {
+    label?: string;
+}
+export declare const DismissButton: React.ForwardRefExoticComponent<DismissButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/build/components/message/FormErrorMessage.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { MessageProps } from './Message';
+export interface FormErrorMessageProps {
+    className?: string;
+    id?: string;
+    /**
+     * @default { title: "Feil og mangler i skjemaet" }
+     */
+    messageProps?: Partial<MessageProps>;
+    errors: (string | undefined)[];
+    isSubmitted: boolean;
+    isValid: boolean;
+}
+export declare const FormErrorMessage: React.ForwardRefExoticComponent<FormErrorMessageProps & React.RefAttributes<HTMLDivElement>>;

package/build/components/message/Message.d.ts

@@ -0,0 +1,19 @@
+import { default as React, AriaRole } from 'react';
+import { Density, WithChildren } from '../..';
+export interface MessageProps extends WithChildren {
+    id?: string;
+    title?: string;
+    fullWidth?: boolean;
+    density?: Density;
+    className?: string;
+    dismissed?: boolean;
+    dismissAction?: {
+        handleDismiss: () => void;
+        buttonTitle?: string;
+    };
+    role?: AriaRole;
+}
+export declare const InfoMessage: React.ForwardRefExoticComponent<MessageProps & React.RefAttributes<HTMLDivElement>>;
+export declare const ErrorMessage: React.ForwardRefExoticComponent<MessageProps & React.RefAttributes<HTMLDivElement>>;
+export declare const WarningMessage: React.ForwardRefExoticComponent<MessageProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SuccessMessage: React.ForwardRefExoticComponent<MessageProps & React.RefAttributes<HTMLDivElement>>;

package/build/components/message/index.d.ts

@@ -0,0 +1,2 @@
+export { InfoMessage, ErrorMessage, SuccessMessage, WarningMessage, type MessageProps } from './Message';
+export { FormErrorMessage, type FormErrorMessageProps } from './FormErrorMessage';

package/build/components/modal/Modal.d.ts

@@ -0,0 +1,72 @@
+import { default as React } from 'react';
+import { WithOptionalChildren } from '../..';
+import { IconButtonProps } from '../icon-button';
+export interface ModalProps extends WithOptionalChildren {
+    id?: string;
+    className?: string;
+    component?: React.ElementType;
+    style?: React.CSSProperties;
+    /**
+     * Overstyrer padding på modalen via en CSS-variabel.
+     */
+    padding?: 16 | 24 | 40;
+}
+type BaseModalProps = Omit<ModalProps, "padding" | "component">;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalContainer: React.ForwardRefExoticComponent<Omit<{
+    id: string;
+    ref: (node: HTMLElement | React.ReactNode) => void;
+    role: string;
+    'aria-modal': boolean;
+    'aria-hidden': boolean;
+    'aria-labelledby': string;
+} & BaseModalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalOverlay: React.ForwardRefExoticComponent<{
+    onClick?: (() => void) | undefined;
+} & BaseModalProps & {
+    /**
+     * Rendre uten bakgrunnsfarge, men med click target for å lukke modalen ved klikk utenfor.
+     */
+    transparent?: boolean | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const Modal: React.ForwardRefExoticComponent<{
+    role: "document";
+} & ModalProps & React.RefAttributes<HTMLElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalHeader: React.ForwardRefExoticComponent<BaseModalProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalTitle: React.ForwardRefExoticComponent<{
+    role: "heading";
+    'aria-level': number;
+    id: string;
+} & BaseModalProps & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalCloseButton: React.ForwardRefExoticComponent<Omit<{
+    type: "button";
+    onClick: () => void;
+} & {
+    "aria-label": string;
+}, "onClick"> & BaseModalProps & IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalBody: React.ForwardRefExoticComponent<BaseModalProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Ment å brukes med `useModal`.
+ */
+export declare const ModalActions: React.ForwardRefExoticComponent<BaseModalProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,4 @@
+export type { ModalProps } from './Modal';
+export { ModalContainer, ModalOverlay, Modal, ModalHeader, ModalTitle, ModalCloseButton, ModalBody, ModalActions, } from './Modal';
+export type { UseModalOptions, ModalInstance, ModalConfig } from './useModal';
+export { useModal } from './useModal';

package/build/components/modal/useModal.d.ts

@@ -0,0 +1,69 @@
+import { A11yDialogConfig, A11yDialogProps } from 'react-a11y-dialog';
+export interface UseModalOptions extends Omit<A11yDialogProps, "id" | "closeButtonPosition"> {
+    id?: string;
+    /**
+     * @default "Lukk"
+     */
+    closeButtonLabel?: string;
+    /**
+     * Sett til `alertdialog` om du ønsker å slå av muligheten til å lukke med ESC og klikk utenfor.
+     *
+     * @default "dialog"
+     */
+    role?: "dialog" | "alertdialog";
+    /**
+     * Påkrevd for universell utforming. Tittelen kan gjenbrukes som `children` i `<ModalTitle>` med en konstant.
+     */
+    title: string;
+}
+export type ModalInstance = ReturnType<typeof useModal>[0];
+export interface ModalConfig extends Omit<A11yDialogConfig, "dialog"> {
+    modal: A11yDialogConfig["dialog"];
+    closeButton: A11yDialogConfig["closeButton"] & {
+        "aria-label": string;
+    };
+}
+/**
+ * @example
+ * ```jsx
+ * const heading = "Bekreft sletting";
+ * const [instance, { title, overlay, container, modal, closeButton }] = useModal({ title: heading });
+ *
+ * useEffect(() => {
+ *      if (!instance) {
+ *          return;
+ *      }
+ *      instance.show();
+ *  }, [instance]);
+ *
+ * return ReactDOM.createPortal(
+ *      <ModalContainer {...container}>
+ *          <ModalOverlay {...overlay} />
+ *          <Modal {...modal}>
+ *              <ModalHeader>
+ *                  <ModalTitle {...title}>{heading}</ModalTitle>
+ *                  <ModalCloseButton {...closeButton} />
+ *              </ModalHeader>
+ *              <ModalBody>
+ *                  Er du sikker på at du vil slette Foo Bar Baz?
+ *              </ModalBody>
+ *              <ModalActions>
+ *                  <PrimaryButton
+ *                      onClick={() => {
+ *                          // Do the thing
+ *                          instance?.hide()
+ *                      }}
+ *                  >
+ *                      Bekreft
+ *                  </PrimaryButton>
+ *                  <TertiaryButton onClick={() => instance?.hide()}>
+ *                     Avbryt
+ *                 </TertiaryButton>
+ *              </ModalActions>
+ *          </Modal>
+ *      </ModalContainer>,
+ *      document.body,
+ *  );
+ * ```
+ */
+export declare function useModal(props: UseModalOptions): readonly [A11yDialog.A11yDialog, ModalConfig];

package/build/components/pagination/PageButton.d.ts

@@ -0,0 +1,7 @@
+import { FC, MouseEventHandler } from 'react';
+export declare const PageButton: FC<{
+    isActive: boolean;
+    number: number;
+    onClick: MouseEventHandler;
+    total: number;
+}>;

package/build/components/pagination/Pagination.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { PolymorphicPropsWithRef } from '../../utilities/polymorphism';
+export type PaginationProps<ElementType extends React.ElementType> = PolymorphicPropsWithRef<ElementType, {
+    currentPage: number;
+    numberOfPages: number;
+    onPageChange: (toPage: number, fromPage: number) => void;
+    /**
+     * Dersom du ønsker å ha custom labels kan du sende inn disse. "next" og "previous"
+     * brukes som hint til skjermlesere for ikon-knappene til Neste/Forrige side
+     * @default { previous: "Forrige side", next: "Neste side" }
+     */
+    labels?: {
+        previous: string;
+        next: string;
+    };
+}>;
+export type PaginationComponent = <ElementType extends React.ElementType = "nav">(props: PaginationProps<ElementType>) => React.ReactElement | null;
+export declare const Pagination: PaginationComponent;

package/build/components/pagination/index.d.ts

@@ -0,0 +1 @@
+export * from './Pagination';

package/build/components/popover/Popover.d.ts

@@ -0,0 +1,154 @@
+import { useFocus, useHover, useClick, useDismiss, useRole, UseFloatingOptions, ReferenceType } from '@floating-ui/react';
+import * as React from "react";
+type ClickOptions = Parameters<typeof useClick>[1];
+type DismissOptions = Parameters<typeof useDismiss>[1];
+type FocusOptions = Parameters<typeof useFocus>[1];
+type HoverOptions = Parameters<typeof useHover>[1];
+type RoleOptions = Parameters<typeof useRole>[1];
+interface PopoverOptions {
+    /**
+     * Angir om popoveren er åpen eller lukket.
+     *
+     * @see https://floating-ui.com/docs/usefloating#open
+     */
+    open?: boolean;
+    /**
+     * Callback som trigges når popoveren åpnes eller lukkes.
+     *
+     * @see https://floating-ui.com/docs/usefloating#onopenchange
+     */
+    onOpenChange?: UseFloatingOptions["onOpenChange"];
+    /**
+     * Bestemmer plasseringen av popoveren.
+     *
+     * @see https://floating-ui.com/docs/usefloating#placement
+     *
+     * @default "bottom-start"
+     */
+    placement?: UseFloatingOptions["placement"];
+    /**
+     * Definerer strategien for posisjonering av popoveren.
+     *
+     * @see https://floating-ui.com/docs/usefloating#strategy
+     *
+     * @default "absolute"
+     */
+    strategy?: UseFloatingOptions["strategy"];
+    /**
+     * Angir om popoveren skal fungere som en modal, der fokus er låst til det flytende elementet
+     * og innhold utenfor ikke kan interageres med.
+     *
+     * @see https://floating-ui.com/docs/usefloating#modal
+     *
+     * @default true
+     */
+    modal?: boolean;
+    /**
+     * Justerer avstanden mellom referanse-elementet og popoveren.
+     *
+     * @see https://floating-ui.com/docs/offset
+     *
+     * @default 4
+     */
+    offset?: number;
+    /**
+     * Referanse til elementet som popoveren skal posisjoneres i forhold til.
+     *
+     * @see https://floating-ui.com/docs/usefloating#setpositionreference
+     *
+     * @default Popover.Trigger
+     */
+    positionReference?: React.RefObject<ReferenceType>;
+    /**
+     * Options for hover-interaksjoner.
+     *
+     * @see https://floating-ui.com/docs/usehover
+     *
+     * @default { enabled: false }
+     */
+    hoverOptions?: HoverOptions;
+    /**
+     * Options for fokus-interaksjoner.
+     *
+     * @see https://floating-ui.com/docs/usefocus
+     *
+     * @default { enabled: false }
+     */
+    focusOptions?: FocusOptions;
+    /**
+     * Options for klikk-interaksjoner.
+     *
+     * @see https://floating-ui.com/docs/useclick
+     *
+     * @default { enabled: false }
+     */
+    clickOptions?: ClickOptions;
+    /**
+     * Konfigurerer rollen for popoveren.
+     *
+     * @see https://floating-ui.com/docs/userole
+     *
+     * @default { enabled: true, role: "dialog" }
+     */
+    roleOptions?: RoleOptions;
+    /**
+     * Options for å lukke popoveren når en dismissal skjer,
+     * som ved å klikke utenfor eller trykke på "Escape"-tasten.
+     *
+     * @see https://floating-ui.com/docs/usedismiss
+     *
+     * @default { enabled: true }
+     */
+    dismissOptions?: DismissOptions;
+}
+declare const Popover: {
+    ({ children, ...restOptions }: {
+        children: React.ReactNode;
+    } & PopoverOptions): React.JSX.Element;
+    Trigger: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLElement> & PopoverTriggerProps, "ref"> & React.RefAttributes<HTMLElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<React.HTMLProps<HTMLDivElement> & PopoverContentProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+interface PopoverTriggerProps {
+    children: React.ReactNode;
+    /**
+     * Rendrer komponenten som child-elementet sitt, og slår sammen egenskaper og props.
+     *
+     * Default er `false`.
+     *
+     * @example
+     * ```tsx
+     * <Component asChild foo="bar">
+     *    <Child baz="qux" />
+     * </Component>
+     *
+     * // Rendrer følgende:
+     * <Child foo="bar" baz="qux" />
+     * ```
+     */
+    asChild?: boolean;
+}
+interface PopoverContentProps {
+    /**
+     * Padding rundt innholdet i popoveren.
+     *
+     * Default er `0`.
+     */
+    padding?: 0 | 8 | 16 | 24;
+    /**
+     *
+     * Angir hvilket element som skal motta fokus ved åpning.
+     * Kan være en tabbar index eller en referanse til et element."
+     *
+     * Default er `0`, som betyr at det første fokuserbare elementet i popoveren får fokus.
+     * @see https://floating-ui.com/docs/FloatingFocusManager#initialfocus
+     */
+    initialFocus?: number | React.RefObject<HTMLElement>;
+    /**
+     * Angir om fokus skal returneres til triggeren når popoveren lukkes.
+     *
+     * Default er `true`.
+     * @see https://floating-ui.com/docs/FloatingFocusManager#returnfocus
+     */
+    returnFocus?: boolean;
+}
+export default Popover;

package/build/components/popover/index.d.ts

@@ -0,0 +1 @@
+export { default as Popover } from './Popover';

package/build/components/progress-bar/Countdown.d.ts

@@ -0,0 +1,12 @@
+import { default as React, CSSProperties, FC } from 'react';
+export interface CountdownProps extends Pick<React.HTMLAttributes<HTMLDivElement>, "onAnimationEnd" | "onAnimationStart"> {
+    id?: string;
+    className?: string;
+    /**
+     * Millisekunder å telle ned fra
+     */
+    from: number;
+    isPaused?: boolean;
+    style?: CSSProperties;
+}
+export declare const Countdown: FC<CountdownProps>;

package/build/components/progress-bar/ProgressBar.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties, FC } from 'react';
+export interface ProgressBarProps {
+    id?: string;
+    className?: string;
+    /**
+     * @default "Fremdrift"
+     */
+    title?: string;
+    "aria-valuetext"?: string;
+    /**
+     * @default 0
+     */
+    "aria-valuemin"?: number;
+    "aria-valuenow": number;
+    /**
+     * @default 100
+     */
+    "aria-valuemax"?: number;
+    style?: CSSProperties;
+}
+export declare const calculatePercentage: (current: number, total: number) => number;
+export declare const ProgressBar: FC<ProgressBarProps>;

package/build/components/progress-bar/index.d.ts

@@ -0,0 +1,4 @@
+export type { CountdownProps } from './Countdown';
+export { Countdown } from './Countdown';
+export type { ProgressBarProps } from './ProgressBar';
+export { ProgressBar } from './ProgressBar';

package/build/components/radio-button/BaseRadioButton.d.ts

@@ -0,0 +1,10 @@
+import { default as React, ChangeEventHandler } from 'react';
+import { Density } from '../..';
+import { RadioButtonProps } from './RadioButton';
+export interface BaseRadioButtonProps extends RadioButtonProps {
+    inline?: boolean;
+    density?: Density;
+    invalid?: boolean;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+}
+export declare const BaseRadioButton: React.ForwardRefExoticComponent<BaseRadioButtonProps & React.RefAttributes<HTMLInputElement>>;

package/build/components/radio-button/RadioButton.d.ts

@@ -0,0 +1,15 @@
+import { default as React, InputHTMLAttributes, ChangeEventHandler, ReactNode } from 'react';
+import { SupportLabelProps } from '../input-group';
+export interface RadioButtonProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "children"> {
+    children?: ReactNode;
+    value: string;
+    /** Kan også settes på RadioButtonGroup, men settes på RadioButton f. eks. av react-hook-form */
+    name?: string;
+    /** Kan også settes på RadioButtonGroup, men settes på RadioButton f. eks. av react-hook-form */
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    /** @deprecated Bruk children */
+    label?: ReactNode;
+    helpLabel?: ReactNode;
+    supportLabelProps?: Omit<SupportLabelProps, "id" | "errorLabel" | "helpLabel" | "density">;
+}
+export declare const RadioButton: React.ForwardRefExoticComponent<RadioButtonProps & React.RefAttributes<HTMLInputElement>>;

package/build/components/radio-button/RadioButtonGroup.d.ts

@@ -0,0 +1,24 @@
+import { ChangeEventHandler, FC } from 'react';
+import { Density } from '../..';
+import { FieldGroupProps } from '../input-group';
+export interface RadioButtonGroupProps extends Omit<FieldGroupProps, "onChange"> {
+    legend: string;
+    /** Alle RadioButton i gruppen får dette som name. */
+    name?: string;
+    /** Om gruppen skal være controlled setter du den valgte verdien her. */
+    value?: string;
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    helpLabel?: string;
+    /**
+     * Erstatter hjelpeteksten (hvis noen) med en feilmelding.
+     * Merker samtidig alle RadioButton i gruppen som ugyldige.
+     */
+    errorLabel?: string;
+    /**
+     * Setter inline-modifieren på alle RadioButton i gruppen.
+     * @default false
+     */
+    inline?: boolean;
+    density?: Density;
+}
+export declare const RadioButtonGroup: FC<RadioButtonGroupProps>;

package/build/components/radio-button/index.d.ts

@@ -0,0 +1,6 @@
+export type { RadioButtonProps } from './RadioButton';
+export { RadioButton } from './RadioButton';
+export type { RadioButtonGroupProps } from './RadioButtonGroup';
+export { RadioButtonGroup } from './RadioButtonGroup';
+export type { BaseRadioButtonProps } from './BaseRadioButton';
+export { BaseRadioButton } from './BaseRadioButton';

package/build/components/radio-button/radioGroupContext.d.ts

@@ -0,0 +1,16 @@
+import { default as React, ChangeEventHandler } from 'react';
+import { Density, WithChildren } from '../..';
+type RadioGroupContext = {
+    name: string | undefined;
+    value: string | undefined;
+    inline: boolean;
+    density?: Density;
+    invalid: boolean;
+    onChange: ChangeEventHandler<HTMLInputElement> | undefined;
+};
+export declare const useRadioGroupContext: () => RadioGroupContext;
+interface Props extends WithChildren {
+    state: RadioGroupContext;
+}
+export declare const RadioGroupContextProvider: React.FC<Props>;
+export {};

package/build/components/select/NativeSelect.d.ts

@@ -0,0 +1,19 @@
+import { default as React, SelectHTMLAttributes } from 'react';
+import { ValuePair } from '../..';
+import { InputGroupProps } from '../input-group';
+export interface NativeSelectProps extends Omit<InputGroupProps, "children">, SelectHTMLAttributes<HTMLSelectElement> {
+    /**
+     * Merk som ugyldig uten å sende inn en errorLabel.
+     * NB! Brukes kun i tilfeller der valideringsfeil dukker opp andre steder, for eksempel i en FieldGroup.
+     */
+    invalid?: boolean;
+    /**
+     * Setter inn et placeholderelement som vises når ingenting er valgt i nedtrekkslisten.
+     * @default "Velg"
+     */
+    placeholder?: string;
+    items: Array<string | ValuePair>;
+    selectClassName?: string;
+    width?: string;
+}
+export declare const NativeSelect: React.ForwardRefExoticComponent<NativeSelectProps & React.RefAttributes<HTMLSelectElement>>;