@dnb/eufemia 10.1.0 → 10.2.0

package/es/components/heading/Heading.d.ts

@@ -1,107 +1,90 @@
-import * as React from 'react';
-import type { SkeletonShow } from '../Skeleton';
-import type { SpacingProps } from '../space/types';
-type HeadingText = React.ReactNode | ((...args: any[]) => any);
-type HeadingSize =
-  | 'auto'
-  | 'xx-large'
-  | 'x-large'
-  | 'large'
-  | 'medium'
-  | 'basis'
-  | 'small'
-  | 'x-small';
-type HeadingLevel = number | string;
-type HeadingDebug = boolean | ((...args: any[]) => any);
-type HeadingDebugCounter = boolean | ((...args: any[]) => any);
-type HeadingReset = number | boolean;
-type HeadingChildren = React.ReactNode | ((...args: any[]) => any);
-export interface HeadingProps
-  extends Omit<React.HTMLProps<HTMLElement>, 'ref'>,
-    SpacingProps {
-  id?: string;
-  group?: string;
-
-  /**
-   * <em>(required)</em> a heading, can be text or React.Node.
-   */
-  text?: HeadingText;
-
-  /**
-   * Define the typography <a href="/uilib/typography/font-size">font-size</a> by a size <em>type</em>, e.g. `x-large`. Defaults to the predefined heading sizes.
-   */
-  size?: HeadingSize;
-  level?: HeadingLevel;
-
-  /**
-   * If set to `true`, the heading level will be incremented by 1.
-   */
-  increase?: boolean;
-
-  /**
-   * If set to `true`, the heading level will be decremented by 1.
-   */
-  decrease?: boolean;
-  up?: boolean;
-  down?: boolean;
-
-  /**
-   * If set to `true`, the heading will not be corrected and warnings will not be shown. Warnings do not show up in "production builds" else either.
-   */
-  skip_correction?: boolean;
-
-  /**
-   * If set to `true`, the content will have a prefix, showing the heading level.
-   */
-  debug?: HeadingDebug;
-
-  /**
-   * If set to `true`, the content will have both a prefix and a JSON log attached to both headings and level contexts.
-   */
-  debug_counter?: HeadingDebugCounter;
-  counter?: any;
-
-  /**
-   * If set to `true`, the heading last used level will be inherited. Also from inside a level context.
-   */
-  inherit?: boolean;
-
-  /**
-   * If set to `true`, the heading level will be reset to 2. You can give it a custom level if you need to, e.g. `reset(1)`.
-   */
-  reset?: HeadingReset;
-
-  /**
-   * If set to `true`, an overlaying skeleton with animation will be shown.
-   */
-  skeleton?: SkeletonShow;
-
-  /**
-   * Define what HTML element should be used. If you use, e.g. a `span`, then `role="heading"` and `aria-level` gets set. Defaults to semantic heading element.
-   */
-  element?: string;
-  class?: string;
-  className?: string;
-
-  /**
-   * <em>(required)</em> a heading, can be text or React.Node.
-   */
-  children?: HeadingChildren;
+/**
+ * Web Heading Component
+ *
+ */
+import React from 'react';
+import '../../shared/helpers';
+import HeadingProvider from './HeadingProvider';
+import { resetLevels, resetAllLevels, setNextLevel } from './HeadingHelpers';
+import { HeadingCounter, HeadingDebugCounter } from './HeadingCounter';
+import { SpacingProps } from '../space/types';
+import { SkeletonShow } from '../Skeleton';
+import { DynamicElement } from '../../shared/types';
+export declare const levelResolution: {
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+};
+export declare type HeadingSize = 'auto' | 'xx-large' | 'x-large' | 'large' | 'medium' | 'basis' | 'small' | 'x-small';
+export declare type HeadingLevel = '1' | '2' | '3' | '4' | '5' | '6' | 1 | 2 | 3 | 4 | 5 | 6;
+export declare type InternalHeadingLevel = number;
+export declare type HeadingProps = {
+    id?: string;
+    group?: string;
+    /**
+     * <em>(required)</em> a heading, can be text or React.Node.
+     */
+    text?: React.ReactNode;
+    /**
+     * Define the typography <a href="/uilib/typography/font-size">font-size</a> by a size <em>type</em>, e.g. `x-large`. Defaults to the predefined heading sizes.
+     */
+    size?: HeadingSize;
+    level?: HeadingLevel;
+    /**
+     * If set to `true`, the heading level will be incremented by 1.
+     */
+    increase?: boolean;
+    /**
+     * If set to `true`, the heading level will be decremented by 1.
+     */
+    decrease?: boolean;
+    up?: boolean;
+    down?: boolean;
+    /**
+     * If set to `true`, the heading will not be corrected and warnings will not be shown. Warnings do not show up in "production builds" else either.
+     */
+    skip_correction?: boolean;
+    /**
+     * If set to `true`, the content will have a prefix, showing the heading level.
+     */
+    debug?: boolean | (() => void);
+    /**
+     * If set to `true`, the content will have both a prefix and a JSON log attached to both headings and level contexts.
+     */
+    debug_counter?: HeadingDebugCounter;
+    counter?: HeadingCounter;
+    /**
+     * If set to `true`, the heading last used level will be inherited. Also from inside a level context.
+     */
+    inherit?: boolean;
+    /**
+     * If set to `true`, the heading level will be reset to 2. You can give it a custom level if you need to, e.g. `reset(1)`.
+     */
+    reset?: number | boolean;
+    /**
+     * If set to `true`, an overlaying skeleton with animation will be shown.
+     */
+    skeleton?: SkeletonShow;
+    /**
+     * Define what HTML element should be used. If you use, e.g. a `span`, then `role="heading"` and `aria-level` gets set. Defaults to semantic heading element.
+     */
+    element?: DynamicElement;
+};
+export declare type HeadingAllProps = HeadingProps & Omit<React.HTMLProps<HTMLElement>, 'size'> & SpacingProps;
+declare function Heading(props: HeadingAllProps): JSX.Element;
+declare namespace Heading {
+    var Level: typeof HeadingProvider;
+    var Increase: (props: HeadingStaticProps) => JSX.Element;
+    var Decrease: (props: HeadingStaticProps) => JSX.Element;
+    var Up: (props: HeadingStaticProps) => JSX.Element;
+    var Down: (props: HeadingStaticProps) => JSX.Element;
+    var Reset: (props: HeadingStaticProps) => JSX.Element;
+    var resetLevels: typeof import("./HeadingHelpers").resetLevels;
+    var setNextLevel: typeof import("./HeadingHelpers").setNextLevel;
 }
-export default class Heading extends React.Component<HeadingProps, any> {
-  static defaultProps: object;
-  static Level: (props: HeadingProps) => JSX.Element;
-  static Increase: (props: HeadingProps) => JSX.Element;
-  static Decrease: (props: HeadingProps) => JSX.Element;
-  static resetLevels: resetLevels;
-  static setNextLevel: setNextLevel;
-  render(): JSX.Element;
-}
-export const setNextLevel = (
-  level: HeadingLevel,
-  { overwriteContext: boolean } = {}
-) => null;
-export const resetLevels = (
-  level: HeadingLevel,
-  { overwriteContext: boolean } = {}
-) => null;
+export default Heading;
+declare type HeadingStaticProps = Omit<HeadingAllProps, 'ref' | 'size'>;
+export { resetAllLevels, resetLevels, setNextLevel };

package/es/components/heading/Heading.js

@@ -1,23 +1,22 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-const _excluded = ["text", "relevel", "group", "debug", "debug_counter", "reset", "skip_correction", "increase", "decrease", "up", "down", "inherit", "level", "size", "skeleton", "element", "class", "className", "children"];
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+const _excluded = ["text", "group", "debug", "debug_counter", "reset", "skip_correction", "increase", "decrease", "up", "down", "inherit", "level", "size", "skeleton", "element", "className", "children"];
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 import React from 'react';
-import PropTypes from 'prop-types';
 import classnames from 'classnames';
 import { isTrue, validateDOMAttributes } from '../../shared/component-helper';
 import '../../shared/helpers';
-import { spacingPropTypes, createSpacingClasses } from '../space/SpacingHelper';
+import { createSpacingClasses } from '../space/SpacingHelper';
 import HeadingContext from './HeadingContext';
 import Context from '../../shared/Context';
 import HeadingProvider from './HeadingProvider';
 import { createSkeletonClass } from '../skeleton/SkeletonHelper';
-import { correctHeadingLevel, resetLevels, resetAllLevels, setNextLevel, globalSyncCounter, globalHeadingCounter, windupHeadings, teardownHeadings, debugCounter } from './HeadingHelpers';
+import { correctInternalHeadingLevel, resetLevels, resetAllLevels, setNextLevel, globalSyncCounter, globalHeadingCounter, windupHeadings, teardownHeadings, debugCounter } from './HeadingHelpers';
 import { initCounter } from './HeadingCounter';
 export const levelResolution = {
   1: 'xx-large',
@@ -27,205 +26,138 @@ export const levelResolution = {
   5: 'small',
   6: 'x-small'
 };
-export default class Heading extends React.PureComponent {
-  static getDerivedStateFromProps(props, state) {
-    if (state._listenForPropChanges) {
-      const level = parseFloat(props.level);
-
-      if (state.prevLevel !== props.level && level > 0 && level !== state.level || props.relevel) {
-        var _state$context$headin, _state$context$headin2;
-
-        state.counter.skipMakeMeReady();
-        const {
-          level: newLevel
-        } = correctHeadingLevel({
-          counter: state.counter,
-          level,
-          bypassChecks: isTrue(props.skip_correction) || isTrue((_state$context$headin = state.context.heading) === null || _state$context$headin === void 0 ? void 0 : _state$context$headin.skip_correction),
-          source: props.text || props.children,
-          debug: props.debug || ((_state$context$headin2 = state.context.heading) === null || _state$context$headin2 === void 0 ? void 0 : _state$context$headin2.debug)
-        });
-        state.level = state.prevLevel = newLevel;
-      }
-    }
-
-    state._listenForPropChanges = true;
-    return state;
-  }
-
-  constructor(props, context) {
-    var _context$heading, _state$context$headin3, _state$context$headin4;
+export default function Heading(props) {
+  var _headingContext$headi2, _headingContext$headi3;
+
+  const context = React.useContext(Context);
+  const headingContext = React.useContext(HeadingContext);
+
+  const _ref = React.useRef();
+
+  const {
+    text,
+    group: _group,
+    debug: _debug,
+    debug_counter: _debug_counter,
+    reset: _reset,
+    skip_correction: _skip_correction,
+    increase: _increase,
+    decrease: _decrease,
+    up: _up,
+    down: _down,
+    inherit: _inherit,
+    level: _level,
+    size: _size = 'auto',
+    skeleton: _skeleton,
+    element: _element,
+    className,
+    children
+  } = props,
+        rest = _objectWithoutProperties(props, _excluded);
+
+  const [state, setState] = React.useState(() => {
+    var _headingContext$headi, _state$headingContext, _state$headingContext2, _state$headingContext3, _state$headingContext4;
 
-    super(props);
-    this._ref = React.createRef();
     const state = {
+      level: null,
+      counter: null,
       context,
-      _listenForPropChanges: true
+      headingContext
     };
-
-    if ((_context$heading = context.heading) !== null && _context$heading !== void 0 && _context$heading.counter) {
-      state.counter = initCounter(props);
-      state.counter.setContextCounter(context.heading.counter);
-      state.counter.isHeading = true;
-    } else {
-      state.counter = initCounter(props);
-      state.counter.setContextCounter(globalHeadingCounter.current);
-      state.counter.isHeading = true;
-    }
-
-    state.counter = correctHeadingLevel({
-      ref: props,
+    state.counter = initCounter(props);
+    const counter = (_headingContext$headi = headingContext.heading) !== null && _headingContext$headi !== void 0 && _headingContext$headi.counter ? headingContext.heading.counter : globalHeadingCounter.current;
+    state.counter.setContextCounter(counter);
+    state.counter.isHeading = true;
+    state.counter = correctInternalHeadingLevel({
       counter: state.counter,
-      level: parseFloat(props.level),
+      ref: props,
+      level: parseFloat(String(props.level)),
       inherit: isTrue(props.inherit),
       reset: props.reset,
       increase: isTrue(props.increase) || isTrue(props.up),
       decrease: isTrue(props.decrease) || isTrue(props.down),
-      bypassChecks: isTrue(props.skip_correction) || isTrue((_state$context$headin3 = state.context.heading) === null || _state$context$headin3 === void 0 ? void 0 : _state$context$headin3.skip_correction),
+      bypassChecks: isTrue(props.skip_correction) || isTrue((_state$headingContext = state.headingContext) === null || _state$headingContext === void 0 ? void 0 : (_state$headingContext2 = _state$headingContext.heading) === null || _state$headingContext2 === void 0 ? void 0 : _state$headingContext2.skip_correction),
       source: props.text || props.children,
-      debug: props.debug || ((_state$context$headin4 = state.context.heading) === null || _state$context$headin4 === void 0 ? void 0 : _state$context$headin4.debug)
+      debug: props.debug || ((_state$headingContext3 = state.headingContext) === null || _state$headingContext3 === void 0 ? void 0 : (_state$headingContext4 = _state$headingContext3.heading) === null || _state$headingContext4 === void 0 ? void 0 : _state$headingContext4.debug)
     });
     globalSyncCounter.current = state.counter;
     state.level = state.counter.level;
-    state.prevLevel = props.level;
-    this.state = state;
-  }
-
-  componentDidMount() {
+    state.prevLevel = parseFloat(String(props.level));
+    return state;
+  });
+  React.useEffect(() => {
     windupHeadings();
-    this.state.counter.windup();
-  }
-
-  componentWillUnmount() {
-    teardownHeadings();
-    this.state.counter.teardown();
-  }
-
-  render() {
-    var _this$context$heading, _this$context$heading2;
-
-    const _this$props = this.props,
-          {
-      text,
-      relevel: _relevel,
-      group: _group,
-      debug: _debug,
-      debug_counter: _debug_counter,
-      reset: _reset,
-      skip_correction: _skip_correction,
-      increase: _increase,
-      decrease: _decrease,
-      up: _up,
-      down: _down,
-      inherit: _inherit,
-      level: _level,
-      size: _size,
-      skeleton: _skeleton,
-      element: _element,
-      class: _className,
-      className,
-      children
-    } = _this$props,
-          rest = _objectWithoutProperties(_this$props, _excluded);
-
-    let {
-      size,
-      element,
-      skeleton
-    } = this.props;
-    const {
-      level
-    } = this.state;
-    const debug = _debug || ((_this$context$heading = this.context.heading) === null || _this$context$heading === void 0 ? void 0 : _this$context$heading.debug);
-    const debug_counter = _debug_counter || ((_this$context$heading2 = this.context.heading) === null || _this$context$heading2 === void 0 ? void 0 : _this$context$heading2.debug_counter);
-
-    const attributes = _objectSpread({}, rest);
-
-    if (element === 'auto' || element === null) {
-      element = `h${level || '6'}`;
-
-      if (_size === 'auto' || _size === null) {
-        size = levelResolution[level || '6'];
-      }
-    } else {
-      if (!attributes.role) {
-        attributes.role = 'heading';
-      }
+    state.counter.windup();
+    return () => {
+      teardownHeadings();
+      state.counter.teardown();
+    };
+  }, []);
+  React.useEffect(() => {
+    const level = parseFloat(String(props.level));
+
+    if (state.prevLevel !== props.level && level > 0 && level !== state.level) {
+      var _state$headingContext5, _state$headingContext6, _state$headingContext7, _state$headingContext8;
+
+      const {
+        level: newLevel
+      } = correctInternalHeadingLevel({
+        counter: state.counter,
+        isRerender: true,
+        level,
+        bypassChecks: isTrue(props.skip_correction) || isTrue((_state$headingContext5 = state.headingContext) === null || _state$headingContext5 === void 0 ? void 0 : (_state$headingContext6 = _state$headingContext5.heading) === null || _state$headingContext6 === void 0 ? void 0 : _state$headingContext6.skip_correction),
+        source: props.text || props.children,
+        debug: props.debug || ((_state$headingContext7 = state.headingContext) === null || _state$headingContext7 === void 0 ? void 0 : (_state$headingContext8 = _state$headingContext7.heading) === null || _state$headingContext8 === void 0 ? void 0 : _state$headingContext8.debug)
+      });
+      state.level = state.prevLevel = newLevel;
+      setState(_objectSpread({}, state));
+    }
+  }, [props.level]);
+  let {
+    size,
+    element = 'auto',
+    skeleton
+  } = props;
+  const {
+    level
+  } = state;
+  const debug = _debug || (headingContext === null || headingContext === void 0 ? void 0 : (_headingContext$headi2 = headingContext.heading) === null || _headingContext$headi2 === void 0 ? void 0 : _headingContext$headi2.debug);
+  const debug_counter = _debug_counter || (headingContext === null || headingContext === void 0 ? void 0 : (_headingContext$headi3 = headingContext.heading) === null || _headingContext$headi3 === void 0 ? void 0 : _headingContext$headi3.debug_counter);
+
+  const attributes = _objectSpread({}, rest);
+
+  if (element === 'auto' || element === null) {
+    element = `h${level || 'x-small'}`;
+
+    if (_size === 'auto' || _size === null) {
+      size = levelResolution[level || 'x-small'];
+    }
+  } else {
+    if (!attributes.role) {
+      attributes.role = 'heading';
+    }
 
-      if (!attributes['aria-level']) {
-        attributes['aria-level'] = String(level);
-      }
+    if (!attributes['aria-level']) {
+      attributes['aria-level'] = String(level);
     }
+  }
 
-    validateDOMAttributes(this.props, attributes);
-    const Element = element;
-    return React.createElement(Context.Consumer, null, context => {
-      if (typeof (context === null || context === void 0 ? void 0 : context.skeleton) !== 'undefined') {
-        skeleton = context.skeleton;
-      }
+  validateDOMAttributes(props, attributes);
 
-      attributes.className = classnames(`dnb-heading dnb-h--${size}`, createSkeletonClass('font', skeleton, this.context), className, _className, createSpacingClasses(this.props));
-      attributes.children = React.createElement(React.Fragment, null, debug && React.createElement("span", {
-        className: "dnb-heading__debug"
-      }, `[h${level || '6'}] `, debug_counter && React.createElement(React.Fragment, null, ' ', React.createElement("span", {
-        className: "dnb-code"
-      }, debugCounter(this.state.counter)))), text || children);
-      return React.createElement(Element, _extends({
-        ref: this._ref
-      }, attributes));
-    });
+  if (typeof (context === null || context === void 0 ? void 0 : context.skeleton) !== 'undefined') {
+    skeleton = context.skeleton;
   }
 
+  const Element = element;
+  return React.createElement(Element, _extends({}, attributes, {
+    ref: _ref,
+    className: classnames(`dnb-heading dnb-h--${size}`, createSkeletonClass('font', skeleton, headingContext), className, createSpacingClasses(props))
+  }), debug && React.createElement("span", {
+    className: "dnb-heading__debug"
+  }, `[h${level || '6'}] `, debug_counter && React.createElement(React.Fragment, null, ' ', React.createElement("span", {
+    className: "dnb-code"
+  }, debugCounter(state.counter)))), text || children);
 }
-
-_defineProperty(Heading, "contextType", HeadingContext);
-
-_defineProperty(Heading, "defaultProps", {
-  id: null,
-  group: null,
-  text: null,
-  size: 'auto',
-  level: null,
-  increase: null,
-  decrease: null,
-  up: null,
-  down: null,
-  skip_correction: null,
-  debug: null,
-  debug_counter: null,
-  counter: null,
-  reset: null,
-  inherit: null,
-  skeleton: null,
-  element: 'auto',
-  class: null,
-  className: null,
-  children: null
-});
-
-process.env.NODE_ENV !== "production" ? Heading.propTypes = _objectSpread(_objectSpread({
-  id: PropTypes.string,
-  group: PropTypes.string,
-  text: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
-  size: PropTypes.oneOf(['auto', 'xx-large', 'x-large', 'large', 'medium', 'basis', 'small', 'x-small']),
-  level: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
-  increase: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
-  decrease: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
-  up: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
-  down: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
-  skip_correction: PropTypes.bool,
-  debug: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-  debug_counter: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-  counter: PropTypes.any,
-  inherit: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
-  reset: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.bool]),
-  skeleton: PropTypes.oneOfType([PropTypes.string, PropTypes.bool]),
-  element: PropTypes.string
-}, spacingPropTypes), {}, {
-  class: PropTypes.string,
-  className: PropTypes.string,
-  children: PropTypes.oneOfType([PropTypes.node, PropTypes.func])
-}) : void 0;
 Heading.Level = HeadingProvider;
 
 Heading.Increase = props => React.createElement(HeadingProvider, _extends({

package/es/components/heading/HeadingContext.d.ts

@@ -1,5 +1,12 @@
-export default Context;
-declare const Context: React.Context<{
-    heading: any;
-}>;
-import React from "react";
+/**
+ * Web Heading Context
+ *
+ */
+import React from 'react';
+import { SkeletonContextProps } from '../skeleton/SkeletonHelper';
+import { HeadingProps } from './Heading';
+export declare type HeadingContextProps = {
+    heading?: HeadingProps;
+} & SkeletonContextProps;
+declare const HeadingContext: React.Context<HeadingContextProps>;
+export default HeadingContext;

package/es/components/heading/HeadingContext.js

@@ -1,5 +1,5 @@
 import React from 'react';
-const Context = React.createContext({
+const HeadingContext = React.createContext({
   heading: null
 });
-export default Context;
+export default HeadingContext;

package/es/components/heading/HeadingCounter.d.ts

@@ -1,18 +1,42 @@
-export function initCounter(props?: any): any;
-export class Counter {
-    constructor(props?: any);
-    level: number;
-    entry: number;
+/**
+ * Web Heading Counter Instance
+ *
+ */
+import { HeadingAllProps, InternalHeadingLevel } from './Heading';
+export declare type HeadingCounter = Counter;
+export declare type HeadingDebugCounter = boolean | (() => void);
+export declare type ContextCounter = {
+    level: InternalHeadingLevel;
+    entry: InternalHeadingLevel;
+    countHeadings: number;
+    _initCount: number;
+    _isReady: boolean;
+    isGlobal?: boolean;
+};
+export declare const initCounter: (props?: CounterProps) => Counter;
+export declare type CounterGroup = HeadingAllProps['group'];
+export declare type CounterChildren = HeadingAllProps['children'];
+export declare type CounterProps = {
+    isGlobal?: boolean;
+    group?: CounterGroup;
+    children?: CounterChildren;
+    counter?: CounterProps;
+};
+export declare class Counter {
+    level: InternalHeadingLevel;
+    entry: InternalHeadingLevel;
+    lastResetLevel: InternalHeadingLevel;
     _isReady: boolean;
     countHeadings: number;
     _initCount: number;
     isGlobal: boolean;
     isHeading: boolean;
     bypassChecks: boolean;
-    contextCounter: any;
+    contextCounter: ContextCounter;
     reports: any[];
-    group: any;
-    children: any;
+    group: CounterGroup;
+    children: CounterChildren;
+    constructor(props?: CounterProps);
     report(...str: any[]): void;
     useLastReport(): any;
     enableBypassChecks(): void;
@@ -20,23 +44,23 @@ export class Counter {
     getLevel(): number;
     hasEntryLevel(): boolean;
     hasCorrection(): boolean;
-    setEntryLevel(level?: any): void;
+    setEntryLevel(level?: InternalHeadingLevel): void;
     isInContext(): boolean;
-    setContextCounter(contextCounter: any): void;
-    skipMakeMeReady(): void;
+    setContextCounter(contextCounter: ContextCounter): void;
     windup(): void;
     teardown(): void;
-    makeMeReady(): void;
+    makeMeReady({ level }?: {
+        level?: InternalHeadingLevel;
+    }): void;
     factorCheck({ action, level, current, report }: {
         action: any;
         level: any;
         current: any;
         report: any;
     }): any;
-    setLevel(level: any, action?: string): void;
+    setLevel(level: InternalHeadingLevel, action?: string): void;
     increment(): void;
     decrement(): void;
     force(level?: number): void;
     reset(toLevel?: any): void;
-    lastResetLevel: any;
 }