@public-ui/components 1.1.7-rc.10

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

@@ -0,0 +1,61 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { AriaCurrent, KoliBriButtonLinkShowAs, LinkOnCallbacks, LinkStates, LinkTarget, LinkUseCase, OptionalLinkProps, OptionalLinkStates, RequiredLinkProps, RequiredLinkStates } from '../../types/button-link';
+import { Alignment, KoliBriIconProp } from '../../types/icon';
+import { TooltipAlignment } from '../tooltip/component';
+declare type RequiredNavLinkProps = RequiredLinkProps & unknown;
+declare type OptionalNavLinkProps = OptionalLinkProps & {
+  active: boolean;
+  label?: string;
+};
+export declare type NavLinkProps = Generic.Element.Members<RequiredNavLinkProps, OptionalNavLinkProps>;
+export declare class KolLinkWc implements Generic.Element.ComponentApi<RequiredLinkProps, OptionalLinkProps, RequiredLinkStates, OptionalLinkStates> {
+  private readonly nonce;
+  private readonly getRenderValues;
+  render(): JSX.Element;
+  _ariaControls?: string;
+  _ariaCurrent?: AriaCurrent;
+  _ariaExpanded?: boolean;
+  _ariaLabel?: string;
+  _ariaSelected?: boolean;
+  _disabled?: boolean;
+  _fill?: boolean;
+  _href?: string;
+  _icon?: KoliBriIconProp;
+  _iconAlign?: Alignment;
+  _iconOnly?: boolean;
+  _on?: LinkOnCallbacks;
+  _part?: string;
+  _selector?: string;
+  _showAs?: KoliBriButtonLinkShowAs;
+  _stealth?: boolean;
+  _target?: LinkTarget;
+  _targetDescription?: string;
+  _tooltipAlign?: TooltipAlignment;
+  _underline?: boolean;
+  _useCase?: LinkUseCase;
+  state: LinkStates;
+  validateAriaControls(value?: string): void;
+  validateAriaCurrent(value?: AriaCurrent): void;
+  validateAriaExpanded(value?: boolean): void;
+  validateAriaLabel(value?: string): void;
+  validateAriaSelected(value?: boolean): void;
+  validateDisabled(value?: boolean): void;
+  validateFill(value?: boolean): void;
+  validateHref(value?: string): void;
+  validateIcon(value?: KoliBriIconProp): void;
+  validateIconAlign(value?: Alignment): void;
+  validateIconOnly(value?: boolean): void;
+  validateSelector(value?: string): void;
+  validateShowAs(value?: KoliBriButtonLinkShowAs): void;
+  validateStealth(value?: boolean): void;
+  validateTarget(value?: LinkTarget): void;
+  validateTargetDescription(value?: string): void;
+  validateUnderline(value?: boolean): void;
+  validateUseCase(value?: LinkUseCase): void;
+  validatePart(value?: string): void;
+  validateTooltipAlign(value?: TooltipAlignment): void;
+  validateOn(value?: LinkOnCallbacks): void;
+  componentWillLoad(): void;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Alignment, KoliBriIconProp } from '../../types/icon';
+import { Generic } from '@public-ui/core';
+import { AriaCurrent, KoliBriButtonLinkShowAs, LinkOnCallbacks, LinkTarget, LinkUseCase, OptionalLinkProps, RequiredLinkProps } from '../../types/button-link';
+import { TooltipAlignment } from '../tooltip/component';
+export declare class KolLink implements Generic.Element.Members<RequiredLinkProps, OptionalLinkProps> {
+  render(): JSX.Element;
+  _ariaControls?: string;
+  _ariaCurrent?: AriaCurrent;
+  _ariaExpanded?: boolean;
+  _ariaLabel?: string;
+  _ariaSelected?: boolean;
+  _disabled?: boolean;
+  _fill?: boolean;
+  _href?: string;
+  _icon?: KoliBriIconProp;
+  _iconAlign?: Alignment;
+  _iconOnly?: boolean;
+  _on?: LinkOnCallbacks;
+  _part?: string;
+  _selector?: string;
+  _showAs?: KoliBriButtonLinkShowAs;
+  _stealth?: boolean;
+  _target?: LinkTarget;
+  _targetDescription?: string;
+  _tooltipAlign?: TooltipAlignment;
+  _underline?: boolean;
+  _useCase?: LinkUseCase;
+}

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

@@ -0,0 +1,2 @@
+import { LinkProps } from '../../../types/button-link';
+export declare const getLinkHtml: (props: LinkProps, innerHTML?: string) => string;

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

@@ -0,0 +1,52 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { Orientation } from '../../types/orientation';
+import { HeadingLevel } from '../../types/heading-level';
+import { NavLinkProps } from '../link/component';
+import { Stringified } from '../../types/common';
+export declare type ListStyleType = 'disc' | 'circle' | 'square' | 'none' | 'decimal' | 'decimal-leading-zero' | 'lower-alpha' | 'lower-greek' | 'lower-latin' | 'lower-roman' | 'upper-alpha' | 'upper-latin' | 'upper-roman';
+declare type RequiredProps = {
+  ariaLabel: string;
+  links: Stringified<NavLinkProps[]>;
+};
+declare type OptionalProps = {
+  heading: string;
+  level: HeadingLevel;
+  listStyleType: ListStyleType;
+  ordered: boolean;
+  orientation: Orientation;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = {
+  ariaLabel: string;
+  links: NavLinkProps[];
+  listStyleType: ListStyleType;
+  orientation: Orientation;
+};
+declare type OptionalStates = {
+  heading: string;
+  level: HeadingLevel;
+  ordered: boolean;
+};
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolLinkGroup implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  private isUl;
+  _ariaLabel: string;
+  _listStyleType?: ListStyleType;
+  _heading?: string;
+  _level?: HeadingLevel;
+  _links: Stringified<NavLinkProps[]>;
+  _ordered?: boolean;
+  _orientation?: Orientation;
+  state: States;
+  validateAriaLabel(value?: string): void;
+  validateListStyleType(value?: ListStyleType): void;
+  validateHeading(value?: string): void;
+  validateLevel(value?: HeadingLevel): void;
+  validateLinks(value?: Stringified<NavLinkProps[]>): void;
+  validateOrdered(value?: boolean): void;
+  validateOrientation(value?: Orientation): void;
+  componentWillLoad(): void;
+}
+export {};

package/dist/types/components/link-group/test/html.mock.d.ts

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

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

@@ -0,0 +1,22 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Bundesamt, Bundesanstalt, Bundesministerium } from '../../enums/bund';
+import { Generic } from '@public-ui/core';
+declare type RequiredProps = {
+  org: Bundesministerium | Bundesamt | Bundesanstalt;
+};
+declare type OptionalProps = {
+  abbr: Bundesministerium | Bundesamt | Bundesanstalt;
+};
+declare type RequiredStates = RequiredProps;
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolLogo implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  _abbr?: Bundesministerium | Bundesamt | Bundesanstalt;
+  _org: Bundesministerium | Bundesamt | Bundesanstalt;
+  state: States;
+  validateAbbr(value?: Bundesministerium | Bundesamt | Bundesanstalt): void;
+  validateOrg(value?: Bundesministerium | Bundesamt | Bundesanstalt): void;
+  componentWillLoad(): void;
+  render(): JSX.Element;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { AriaLabel } from '../../types/aria-label';
+import { KoliBriModalEventCallbacks } from '../../types/modal';
+declare type RequiredProps = AriaLabel;
+declare type OptionalProps = {
+  activeElement: HTMLElement | null;
+  on: KoliBriModalEventCallbacks;
+  width: string;
+  show: boolean;
+};
+declare type RequiredStates = AriaLabel & {
+  activeElement: HTMLElement | null;
+  width: string;
+};
+declare type OptionalStates = {
+  on: KoliBriModalEventCallbacks;
+  show: boolean;
+};
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolModal implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private hostElement?;
+  componentDidRender(): void;
+  disconnectedCallback(): void;
+  private readonly onKeyDown;
+  render(): JSX.Element;
+  _activeElement?: HTMLElement | null;
+  _ariaLabel: string;
+  _width?: string;
+  _on?: KoliBriModalEventCallbacks;
+  _show?: boolean;
+  state: States;
+  validateActiveElement(value?: HTMLElement | null): void;
+  validateAriaLabel(value?: string): void;
+  validateOn(value?: KoliBriModalEventCallbacks): void;
+  validateShow(value?: boolean): void;
+  validateWidth(value?: string): void;
+  componentWillLoad(): void;
+}
+export {};

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

@@ -0,0 +1,11 @@
+export declare class ModalService {
+  private lockedElements;
+  private modalStack;
+  private lockElement;
+  private unlockElement;
+  private unlockLockedElements;
+  private lockFocus;
+  private renderModalIfExists;
+  openModal(modalRef: HTMLElement, activeElement?: HTMLElement): void;
+  closeModal(modalRef: HTMLElement): void;
+}

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

@@ -0,0 +1,56 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { Orientation } from '../../types/orientation';
+import { NavLinkProps } from '../link/component';
+import { Stringified } from '../../types/common';
+export declare type NavLinkWithChildrenProps = NavLinkProps & {
+  _children?: NavLinkWithChildrenProps[];
+};
+export declare type KoliBriNavVariant = 'primary' | 'secondary';
+declare type RequiredProps = {
+  ariaLabel: string;
+  links: Stringified<NavLinkWithChildrenProps[]>;
+};
+declare type OptionalProps = {
+  collapsible: boolean;
+  compact: boolean;
+  hasCompactButton: boolean;
+  orientation: Orientation;
+  variant: KoliBriNavVariant;
+};
+declare type RequiredStates = {
+  ariaLabel: string;
+  collapsible: boolean;
+  hasCompactButton: boolean;
+  links: NavLinkWithChildrenProps[];
+  orientation: Orientation;
+  variant: KoliBriNavVariant;
+};
+declare type OptionalStates = {
+  compact: boolean;
+};
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolNav implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private readonly onClick;
+  private readonly hasActiveChild;
+  private linkList;
+  render(): JSX.Element;
+  _ariaLabel: string;
+  _collapsible?: boolean;
+  _compact?: boolean;
+  _hasCompactButton?: boolean;
+  _orientation?: Orientation;
+  _links: Stringified<NavLinkWithChildrenProps[]>;
+  _variant?: KoliBriNavVariant;
+  state: States;
+  validateAriaLabel(value?: string): void;
+  validateCollapsible(value?: boolean): void;
+  validateCompact(value?: boolean): void;
+  validateHasCompactButton(value?: boolean): void;
+  validateLinks(value?: Stringified<NavLinkWithChildrenProps[]>): void;
+  validateOrientation(value?: Orientation): void;
+  validateVariant(value?: KoliBriNavVariant): void;
+  componentWillLoad(): void;
+  disconnectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { Generic } from '@public-ui/core';
+import { Stringified } from '../../types/common';
+import { NavLinkProps } from '../link/component';
+export declare const watchNavLinks: (className: string, component: Generic.Element.Component & {
+  state: {
+    _links: NavLinkProps[];
+  };
+}, value?: Stringified<NavLinkProps[]>) => void;

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

@@ -0,0 +1,83 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { KoliBriButtonVariant, KoliBriButtonVariantCustomClass } from '../../types/button-link';
+import { TooltipAlignment } from '../tooltip/component';
+import { KoliBriPaginationButtonCallbacks } from './types';
+import { Stringified } from '../../types/common';
+import { Option } from '../../types/input/types';
+export declare type PaginationHasButton = {
+  first: boolean;
+  last: boolean;
+  next: boolean;
+  previous: boolean;
+};
+export declare type RequiredProps = {
+  on: KoliBriPaginationButtonCallbacks;
+  page: number;
+  total: number;
+};
+export declare type OptionalProps = KoliBriButtonVariantCustomClass & {
+  boundaryCount: number;
+  hasButtons: boolean | Stringified<PaginationHasButton>;
+  pageSize: number;
+  pageSizeOptions: Stringified<number[]>;
+  siblingCount: number;
+  tooltipAlign: TooltipAlignment;
+};
+declare type RequiredStates = {
+  boundaryCount: number;
+  hasButtons: PaginationHasButton;
+  page: number;
+  pageSize: number;
+  pageSizeOptions: Option<number>[];
+  on: KoliBriPaginationButtonCallbacks;
+  siblingCount: number;
+  total: number;
+};
+declare type OptionalStates = KoliBriButtonVariantCustomClass & {
+  tooltipAlign: TooltipAlignment;
+};
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolPagination implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private readonly nonce;
+  private readonly calcCount;
+  private readonly getCount;
+  render(): JSX.Element;
+  _boundaryCount?: number;
+  _customClass?: string;
+  _hasButtons?: boolean | Stringified<PaginationHasButton>;
+  _page: number;
+  _pageSize: number;
+  _pageSizeOptions: Stringified<number[]>;
+  _on: KoliBriPaginationButtonCallbacks;
+  _siblingCount?: number;
+  _tooltipAlign?: TooltipAlignment;
+  _total: number;
+  _variant?: KoliBriButtonVariant;
+  state: States;
+  private onClick;
+  private onChangePage;
+  private onChangePageSize;
+  private readonly onGoToFirst;
+  private readonly onGoToEnd;
+  private readonly onGoBackward;
+  private readonly onGoForward;
+  private getUnselectedPageButton;
+  private getSelectedPageButton;
+  validateBoundaryCount(value?: number): void;
+  validateCustomClass(value?: string): void;
+  validateHasButtons(value?: string | boolean | Stringified<PaginationHasButton>): void;
+  validateOn(value?: KoliBriPaginationButtonCallbacks): void;
+  validatePage(value?: number): void;
+  private beforePageSize;
+  private syncPage;
+  private beforePageSizeOptions;
+  validatePageSize(value?: number): void;
+  validatePageSizeOptions(value?: Stringified<number[]>): void;
+  validateSiblingCount(value?: number): void;
+  validateTotal(value?: number): void;
+  validateTooltipAlign(value?: TooltipAlignment): void;
+  validateVariant(value?: KoliBriButtonVariant): void;
+  componentWillLoad(): void;
+}
+export {};

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

@@ -0,0 +1,7 @@
+import { Events } from '../../enums/events';
+import { EventValueCallback } from '../../types/callbacks';
+export declare type KoliBriPaginationButtonCallbacks = {
+  [Events.onClick]?: EventValueCallback<Event, number>;
+  onChangePage?: EventValueCallback<Event, number>;
+  onChangePageSize?: EventValueCallback<Event, number>;
+};

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

@@ -0,0 +1,32 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { KoliBriProgressType } from '../../types/progress';
+declare type RequiredProps = {
+  max: number;
+  value: number;
+};
+declare type OptionalProps = {
+  type: KoliBriProgressType;
+  unit: string;
+};
+declare type RequiredStates = RequiredProps & {
+  liveValue: number;
+};
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolProcess implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  private interval?;
+  render(): JSX.Element;
+  _max: number;
+  _type?: KoliBriProgressType;
+  _unit?: string;
+  _value: number;
+  state: States;
+  validateMax(value?: number): void;
+  validateType(value?: KoliBriProgressType): void;
+  validateUnit(value?: string): void;
+  validateValue(value?: number): void;
+  componentWillLoad(): void;
+  disconnectedCallback(): void;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Stringified } from '../../types/common';
+import { InputTypeOnDefault, SelectOption } from '../../types/input/types';
+import { KoliBriInputIcon } from '../input-text/types';
+import { ComponentApi, States } from './types';
+export declare class KolSelect implements ComponentApi {
+  private htmlSelect?;
+  private renderOptgroup;
+  render(): JSX.Element;
+  private readonly controller;
+  _accessKey?: string;
+  _alert?: boolean;
+  _disabled?: boolean;
+  _error?: string;
+  _height?: string;
+  _hideLabel?: boolean;
+  _hint?: string;
+  _icon?: Stringified<KoliBriInputIcon>;
+  _id: string;
+  _list: Stringified<SelectOption<unknown>[]>;
+  _multiple?: boolean;
+  _name?: string;
+  _on?: InputTypeOnDefault;
+  _required?: boolean;
+  _size?: number;
+  _tabIndex?: number;
+  _touched?: boolean;
+  _value?: Stringified<unknown[]>;
+  state: States;
+  constructor();
+  validateAccessKey(value?: string): void;
+  validateAlert(value?: boolean): void;
+  validateDisabled(value?: boolean): void;
+  validateError(value?: string): void;
+  validateHeight(value?: string): void;
+  validateHideLabel(value?: boolean): void;
+  validateHint(value?: string): void;
+  validateIcon(value?: Stringified<KoliBriInputIcon>): void;
+  validateId(value?: string): void;
+  validateList(value?: Stringified<SelectOption<unknown>[]>): void;
+  validateMultiple(value?: boolean): void;
+  validateName(value?: string): void;
+  validateOn(value?: InputTypeOnDefault): void;
+  validateRequired(value?: boolean): void;
+  validateSize(value?: number): void;
+  validateTabIndex(value?: number): void;
+  validateTouched(value?: boolean): void;
+  validateValue(value?: Stringified<unknown[]>): void;
+  componentWillLoad(): void;
+  private onChange;
+}

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

@@ -0,0 +1,22 @@
+import { Generic } from '@public-ui/core';
+import { Stringified } from '../../types/common';
+import { Option, SelectOption } from '../../types/input/types';
+import { InputController } from '../@deprecated/input/controller';
+import { Props, Watches } from './types';
+export declare class SelectController extends InputController implements Watches {
+  protected readonly component: Generic.Element.Component & Props;
+  private onStateChange;
+  private readonly keyOptionMap;
+  constructor(component: Generic.Element.Component & Props, name: string);
+  readonly getOptionByKey: (key: string) => Option<unknown> | undefined;
+  private readonly isValueInOptions;
+  private readonly filterValuesInOptions;
+  private readonly beforePatchListValue;
+  validateHeight(value?: string): void;
+  validateList<T>(value?: SelectOption<T>[] | string): void;
+  validateMultiple(value?: boolean): void;
+  validateRequired(value?: boolean): void;
+  validateSize(value?: number): void;
+  validateValue(value?: Stringified<unknown[]>): void;
+  componentWillLoad(onChange?: (event: Event) => void): void;
+}

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

@@ -0,0 +1,54 @@
+import { Generic } from '@public-ui/core';
+import { Stringified } from '../../types/common';
+import { InputTypeOnDefault, SelectOption } from '../../types/input/types';
+import { InputRequiredProps, KoliBriInputIcon } from '../input-text/types';
+declare type RequiredProps = InputRequiredProps & {
+  list: Stringified<SelectOption<unknown>[]>;
+};
+declare type OptionalProps = {
+  accessKey: string;
+  alert: boolean;
+  disabled: boolean;
+  error: string;
+  height: string;
+  hideLabel: boolean;
+  hint: string;
+  icon: Stringified<KoliBriInputIcon>;
+  multiple: boolean;
+  name: string;
+  on: InputTypeOnDefault;
+  required: boolean;
+  size: number;
+  tabIndex: number;
+  touched: boolean;
+  value: Stringified<unknown[]>;
+};
+export declare type Props = Generic.Element.Members<RequiredProps, OptionalProps>;
+declare type RequiredStates = {
+  id: string;
+  list: SelectOption<unknown>[];
+  name: string;
+  value: unknown[];
+};
+declare type OptionalStates = {
+  accessKey: string;
+  alert: boolean;
+  disabled: boolean;
+  error: string;
+  height: string;
+  hideLabel: boolean;
+  hint: string;
+  icon: KoliBriInputIcon;
+  id: string;
+  multiple: boolean;
+  name: string;
+  on: InputTypeOnDefault;
+  required: boolean;
+  size: number;
+  tabIndex: number;
+  touched: boolean;
+};
+export declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare type Watches = Generic.Element.Watchers<RequiredProps, OptionalProps>;
+export declare type ComponentApi = Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates>;
+export {};

package/dist/types/components/skip-nav/component.d.ts

@@ -0,0 +1,25 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+import { NavLinkProps } from '../link/component';
+import { Stringified } from '../../types/common';
+declare type RequiredProps = {
+  ariaLabel: string;
+  links: Stringified<NavLinkProps[]>;
+};
+declare type OptionalProps = unknown;
+declare type RequiredStates = {
+  ariaLabel: string;
+  links: NavLinkProps[];
+};
+declare type OptionalStates = OptionalProps;
+declare type States = Generic.Element.Members<RequiredStates, OptionalStates>;
+export declare class KolSkipNav 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/spin/component.d.ts

@@ -0,0 +1,19 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+declare type RequiredProps = unknown;
+declare type OptionalProps = {
+  show: 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 KolSpin implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  _show?: boolean;
+  state: States;
+  private showToggled;
+  validateShow(value?: boolean): void;
+  componentWillLoad(): void;
+}
+export {};

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

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

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

@@ -0,0 +1,21 @@
+import { JSX } from '../../stencil-public-runtime';
+import { Generic } from '@public-ui/core';
+declare type RequiredProps = {
+  ariaLabel: string;
+  symbol: string;
+};
+declare type OptionalProps = unknown;
+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 KolSymbol implements Generic.Element.ComponentApi<RequiredProps, OptionalProps, RequiredStates, OptionalStates> {
+  render(): JSX.Element;
+  _ariaLabel: string;
+  _symbol: string;
+  state: States;
+  validateAriaLabel(value?: string): void;
+  validateSymbol(value?: string): void;
+  componentWillLoad(): void;
+}
+export {};

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

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