@guillotinaweb/react-gmi 0.35.0 → 0.35.1

package/dist/src/guillo-gmi/components/layout.d.ts

@@ -0,0 +1,8 @@
+import { Auth } from '../lib/auth';
+interface Props {
+    children: React.ReactNode;
+    onLogout: () => void;
+    auth: Auth;
+}
+export declare function Layout({ children, onLogout, auth }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/login.d.ts

@@ -0,0 +1,10 @@
+import { Auth } from '../lib/auth';
+interface Props {
+    currentSchema: string;
+    setCurrentSchema: (schema: string) => void;
+    schemas: string[];
+    auth: Auth;
+    onLogin?: () => void;
+}
+export declare const Login: ({ currentSchema, setCurrentSchema, schemas, auth, onLogin, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/modal.d.ts

@@ -0,0 +1,23 @@
+interface ModalProps {
+    isActive: boolean;
+    setActive: (value: boolean) => void;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function Modal(props: ModalProps): import('react').ReactPortal;
+interface ConfirmProps {
+    message?: React.ReactNode;
+    onCancel: () => void;
+    onConfirm: () => void;
+    loading?: boolean;
+}
+export declare function Confirm({ message, onCancel, onConfirm, loading, }: ConfirmProps): import("react/jsx-runtime").JSX.Element;
+interface PathTreeProps {
+    title: string;
+    defaultPath?: string;
+    children?: React.ReactNode;
+    onConfirm: (path: string, target: EventTarget) => void;
+    onCancel: () => void;
+}
+export declare function PathTree({ title, defaultPath, children, onConfirm, onCancel, }: PathTreeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/notallowed.d.ts

@@ -0,0 +1 @@
+export declare function NotAllowed(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/notfound.d.ts

@@ -0,0 +1 @@
+export declare function NotFound(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/pagination.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    current: number;
+    total: number;
+    doPaginate: (page: number) => void;
+    pager: number;
+}
+export declare function Pagination({ current, total, doPaginate, pager }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/src/guillo-gmi/components/panel/actions.d.ts

@@ -0,0 +1 @@
+export declare function PanelActions(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/panel/addons.d.ts

@@ -0,0 +1 @@
+export declare function PanelAddons(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/panel/behaviors.d.ts

@@ -0,0 +1 @@
+export declare function PanelBehaviors(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/panel/index.d.ts

@@ -0,0 +1,4 @@
+export * from './addons';
+export * from './actions';
+export * from './items';
+export * from './properties';

package/dist/src/guillo-gmi/components/panel/items.d.ts

@@ -0,0 +1 @@
+export declare function PanelItems(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/panel/permissions.d.ts

@@ -0,0 +1,7 @@
+export declare function PanelPermissions(): import("react/jsx-runtime").JSX.Element | null;
+interface AddPermissionProps {
+    refresh: (state: number) => void;
+    reset: number;
+}
+export declare function AddPermission({ refresh, reset }: AddPermissionProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/panel/permissions_prinperm.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    principals?: {
+        text: string;
+        value: string;
+    }[];
+    permissions?: {
+        text: string;
+        value: string;
+    }[];
+    operations: {
+        text: string;
+        value: string;
+    }[];
+    refresh: (value: number) => void;
+}
+export declare function PermissionPrinperm({ principals, permissions, operations, refresh, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/panel/permissions_prinrole.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    principals?: {
+        text: string;
+        value: string;
+    }[];
+    roles: {
+        text: string;
+        value: string;
+    }[];
+    operations: {
+        text: string;
+        value: string;
+    }[];
+    refresh: (value: number) => void;
+}
+export declare function PermissionPrinrole({ principals, roles, operations, refresh, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/panel/permissions_roleperm.d.ts

@@ -0,0 +1,17 @@
+interface Props {
+    roles: {
+        text: string;
+        value: string;
+    }[];
+    permissions?: {
+        text: string;
+        value: string;
+    }[];
+    operations: {
+        text: string;
+        value: string;
+    }[];
+    refresh: (value: number) => void;
+}
+export declare function PermissionRoleperm({ roles, permissions, operations, refresh, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/panel/properties.d.ts

@@ -0,0 +1 @@
+export declare function PanelProperties(): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/components/path.d.ts

@@ -0,0 +1 @@
+export declare function Path(): import("react/jsx-runtime").JSX.Element | null;

package/dist/src/guillo-gmi/components/properties_view.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export declare function PropertiesButtonView(): React.ReactElement<{
+    Ctx?: import('..').Traversal;
+}, string | React.JSXElementConstructor<any>> | null;
+export declare function PropertiesView(): React.ReactElement<{
+    Ctx?: import('..').Traversal;
+}, string | React.JSXElementConstructor<any>> | null;

package/dist/src/guillo-gmi/components/search_labels.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    query?: string;
+}
+export declare function SearchLabels({ query }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/src/guillo-gmi/components/search_options_labels.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    query?: string;
+    options?: {
+        value: string;
+        text: string;
+    }[];
+}
+export declare function SearchOptionsLabels({ query, options }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/src/guillo-gmi/components/search_vocabulary_labels.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    query?: string;
+    vocabularyName: string;
+}
+export declare function SearchVocabularyLabels({ query, vocabularyName }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/src/guillo-gmi/components/selected_items_actions.d.ts

@@ -0,0 +1,48 @@
+import { SearchItem } from '../types/guillotina';
+export declare const ItemsActionsCtx: import('react').Context<{
+    selected: {
+        all: boolean;
+        [key: string]: boolean;
+    };
+    onSelectOneItem?: (item: SearchItem) => void;
+    onSelectAllItems?: (chedked: boolean) => void;
+    onAction?: (action: string) => void;
+}>;
+/**
+ * Actions to apply after select some items
+ * Ex: Delete, Move, Copy...
+ */
+interface PropsItemsActionsProvider {
+    items: SearchItem[];
+    children: React.ReactNode;
+}
+export declare function ItemsActionsProvider({ items, children, }: PropsItemsActionsProvider): import("react/jsx-runtime").JSX.Element;
+export declare const useItemsActions: () => {
+    onAction: (action: string) => void;
+    onSelectOneItem: (item: SearchItem) => void;
+    onSelectAllItems: (chedked: boolean) => void;
+    selected: {
+        [key: string]: boolean;
+        all: boolean;
+    };
+};
+/**
+ * Checkbox component without props that consume the ItemsActionsContext
+ * and it select/unselect all items of the page.
+ */
+export declare function AllItemsCheckbox({ dataTest }: {
+    dataTest?: string;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Checkbox component to select ONE item.
+ */
+interface PropsItemCheckbox {
+    item: SearchItem;
+    dataTest?: string;
+}
+export declare function ItemCheckbox({ item, dataTest }: PropsItemCheckbox): import("react/jsx-runtime").JSX.Element;
+/**
+ * Dropdown to choose some action to apply to the selected items.
+ */
+export declare function ItemsActionsDropdown(): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/tabs.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { IndexSignature } from '../types/global';
+interface TabsPanelProps {
+    tabs: IndexSignature;
+    currentTab: string;
+    rightToolbar?: React.ReactNode;
+    fallback?: React.ComponentType<{
+        title: string;
+    }>;
+}
+type TabsPanelPropsWithChildren<T = Record<string, unknown>> = TabsPanelProps & T;
+export declare function TabsPanel<T extends Record<string, unknown> = Record<string, unknown>>({ tabs, currentTab, rightToolbar, fallback, ...restProps }: TabsPanelPropsWithChildren<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/ui/delete.d.ts

@@ -0,0 +1,8 @@
+import { MouseEvent } from 'react';
+interface Props {
+    onClick: (event: MouseEvent<HTMLButtonElement>) => void;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare function Delete({ onClick, className, children }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/ui/icon.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    icon: string;
+    className?: string;
+    align?: string;
+}
+export declare const Icon: ({ icon, className, align }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/ui/index.d.ts

@@ -0,0 +1,6 @@
+export * from './icon';
+export * from './loading';
+export * from './tag';
+export * from './delete';
+export * from './table';
+export * from './notification';

package/dist/src/guillo-gmi/components/ui/loading.d.ts

@@ -0,0 +1,6 @@
+import { IndexSignature } from '../../types/global';
+interface Props {
+    style?: IndexSignature;
+}
+export declare const Loading: ({ style }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/ui/notification.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    isColor?: string;
+    children: React.ReactNode;
+}
+export declare function Notification({ isColor, children }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/ui/table.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    headers?: string[];
+    className?: string;
+    children: React.ReactNode;
+}
+export declare function Table({ headers, children, className }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/ui/tag.d.ts

@@ -0,0 +1,9 @@
+interface Props {
+    name: string;
+    id: string;
+    onRemove?: () => void;
+    size?: string;
+    color?: string;
+}
+export declare const Tag: ({ name, id, onRemove, size, color, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/components/widgets/index.d.ts

@@ -0,0 +1 @@
+export * from './tags';

package/dist/src/guillo-gmi/components/widgets/tags.d.ts

@@ -0,0 +1,13 @@
+interface Props {
+    items: string[];
+    available?: {
+        value: string;
+        text: string;
+    }[];
+    title: string;
+    noData: string;
+    onChange: (items: string[]) => void;
+    loading?: boolean;
+}
+export declare function TagsWidget({ items, available, title, noData, onChange, loading, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/contexts/index.d.ts

@@ -0,0 +1,57 @@
+import { Dispatch } from 'react';
+import { GuillotinaClient } from '../lib/client.js';
+import { Auth } from '../lib/auth.js';
+import { IndexSignature } from '../types/global';
+import { GuillotinaGlobalState, GuillotinaReducerActionTypes } from '../reducers/guillotina';
+import { GuillotinaCommonObject } from '../types/guillotina.js';
+import { IManageRegistry } from '../hooks/useRegistry.js';
+export declare const AuthContext: import('react').Context<{}>;
+export declare const ClientContext: import('react').Context<GuillotinaClient | null>;
+interface PropsTraversal {
+    client: GuillotinaClient;
+    auth: Auth;
+    state: GuillotinaGlobalState;
+    dispatch: Dispatch<{
+        type: GuillotinaReducerActionTypes;
+        payload: IndexSignature;
+    }>;
+    registry: IManageRegistry;
+    flash?: (action: string, result: string) => void;
+    url: string;
+    children?: React.ReactNode;
+}
+export declare class Traversal {
+    private dispatch;
+    state: GuillotinaGlobalState;
+    client: GuillotinaClient;
+    registry: IManageRegistry;
+    url: string;
+    auth: Auth;
+    constructor({ flash, ...props }: PropsTraversal);
+    refresh({ transparent }?: {
+        transparent?: boolean | undefined;
+    }): void;
+    get path(): string;
+    get pathPrefix(): string;
+    get context(): GuillotinaCommonObject;
+    get containerPath(): string;
+    apply(data: IndexSignature): void;
+    flash(message: string, type: string): void;
+    clearFlash(): void;
+    doAction(action: string, params?: {}): void;
+    cancelAction(): void;
+    hasPerm(permission: string): boolean;
+    filterTabs(tabs: IndexSignature, tabsPermissions: IndexSignature): IndexSignature<any>;
+}
+export declare const TraversalContext: import('react').Context<Traversal | null>;
+export declare function TraversalProvider({ children, ...props }: PropsTraversal & {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useTraversal(): Traversal;
+interface PropsClient {
+    children: React.ReactNode;
+    client: GuillotinaClient;
+}
+export declare function ClientProvider({ children, client }: PropsClient): import("react/jsx-runtime").JSX.Element;
+export declare function useGuillotinaClient(): GuillotinaClient;
+export {};

package/dist/src/guillo-gmi/forms/base.d.ts

@@ -0,0 +1,12 @@
+export interface BaseFormProps {
+    onSubmit: (data: {
+        title: string;
+        id: string;
+    }) => void;
+    actionName?: string;
+    title?: string;
+    dataTest?: string;
+    loading?: boolean;
+    type: string;
+}
+export declare function BaseForm({ onSubmit, actionName, title, dataTest, loading, }: BaseFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/guillo-gmi/forms/required_fields.d.ts

@@ -0,0 +1,11 @@
+import { IndexSignature } from '../types/global';
+interface Props {
+    onSubmit: (data: IndexSignature) => void;
+    actionName?: string;
+    title?: string;
+    dataTest?: string;
+    loading?: boolean;
+    type: string;
+}
+export declare function RequiredFieldsForm({ loading, onSubmit, actionName, title, dataTest, type, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/forms/users.d.ts

@@ -0,0 +1,12 @@
+import { IndexSignature } from '../types/global';
+interface Props {
+    children: React.ReactNode;
+    onSubmit: (data: IndexSignature) => void;
+    actionName: string;
+    formData?: IndexSignature;
+    exclude?: string[];
+    remotes?: IndexSignature;
+    submitButton?: boolean;
+}
+export declare const UserForm: ({ children, actionName, onSubmit, formData, exclude, remotes, submitButton, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/guillo-gmi/hooks/useClickAway.d.ts

@@ -0,0 +1 @@
+export default function useClickAway(ref: React.RefObject<HTMLElement>, onClickAway: (event: Event) => void, events?: string[]): void;

package/dist/src/guillo-gmi/hooks/useConfig.d.ts

@@ -0,0 +1,19 @@
+import { GuillotinaSchemaProperty } from '../types/guillotina';
+export declare const Permissions: string[];
+export interface IConfig {
+    DisabledTypes: string[];
+    PageSize: number;
+    DelayActions: number;
+    Permissions: string[];
+    SearchEngine: string;
+    SizeImages?: string[];
+    icons?: {
+        [key: string]: string;
+    };
+    properties_default?: string[];
+    properties_ignore_fields?: string[];
+    fieldHaveDeleteButton: (schema: GuillotinaSchemaProperty) => boolean;
+    flash?: (message: string, type: string) => void;
+}
+export declare const defaultConfig: IConfig;
+export declare function useConfig(cfg?: {}): IConfig;

package/dist/src/guillo-gmi/hooks/useCrudContext.d.ts

@@ -0,0 +1,21 @@
+import { Traversal } from '../contexts';
+interface State<T> {
+    loading?: boolean;
+    isError?: boolean;
+    errorMessage?: string;
+    result?: T;
+    response?: unknown;
+}
+export declare function useCrudContext<T>(): {
+    Ctx: Traversal;
+    patch: (data?: {}, endpoint?: string, body?: boolean) => Promise<State<T>>;
+    del: (data?: {}, endpoint?: string, body?: boolean) => Promise<State<T>>;
+    post: (data?: {}, endpoint?: string, body?: boolean) => Promise<State<T>>;
+    get: (endpoint?: string) => Promise<State<T>>;
+    loading?: boolean;
+    isError?: boolean;
+    errorMessage?: string;
+    result?: T | undefined;
+    response?: unknown;
+};
+export {};

package/dist/src/guillo-gmi/hooks/useInput.d.ts

@@ -0,0 +1,11 @@
+import { ChangeEvent } from 'react';
+declare const useInput: (onChange: (value: string) => void | undefined, value: string, validators: ((value: string) => boolean)[]) => {
+    onChange: (ev: ChangeEvent<HTMLInputElement>) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    state: {
+        hasError: boolean;
+        value: string;
+    };
+};
+export default useInput;

package/dist/src/guillo-gmi/hooks/useLocation.d.ts

@@ -0,0 +1,2 @@
+import { IndexSignature } from '../types/global';
+export declare const useLocation: () => [URLSearchParams, (to: IndexSignature, replace?: boolean) => void, (param: string) => void];

package/dist/src/guillo-gmi/hooks/useMountedState.d.ts

@@ -0,0 +1 @@
+export default function useMountedState(): () => boolean;

package/dist/src/guillo-gmi/hooks/useRegistry.d.ts

@@ -0,0 +1,95 @@
+import { FolderCtx } from '../views/folder';
+import { BaseFormProps } from '../forms/base';
+import { default as React } from 'react';
+import { GuillotinaCommonObject, ItemColumn, RegistrySchema, SearchOrCommonObject } from '../types/guillotina';
+import { MessageDescriptor } from 'react-intl';
+import { Traversal } from '../contexts';
+export interface RegistrySortValue {
+    direction: 'asc' | 'des';
+    key: string;
+}
+export interface RegistryProperties {
+    Buttons: React.ReactElement<{
+        Ctx?: Traversal;
+    }>;
+    Panels: React.ReactElement<{
+        Ctx?: Traversal;
+    }>;
+    default: string[];
+    ignoreField: string[];
+}
+export interface IRegistry {
+    paths: {
+        [key: string]: React.FC;
+    };
+    views: {
+        [key: string]: React.ComponentType<any>;
+    };
+    actions: {
+        [key: string]: (props: any) => React.ReactElement;
+    };
+    forms: {
+        [key: string]: (props: any) => React.ReactElement;
+    };
+    behaviors: {
+        [key: string]: (props: any | undefined) => React.ReactElement | null;
+    };
+    itemsColumn: {
+        [key: string]: <T extends SearchOrCommonObject = SearchOrCommonObject>() => ItemColumn<T>[];
+    };
+    schemas: {
+        [key: string]: RegistrySchema;
+    };
+    properties: {
+        [key: string]: RegistryProperties;
+    };
+    components: {
+        [key: string]: (props: any) => React.ReactNode | null | undefined;
+    };
+    searchEngineQueryParamsFunction: {
+        [key: string]: string;
+    };
+    fieldsToFilter: {
+        [key: string]: string[];
+    };
+    parseSearchQueryParamFunction: {
+        [key: string]: (query: string, type: string) => string;
+    };
+    defaultSortValue: {
+        [key: string]: RegistrySortValue;
+    };
+    actionsList: {
+        [key: string]: (multiple: boolean) => {
+            [key: string]: {
+                text: MessageDescriptor;
+                perms: string[];
+                action: string;
+            };
+        };
+    };
+}
+export interface IManageRegistry {
+    registry: IRegistry;
+    getPathComponent: (context: GuillotinaCommonObject | undefined, path: string, fallback?: React.FC) => React.ComponentType<any>;
+    getComponent: (name: string) => React.ComponentType<any>;
+    getView: (name: string) => React.ComponentType<any>;
+    getForm: (type: string, fallback?: React.FC) => React.FC<BaseFormProps>;
+    getAction: (type: string, fallback?: React.FC) => React.FC;
+    getBehavior: (type: string, fallback?: React.FC) => React.FC<any>;
+    getProperties: (type: string) => RegistryProperties;
+    getItemsColumn: <T extends SearchOrCommonObject = SearchOrCommonObject>(type: string) => ItemColumn<T>[] | undefined;
+    getSchemas: (type: string) => RegistrySchema;
+    getFieldsToFilter: (type: string, fallback?: string[]) => string[];
+    getParsedSearchQueryParam: (query: string, type: string) => string;
+    getDefaultSortValue: (type: string, fallback?: RegistrySortValue) => RegistrySortValue;
+    getSearchEngineQueryParamsFunction: (type: string) => string;
+    getActionsList: (type: string, multiple: boolean) => {
+        [key: string]: {
+            text: MessageDescriptor;
+            perms: string[];
+            action: string;
+        };
+    };
+}
+export declare const defaultComponent: (context: GuillotinaCommonObject) => typeof FolderCtx;
+export declare function useRegistry(data: Partial<IRegistry>): IManageRegistry;

package/dist/src/guillo-gmi/hooks/useRemoteField.d.ts

@@ -0,0 +1,2 @@
+import { IndexSignature } from '../types/global';
+export declare const useRemoteField: (initial: IndexSignature<string[]>) => [IndexSignature<string[]>, (name: string) => (value: string[]) => void];

package/dist/src/guillo-gmi/hooks/useSetState.d.ts

@@ -0,0 +1,6 @@
+export type TSetState<T> = (newPartialState: Partial<T>) => void;
+/**
+ * Do setState like react class component.
+ */
+declare function useSetState<T extends object>(initialState: T): [T, TSetState<T>];
+export default useSetState;

package/dist/src/guillo-gmi/hooks/useVocabulary.d.ts

@@ -0,0 +1,8 @@
+import { GuillotinaVocabulary } from '../types/guillotina';
+interface State {
+    data?: GuillotinaVocabulary;
+    loading: boolean;
+    error: any;
+}
+export declare function useVocabulary(vocabularyName: string, path?: string): State;
+export {};

package/dist/src/guillo-gmi/index.d.ts

@@ -0,0 +1,30 @@
+export * from './actions';
+export * from './components';
+export * from './contexts';
+export * from './forms/base';
+export * from './forms/users';
+export * from './forms/required_fields';
+export * from './hooks/useConfig';
+export * from './hooks/useCrudContext';
+export * from './hooks/useInput';
+export * from './hooks/useRemoteField';
+export * from './hooks/useLocation';
+export * from './hooks/useRegistry';
+export * from './hooks/useVocabulary';
+export * from './lib/helpers';
+export * from './lib/validators';
+export * from './lib/utils';
+export * from './lib/client';
+export * from './lib/auth';
+export * from './lib/rest';
+export * from './lib/search';
+export * from './models';
+export * from './views/base';
+export * from './views/application';
+export * from './views/container';
+export * from './views/folder';
+export * from './views/item';
+export * from './views/users';
+export * from './views/groups';
+export * from './locales/generic_messages';
+export * from './types/guillotina';