cozy-ui-plus 1.1.0

package/dist/hooks/useClientErrors.js

@@ -0,0 +1,185 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useClientErrors;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _filter = _interopRequireDefault(require("lodash/filter"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _cozyClient = require("cozy-client");
+
+var _cozyStackClient = require("cozy-stack-client");
+
+var _Paywall = _interopRequireDefault(require("../Paywall"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Rendering functions for client fetch errors by status code
+ *
+ * @private
+ * @type {object}
+ */
+var byHttpStatus = {
+  413: QuotaError // <QuotaError />
+
+};
+/**
+ * Display for a quota error from the client
+ *
+ * @see QuotaPaywall
+ * @private
+ * @param {object} props - Props
+ * @param {Function} props.dismiss - remove the error from the stack to display
+ * @returns {React.ReactElement}
+ */
+
+function QuotaError(_ref) {
+  var dismiss = _ref.dismiss;
+  return /*#__PURE__*/_react.default.createElement(_Paywall.default, {
+    onClose: dismiss
+  });
+}
+/**
+ * Returns the handler for an error
+ *
+ * @param {import("../types").ClientError} error - The error
+ * @returns {Function|null} React Component
+ */
+
+
+function getErrorComponent(error) {
+  if (error instanceof Response || error instanceof _cozyStackClient.FetchError) {
+    var status = error.status || '';
+    return byHttpStatus[status] || null;
+  }
+
+  return null;
+}
+/**
+ * Renders a stack of errors
+ *
+ * @private
+ * @see ClientErrors
+ * @param {import("../types").ClientError[]} errorStack - array of errors/exceptions
+ * @param {Function} setErrorStack - mutates the array of errors
+ * @returns {Array<React.ReactElement>} React rendering
+ */
+
+
+function renderErrors(errorStack, setErrorStack) {
+  var errors = errorStack.map(function (error, key) {
+    var Component = getErrorComponent(error);
+
+    if (Component) {
+      var dismiss = function dismiss() {
+        return setErrorStack(function (stack) {
+          return (0, _filter.default)(stack, function (e) {
+            return e !== error;
+          });
+        });
+      };
+
+      return /*#__PURE__*/_react.default.createElement(Component, {
+        key: key,
+        error: error,
+        dismiss: dismiss
+      });
+    } else {
+      return null;
+    }
+  });
+  return errors;
+}
+/**
+ * Manages the client errors and allows to display them
+ *
+ * Returns a `ClientErrors` React component that takes care
+ * of how to display cozy-client errors (probably displaying a modal)
+ *
+ * Only Quota Errors are managed for now.
+ *
+ * @example
+ * ```
+ * const App = () => {
+ *   const { ClientErrors } = useClientErrors()
+ *
+ *   return <Layout>
+ *      <h1>My app</h1>
+ *      <ClientErrors />
+ *   </Layout>
+ * }
+ * ```
+ *
+ * @param {object} [props] - Props
+ * @param {boolean} [props.handleExceptions] - should cozy-client directly handle errors before forwarding them to the caller?
+ * @returns {{ClientErrors: Function}} React component
+ */
+
+
+function useClientErrors() {
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      _ref2$handleException = _ref2.handleExceptions,
+      handleExceptions = _ref2$handleException === void 0 ? true : _ref2$handleException;
+
+  var client = (0, _cozyClient.useClient)();
+
+  var _useState = (0, _react.useState)([]),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      errorStack = _useState2[0],
+      setErrorStack = _useState2[1];
+  /**
+   * Handle client errors, add them to the error stack
+   *
+   * @param {import("../types").ClientError} error -
+   * @returns {boolean} true if the error was manager, false otherwise
+   */
+
+
+  var handleError = (0, _react.useCallback)(function (error) {
+    // `isErrorManaged` is there to avoid the same error to be added twice
+    // once the error has been added once, the `isErrorManaged`is set to true
+    // and any future push is ignored
+    if (error.isErrorManaged) return false;
+    var isManageable = !!getErrorComponent(error);
+
+    if (isManageable) {
+      error.isErrorManaged = true;
+      setErrorStack(function (stack) {
+        return stack.concat(error);
+      });
+      return true;
+    } else {
+      error.isErrorManaged = false;
+      return false;
+    }
+  }, [setErrorStack]);
+  (0, _react.useEffect)(function () {
+    if (handleExceptions) {
+      client.on('error', handleError);
+      return function () {
+        return client.removeListener('error', handleError);
+      };
+    } else {
+      return undefined;
+    }
+  }, [client, handleError, handleExceptions]); // @ts-ignore
+
+  var ClientErrors = (0, _react.useCallback)(function () {
+    return renderErrors(errorStack, setErrorStack);
+  }, [errorStack, setErrorStack]); // @ts-ignore
+
+  ClientErrors.displayName = 'ClientErrors';
+  return {
+    ClientErrors: ClientErrors
+  };
+}

package/dist/proptypes.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileDoctype = exports.AppDoctype = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var AppDoctype = _propTypes.default.shape({
+  name: _propTypes.default.string,
+  slug: _propTypes.default.string,
+  developer: _propTypes.default.object,
+  links: _propTypes.default.shape({
+    icon: _propTypes.default.string
+  }),
+  latest_version: _propTypes.default.shape({
+    version: _propTypes.default.string
+  })
+});
+
+exports.AppDoctype = AppDoctype;
+
+var FileDoctype = _propTypes.default.shape({
+  _id: _propTypes.default.string,
+  class: _propTypes.default.string,
+  mime: _propTypes.default.string,
+  name: _propTypes.default.string
+});
+
+exports.FileDoctype = FileDoctype;

package/dist/providers/CozyTheme/CozyThemeWithQuery.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _cozyClient = require("cozy-client");
+
+var _CozyTheme = _interopRequireDefault(require("cozy-ui/transpiled/react/providers/CozyTheme"));
+
+var _queries = require("./queries");
+
+var _excluded = ["data"];
+
+var CozyThemeWithQuery = function CozyThemeWithQuery(props) {
+  var instanceQuery = (0, _queries.buildSettingsInstanceQuery)();
+
+  var _useQuery = (0, _cozyClient.useQuery)(instanceQuery.definition, instanceQuery.options),
+      instance = _useQuery.data,
+      instanceQueryLeft = (0, _objectWithoutProperties2.default)(_useQuery, _excluded);
+
+  if ((0, _cozyClient.isQueryLoading)(instanceQueryLeft) && !(0, _cozyClient.hasQueryBeenLoaded)(instanceQueryLeft)) {
+    return null;
+  }
+
+  return /*#__PURE__*/_react.default.createElement(_CozyTheme.default, (0, _extends2.default)({}, props, {
+    settingsThemeType: instance === null || instance === void 0 ? void 0 : instance.colorScheme
+  }));
+};
+
+var _default = CozyThemeWithQuery;
+exports.default = _default;

package/dist/providers/CozyTheme/index.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+Object.defineProperty(exports, "useCozyTheme", {
+  enumerable: true,
+  get: function get() {
+    return _CozyTheme.useCozyTheme;
+  }
+});
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _helpers = require("cozy-ui/transpiled/react/hooks/useSetFlagshipUi/helpers");
+
+var _CozyTheme = _interopRequireWildcard(require("cozy-ui/transpiled/react/providers/CozyTheme"));
+
+var _CozyThemeWithQuery = _interopRequireDefault(require("./CozyThemeWithQuery"));
+
+var _excluded = ["ignoreCozySettings"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var CozyTheme = function CozyTheme(_ref) {
+  var ignoreCozySettings = _ref.ignoreCozySettings,
+      props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  var Comp = ignoreCozySettings || process.env.NODE_ENV === 'test' || _helpers.isRsg ? _CozyTheme.default : _CozyThemeWithQuery.default;
+  return /*#__PURE__*/_react.default.createElement(Comp, props);
+};
+
+CozyTheme.propTypes = {
+  variant: _propTypes.default.oneOf(['normal', 'inverted']),
+
+  /** Causes this element's children to appear as if they were direct children of the element's parent, ignoring the element itself. */
+  ignoreItself: _propTypes.default.bool,
+
+  /** Bypasses the request that retrieves the app's settings in order to define the theme type */
+  ignoreCozySettings: _propTypes.default.bool,
+  className: _propTypes.default.string,
+  children: _propTypes.default.node
+};
+CozyTheme.defaultProps = {
+  variant: 'normal',
+  ignoreCozySettings: false,
+  ignoreItself: true
+};
+var _default = CozyTheme;
+exports.default = _default;

package/dist/providers/CozyTheme/queries.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildSettingsInstanceQuery = void 0;
+
+var _cozyClient = require("cozy-client");
+
+var SETTINGS_DOCTYPE = 'io.cozy.settings';
+
+var defaultFetchPolicy = _cozyClient.fetchPolicies.olderThan(5 * 60 * 1000);
+
+var buildSettingsInstanceQuery = function buildSettingsInstanceQuery() {
+  return {
+    definition: (0, _cozyClient.Q)(SETTINGS_DOCTYPE).getById('io.cozy.settings.instance'),
+    options: {
+      as: "".concat(SETTINGS_DOCTYPE, "/io.cozy.settings.instance"),
+      fetchPolicy: defaultFetchPolicy,
+      singleDocData: true
+    }
+  };
+};
+
+exports.buildSettingsInstanceQuery = buildSettingsInstanceQuery;

package/dist/providers/DemoProvider.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _cozyClient = require("cozy-client");
+
+var _DemoProvider = _interopRequireDefault(require("cozy-ui/transpiled/react/providers/DemoProvider"));
+
+var _excluded = ["client", "children"];
+var defaultClient = {
+  plugins: {
+    realtime: {
+      subscribe: function subscribe() {},
+      unsubscribe: function unsubscribe() {},
+      unsubscribeAll: function unsubscribeAll() {}
+    }
+  },
+  getStackClient: function getStackClient() {
+    return {
+      uri: 'https://cozy.io/'
+    };
+  },
+  getInstanceOptions: function getInstanceOptions() {
+    return {
+      subdomain: ''
+    };
+  }
+};
+
+var DemoProvider = function DemoProvider(_ref) {
+  var client = _ref.client,
+      children = _ref.children,
+      props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  return /*#__PURE__*/_react.default.createElement(_cozyClient.CozyProvider, {
+    client: client || defaultClient
+  }, /*#__PURE__*/_react.default.createElement(_DemoProvider.default, props, children));
+};
+
+var _default = DemoProvider;
+exports.default = _default;

package/dist/providers/Intent/index.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIntent = exports.default = exports.IntentContext = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _cozyClient = require("cozy-client");
+
+var _Backdrop = _interopRequireDefault(require("cozy-ui/transpiled/react/Backdrop"));
+
+var _Spinner = _interopRequireDefault(require("cozy-ui/transpiled/react/Spinner"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var IntentContext = /*#__PURE__*/(0, _react.createContext)();
+exports.IntentContext = IntentContext;
+
+var useIntent = function useIntent() {
+  var context = (0, _react.useContext)(IntentContext);
+
+  if (!context) {
+    throw new Error('useIntent must be used within a IntentProvider');
+  }
+
+  return context;
+};
+
+exports.useIntent = useIntent;
+
+var IntentProvider = function IntentProvider(_ref) {
+  var intentId = _ref.intentId,
+      componentsProps = _ref.componentsProps,
+      children = _ref.children;
+  var client = (0, _cozyClient.useClient)();
+
+  var _useState = (0, _react.useState)({
+    service: null,
+    intent: null,
+    data: null
+  }),
+      _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+
+  var value = (0, _react.useMemo)(function () {
+    return {
+      service: state.service,
+      intent: state.intent,
+      data: state.data
+    };
+  }, [state]);
+  (0, _react.useEffect)(function () {
+    var startService = /*#__PURE__*/function () {
+      var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var service, intent, data;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.prev = 0;
+                _context.next = 3;
+                return client.intents.createService(intentId, window);
+
+              case 3:
+                service = _context.sent;
+                intent = service.getIntent();
+                data = service.getData();
+                setState({
+                  service: service,
+                  intent: intent,
+                  data: data
+                });
+                _context.next = 12;
+                break;
+
+              case 9:
+                _context.prev = 9;
+                _context.t0 = _context["catch"](0);
+                service.throw(_context.t0);
+
+              case 12:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[0, 9]]);
+      }));
+
+      return function startService() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+
+    if (!state.service) {
+      startService();
+    }
+  }, [client, intentId, state.service]);
+
+  if (!state.service) {
+    return /*#__PURE__*/_react.default.createElement(_Backdrop.default, (0, _extends2.default)({
+      open: true
+    }, componentsProps === null || componentsProps === void 0 ? void 0 : componentsProps.backdrop), /*#__PURE__*/_react.default.createElement(_Spinner.default, (0, _extends2.default)({
+      className: "u-m-0",
+      size: "xxlarge",
+      middle: true
+    }, componentsProps === null || componentsProps === void 0 ? void 0 : componentsProps.spinner)));
+  }
+
+  return /*#__PURE__*/_react.default.createElement(IntentContext.Provider, {
+    value: value
+  }, children);
+};
+
+var _default = IntentProvider;
+exports.default = _default;

package/dist/src/AppIcon/index.d.ts

@@ -0,0 +1,50 @@
+export class AppIcon extends React.Component<any, any, any> {
+    constructor(props: any, context: any);
+    isUnmounting: boolean;
+    handleError(): void;
+    fetchIcon(): any;
+    state: {
+        error: any;
+        icon: any;
+        status: string;
+    };
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: any): void;
+    load(): Promise<void>;
+    render(): JSX.Element;
+}
+export namespace AppIcon {
+    namespace propTypes {
+        export let alt: PropTypes.Requireable<string>;
+        export let app: PropTypes.Requireable<NonNullable<string | PropTypes.InferProps<{
+            name: PropTypes.Requireable<string>;
+            slug: PropTypes.Requireable<string>;
+            developer: PropTypes.Requireable<object>;
+            links: PropTypes.Requireable<PropTypes.InferProps<{
+                icon: PropTypes.Requireable<string>;
+            }>>;
+            latest_version: PropTypes.Requireable<PropTypes.InferProps<{
+                version: PropTypes.Requireable<string>;
+            }>>;
+        }>>>;
+        export { iconPropType as fallbackIcon };
+        export let fetchIcon: PropTypes.Requireable<(...args: any[]) => any>;
+        export let client: PropTypes.Validator<object>;
+        export let className: PropTypes.Requireable<string>;
+        export let onReady: PropTypes.Requireable<(...args: any[]) => any>;
+        export let type: PropTypes.Requireable<string>;
+        export let priority: PropTypes.Requireable<string>;
+    }
+    namespace defaultProps {
+        let type_1: string;
+        export { type_1 as type };
+        let priority_1: string;
+        export { priority_1 as priority };
+    }
+}
+declare const _default: Function;
+export default _default;
+import React from 'react';
+import PropTypes from 'prop-types';
+import { iconPropType } from 'cozy-ui/transpiled/react/Icon';

package/dist/src/AppIcon/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/AppLinker/index.d.ts

@@ -0,0 +1,35 @@
+export class AppLinker extends React.Component<any, any, any> {
+    static contextType: React.Context<import("cozy-intent").WebviewService>;
+    static getSlug(props: any): any;
+    static getOnClickHref(props: any, context: any, imgRef: any): {
+        onClick: (event: any) => void;
+        href: string;
+    } | {
+        href: any;
+        onClick: any;
+    };
+    constructor(props: any);
+    state: {
+        imgRef: any;
+    };
+    setImgRef: (img: any) => void;
+    imgRef: any;
+    render(): any;
+}
+export namespace AppLinker {
+    namespace propTypes {
+        let href: PropTypes.Requireable<string>;
+        let onAppSwitch: PropTypes.Requireable<(...args: any[]) => any>;
+        let app: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            slug: PropTypes.Validator<string>;
+        }>>>;
+    }
+}
+declare const _default: Function;
+export default _default;
+import React from 'react';
+import PropTypes from 'prop-types';
+import { getUniversalLinkDomain } from './native';
+import { generateWebLink } from './native';
+import { generateUniversalLink } from './native';
+export { getUniversalLinkDomain, generateWebLink, generateUniversalLink };

package/dist/src/AppLinker/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/AppLinker/native.config.d.ts

@@ -0,0 +1 @@
+export const UNIVERSAL_LINK_URL: "https://links.mycozy.cloud";

package/dist/src/AppLinker/native.d.ts

@@ -0,0 +1,6 @@
+export function getUniversalLinkDomain(): string;
+export function generateWebLink({ nativePath, ...props }: {
+    [x: string]: any;
+    nativePath: any;
+}): string;
+export function generateUniversalLink(options: any): string;

package/dist/src/AppLinker/native.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/AppSections/Sections.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shows a list of apps grouped by categories.
+ *
+ * Can be
+ *
+ * - uncontrolled: it controls an internal search object to filter the list.
+ * - controlled: it is controlled by the `search` prop
+ */
+export class Sections extends React.Component<any, any, any> {
+    constructor(props: any, context: any);
+    state: {
+        search: any;
+    };
+    handleCategoryChange(categoryOption: any): void;
+    render(): JSX.Element;
+}
+export namespace Sections {
+    namespace propTypes {
+        let t: PropTypes.Validator<(...args: any[]) => any>;
+        let apps: PropTypes.Validator<any[]>;
+        let error: PropTypes.Requireable<object>;
+        let config: PropTypes.Requireable<object>;
+        let onAppClick: PropTypes.Validator<(...args: any[]) => any>;
+        let hasNav: PropTypes.Requireable<boolean>;
+        let initialSearch: PropTypes.Requireable<object>;
+        let displaySpecificMaintenanceStyle: PropTypes.Requireable<boolean>;
+    }
+    namespace defaultProps {
+        let hasNav_1: boolean;
+        export { hasNav_1 as hasNav };
+        let displaySpecificMaintenanceStyle_1: boolean;
+        export { displaySpecificMaintenanceStyle_1 as displaySpecificMaintenanceStyle };
+        export let showFilterDropdown: boolean;
+        export let showTitles: boolean;
+        export let showSubTitles: boolean;
+        export let showSubSubTitles: boolean;
+        export let componentsProps: PropTypes.Requireable<PropTypes.InferProps<{
+            /** Props spread to AppsSection component */
+            appsSection: PropTypes.Requireable<PropTypes.InferProps<{
+                /** Props spread to onClick method of AppTile component */
+                disableClick: PropTypes.Requireable<(...args: any[]) => any>;
+            }>>;
+        }>>;
+    }
+}
+declare const _default: any;
+export default _default;
+import React from 'react';
+import PropTypes from 'prop-types';