@mittwald/flow-remote-vue-components 0.0.0-stage → 1.5.0

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

@@ -0,0 +1,11 @@
+/**
+ * Renders its children only once mounted.
+ *
+ * A remote app is client-only by nature, so this matters where the app itself
+ * is server-rendered — a Nuxt or Next page hosting the remote root — and a
+ * subtree must not be part of that render.
+ */
+export declare const BrowserOnly: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default BrowserOnly;

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

@@ -0,0 +1,41 @@
+import { CountryData } from 'country-codes-list';
+import { PropType } from 'vue';
+export type Country = CountryData & {
+    name: string;
+    code: string;
+};
+export type CountryFilterFn = (country: Country) => boolean;
+export type CountrySortFn = (left: Country, right: Country) => number;
+/**
+ * The countries of the world, as `Option`s for a `Select` or `ComboBox`.
+ *
+ * Flow ships the country names as locale files. Here they come from
+ * `Intl.DisplayNames` in the host's language, which is the same data every
+ * browser already carries — no translation files to keep in sync, at the price
+ * of the browser's spelling rather than Flow's.
+ */
+export declare const CountryOptions: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    filterBy: {
+        type: PropType<CountryFilterFn>;
+        default: CountryFilterFn;
+    };
+    sortBy: {
+        type: PropType<CountrySortFn>;
+        default: CountrySortFn;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    filterBy: {
+        type: PropType<CountryFilterFn>;
+        default: CountryFilterFn;
+    };
+    sortBy: {
+        type: PropType<CountrySortFn>;
+        default: CountrySortFn;
+    };
+}>> & Readonly<{}>, {
+    filterBy: CountryFilterFn;
+    sortBy: CountrySortFn;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default CountryOptions;

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

@@ -0,0 +1,31 @@
+import { PropType } from 'vue';
+export type DeprecationWarningHandler = (message: string) => void;
+/**
+ * Collects the deprecation warnings a remote app triggers.
+ *
+ * `RemoteRoot` installs one that forwards to the host, which is how mStudio
+ * learns which deprecated paths an extension still uses.
+ */
+export declare const DeprecationWarningProvider: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    onWarning: {
+        type: PropType<DeprecationWarningHandler>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    onWarning: {
+        type: PropType<DeprecationWarningHandler>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    onWarning: DeprecationWarningHandler;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/**
+ * Warns once per message, in the console and to the provider.
+ *
+ * Deduplicated per call site, like Flow's hook: a component that warns on every
+ * render must not fill the console.
+ */
+export declare const useWarnDeprecation: () => DeprecationWarningHandler;
+export default DeprecationWarningProvider;

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

@@ -0,0 +1,12 @@
+import { FlowRemoteVueComponent } from '../lib/types';
+import { RemoteFormElementProps } from '@mittwald/flow-remote-elements';
+export type { RemoteFormElementProps as FormProps } from '@mittwald/flow-remote-elements';
+/**
+ * Hand-written, like its React counterpart: `flr-form` has no Flow component
+ * behind it, so the generator never sees it.
+ *
+ * Unlike React's, this one adds nothing — that version wraps a function
+ * `action` in `startTransition`, which is React's own scheduling.
+ */
+export declare const Form: FlowRemoteVueComponent<RemoteFormElementProps>;
+export default Form;

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

@@ -0,0 +1,38 @@
+/**
+ * Tells the host the extension is still loading, so mStudio shows its own
+ * loading state instead of an empty page.
+ *
+ * The React package calls this `LoadingFallbackTrigger` and re-exports it as
+ * `LoadingIndicator` from `@mittwald/mstudio-ext-react-components`.
+ */
+export declare const LoadingIndicator: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    show: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/**
+ * The name the React package publishes it under. Exported as well so a port
+ * does not have to rename an import that means the same thing.
+ */
+export declare const LoadingFallbackTrigger: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    show: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    show: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default LoadingIndicator;

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

@@ -0,0 +1,40 @@
+import { VNode } from 'vue';
+interface NotificationEntry {
+    id: number;
+    element: VNode;
+    autoCloseTimeout?: ReturnType<typeof setTimeout>;
+    autoCloseRemaining?: number;
+    autoCloseStartedAt?: number;
+}
+/**
+ * Holds the notifications an app has raised.
+ *
+ * Flow's controller is a MobX model; this one is a reactive array. The contract
+ * an extension sees is the same: `add()` a notification, get an id back,
+ * `remove()` it — and `autoClose` pauses while the pointer or the focus rests
+ * on it, which is why the timer is tracked per entry rather than by the host.
+ */
+export declare class NotificationController {
+    private readonly entries;
+    private nextId;
+    get notifications(): NotificationEntry[];
+    add(notification: VNode): number;
+    remove(id: number): void;
+    pauseAutoClose(entry: NotificationEntry): void;
+    resumeAutoClose(entry: NotificationEntry): void;
+    private startAutoClose;
+}
+export declare const useNotificationController: () => NotificationController;
+/**
+ * Renders the app's notifications and hands its controller to everything below.
+ *
+ * The container is not a separate element: the notifications are remote
+ * `Notification` components, and the host's own container is what positions
+ * them.
+ */
+export declare const NotificationProvider: import('vue').DefineComponent<{}, () => (VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default NotificationProvider;

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

@@ -0,0 +1,48 @@
+import { RemoteReceiver } from '@mittwald/flow-remote-core';
+import { PropType } from 'vue';
+/**
+ * Connects a Vue app to the mStudio host and renders its children into the
+ * remote tree.
+ *
+ * Everything below it renders `flr-*` elements, never visible DOM — see
+ * `docs/remote-ui.md`.
+ */
+export declare const RemoteRoot: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** Forwarded to the host, which shows its own loading state. */
+    isLoading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     * Internal use only: renders against a receiver in the same realm instead
+     * of connecting to a parent frame.
+     */
+    __remoteReceiver: {
+        type: PropType<RemoteReceiver>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    hostPathnameChanged: (pathname: string) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** Forwarded to the host, which shows its own loading state. */
+    isLoading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    /**
+     * Internal use only: renders against a receiver in the same realm instead
+     * of connecting to a parent frame.
+     */
+    __remoteReceiver: {
+        type: PropType<RemoteReceiver>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onHostPathnameChanged?: ((pathname: string) => any) | undefined;
+}>, {
+    isLoading: boolean;
+    __remoteReceiver: RemoteReceiver;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default RemoteRoot;

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

@@ -0,0 +1,109 @@
+import { PropType } from 'vue';
+/**
+ * What a backend loads and stores: per component, per key, the value as a JSON
+ * string — `{"List":{"crew.sorting.autosave":"{\"property\":\"name\",…}"}}`.
+ * Flow's React `SettingsProvider` writes the same shape, so the two bindings
+ * read each other's settings.
+ */
+export type SettingsJson = Record<string, Record<string, string>>;
+export interface SettingsBackend {
+    load(): Promise<SettingsJson>;
+    store(settings: SettingsJson): Promise<void>;
+}
+export type GetSettingsMiddleware = (component: string, key: string, settings: unknown, getParent: () => unknown) => unknown;
+export type SetSettingsMiddleware = (component: string, key: string, settings: unknown, setParent: (settings: unknown) => void) => unknown;
+export interface SettingsMiddleware {
+    get?: GetSettingsMiddleware;
+    set?: SetSettingsMiddleware;
+}
+/**
+ * The settings of one provider, with its parent's behind it — the Vue
+ * counterpart of `SettingsStore` in packages/components, with the same
+ * middleware and the same defaults: a value is read here, then from the parent;
+ * it is written here only.
+ */
+export declare class SettingsStore {
+    private readonly options;
+    private readonly settings;
+    constructor(json: SettingsJson, options?: {
+        middleware?: SettingsMiddleware;
+        parentStore?: SettingsStore;
+        onChange?: () => void;
+    });
+    get(component: string, key: string): unknown;
+    set(component: string, key: string, value: unknown): void;
+    clear(component: string, key: string): void;
+    get asJson(): SettingsJson;
+}
+/**
+ * The store of the surrounding `SettingsProvider`, if there is one. Read in
+ * `setup()`: a provider renders its children only once a store is loaded, and
+ * again from scratch when its `id` changes.
+ */
+export declare const injectSettings: () => SettingsStore | undefined;
+/**
+ * Remembers component settings — the `List`'s view settings — in the shape
+ * Flow's React `SettingsProvider` does, with the same props:
+ * `type="localStorage"` plus a `storageKey`, or `type="custom"` plus a `store`
+ * that loads and stores asynchronously.
+ *
+ * Its children render once the settings are loaded, the way React's suspend.
+ * The backend is read per `id`, as in React: change the `id` to switch it.
+ */
+export declare const SettingsProvider: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    type: {
+        type: PropType<"localStorage" | "custom">;
+        required: true;
+    };
+    /** The `localStorage` key, for `type="localStorage"`. */
+    storageKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** The backend, for `type="custom"`. */
+    store: {
+        type: PropType<SettingsBackend>;
+        default: undefined;
+    };
+    /** Identifies the settings; a new one loads them again. */
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    middleware: {
+        type: PropType<SettingsMiddleware>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    type: {
+        type: PropType<"localStorage" | "custom">;
+        required: true;
+    };
+    /** The `localStorage` key, for `type="localStorage"`. */
+    storageKey: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    /** The backend, for `type="custom"`. */
+    store: {
+        type: PropType<SettingsBackend>;
+        default: undefined;
+    };
+    /** Identifies the settings; a new one loads them again. */
+    id: {
+        type: StringConstructor;
+        default: string;
+    };
+    middleware: {
+        type: PropType<SettingsMiddleware>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    id: string;
+    storageKey: string;
+    store: SettingsBackend;
+    middleware: SettingsMiddleware;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default SettingsProvider;

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

@@ -0,0 +1,20 @@
+/**
+ * Renders its child when `if` holds, and that child's own children otherwise —
+ * a wrapper you can switch off without branching the tree around it.
+ */
+export declare const Wrap: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    if: {
+        type: null;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    if: {
+        type: null;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Wrap;

package/dist/types/composables/remoteContext.d.ts

@@ -0,0 +1,23 @@
+import { RemoteToHostConnection } from '@mittwald/flow-remote-core';
+import { InjectionKey, Ref } from 'vue';
+export interface RemoteContext {
+    connection: Ref<RemoteToHostConnection | undefined>;
+    /** The backoffice's language, once the host has reported its config. */
+    language: Ref<string | undefined>;
+    reportComponentUsage: (component: string) => void;
+}
+export declare const remoteContextKey: InjectionKey<RemoteContext>;
+export declare const provideRemoteContext: (context: RemoteContext) => void;
+/**
+ * The connection to the host, for the imperative half of the bridge (host
+ * config, navigation, notifications). `undefined` until the host has answered.
+ */
+export declare const useRemoteConnection: () => Ref<RemoteToHostConnection | undefined>;
+/**
+ * The language the host renders in.
+ *
+ * Flow's React `useLanguage()` reads react-aria's locale, which a local
+ * `IntlProvider` sets. A Vue app renders nothing locally, so the only locale
+ * that exists is the host's — which is why this package has no `IntlProvider`.
+ */
+export declare const useLanguage: () => Ref<string | undefined>;

package/dist/types/composables/useComponentUsage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reports that a component was rendered, so the host can tell which parts of
+ * Flow an extension actually uses.
+ *
+ * Only what the extension wrote counts. An element one of this package's
+ * compositions renders for itself — the `OverlayContent` of a `Modal`, the
+ * `ItemsGridList` of a `List` — reports nothing, and the composition reports
+ * its own name instead. That is what Flow's React binding reports: a
+ * `flowComponent` under its name, the views it composes not at all.
+ */
+export declare const useComponentUsage: (component: string) => (() => void);

package/dist/types/composables/useIsMounted.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+/** Whether the component has mounted — the client-only guard. */
+export declare const useIsMounted: () => Readonly<Ref<boolean>>;

package/dist/types/composables/useOnChange.d.ts

@@ -0,0 +1,7 @@
+import { WatchSource } from 'vue';
+/**
+ * Runs `callback` when `source` changes — Flow's `useOnChange`, which exists
+ * because an effect with a dependency array also runs on the first render.
+ * Vue's `watch` is lazy by default, so this is a thin naming layer.
+ */
+export declare const useOnChange: <T>(source: WatchSource<T>, callback: (value: T, previousValue: T) => void) => void;

package/dist/types/composables/useWatchPathname.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reports the remote app's own pathname to the host, so the backoffice URL
+ * follows the extension's navigation.
+ *
+ * Polled, like the React counterpart: no browser API fires on a `pushState` the
+ * app performs itself.
+ */
+export declare const useWatchPathname: (callback: (pathname: string) => void) => void;

package/dist/types/icons/IconSetProvider.d.ts

@@ -0,0 +1,45 @@
+import { IconName } from './iconNames';
+import { Component, ComputedRef, PropType } from 'vue';
+/**
+ * Icons to render instead of Flow's own.
+ *
+ * Each entry is a component rendering an `<svg>` — Flow's `Icon` still supplies
+ * the sizing, the colour and the ARIA around it, exactly as for a built-in
+ * icon.
+ *
+ * Partial, unlike React's `IconSet`, which is `typeof defaultIconSet` and so
+ * demands every icon. That works there because `@mittwald/flow-icons-pro` is a
+ * complete second set to hand it; there is no Vue build of it, so a set here is
+ * something an app assembles, and an icon it leaves out keeps Flow's.
+ */
+export type IconSet = Partial<Record<IconName, Component>>;
+/** The replacement for one icon, if a surrounding set has one. */
+export declare const injectContextIcon: (name: IconName) => ComputedRef<Component | undefined>;
+/**
+ * Swaps Flow's icons for another set, below this component.
+ *
+ * Unlike the rest of this package, it has no counterpart in
+ * `@mittwald/flow-remote-react-components`: React's `IconSetProvider` is
+ * exported from `@mittwald/flow-react-components` and not from the remote
+ * surface. It earns its place here because there is no Vue build of the pro set
+ * — an app that licenses FontAwesome Pro, or wants its own icons, has this and
+ * nothing else.
+ */
+export declare const IconSetProvider: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /** The icons to use instead. Omitting one keeps Flow's. */
+    set: {
+        type: PropType<IconSet>;
+        default: undefined;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** The icons to use instead. Omitting one keeps Flow's. */
+    set: {
+        type: PropType<IconSet>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    set: Partial<Record<IconName, Component>>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default IconSetProvider;

package/dist/types/icons/components/IconAI.d.ts

@@ -0,0 +1,2 @@
+export declare const IconAI: import('../lib/createIcon').FlowIconComponent;
+export default IconAI;

package/dist/types/icons/components/IconAIHosting.d.ts

@@ -0,0 +1,2 @@
+export declare const IconAIHosting: import('../lib/createIcon').FlowIconComponent;
+export default IconAIHosting;

package/dist/types/icons/components/IconAnalytics.d.ts

@@ -0,0 +1,2 @@
+export declare const IconAnalytics: import('../lib/createIcon').FlowIconComponent;
+export default IconAnalytics;

package/dist/types/icons/components/IconApp.d.ts

@@ -0,0 +1,2 @@
+export declare const IconApp: import('../lib/createIcon').FlowIconComponent;
+export default IconApp;

package/dist/types/icons/components/IconAscending.d.ts

@@ -0,0 +1,2 @@
+export declare const IconAscending: import('../lib/createIcon').FlowIconComponent;
+export default IconAscending;

package/dist/types/icons/components/IconAttachment.d.ts

@@ -0,0 +1,2 @@
+export declare const IconAttachment: import('../lib/createIcon').FlowIconComponent;
+export default IconAttachment;

package/dist/types/icons/components/IconAutoresponder.d.ts

@@ -0,0 +1,2 @@
+export declare const IconAutoresponder: import('../lib/createIcon').FlowIconComponent;
+export default IconAutoresponder;

package/dist/types/icons/components/IconBackLink.d.ts

@@ -0,0 +1,2 @@
+export declare const IconBackLink: import('../lib/createIcon').FlowIconComponent;
+export default IconBackLink;

package/dist/types/icons/components/IconBackup.d.ts

@@ -0,0 +1,2 @@
+export declare const IconBackup: import('../lib/createIcon').FlowIconComponent;
+export default IconBackup;

package/dist/types/icons/components/IconBold.d.ts

@@ -0,0 +1,2 @@
+export declare const IconBold: import('../lib/createIcon').FlowIconComponent;
+export default IconBold;

package/dist/types/icons/components/IconCamera.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCamera: import('../lib/createIcon').FlowIconComponent;
+export default IconCamera;

package/dist/types/icons/components/IconCertificate.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCertificate: import('../lib/createIcon').FlowIconComponent;
+export default IconCertificate;

package/dist/types/icons/components/IconChangelog.d.ts

@@ -0,0 +1,2 @@
+export declare const IconChangelog: import('../lib/createIcon').FlowIconComponent;
+export default IconChangelog;

package/dist/types/icons/components/IconCheck.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCheck: import('../lib/createIcon').FlowIconComponent;
+export default IconCheck;

package/dist/types/icons/components/IconCheckboxChecked.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCheckboxChecked: import('../lib/createIcon').FlowIconComponent;
+export default IconCheckboxChecked;

package/dist/types/icons/components/IconCheckboxEmpty.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCheckboxEmpty: import('../lib/createIcon').FlowIconComponent;
+export default IconCheckboxEmpty;

package/dist/types/icons/components/IconCheckboxIndeterminate.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCheckboxIndeterminate: import('../lib/createIcon').FlowIconComponent;
+export default IconCheckboxIndeterminate;

package/dist/types/icons/components/IconChevronDown.d.ts

@@ -0,0 +1,2 @@
+export declare const IconChevronDown: import('../lib/createIcon').FlowIconComponent;
+export default IconChevronDown;

package/dist/types/icons/components/IconChevronLeft.d.ts

@@ -0,0 +1,2 @@
+export declare const IconChevronLeft: import('../lib/createIcon').FlowIconComponent;
+export default IconChevronLeft;

package/dist/types/icons/components/IconChevronRight.d.ts

@@ -0,0 +1,2 @@
+export declare const IconChevronRight: import('../lib/createIcon').FlowIconComponent;
+export default IconChevronRight;

package/dist/types/icons/components/IconChevronUp.d.ts

@@ -0,0 +1,2 @@
+export declare const IconChevronUp: import('../lib/createIcon').FlowIconComponent;
+export default IconChevronUp;

package/dist/types/icons/components/IconClose.d.ts

@@ -0,0 +1,2 @@
+export declare const IconClose: import('../lib/createIcon').FlowIconComponent;
+export default IconClose;

package/dist/types/icons/components/IconCode.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCode: import('../lib/createIcon').FlowIconComponent;
+export default IconCode;

package/dist/types/icons/components/IconContainer.d.ts

@@ -0,0 +1,2 @@
+export declare const IconContainer: import('../lib/createIcon').FlowIconComponent;
+export default IconContainer;

package/dist/types/icons/components/IconContextMenu.d.ts

@@ -0,0 +1,2 @@
+export declare const IconContextMenu: import('../lib/createIcon').FlowIconComponent;
+export default IconContextMenu;

package/dist/types/icons/components/IconContextMenuVertical.d.ts

@@ -0,0 +1,2 @@
+export declare const IconContextMenuVertical: import('../lib/createIcon').FlowIconComponent;
+export default IconContextMenuVertical;

package/dist/types/icons/components/IconContract.d.ts

@@ -0,0 +1,2 @@
+export declare const IconContract: import('../lib/createIcon').FlowIconComponent;
+export default IconContract;

package/dist/types/icons/components/IconContractPartner.d.ts

@@ -0,0 +1,2 @@
+export declare const IconContractPartner: import('../lib/createIcon').FlowIconComponent;
+export default IconContractPartner;

package/dist/types/icons/components/IconContributor.d.ts

@@ -0,0 +1,2 @@
+export declare const IconContributor: import('../lib/createIcon').FlowIconComponent;
+export default IconContributor;

package/dist/types/icons/components/IconCopy.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCopy: import('../lib/createIcon').FlowIconComponent;
+export default IconCopy;

package/dist/types/icons/components/IconCronjob.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCronjob: import('../lib/createIcon').FlowIconComponent;
+export default IconCronjob;

package/dist/types/icons/components/IconCustomer.d.ts

@@ -0,0 +1,2 @@
+export declare const IconCustomer: import('../lib/createIcon').FlowIconComponent;
+export default IconCustomer;

package/dist/types/icons/components/IconDanger.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDanger: import('../lib/createIcon').FlowIconComponent;
+export default IconDanger;

package/dist/types/icons/components/IconDashboard.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDashboard: import('../lib/createIcon').FlowIconComponent;
+export default IconDashboard;

package/dist/types/icons/components/IconDatabase.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDatabase: import('../lib/createIcon').FlowIconComponent;
+export default IconDatabase;

package/dist/types/icons/components/IconDate.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDate: import('../lib/createIcon').FlowIconComponent;
+export default IconDate;

package/dist/types/icons/components/IconDelete.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDelete: import('../lib/createIcon').FlowIconComponent;
+export default IconDelete;

package/dist/types/icons/components/IconDeliveryBox.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDeliveryBox: import('../lib/createIcon').FlowIconComponent;
+export default IconDeliveryBox;

package/dist/types/icons/components/IconDescending.d.ts

@@ -0,0 +1,2 @@
+export declare const IconDescending: import('../lib/createIcon').FlowIconComponent;
+export default IconDescending;