@public-ui/components 1.1.7-rc.6

package/dist/loader/index.js

@@ -0,0 +1,4 @@
+/*!
+ * KoliBri - the accessible web component library
+ */
+!function(){if("undefined"!=typeof window&&void 0!==window.Reflect&&void 0!==window.customElements){var e=HTMLElement;window.HTMLElement=function(){return Reflect.construct(e,[],this.constructor)},HTMLElement.prototype=e.prototype,HTMLElement.prototype.constructor=HTMLElement,Object.setPrototypeOf(HTMLElement,e)}}();export*from"../esm/polyfills/index.js";export*from"../esm/loader.js";

package/dist/loader/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "kolibri-loader",
+  "private": true,
+  "typings": "./index.d.ts",
+  "module": "./index.js",
+  "main": "./index.cjs.js",
+  "jsnext:main": "./index.es2017.js",
+  "es2015": "./index.es2017.js",
+  "es2017": "./index.es2017.js",
+  "unpkg": "./cdn.js"
+}

package/dist/types/components/@deprecated/input/controller.d.ts

@@ -0,0 +1,36 @@
+import { Generic } from '@public-ui/core';
+import { ButtonProps } from '../../../types/button-link';
+import { InputTypeOnDefault } from '../../../types/input/types';
+import { ControlledInputController } from '../../input-adapter-leanup/controller';
+import { KoliBriInputIcon } from '../../input-text/types';
+import { Props, Watches } from './types';
+import { Props as AdapterProps } from '../../input-adapter-leanup/types';
+import { Stringified } from '../../../types/common';
+export declare class InputController extends ControlledInputController implements Watches {
+  protected readonly component: Generic.Element.Component & Props & AdapterProps;
+  hideLabel: boolean;
+  constructor(component: Generic.Element.Component & Props, name: string);
+  validateAccessKey(value?: string): void;
+  validateDisabled(value?: boolean): void;
+  validateError(value?: string): void;
+  validateHideLabel(value?: boolean): void;
+  validateHint(value?: string): void;
+  validateIcon(value?: Stringified<KoliBriInputIcon>): void;
+  validateId(value?: string): void;
+  validateName(value?: string): void;
+  validateOn(value?: InputTypeOnDefault): void;
+  validateSmartButton(value?: ButtonProps | string): void;
+  validateTabIndex(value?: number): void;
+  componentWillLoad(): void;
+  protected onBlur(event: Event): void;
+  protected onChange(event: Event): void;
+  protected onClick(event: Event): void;
+  protected onFocus(event: Event): void;
+  setValue(event: Event, value: string | number | boolean): void;
+  readonly onFacade: {
+    onBlur: (event: Event) => void;
+    onChange: (event: Event) => void;
+    onClick: (event: Event) => void;
+    onFocus: (event: Event) => void;
+  };
+}

package/dist/types/components/@deprecated/input/types.d.ts

@@ -0,0 +1,22 @@
+import { Generic } from '@public-ui/core';
+import { ButtonProps } from '../../../types/button-link';
+import { Stringified } from '../../../types/common';
+import { InputTypeOnDefault } from '../../../types/input/types';
+import { KoliBriInputIcon } from '../../input-text/types';
+declare type RequiredProps = unknown;
+declare type OptionalProps = {
+  accessKey: string;
+  disabled: boolean;
+  error: string;
+  hideLabel: boolean;
+  hint: string;
+  icon: Stringified<KoliBriInputIcon>;
+  id: string;
+  name: string;
+  on: InputTypeOnDefault;
+  smartButton: ButtonProps;
+  tabIndex: number;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+export declare type Watches = Generic.Element.Watchers<RequiredProps, OptionalProps>;
+export {};

package/dist/types/components/@else/all/component.d.ts

@@ -0,0 +1,12 @@
+import { JSX } from '../../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+declare type RequiredProps = unknown;
+declare type OptionalProps = unknown;
+declare type RequiredStates = RequiredProps & OptionalProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolAll implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  state: States;
+  render(): JSX.Element;
+}
+export {};

package/dist/types/components/@else/color/component.d.ts

@@ -0,0 +1,5 @@
+import { JSX } from '../../../stencil-public-runtime';
+export declare class KolColor {
+  private selectedColor;
+  render(): JSX.Element;
+}

package/dist/types/components/@else/counter/component.d.ts

@@ -0,0 +1,9 @@
+import { JSX } from '../../../stencil-public-runtime';
+export declare class KolCounter {
+  state: {
+    _count: number;
+  };
+  private inc;
+  private dec;
+  render(): JSX.Element;
+}

package/dist/types/components/abbr/component.d.ts

@@ -0,0 +1,23 @@
+import { Generic } from '@public-ui/core';
+import { JSX } from '../../stencil-public-runtime';
+import { TooltipAlignment } from '../tooltip/component';
+declare type RequiredProps = {
+  title: string;
+};
+declare type OptionalProps = {
+  tooltipAlign: TooltipAlignment;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps & OptionalProps;
+declare type OptionalStates = unknown;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolAbbr implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  _tooltipAlign?: TooltipAlignment;
+  _title: string;
+  state: States;
+  validateTitle(value?: string): void;
+  validateTooltipAlign(value?: TooltipAlignment): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/abbr/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getAbbrHtml: (props: Props) => string;

package/dist/types/components/accordion/component.d.ts

@@ -0,0 +1,38 @@
+import { Generic } from '@public-ui/core';
+import { JSX } from '../../stencil-public-runtime';
+import { Events } from '../../enums/events';
+import { EventValueCallback } from '../../types/callbacks';
+import { HeadingLevel } from '../../types/heading-level';
+export declare type KoliBriAccordionCallbacks = {
+  [Events.onClick]?: EventValueCallback<Event, boolean>;
+};
+declare type RequiredProps = {
+  heading: string;
+};
+declare type OptionalProps = {
+  level: HeadingLevel;
+  open: boolean;
+  on: KoliBriAccordionCallbacks;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolAccordion implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private buttonRef?;
+  private catchAriaExpanded;
+  private triggerAriaExpanded;
+  render(): JSX.Element;
+  _heading: string;
+  _level?: HeadingLevel;
+  _on?: KoliBriAccordionCallbacks;
+  _open?: boolean;
+  state: States;
+  validateHeading(value?: string): void;
+  validateLevel(value?: HeadingLevel): void;
+  validateOn(value?: KoliBriAccordionCallbacks): void;
+  validateOpen(value?: boolean): void;
+  componentWillLoad(): void;
+  private onClick;
+}
+export {};

package/dist/types/components/accordion/test/html.mock.d.ts

@@ -0,0 +1,6 @@
+import { Props } from '../component';
+export declare const getAccordionHtml: (props: Props, slots?: {
+  header?: string;
+  content?: string;
+  footer?: string;
+}) => string;

package/dist/types/components/alert/component.d.ts

@@ -0,0 +1,40 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { AlertType, AlertVariant, KoliBriAlertEventCallbacks } from '../../types/alert';
+import { HeadingLevel } from '../../types/heading-level';
+declare type RequiredProps = unknown;
+declare type OptionalProps = {
+  alert: boolean;
+  hasCloser: boolean;
+  heading: string;
+  level: HeadingLevel;
+  on: KoliBriAlertEventCallbacks;
+  type: AlertType;
+  variant: AlertVariant;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolAlert implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private readonly close;
+  private readonly on;
+  render(): JSX.Element;
+  _alert?: boolean;
+  _hasCloser?: boolean;
+  _heading?: string;
+  _level?: HeadingLevel;
+  _on?: KoliBriAlertEventCallbacks;
+  _type?: AlertType;
+  _variant?: AlertVariant;
+  state: States;
+  validateAlert(value?: boolean): void;
+  validateHasCloser(value?: boolean): void;
+  validateHeading(value?: string): void;
+  validateLevel(value?: HeadingLevel): void;
+  validateOn(value?: KoliBriAlertEventCallbacks): void;
+  validateType(value?: AlertType): void;
+  validateVariant(value?: AlertVariant): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/alert/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getAlertHtml: (props: Props, innerHTML?: string, additionalHTML?: string) => string;

package/dist/types/components/badge/color-rgba.d.ts

@@ -0,0 +1 @@
+import rgba from"color-rgba";export{rgba as colorRgba};

package/dist/types/components/badge/component.d.ts

@@ -0,0 +1,47 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { Alignment } from '../../types/icon';
+import { Icofont } from '../../types/icofont';
+export declare type KoliBriColor = {
+  backgroundColor: string;
+  color: string;
+};
+declare type RequiredProps = {
+  label: string;
+};
+declare type OptionalProps = {
+  color: string | KoliBriColor;
+  icon: Icofont;
+  iconAlign: Alignment;
+  iconOnly: boolean;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = {
+  color: string | KoliBriColor;
+  label: string;
+};
+declare type OptionalStates = {
+  icon: Icofont;
+  iconAlign: Alignment;
+  iconOnly: boolean;
+};
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolBadge implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private bgColorStr;
+  private colorStr;
+  render(): JSX.Element;
+  _color?: string | KoliBriColor;
+  _icon?: Icofont;
+  _iconAlign?: Alignment;
+  _iconOnly?: boolean;
+  _label: string;
+  state: States;
+  private handleColorChange;
+  validateColor(value?: string | KoliBriColor): void;
+  validateIcon(value?: Icofont): void;
+  validateIconAlign(value?: Alignment): void;
+  validateIconOnly(value?: boolean): void;
+  validateLabel(value?: string): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/badge/contrast.d.ts

@@ -0,0 +1,9 @@
+import { RGB } from 'color-convert/conversions';
+export declare const getContrastYIQ: (r: number, g: number, b: number) => number;
+export declare const calcContrastColor: (baseColor: RGB, contrastColor: RGB, ratio: number, dir?: number) => RGB;
+export declare const getContrastColor: (baseColor: RGB, contrastcolor: RGB, ratio: number, dir?: number) => RGB;
+export declare type KoliBriContrastColor = {
+  baseColor: string;
+  contrastColor: string;
+};
+export declare const createContrastColorPair: (color: string | KoliBriContrastColor, contrastRatio?: number) => KoliBriContrastColor;

package/dist/types/components/badge/rgba-convert.d.ts

@@ -0,0 +1 @@
+import rgba from"rgba-convert";export{rgba as rgbaConvert};

package/dist/types/components/badge/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getBadgeHtml: (props: Props, additionalAttrs?: string) => string;

package/dist/types/components/breadcrumb/component.d.ts

@@ -0,0 +1,26 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { Stringified } from '../../types/common';
+import { NavLinkProps } from '../link/component';
+declare type RequiredProps = {
+  ariaLabel: string;
+  links: Stringified<NavLinkProps[]>;
+};
+declare type OptionalProps = unknown;
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = {
+  ariaLabel: string;
+  links: NavLinkProps[];
+};
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolBreadcrumb implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  _ariaLabel: string;
+  _links: Stringified<NavLinkProps[]>;
+  state: States;
+  validateAriaLabel(value?: string): void;
+  validateLinks(value?: Stringified<NavLinkProps[]>): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/breadcrumb/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getBreadcrumbHtml: (props: Props) => string;

package/dist/types/components/button/component.d.ts

@@ -0,0 +1,52 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { AriaCurrent, ButtonStates, KoliBriButtonCallbacks, KoliBriButtonLinkShowAs, KoliBriButtonType, KoliBriButtonVariant, OptionalButtonProps, OptionalButtonStates, RequiredButtonProps, RequiredButtonStates } from '../../types/button-link';
+import { Alignment, KoliBriIconProp } from '../../types/icon';
+import { TooltipAlignment } from '../tooltip/component';
+export declare class KolButtonWc implements Generic.Element.ComponentApi<RequiredButtonProps, OptionalButtonProps, RequiredButtonStates, OptionalButtonStates> {
+  private host?;
+  private readonly nonce;
+  forwardedRef?: HTMLButtonElement;
+  ref?: HTMLButtonElement;
+  private readonly catchHost;
+  private readonly catchRef;
+  private readonly onClick;
+  render(): JSX.Element;
+  getInteractiveElementRef(): Promise<HTMLButtonElement | undefined>;
+  _accessKey?: string;
+  _ariaControls?: string;
+  _ariaCurrent?: AriaCurrent;
+  _ariaExpanded?: boolean;
+  _ariaLabel?: string;
+  _customClass?: string;
+  _disabled?: boolean;
+  _icon?: KoliBriIconProp;
+  _iconAlign?: Alignment;
+  _iconOnly?: boolean;
+  _id?: string;
+  _label: string;
+  _on?: KoliBriButtonCallbacks;
+  _showAs?: KoliBriButtonLinkShowAs;
+  _tooltipAlign?: TooltipAlignment;
+  _type?: KoliBriButtonType;
+  _variant?: KoliBriButtonVariant;
+  state: ButtonStates;
+  validateAccessKey(value?: string): void;
+  validateAriaControls(value?: string): void;
+  validateAriaCurrent(value?: AriaCurrent): void;
+  validateAriaExpanded(value?: boolean): void;
+  validateAriaLabel(value?: string): void;
+  validateCustomClass(value?: string): void;
+  validateDisabled(value?: boolean): void;
+  validateIcon(value?: KoliBriIconProp): void;
+  validateIconAlign(value?: Alignment): void;
+  validateIconOnly(value?: boolean): void;
+  validateId(value?: string): void;
+  validateLabel(value?: string): void;
+  validateOn(value?: KoliBriButtonCallbacks): void;
+  validateShowAs(value?: KoliBriButtonLinkShowAs): void;
+  validateTooltipAlign(value?: TooltipAlignment): void;
+  validateType(value?: KoliBriButtonType): void;
+  validateVariant(value?: KoliBriButtonVariant): void;
+  componentWillLoad(): void;
+}

package/dist/types/components/button/controller.d.ts

@@ -0,0 +1,5 @@
+import { Generic } from '@public-ui/core';
+import { KoliBriButtonType, KoliBriButtonVariant } from '../../types/button-link';
+export declare const syncAriaLabelBeforePatch: Generic.Element.NextStateHooksCallback;
+export declare const watchButtonType: (component: Generic.Element.Component, propName: string, value?: KoliBriButtonType) => void;
+export declare const watchButtonVariant: (component: Generic.Element.Component, propName: string, value?: KoliBriButtonVariant) => void;

package/dist/types/components/button/shadow.d.ts

@@ -0,0 +1,29 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { AriaCurrent, KoliBriButtonCallbacks, KoliBriButtonLinkShowAs, KoliBriButtonType, KoliBriButtonVariant, OptionalButtonProps, RequiredButtonProps } from '../../types/button-link';
+import { Alignment, KoliBriIconProp } from '../../types/icon';
+import { TooltipAlignment } from '../tooltip/component';
+export declare class KolButton implements Generic.Element.Members<RequiredButtonProps, OptionalButtonProps> {
+  forwardedRef?: HTMLKolButtonWcElement;
+  ref?: HTMLKolButtonWcElement;
+  private readonly catchRef;
+  getInteractiveElementRef(): Promise<HTMLButtonElement | undefined>;
+  render(): JSX.Element;
+  _accessKey?: string;
+  _ariaControls?: string;
+  _ariaCurrent?: AriaCurrent;
+  _ariaExpanded?: boolean;
+  _ariaLabel?: string;
+  _customClass?: string;
+  _disabled?: boolean;
+  _icon?: KoliBriIconProp;
+  _iconAlign?: Alignment;
+  _iconOnly?: boolean;
+  _id?: string;
+  _label: string;
+  _on?: KoliBriButtonCallbacks;
+  _showAs?: KoliBriButtonLinkShowAs;
+  _tooltipAlign?: TooltipAlignment;
+  _type?: KoliBriButtonType;
+  _variant?: KoliBriButtonVariant;
+}

package/dist/types/components/button-group/component.d.ts

@@ -0,0 +1,12 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+declare type RequiredProps = unknown;
+declare type OptionalProps = unknown;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolButtonGroup implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  state: States;
+}
+export {};

package/dist/types/components/card/component.d.ts

@@ -0,0 +1,29 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { HeadingLevel } from '../../types/heading-level';
+declare type RequiredProps = {
+  heading: string;
+};
+declare type OptionalProps = {
+  hasFooter: boolean;
+  headline: string;
+  level: HeadingLevel;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolCard implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  _hasFooter?: boolean;
+  _heading: string;
+  _headline?: string;
+  _level?: HeadingLevel;
+  state: States;
+  validateHasFooter(value?: boolean): void;
+  validateHeading(value?: string): void;
+  validateHeadline(value?: string): void;
+  validateLevel(value?: HeadingLevel): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/card/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getCardHtml: (props: Props) => string;

package/dist/types/components/component-list.d.ts

@@ -0,0 +1,9 @@
+import { KolButtonGroup } from './button-group/component';
+import { KolButton } from './button/shadow';
+import { KolHeading } from './heading/shadow';
+import { KolIconFontAwesome } from './icon-font-awesome/component';
+import { KolIconIcofont } from './icon-icofont/component';
+import { KolInputRadioGroup } from './input-radio-group/component';
+import { KolInput } from './input/component';
+import { KolLink } from './link/shadow';
+export declare const COMPONENTS: (typeof KolButtonGroup | typeof KolButton | typeof KolHeading | typeof KolIconFontAwesome | typeof KolIconIcofont | typeof KolInputRadioGroup | typeof KolInput | typeof KolLink)[];

package/dist/types/components/details/component.d.ts

@@ -0,0 +1,24 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+declare type RequiredProps = {
+  summary: string;
+};
+declare type OptionalProps = {
+  open: boolean;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolDetails implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private htmlDetailsElement?;
+  render(): JSX.Element;
+  _open?: boolean;
+  _summary: string;
+  state: States;
+  validateOpen(value?: boolean): void;
+  validateSummary(value?: string): void;
+  componentWillLoad(): void;
+  private onClick;
+}
+export {};

package/dist/types/components/details/test/html.mock.d.ts

@@ -0,0 +1,4 @@
+import { Props } from '../component';
+export declare const getDetailsHtml: (props: Props, slots?: {
+  default?: string;
+}) => string;

package/dist/types/components/form/component.d.ts

@@ -0,0 +1,30 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Events } from '../../enums/events';
+import { Generic } from '@public-ui/core';
+import { EventCallback } from '../../types/callbacks';
+import { Stringified } from '../../types/common';
+export declare type KoliBriFormCallbacks = {
+  [Events.onSubmit]?: EventCallback<SubmitEvent>;
+  [Events.onReset]?: EventCallback<Event>;
+};
+declare type RequiredProps = unknown;
+declare type OptionalProps = {
+  on: KoliBriFormCallbacks;
+  requiredText: string | boolean;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolForm implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private readonly onSubmit;
+  private readonly onReset;
+  render(): JSX.Element;
+  _on?: KoliBriFormCallbacks;
+  _requiredText?: Stringified<boolean>;
+  state: States;
+  validateOn(value?: KoliBriFormCallbacks): void;
+  validateRequiredText(value?: Stringified<boolean>): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/form/controller.d.ts

@@ -0,0 +1,8 @@
+export declare const propergateResetEventToForm: (options?: {
+  form?: HTMLElement | ParentNode | null;
+  ref?: HTMLElement;
+}) => void;
+export declare const propergateSubmitEventToForm: (options?: {
+  form?: HTMLElement | ParentNode | null;
+  ref?: HTMLElement;
+}) => void;

package/dist/types/components/form/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getFormHtml: (props: Props) => string;

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

@@ -0,0 +1,19 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { HeadingLevel } from '../../types/heading-level';
+declare type RequiredProps = unknown;
+declare type OptionalProps = {
+  level: HeadingLevel;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolHeadingWc implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  _level?: HeadingLevel;
+  state: States;
+  validateLevel(value?: HeadingLevel): void;
+  componentWillLoad(): void;
+  render(): JSX.Element;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { JSX } from '../../stencil-public-runtime';
+import { HeadingLevel } from '../../types/heading-level';
+import { Props } from './component';
+export declare class KolHeading implements Props {
+  render(): JSX.Element;
+  _level?: HeadingLevel;
+}

package/dist/types/components/heading/test/html.mock.d.ts

@@ -0,0 +1,7 @@
+import { Props } from '../component';
+export declare const getHeadingWcHtml: (props: Props, slots?: {
+  default?: string;
+}, additionalAttrs?: string) => string;
+export declare const getHeadingHtml: (props: Props, slots?: {
+  default?: string;
+}, additionalAttrs?: string) => string;

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

@@ -0,0 +1,2 @@
+import { Generic } from '@public-ui/core';
+export declare const watchHeadingLevel: (component: Generic.Element.Component, value?: number) => void;

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

@@ -0,0 +1,25 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { AriaLabel } from '../../types/aria-label';
+declare type RequiredProps = AriaLabel & {
+  icon: string;
+};
+declare type OptionalProps = {
+  part: string;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolIcon implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  _ariaLabel: string;
+  _icon: string;
+  _part?: string;
+  state: States;
+  validateAriaLabel(value?: string): void;
+  validateIcon(value?: string): void;
+  validatePart(value?: string): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/icon/test/html.mock.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '../component';
+export declare const getIconHtml: (props: Props, additionalAttrs?: string) => string;