import { Resource } from 'i18next';
import { Endpoint, AdminView, Locale as Locale$1, Config } from 'payload/config';
import { FieldBase, Tab, UIField } from 'payload/dist/fields/config/types';
import * as payload_types from 'payload/types';
import { AccessArgs, CollectionConfig, PayloadRequest, SanitizedCollectionConfig, Field, CollectionAfterChangeHook, CollectionAfterDeleteHook, TypeWithID, BeforeDuplicate, Where, Block, GlobalConfig, FieldHook, RichTextField, RelationshipField, CheckboxField, BlockField, DateField, TextField, GroupField, UploadField, ArrayField, NumberField, SelectField, Option as Option$1, CollapsibleField, RowField, TabsField } from 'payload/types';
import * as payload_dist_admin_components_forms_FieldDescription_types from 'payload/dist/admin/components/forms/FieldDescription/types';
import * as React from 'react';
import React__default, { ReactNode } from 'react';
import * as _websolutespa_bom_core from '@websolutespa/bom-core';
import { UserWithRoles, IRoute, IEquatable, ICategory, ILocale, ICategorized, IEntity, IMarket, IMemoryStore, ILocalizable, IMedia, MenuCategoryStrategy, IPageRelation, ISchema, IMenuItem, IMenuGroup, IMenuLink, IMenuPage, IMenuRoute, IMenu } from '@websolutespa/bom-core';
import { DocumentDrawerProps } from 'payload/dist/admin/components/elements/DocumentDrawer/types';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { TreeDataProvider, TreeItemIndex, TreeItem, Disposable, TreeItemRenderContext, TreeInformation } from 'react-complex-tree';
import { Props as Props$2 } from 'payload/dist/admin/components/views/collections/List/types';
import { User } from 'payload/dist/auth';
import { PaginatedDocs } from 'payload/database';
import { Response, NextFunction } from 'express';
import { RequestContext } from 'payload';
import { ContextType } from 'payload/dist/admin/components/utilities/DocumentInfo/types';
import { Props as Props$3 } from 'payload/components/views/Cell';
import { Props as Props$4 } from 'payload/components/fields/Text';
import { FieldTypes } from 'payload/dist/admin/components/forms/field-types';

declare const hasRole: (user: User, ...roles: BowlRole[]) => boolean;
declare const isRole: (...roles: BowlRole[]) => (args: AccessArgs) => boolean;
declare const isPageRole: (...roles: BowlRole[]) => (args: AccessArgs) => boolean | {
    or: ({
        _status: {
            equals: string;
            exists?: undefined;
        };
    } | {
        _status: {
            exists: boolean;
            equals?: undefined;
        };
    })[];
};
declare const isAdmin: (args: AccessArgs) => boolean;
declare const isSelf: (args: AccessArgs) => false | {
    id: {
        equals: any;
    };
};
declare const isOwn: (args: AccessArgs) => false | {
    'user.id': {
        equals: any;
    };
};
declare const isAdminOrSelf: (args: AccessArgs) => boolean | {
    id: {
        equals: any;
    };
};
declare const isAdminOrOwn: (args: AccessArgs) => boolean | {
    'user.id': {
        equals: any;
    };
};
declare const isTenant: (slug: string) => (args: AccessArgs) => false | {
    id: {
        in: string[];
    };
} | {
    and: {
        or: ({
            [x: string]: {
                in: string[];
            };
        } | {
            [x: string]: {
                exists: boolean;
            };
        } | {
            [x: string]: {
                equals: string;
            };
        } | {
            [x: string]: {
                equals: any[];
            };
        })[];
    }[];
};

type IEndUserConsentPreference = {
    consentPreference: string;
    date: string | Date;
};
type IEndUserData = Partial<UserWithRoles & {
    consentPreferences?: IEndUserConsentPreference[];
}>;
declare const optinGet: Endpoint;
declare const optoutGet: Endpoint;
/**
   * beforeValidateActionHook:
   * check existing email address if createEndUser == 'user'
   */
declare const beforeValidateActionHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['beforeValidate'][number];
/**
 * beforeChangeActionHook:
 * assigning endUser id if user is logged in
 */
declare const beforeChangeActionHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['beforeChange'][number];
/**
 * afterChangeActionHook:
 * on operation create, send emails if the post data contains an emailData array
 */
declare const afterChangeActionHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['afterChange'][number];

type ICache<T = any> = {
    timestamp: number;
    data: T;
};
type InMemoryCacheOptions = {
    duration?: number | false;
};
declare class InMemoryCache<T = any> {
    duration: number | false;
    cache: Map<string, ICache<T>>;
    constructor(options?: InMemoryCacheOptions);
    private isExpired_;
    has(key: string): boolean;
    get(key: string): T;
    set(key: string, data: T): void;
}
declare function keyWithRequest(key: string, req: PayloadRequest<any>): string;

type CategoryMenuProps = {
    collection: SanitizedCollectionConfig;
};
declare const CategoryMenu: React__default.FC<CategoryMenuProps>;

type CategoryTreeConflictProps = {
    conflicts: IRoute[][];
};
type RouteConflict = {
    schema: string;
    page: IEquatable;
    template: string;
    category: IEquatable;
    routes: IRoute[];
};
type CategoryTreeProps = {
    collection: SanitizedCollectionConfig;
};
declare const CategoryTree: React__default.FC<CategoryTreeProps>;

type CustomEditModalProps = DocumentDrawerProps & {
    filter?: (fields: Field[]) => Field[];
};
declare const CustomEditModal: React__default.FC<CustomEditModalProps>;

type TreeItemData = {
    title: string;
    extra?: ReactNode;
};
declare class DataTreeProvider<T extends TreeItemData> implements TreeDataProvider {
    private data;
    private onDidChangeTreeDataEmitter;
    private onSetData?;
    constructor(items: Record<TreeItemIndex, TreeItem<T>>, onSetData?: (item: TreeItem<T>, data: T) => TreeItem<T>);
    getTreeItem(itemId: TreeItemIndex): Promise<TreeItem>;
    onChangeItemChildren(itemId: TreeItemIndex, children: TreeItemIndex[]): Promise<void>;
    onRenameItem(item: TreeItem<T>, name: string): Promise<void>;
    onDidChangeTreeData(callback: (changedItemIds: TreeItemIndex[]) => void): Disposable;
    onItemsDidChange_(items: Record<TreeItemIndex, TreeItem<T>>): void;
    onItemsDidChange(callback: (items: Record<TreeItemIndex, TreeItem<T>>) => void): void;
}

type TreeItems<T extends TreeItemData> = Record<TreeItemIndex, TreeItem<T>>;
type DataTreeItemProps<T extends TreeItemData = TreeItemData, C extends string = never> = {
    item: TreeItem<T>;
    depth: number;
    children: React__default.ReactNode | null;
    title: React__default.ReactNode;
    arrow: React__default.ReactNode;
    context: TreeItemRenderContext<C>;
    info: TreeInformation;
};
declare function getTreeItemClassName(props: DataTreeItemProps): string;
declare const DataTreeItemLi: (props: DataTreeItemProps & {
    interactive: ReactNode;
}) => React__default.ReactElement;
declare const DataTreeDragItem: (props: DataTreeItemProps) => React__default.ReactElement;
declare const DataTreeRenameItem: (props: DataTreeItemProps) => React__default.ReactElement;
declare const DataTreeItem: (props: DataTreeItemProps) => React__default.ReactElement;
type DataTreeInstance<T extends TreeItemData> = {
    onSetData: (item: TreeItem<T>, data: T) => TreeItem<T>;
};
type DataTreeProps<T extends TreeItemData> = {
    items: TreeItems<T>;
    rootItem?: string;
    treeId?: string;
    treeLabel?: string;
    onChange?: (items: TreeItems<T>) => void;
    onEdit?: (items: TreeItem<T>, treeId: string) => void;
};
declare function DataTree_<T extends TreeItemData>(props: DataTreeProps<T>, ref: React__default.ForwardedRef<DataTreeInstance<T>>): react_jsx_runtime.JSX.Element;
declare const DataTree: <T extends TreeItemData>(props: DataTreeProps<T> & {
    ref?: React__default.ForwardedRef<DataTreeInstance<T>>;
}) => ReturnType<typeof DataTree_>;

type DecoratedListProps = {
    props: Props$2;
    before?: ReactNode;
    after?: ReactNode;
};
declare const DecoratedList: React__default.FC<DecoratedListProps>;

type IImportItem = Record<string, string | number | boolean | Date>;

type ImportExportListProps<T = any> = Props$2 & {
    parser?: (items: IImportItem[]) => T[];
};
declare const ImportExportList: React__default.FC<ImportExportListProps>;
declare function importExportListWithParser<T>(parser: (items: IImportItem[]) => T[]): React__default.FC<Props$2>;

declare const redirectParser: (items: IImportItem[]) => any[];
declare const ImportExportRedirectList: React__default.FC<ImportExportListProps>;

declare const modalSlug = "leave-without-saving";
type LeaveWithoutSavingModalProps = {
    onConfirm: () => void;
    onCancel: () => void;
};
declare const LeaveWithoutSavingModal: React__default.FC<LeaveWithoutSavingModalProps>;
declare const LeaveModal: (props: {
    visible: boolean;
}) => react_jsx_runtime.JSX.Element;

type LocalizedDescriptionProps = {
    value?: unknown;
    callback: (value?: unknown) => string;
};
declare const LocalizedDescription: React__default.FC<LocalizedDescriptionProps>;
declare function withLocalizedDescription(callback: (value?: unknown) => string): React__default.FunctionComponent<{
    path: string;
    value?: unknown;
}>;

type Props$1 = {};
declare const Publish: React__default.FC<Props$1>;

type Props = {};
declare const Save: React__default.FC<Props>;

declare const SaveDraft: React__default.FC;

/**
 * afterCategoryChangeHook.
 */
declare const afterCategoryChangeHook: CollectionAfterChangeHook;
/**
 * afterCategoryDeleteHook.
 */
declare const afterCategoryDeleteHook: CollectionAfterDeleteHook;
declare const ROOT_ITEM = "_root";
type CategoryTreeItem = {
    title: string;
    conflicts: IRoute[][];
    extra?: ReactNode;
};
type CategoryTreeItems = TreeItems<CategoryTreeItem>;
declare function getNewCategoriesFromChanges(categories: ICategory[], changes: CategoryTreeItems): {
    [x: string]: unknown;
    id: _websolutespa_bom_core.IEquatable;
    schema?: string;
    category?: _websolutespa_bom_core.IEquatable | ICategory;
    media?: _websolutespa_bom_core.IMedia;
    order?: number;
    slug: _websolutespa_bom_core.ILocalizable; /**
     * afterCategoryChangeHook.
     */
    title: _websolutespa_bom_core.ILocalizable;
    isHidden?: boolean;
}[];

declare function parseDepth(depth: unknown, defaultDepth?: number): number;
declare function getCollectionItems<T extends TypeWithID & Record<string, unknown>>(req: PayloadRequest, slug: string, depth?: number): Promise<T[]>;
declare function getCollectionItem<T extends TypeWithID & Record<string, unknown>>(req: PayloadRequest, slug: string, id: string, depth?: number): Promise<T>;
declare function getGlobalItems<T extends TypeWithID & Record<string, unknown>>(req: PayloadRequest, slug: string, depth?: number): Promise<T[]>;
/**
 * Rest api collection index get handler.
 */
declare const collectionIndexGet: ((slug: string) => Endpoint);
/**
 * Rest api collection detail get handler.
 */
declare const collectionDetailGet: ((slug: string) => Endpoint);
/**
 * Rest api collection bulk patch handler.
 */
declare const collectionBulkPatch: ((slug: string) => Endpoint);
/**
 * Rest api collection update patch handler.
 * known issue: collectionUpdatePatch() does not work, needs to be fixed
 */
declare const collectionUpdatePatch: ((slug: string) => Endpoint);
/**
 * Rest api collection export get handler.
 */
declare const collectionExportGet: ((slug: string) => Endpoint);
declare enum ImportLogType {
    Duplicate = "duplicate",
    Invalid = "invalid",
    Required = "required",
    Unexpected = "unexpected",
    Optional = "optional"
}
declare const ImportLogInvalidTypes: ImportLogType[];
declare enum ImportMode {
    Append = "append",
    Replace = "replace",
    Update = "update"
}
/**
 * Rest api collection import post handler.
 */
declare const collectionImportPost: ((slug: string) => Endpoint);
/**
 * Decorate record with static collection data.
 */
declare const afterCollectionReadHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['afterRead'][number];
/**
 * Enforce unique field values during duplication.
 */
declare const beforeDuplicateCollectionHook: BeforeDuplicate;

declare function getLocale(req: PayloadRequest<any>): Promise<ILocale[]>;
declare const localeGet: Endpoint;

/**
 * Rest api menu get handler.
 */
declare const menuIndexGet: ((options: BowlOptions) => Endpoint);
/**
 * Rest api menu detail get handler.
 */
declare const menuDetailGet: ((options: BowlOptions) => Endpoint);
/**
 * Decorate record for Mixer when queried by market and locale.
 */
declare const afterMenuReadHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['afterRead'][number];

/**
 * Rest api page collection get handler.
 */
declare const pageIndexGet: ((slug: string) => Endpoint);
/**
 * Rest api page collection detail get handler.
 */
declare const pageDetailGet: ((slug: string) => Endpoint);
/**
 * Modify record for Mixer when queried by market and locale.
 */
declare const afterPageOperationHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['afterOperation'][number];
/**
 * Decorate record for Mixer when queried by market and locale.
 */
declare const afterPageReadHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['afterRead'][number];
/**
 * Create a record of the pages collection related to the created document.
 */
declare const afterPageChangeHook: CollectionAfterChangeHook<ICategorized>;
/**
 * Delete records of the pages collection related to the deleted document.
 */
declare const afterPageDeleteHook: CollectionAfterDeleteHook;

type IPagination = {
    hasNextPage: boolean;
    hasPrevPage: boolean;
    limit: number;
    nextPage: number | null;
    page: number;
    pagingCounter: number;
    prevPage: number | null;
    totalDocs: number;
    totalPages: number;
};
declare function getPagination<T = IEntity>(items: T[], page?: number, limit?: number): Promise<PaginatedDocs<T>>;

declare function getRoutes(req: PayloadRequest): Promise<IRoute[]>;
declare function getRoute(req: PayloadRequest<any>, id: string): Promise<IRoute | null>;
declare function getRouteByItemAndLocale(req: PayloadRequest<any>, item: ICategorized, localeId: string, slug: string): Promise<IRoute[]>;
declare function getRouteByCategoryAndLocale(req: PayloadRequest<any>, item: ICategory, localeId: string, slug: string): Promise<IRoute[]>;
declare const routeGet: Endpoint;
declare const routePost: Endpoint;
declare const routeChangesPost: Endpoint;
declare function routePostHandler(request: PayloadRequest, response: Response, next: NextFunction): Promise<Response<any, Record<string, any>>>;
declare function getEachMarketLocale(req: PayloadRequest<any>, callback: (market: IMarket, locale: ILocale, markets: IMarket[], locales: ILocale[]) => void): Promise<void>;
declare function getPages(req: PayloadRequest<any>): Promise<IMemoryStore<ICategorized>>;

type Option = {
    id: string;
    name: string;
    [key: string]: unknown;
};
type KeyMapper = {
    [key: string]: string;
};
declare const staticCollections: string[];
declare const staticCollectionLoaders: Record<string, () => Promise<Option[]>>;
/**
 * Decorate record with static collection data.
 */
declare const afterStaticReadHook: (collectionConfig: CollectionConfig) => CollectionConfig['hooks']['afterRead'][number];
declare const afterReadItem: (req: PayloadRequest, collectionConfig: CollectionConfig, item: Option) => Promise<Option>;
declare const afterReadItems: (req: PayloadRequest, collectionConfig: CollectionConfig, items: Option[]) => Promise<Option[]>;
/**
 * Rest api static collection get handler.
 */
declare const staticIndexGet: ((collectionConfig: CollectionConfig) => Endpoint);
/**
 * Rest api static collection detail get handler.
 */
declare const staticDetailGet: ((collectionConfig: CollectionConfig) => Endpoint);
declare function getStaticLoader(slug: string): () => Promise<Option[]>;

type FindOptions = {
    context?: RequestContext;
    currentDepth?: number;
    depth?: number;
    disableErrors?: boolean;
    draft?: boolean;
    fallbackLocale?: string;
    limit?: number;
    locale?: string;
    overrideAccess?: boolean;
    page?: number;
    pagination?: boolean;
    req?: PayloadRequest;
    showHiddenFields?: boolean;
    sort?: string;
    user?: any;
    where?: Where;
};
declare function findCollection<T>(req: PayloadRequest, collection: string, findOptions?: Omit<FindOptions, 'req'>): Promise<T[]>;
declare function getApiUrl(req: PayloadRequest): string;
declare function getSearchUrl(req: PayloadRequest, overrideQuery?: {}): string;
declare const storeGet: Endpoint;

type IPage = {
    id: string;
    content: {
        value: string;
        relationTo: string;
    };
    createdAt: Date;
    updatedAt: Date;
};
type IPageFull = {
    id: string;
    content: {
        value: {
            id: string;
            slug: ILocalizable;
            category: string;
            category_index?: boolean;
            markets: string[];
            template: string;
            title: ILocalizable;
            _status: string;
            createdAt: Date;
            updatedAt: Date;
        };
        relationTo: string;
    };
    createdAt: Date;
    updatedAt: Date;
};
type IUndecoratedMenuBase = {
    id: IEquatable;
    type: string;
    items: IUndecoratedMenuItem[];
    abstract?: string;
    customClass?: string;
    extra?: string;
    markets?: string[];
    media?: IMedia;
};
type IUndecoratedMenuCategory = Omit<IUndecoratedMenuBase, 'type'> & {
    type: 'category';
    category: IEquatable | ICategory;
    maxDepth: number;
    strategy?: MenuCategoryStrategy;
    customTitle?: string;
};
type IUndecoratedMenuGroup = Omit<IUndecoratedMenuBase, 'type'> & {
    type: 'group';
    title: string;
};
type IUndecoratedMenuLink = Omit<IUndecoratedMenuBase, 'type'> & {
    type: 'link';
    title: string;
    href: string;
    target: string;
};
type IUndecoratedMenuPage = Omit<IUndecoratedMenuBase, 'type'> & {
    type: 'page';
    page: IPageRelation;
    customTitle?: string;
};
type IUndecoratedMenuCustom = Record<string, unknown> & {
    id: IEquatable;
    type: 'custom';
    blockType: string;
};
type IUndecoratedMenuItem = IUndecoratedMenuCategory | IUndecoratedMenuGroup | IUndecoratedMenuLink | IUndecoratedMenuPage | IUndecoratedMenuCustom;
type IUndecoratedNavItem = IUndecoratedMenuCategory | IUndecoratedMenuPage;
type IUndecoratedMenu = {
    createdAt: Date;
    id: string;
    items: IUndecoratedMenuItem[];
    markets?: string[];
    updatedAt: Date;
};
type MixerContext = {
    market?: string;
    locale?: string;
    routes?: IRoute[];
    currentRoutes?: IRoute[];
    categories?: ICategory[];
    richText?: boolean;
    locales?: string[];
    markets?: string[];
};

declare function getObjectParam(value: unknown): {} | undefined;
declare function getNumericParam(value: unknown): number | undefined;
declare function getStringParam(value: unknown): string | undefined;
declare function getSubRequest(req: PayloadRequest): PayloadRequest;
declare function setMixerContext(req: PayloadRequest, market: string, locale: string): Promise<MixerContext>;
declare function filterRoutes(routes: IRoute[], market: string, locale: string): IRoute[];
declare function isMixerRequest(req: PayloadRequest): req is Omit<PayloadRequest, 'query'> & {
    query: PayloadRequest['query'] & {
        market: string;
        locale: string;
    };
};

declare function whereCollection<T = IEntity>(items: T[], where?: {
    [key: string]: any;
}): Promise<T[]>;
declare function sortCollection<T = IEntity>(items: T[], sort?: string): Promise<T[]>;

type AfterOptHook<T extends TypeWithID = any> = (args: {
    collection: SanitizedCollectionConfig;
    doc: T;
    previousDoc: T;
    req: PayloadRequest;
}) => any;
type WithActionProps = (Omit<CollectionConfig, 'fields'> & {
    fields?: BowlField[];
    views?: Record<string, AdminView>;
    custom?: {
        /**
         *
        * eg.
        * contacts
        * newsletter
        * registration
        * order guest
        * order logged
        */
        createEndUser?: false | 'guest' | 'user';
        afterOptin?: AfterOptHook;
        afterOptout?: AfterOptHook;
        [key: string]: unknown;
    };
});
type WithAction = WithActionProps & {
    type: 'withAction';
};
declare const ActionDefault: Partial<CollectionConfig>;
/**
 * @param {CollectionConfig} config
 * @returns {CollectionConfig} Return a `CollectionConfig`.
 */
declare const withAction: (config: WithActionProps) => CollectionConfig;

type WithAddressProps = (Omit<CollectionConfig, 'fields'> & {
    fields: BowlField[];
    views?: Record<string, AdminView>;
});
type WithAddress = WithAddressProps & {
    type: 'withAddress';
};
declare const AddressDefault: Partial<CollectionConfig>;
/**
 *
 * @param {WithAddressProps} config
 * @returns {CollectionConfig} Return a `CollectionConfig` with inherited fields: `id`, `createdAt`, `updatedAt`.
 */
declare const withAddress: (config: WithAddressProps) => CollectionConfig;

type WithBlockProps = (Omit<Block, 'fields'> & {
    fields: BowlField[];
});
type WithBlock = WithBlockProps & {
    type: 'withBlock';
};
declare const BlockDefaults: Partial<Block>;
/**
 *
 * @param {Block} config
 * @returns {Block} Return a `Block` with inherited fields: `id`, `createdAt`, `updatedAt`.
 */
declare const withBlock: (options: BowlBlock) => Block;

type WithCollectionProps = (Omit<CollectionConfig, 'fields'> & {
    fields: BowlField[];
    views?: Record<string, AdminView>;
});
type WithCollection = WithCollectionProps & {
    type: 'withCollection';
};
declare const CollectionDefault: Partial<CollectionConfig>;
/**
 *
 * @param {CollectionConfig} config
 * @returns {CollectionConfig} Return a `CollectionConfig` with inherited fields: `id`, `createdAt`, `updatedAt`.
 */
declare const withCollection: (config: WithCollectionProps) => CollectionConfig;

type WithEndUserProps = (Omit<CollectionConfig, 'fields'> & {
    fields?: BowlField[];
    views?: Record<string, AdminView>;
});
type WithEndUser = WithEndUserProps & {
    type: 'withEndUser';
};
declare const EndUserDefault: Partial<CollectionConfig>;
declare const endUserForgotPost: ((slug: string) => Endpoint);
declare const endUserResetPost: ((slug: string) => Endpoint);
declare const endUserPasswordPost: ((slug: string) => Endpoint);
declare const endUserExistPost: ((slug: string) => Endpoint);
declare const withEndUser: (config: WithEndUserProps) => CollectionConfig;

type WithGlobalProps = (Omit<GlobalConfig, 'fields'> & {
    fields: BowlField[];
    views?: Record<string, AdminView>;
});
type WithGlobal = WithGlobalProps & {
    type: 'withGlobal';
};
declare const GlobalDefault: Partial<GlobalConfig>;
/**
 *
 * @param {GlobalConfig} config
 * @returns {GlobalConfig} Return a `GlobalConfig` with inherited fields: `id`, `createdAt`, `updatedAt`.
 */
declare const withGlobal: (config: WithGlobalProps) => GlobalConfig;

type WithMenuProps = (Omit<CollectionConfig, 'fields'> & {
    fields: BowlField[];
    views?: Record<string, AdminView>;
});
type WithMenu = WithMenuProps & {
    type: 'withMenu';
};
declare const withMenu: (config: WithMenuProps) => CollectionConfig;

type WithPageProps = (Omit<CollectionConfig, 'fields'> & {
    fields: BowlField[];
    views?: Record<string, AdminView>;
});
type WithPage = WithPageProps & {
    type: 'withPage';
};
declare const PageDefault: Partial<CollectionConfig>;
/**
 *
 * @param {CollectionConfig} config
 * @returns {CollectionConfig} Return a `CollectionConfig` with inherited fields: `id`, `title`, `slug`, `category`, `markets`, `template`, `meta`, `status`, `createdAt`, `updatedAt`.
 */
declare const withPage: (config: CollectionConfig) => CollectionConfig;

type WithStaticProps = (Omit<CollectionConfig, 'fields'> & StaticCollectionConfig & {
    fields: BowlField[];
    views?: Record<string, AdminView>;
});
type WithStatic = WithStaticProps & {
    type: 'withStatic';
};
type StaticCollectionSrc = string | Option[] | ((config: CollectionConfig) => Option[]) | ((config: CollectionConfig) => Promise<Option[]>);
type StaticCollectionConfig = {
    src: StaticCollectionSrc;
    map?: KeyMapper;
    duration?: number | false;
};
declare const StaticCollectionDefault: Partial<CollectionConfig>;
/**
 * @param {CollectionConfig & StaticCollectionConfig} config
 * @returns {CollectionConfig} Return a `CollectionConfig` from static or remote dataset.
 */
declare const withStaticCollection: ({ src, map, duration, ...config }: WithStaticProps) => CollectionConfig;

type WithUserProps = (Omit<CollectionConfig, 'fields'> & {
    fields?: BowlField[];
    views?: Record<string, AdminView>;
});
type WithUser = WithUserProps & {
    type: 'withUser';
};
declare const UserDefault: Partial<CollectionConfig>;
declare const withUser: (config: WithUserProps) => CollectionConfig;

declare function decorateCategory_<T extends ICategorized = ICategorized>(item: T, slug: string, context: MixerContext): Promise<T | T & {
    category: ICategory;
}>;
declare function decorateCategories_<T extends ICategorized = ICategorized>(items: T[], slug: string, context: MixerContext): Promise<(T | T & {
    category: ICategory;
})[]>;

declare function decorateHref_<T extends ISchema = ISchema>(item: T, slug: string, context: MixerContext): Promise<T & {
    href: string | null;
}>;
declare function decorateHrefs_<T extends ISchema = ISchema>(items: T[], slug: string, context: MixerContext): Promise<(T & {
    href: string | null;
})[]>;

declare function localizeItem<T = IEntity>(item: T, localizedFields: string[], locale: string): Promise<T>;
declare function localizeCollection<T = IEntity>(items: T[], localizedFields: string[], locale?: string): Promise<T[]>;

declare const MAX_INT = 1000000000000;
declare function decorateMenuCategory_(item: IUndecoratedMenuCategory, categories: ICategory[], routes: IRoute[], market: string, depth?: number): IMenuItem | undefined;
declare function decorateMenuGroup_(item: IUndecoratedMenuGroup, categories: ICategory[], routes: IRoute[], market: string): IMenuGroup;
declare function decorateMenuLink_(item: IUndecoratedMenuLink, categories: ICategory[], routes: IRoute[], market: string): IMenuLink;
declare function decorateMenuPage_(item: IUndecoratedMenuPage, categories: ICategory[], routes: IRoute[], market: string): IMenuPage;
declare function decorateMenuRoute_(item: IRoute): IMenuRoute;
declare function decorateMenuItem_(item: IUndecoratedMenuItem, categories: ICategory[], routes: IRoute[], market: string, depth?: number): IMenuItem;
declare function decorateNavItem_(item: IUndecoratedNavItem, categories: ICategory[], routes: IRoute[], market: string, depth?: number): IMenuItem | IMenuItem[];
declare function hasMarket(item: IUndecoratedMenuItem, market: string): boolean;
declare function decorateMenu_(item: IUndecoratedMenu, context: MixerContext): Promise<IMenu>;

declare function decorateNav_<T extends ISchema = ISchema>(item: T, slug: string, context: MixerContext): Promise<T>;
declare function decorateNavs_<T extends ISchema = ISchema>(items: T[], slug: string, context: MixerContext): Promise<T[]>;
declare function isUndecoratedNavItem(item: unknown): item is IUndecoratedNavItem;
declare function isRelation(item: unknown): item is IRelation;
type IRelation = {
    relationTo: string;
    value: IEntity | IEntity[];
};

declare function decorateSchema_<T extends ISchema = ISchema>(item: T, slug: string): Promise<T & {
    schema: string;
}>;
declare function decorateSchemas_<T extends ISchema = ISchema>(items: T[], slug: string): Promise<(T & {
    schema: string;
})[]>;

declare const encrypt: (text: string) => string;
declare const decrypt: (hash: string) => string;
declare const encryptField: FieldHook;
declare const decryptField: FieldHook;
declare const encryptData: (collectionConfig: CollectionConfig) => void;

type WithAbstractProps = (Omit<RichTextField, 'type' | 'name'> & {
    name?: string;
});
type WithAbstract = WithAbstractProps & {
    type: 'withAbstract';
};
declare const withAbstract: (options?: WithAbstractProps) => RichTextField;
declare const withAbstractRequired: (options?: WithAbstractProps) => RichTextField;

type WithCategoryProps = (Omit<RelationshipField, 'type' | 'name' | 'relationTo'> & {
    name?: string;
});
type WithCategory = WithCategoryProps & {
    type: 'withCategory';
};
declare const CategoryDefaults: RelationshipField;
declare const withCategory: (options?: WithCategoryProps) => RelationshipField;
declare const withCategoryRequired: (options?: WithCategoryProps) => RelationshipField;

type WithCheckboxProps = (Omit<CheckboxField, 'type' | 'name'> & {
    name?: string;
});
type WithCheckbox = WithCheckboxProps & {
    type: 'withCheckbox';
};
declare const CheckboxDefaults: CheckboxField;
declare const withCheckbox: (options?: WithCheckboxProps) => CheckboxField;
declare const withCheckboxRequired: (options?: WithCheckboxProps) => CheckboxField;

type WithComponentsProps = Omit<Partial<BlockField>, 'type' | 'name' | 'blocks'> & {
    name?: string;
    blocks: BowlBlock[];
};
type WithComponents = WithComponentsProps & {
    type: 'withComponents';
};
declare const ComponentsDefaults: BlockField;
declare const withComponents: (options: WithComponentsProps) => BlockField;

type WithDateProps = (Omit<DateField, 'type' | 'name'> & {
    name?: string;
});
type WithDate = WithDateProps & {
    type: 'withDate';
};
declare const DateDefaults: DateField;
declare const withDate: (options?: WithDateProps) => DateField;
declare const withDateRequired: (options?: WithDateProps) => DateField;

type WithDescriptionProps = (Omit<RichTextField, 'type' | 'name'> & {
    name?: string;
});
type WithDescription = WithDescriptionProps & {
    type: 'withDescription';
};
declare const withDescription: (options?: WithDescriptionProps) => RichTextField;
declare const withDescriptionRequired: (options?: WithDescriptionProps) => RichTextField;

type WithIdProps = (Omit<TextField, 'type' | 'name' | 'hasMany'> & {
    name?: string;
});
type WithId = WithIdProps & {
    type: 'withId';
};
declare const withId: (options?: WithIdProps) => TextField;
declare const withIdRequired: (options?: WithIdProps) => TextField;

type WithIsActiveProps = (Omit<CheckboxField, 'type' | 'name'> & {
    name?: string;
});
type WithIsActive = WithIsActiveProps & {
    type: 'withIsActive';
};
declare const withIsActive: (options?: WithIsActiveProps) => CheckboxField;
declare const withIsActiveRequired: (options?: WithIsActiveProps) => CheckboxField;

type WithIsDefaultProps = (Omit<CheckboxField, 'type' | 'name'> & {
    name?: string;
});
type WithIsDefault = WithIsDefaultProps & {
    type: 'withIsDefault';
};
declare const withIsDefault: (options?: WithIsDefaultProps) => CheckboxField;
declare const withIsDefaultRequired: (options?: WithIsDefaultProps) => CheckboxField;

type WithLinkOptions = {
    appearances?: string[] | false;
    disableLabel?: boolean;
};
type WithLinkProps = Omit<GroupField, 'type' | 'name' | 'fields'> & WithLinkOptions;
type WithLink = WithLinkProps & {
    type: 'withLink';
};
declare const appearanceOptions: {
    text: {
        label: string;
        value: string;
    };
    primaryButton: {
        label: string;
        value: string;
    };
    secondaryButton: {
        label: string;
        value: string;
    };
};
declare const withLink: ({ appearances, disableLabel, ...props }?: WithLinkProps) => Omit<payload_types.FieldBase, "validation" | "required"> & {
    admin?: {
        className?: string;
        components?: {
            Cell?: React.ComponentType<any>;
            Field?: React.ComponentType<any>;
            Filter?: React.ComponentType<any>;
        };
        condition?: payload_types.Condition<any, any>;
        description?: payload_dist_admin_components_forms_FieldDescription_types.Description;
        disableBulkEdit?: boolean;
        disableListColumn?: boolean;
        disableListFilter?: boolean;
        disabled?: boolean;
        hidden?: boolean;
        position?: "sidebar";
        readOnly?: boolean;
        style?: React.CSSProperties;
        width?: string;
    } & {
        hideGutter?: boolean;
    };
    fields: Field[];
    interfaceName?: string;
    type: "group";
};

type WithMarketsProps = (Omit<RelationshipField, 'type' | 'name' | 'relationTo'> & {
    name?: string;
});
type WithMarkets = WithMarketsProps & {
    type: 'withMarkets';
};
declare const MarketDefaults: RelationshipField;
declare const withMarkets: (options?: WithMarketsProps) => RelationshipField;
declare const withMarketsRequired: (options?: WithMarketsProps) => RelationshipField;

type WithMediaProps = (Omit<UploadField, 'type' | 'name' | 'relationTo'> & {
    name?: string;
    relationTo?: string;
});
type WithMedia = WithMediaProps & {
    type: 'withMedia';
};
declare const MediaDefaults: UploadField;
declare const withMedia: (options?: WithMediaProps) => UploadField;
declare const withMediaRequired: (options?: WithMediaProps) => UploadField;

type WithMediasProps = (Omit<ArrayField, 'type' | 'name' | 'fields'> & {
    name?: string;
});
type WithMedias = WithMediasProps & {
    type: 'withMedias';
};
declare const MediasDefaults: ArrayField;
declare const withMedias: (options?: WithMediasProps) => ArrayField;
declare const withMediasRequired: (options?: WithMediasProps) => ArrayField;

type WithNameProps = (Omit<TextField, 'type' | 'name' | 'hasMany'> & {
    name?: string;
});
type WithName = WithNameProps & {
    type: 'withName';
};
declare const withName: (options?: WithNameProps) => TextField;
declare const withNameRequired: (options?: WithNameProps) => TextField;

type WithOrderProps = (Omit<NumberField, 'type' | 'name'> & {
    name?: string;
    slug: string;
});
type WithOrder = WithOrderProps & {
    type: 'withOrder';
};
declare const beforeValidate: (slug: string) => FieldHook;
declare const OrderDefaults: NumberField;
declare const withOrder: ({ slug, ...options }: WithOrderProps) => NumberField;
declare const withOrderRequired: ({ slug, ...options }: WithOrderProps) => NumberField;

type WithRelatedProps = Omit<Partial<BlockField>, 'type' | 'name' | 'blocks'> & {
    name?: string;
    blocks: BowlBlock[];
};
type WithRelated = WithRelatedProps & {
    type: 'withRelated';
};
declare const RelatedDefaults: BlockField;
declare const withRelated: (options: WithRelatedProps) => BlockField;

type WithRichTextProps = (Omit<RichTextField, 'type' | 'name'> & {
    name?: string;
});
type WithRichText = WithRichTextProps & {
    type: 'withRichText';
};
declare const richTextAfterReadHook: FieldBase['hooks']['afterRead'][number];
declare const RichTextDefaults: RichTextField;
declare const withRichText: (options?: Partial<RichTextField>) => RichTextField;
declare const withRichTextRequired: (options?: Partial<RichTextField>) => RichTextField;

type WithRolesProps = (Omit<SelectField, 'type' | 'name' | 'options'> & {
    name?: string;
    roles?: BowlRole[];
});
type WithRoles = WithRolesProps & {
    type: 'withRoles';
};
declare const UserRolesDefaults: SelectField;
declare const withRoles: ({ roles, ...fieldOptions }?: WithRolesProps) => SelectField;

type WithSelectProps = (Omit<SelectField, 'type' | 'name'> & {
    name?: string;
});
type WithSelect = WithSelectProps & {
    type: 'withSelect';
};
declare const SelectDefaults: SelectField;
declare const withSelect: (options?: Partial<SelectField>) => SelectField;
declare const withSelectRequired: (options?: Partial<SelectField>) => SelectField;

type WithSlugProps = (Omit<TextField, 'type' | 'name' | 'hasMany'> & {
    fieldToUse: string;
});
type WithSlug = WithSlugProps & {
    type: 'withSlug';
};
declare const withSlug: ({ fieldToUse, ...options }?: WithSlugProps) => TextField;
declare const withSlugRequired: ({ fieldToUse, ...options }?: WithSlugProps) => TextField;

type WithTemplateProps = (Omit<RelationshipField, 'type' | 'name' | 'relationTo'> & {
    slugToUse: string;
});
type WithTemplate = WithTemplateProps & {
    type: 'withTemplate';
};
declare const TemplateDefaults: RelationshipField;
declare const withTemplate: ({ slugToUse, ...options }: WithTemplateProps) => RelationshipField;
declare const withTemplateRequired: ({ slugToUse, ...options }: WithTemplateProps) => RelationshipField;

type WithTenantsProps = (Omit<RelationshipField, 'type' | 'name' | 'hasMany' | 'relationTo'> & {
    name?: string;
    relationTo?: string | string[];
});
type WithTenants = WithTenantsProps & {
    type: 'withTenants';
};
declare const TenantsDefault: RelationshipField;
declare const withTenants: (srcOptions?: WithTenantsProps) => RelationshipField;

type WithTextProps = (Omit<TextField, 'type' | 'name' | 'hasMany'> & {
    name?: string;
});
type WithText = WithTextProps & {
    type: 'withText';
};
declare const TextDefaults: TextField;
declare const withText: (options?: WithTextProps) => TextField;
declare const withTextRequired: (options?: WithTextProps) => TextField;

type WithTitleProps = (Omit<TextField, 'type' | 'name' | 'hasMany'> & {
    name?: string;
});
type WithTitle = WithTitleProps & {
    type: 'withTitle';
};
declare const withTitle: (options?: WithTitleProps) => TextField;
declare const withTitleRequired: (options?: WithTitleProps) => TextField;

declare function log(...rest: unknown[]): void;

declare const locales: any[];
type Locale = typeof locales[number];
type LocalizedText = {
    [key in Locale]?: string;
};
declare function getTranslation(path: string, defaultText: string | undefined, locale: Locale, node?: {
    [key: string]: any;
}, fullPath?: string): string;
declare function getTranslations(path: string, defaultText?: string): LocalizedText;
declare function slugToLabels(slug: string): {
    singular: LocalizedText;
    plural: LocalizedText;
};
declare function slugToLabel(slug: string): LocalizedText;
declare function translateTab(tab: Tab): Tab;
declare function translateTabs(tabs: Tab[]): Tab[];
declare function translateBlock(block: Block): Block;
declare function translateBlocks(blocks: Block[]): Block[];
declare function translateField(field: Field): payload_types.CollapsibleField | payload_types.RowField | payload_types.TabsField | payload_types.UIField | payload_types.ArrayField | BlockField | payload_types.CheckboxField | payload_types.CodeField | payload_types.DateField | payload_types.EmailField | payload_types.GroupField | payload_types.JSONField | payload_types.NumberField | payload_types.PointField | payload_types.RadioField | payload_types.RelationshipField | payload_types.RichTextField<any, any, {}> | payload_types.SelectField | payload_types.TextField | payload_types.TextareaField | payload_types.UploadField;
declare function translateFields(fields: Field[]): Field[];
declare function translateCollection(config: CollectionConfig): CollectionConfig;
declare function translateGlobal(config: GlobalConfig): GlobalConfig;
declare function logMissingTranslations(): void;

type PublicURL = {
    marketId: string;
    localeId: string;
    templateId: string;
    documentId: string;
    _status?: string;
    _live?: boolean;
    _token?: string;
};
declare function getPublicURL({ marketId, localeId, ...qs }: PublicURL): string;
declare function getPreviewURL(doc: Record<string, any>, locale: string, _token?: string): string;
declare function getLivePreviewURL(args: {
    data: Record<string, any>;
    documentInfo: ContextType;
    locale: Locale$1;
}): string;

declare function mergeCollections(source?: (BowlCollection | BowlCollectionFunction)[], target?: (BowlCollection | BowlCollectionFunction)[]): (BowlCollection | BowlCollectionFunction)[];

declare function mergeFields(source?: Field[], target?: Field[], reverse?: boolean): Field[];

declare function mergeGlobals(source?: (BowlGlobal | BowlGlobalFunction)[], target?: (BowlGlobal | BowlGlobalFunction)[]): (BowlGlobal | BowlGlobalFunction)[];

type GroupKey = {
    id: string;
    key?: string;
    value?: string;
};
declare function sortByGroup<T extends (CollectionConfig | GlobalConfig) = CollectionConfig | GlobalConfig>(collectionsOrGlobals: T[]): T[];

type WithAnchorProps = (Omit<GroupField, 'type' | 'name' | 'fields'> & {
    name?: string;
});
type WithAnchor = WithAnchorProps & {
    type: 'withAnchor';
};

type WithSeoWeightProps = (Omit<SelectField, 'type' | 'name' | 'options'> & {
    name?: string;
    options?: Option$1[];
});
type WithSeoWeight = WithSeoWeightProps & {
    type: 'withSeoWeight';
};

type WithColorProps = (Omit<TextField, 'type' | 'name' | 'hasMany'> & {
    name?: string;
});
type WithColor = WithColorProps & {
    type: 'withColor';
};
declare const ColorConfig: TextField;
declare const withColor: (options?: WithColorProps) => TextField;
declare const withColorRequired: (options?: WithColorProps) => TextField;

declare const ColorCell: React__default.FC<Props$3>;

declare const ColorField: React__default.FC<Props$4>;

type FieldPermissions$1 = {
    create: {
        permission: boolean;
    };
    read: {
        permission: boolean;
    };
    update: {
        permission: boolean;
    };
    fields?: {
        [field: string]: FieldPermissions$1;
    };
};
type DebugFieldType = FieldBase & {
    type: keyof FieldTypes;
};
type DebugFieldProps = DebugFieldType & {
    path?: string;
    fieldTypes: FieldTypes;
    permissions: FieldPermissions$1;
    detectLoop?: boolean;
};

declare const debugField: (options?: Partial<DebugFieldType>) => DebugFieldType;

declare const DebugField: React__default.FC<DebugFieldProps>;

type FieldPermissions = {
    create: {
        permission: boolean;
    };
    read: {
        permission: boolean;
    };
    update: {
        permission: boolean;
    };
    fields?: {
        [field: string]: FieldPermissions;
    };
};
type IStatic = FieldBase & {
    type: keyof FieldTypes;
};
type StaticProps = IStatic & {
    path?: string;
    fieldTypes: FieldTypes;
    permissions: FieldPermissions;
};
type StaticField = UIField & {};

declare const withUIStatic: (options?: Partial<UIField>) => StaticField;

declare const UIStaticCell: React__default.FC<Props$3>;

declare const UIStaticField: React__default.FC<StaticProps>;

type BowlTab = Omit<Tab, 'fields'> & {
    fields: BowlField[];
    name?: string;
};
type BowlArrayField = Omit<ArrayField, 'fields'> & {
    fields: BowlField[];
};
type BowlBlockField = Omit<BlockField, 'blocks'> & {
    blocks: BowlBlock[];
};
type BowlCollapsibleField = Omit<CollapsibleField, 'fields'> & {
    fields: BowlField[];
};
type BowlGroupField = Omit<GroupField, 'fields'> & {
    fields: BowlField[];
};
type BowlRowField = Omit<RowField, 'fields'> & {
    fields: BowlField[];
};
type BowlTabsField = Omit<TabsField, 'tabs'> & {
    tabs: BowlTab[];
};
type BowlField = Exclude<Field, ArrayField | BlockField | CollapsibleField | GroupField | RowField | TabsField> | BowlArrayField | BowlBlockField | BowlCollapsibleField | BowlGroupField | BowlRowField | BowlTabsField | WithAbstract | WithAnchor | WithCategory | WithCheckbox | WithColor | WithComponents | WithDate | WithDescription | WithId | WithIsActive | WithIsDefault | WithLink | WithMarkets | WithMedia | WithMedias | WithName | WithOrder | WithRelated | WithRichText | WithSelect | WithSeoWeight | WithSlug | WithTemplate | WithTenants | WithText | WithTitle | WithRoles;
type BowlBlock = Block | WithBlock;
type BowlCollection = WithCollection | WithPage | WithStatic | WithMenu | WithAction | WithAddress | WithUser | WithEndUser | CollectionConfig & {
    type?: string;
    views?: Record<string, AdminView>;
};
type BowlGlobal = WithGlobal | GlobalConfig & {
    type?: string;
    views?: Record<string, AdminView>;
};
type BowlCollectionFunction = ((options: BowlOptions) => BowlCollection);
type BowlGlobalFunction = (options: BowlOptions) => BowlGlobal;
type BowlConfig = (Omit<Config, 'collections' | 'globals'> & {
    collections?: (BowlCollection | BowlCollectionFunction)[];
    globals?: (BowlGlobal | BowlGlobalFunction)[];
});
type BowlSlug = {
    media: string;
    category: string;
    emailConfig: string;
    label: string;
    locale: string;
    market: string;
    menu: string;
    redirect: string;
    template: string;
    legalNotice: string;
    consentPreference: string;
    users: string;
    endUsers: string;
    continent: string;
    country: string;
    countryZone: string;
    language: string;
    municipality: string;
    province: string;
    region: string;
    subContinent: string;
    [key: string]: string;
};
type BowlGroup = {
    content: string;
    nav: string;
    actions: string;
    gdpr: string;
    users: string;
    config: string;
    i18n: string;
    [key: string]: string;
};
/**
 * Defaults user roles and endUser roles available on the bowl plugin configuration:
 *
 * admin: user role with super powers.
 * contributor: user role with minor powers.
 * editor: user role with content editing powers.
 * guest: endUser role with application reading capabilities.
 * user: endUser authenticated role with reserved data.
 *
 */
declare const roles: {
    readonly Admin: "admin";
    readonly Contributor: "contributor";
    readonly Editor: "editor";
    readonly Guest: "guest";
    readonly User: "user";
};
declare const rolesUser: BowlRole[];
declare const rolesEndUser: BowlRole[];
type Values<T> = T[keyof T];
type BowlRole = Values<typeof roles> | string;
type BowlOptions = {
    actions: string[];
    bowlCollections: BowlCollection[];
    bowlGlobals: BowlGlobal[];
    collections: string[];
    defaultLocale: string;
    defaultMarket: string;
    group: BowlGroup;
    locales: string[] | Locale$1[];
    menu: {
        blocks: BowlBlock[];
    };
    pages: string[];
    plugins: BowlPlugin[];
    roles: typeof roles & Record<string, string>;
    rolesEndUser: BowlRole[];
    rolesList: BowlRole[];
    rolesUser: BowlRole[];
    slug: BowlSlug;
    translations: Resource;
    users: string[];
};
type BowlInitOptions = {
    defaultMarket?: string;
    group?: Partial<BowlGroup>;
    menu?: {
        blocks: BowlBlock[];
    };
    slug?: Partial<BowlSlug>;
    plugins?: BowlPlugin[];
    roles?: typeof roles & Record<string, string>;
    rolesUser?: BowlRole[];
    rolesEndUser?: BowlRole[];
};
type BowlPlugin = (config: BowlConfig, bowlOptions: BowlInitOptions) => BowlConfig;

declare const MenuItem: (pages: string[], customBlocks?: BowlBlock[], depth?: number, maxDepth?: number) => BowlBlock;

declare function withComponentBlock({ slug, fields, optionsFields }: {
    slug: string;
    fields?: BowlField[];
    optionsFields?: BowlField[];
}): BowlBlock;

declare const bowl: (sourceOptions?: BowlInitOptions) => (sourceConfig: BowlConfig) => Config;

declare function toCollection(collection: BowlCollection): CollectionConfig;
declare function toGlobal(collection: BowlGlobal): GlobalConfig;
declare function toField(item: BowlField): Field;
declare function toBlock(item: BowlBlock): Block;
declare function toTab(item: BowlTab): Tab;

declare const defaultSlug: BowlSlug;
declare const defaultGroup: BowlGroup;
declare const defaultLocales: string[];
declare const defaultLocale: string;
declare const defaultMarket: string;
declare const options: BowlOptions;
declare const internalSlugs: string[];

declare const Icon: React__default.FC;

declare const Logo: React__default.FC;

declare function webpack(sourceConfig: BowlConfig): (config: any) => any;

export { ActionDefault, AddressDefault, AfterOptHook, BlockDefaults, BowlArrayField, BowlBlock, BowlBlockField, BowlCollapsibleField, BowlCollection, BowlCollectionFunction, BowlConfig, BowlField, BowlGlobal, BowlGlobalFunction, BowlGroup, BowlGroupField, BowlInitOptions, BowlOptions, BowlPlugin, BowlRole, BowlRowField, BowlSlug, BowlTab, BowlTabsField, CategoryDefaults, CategoryMenu, CategoryMenuProps, CategoryTree, CategoryTreeConflictProps, CategoryTreeItem, CategoryTreeItems, CategoryTreeProps, CheckboxDefaults, CollectionDefault, ColorCell, ColorConfig, ColorField, ComponentsDefaults, CustomEditModal, CustomEditModalProps, DataTree, DataTreeDragItem, DataTreeInstance, DataTreeItem, DataTreeItemLi, DataTreeItemProps, DataTreeProps, DataTreeProvider, DataTreeRenameItem, DateDefaults, DebugField, DecoratedList, DecoratedListProps, EndUserDefault, FindOptions, GlobalDefault, GroupKey, ICache, IEndUserConsentPreference, IEndUserData, IImportItem, IPage, IPageFull, IPagination, IRelation, IUndecoratedMenu, IUndecoratedMenuBase, IUndecoratedMenuCategory, IUndecoratedMenuCustom, IUndecoratedMenuGroup, IUndecoratedMenuItem, IUndecoratedMenuLink, IUndecoratedMenuPage, IUndecoratedNavItem, Icon, ImportExportList, ImportExportListProps, ImportExportRedirectList, ImportLogInvalidTypes, ImportLogType, ImportMode, InMemoryCache, InMemoryCacheOptions, KeyMapper, LeaveModal, LeaveWithoutSavingModal, LeaveWithoutSavingModalProps, LocalizedDescription, LocalizedDescriptionProps, Logo, MAX_INT, MarketDefaults, MediaDefaults, MediasDefaults, MenuItem, MixerContext, Option, OrderDefaults, PageDefault, PublicURL, Publish, ROOT_ITEM, RelatedDefaults, RichTextDefaults, RouteConflict, Save, SaveDraft, SelectDefaults, StaticCollectionConfig, StaticCollectionDefault, TemplateDefaults, TenantsDefault, TextDefaults, TreeItemData, TreeItems, UIStaticCell, UIStaticField, UserDefault, UserRolesDefaults, WithAbstract, WithAbstractProps, WithAction, WithActionProps, WithAddress, WithAddressProps, WithBlock, WithBlockProps, WithCategory, WithCategoryProps, WithCheckbox, WithCheckboxProps, WithCollection, WithCollectionProps, WithColor, WithColorProps, WithComponents, WithComponentsProps, WithDate, WithDateProps, WithDescription, WithDescriptionProps, WithEndUser, WithEndUserProps, WithGlobal, WithGlobalProps, WithId, WithIdProps, WithIsActive, WithIsActiveProps, WithIsDefault, WithIsDefaultProps, WithLink, WithLinkOptions, WithLinkProps, WithMarkets, WithMarketsProps, WithMedia, WithMediaProps, WithMedias, WithMediasProps, WithMenu, WithMenuProps, WithName, WithNameProps, WithOrder, WithOrderProps, WithPage, WithPageProps, WithRelated, WithRelatedProps, WithRichText, WithRichTextProps, WithRoles, WithRolesProps, WithSelect, WithSelectProps, WithSlug, WithSlugProps, WithStatic, WithStaticProps, WithTemplate, WithTemplateProps, WithTenants, WithTenantsProps, WithText, WithTextProps, WithTitle, WithTitleProps, WithUser, WithUserProps, afterCategoryChangeHook, afterCategoryDeleteHook, afterChangeActionHook, afterCollectionReadHook, afterMenuReadHook, afterPageChangeHook, afterPageDeleteHook, afterPageOperationHook, afterPageReadHook, afterReadItem, afterReadItems, afterStaticReadHook, appearanceOptions, beforeChangeActionHook, beforeDuplicateCollectionHook, beforeValidate, beforeValidateActionHook, bowl, collectionBulkPatch, collectionDetailGet, collectionExportGet, collectionImportPost, collectionIndexGet, collectionUpdatePatch, debugField, decorateCategories_, decorateCategory_, decorateHref_, decorateHrefs_, decorateMenuCategory_, decorateMenuGroup_, decorateMenuItem_, decorateMenuLink_, decorateMenuPage_, decorateMenuRoute_, decorateMenu_, decorateNavItem_, decorateNav_, decorateNavs_, decorateSchema_, decorateSchemas_, decrypt, decryptField, bowl as default, defaultGroup, defaultLocale, defaultLocales, defaultMarket, defaultSlug, encrypt, encryptData, encryptField, endUserExistPost, endUserForgotPost, endUserPasswordPost, endUserResetPost, filterRoutes, findCollection, getApiUrl, getCollectionItem, getCollectionItems, getEachMarketLocale, getGlobalItems, getLivePreviewURL, getLocale, getNewCategoriesFromChanges, getNumericParam, getObjectParam, getPages, getPagination, getPreviewURL, getPublicURL, getRoute, getRouteByCategoryAndLocale, getRouteByItemAndLocale, getRoutes, getSearchUrl, getStaticLoader, getStringParam, getSubRequest, getTranslation, getTranslations, getTreeItemClassName, hasMarket, hasRole, importExportListWithParser, internalSlugs, isAdmin, isAdminOrOwn, isAdminOrSelf, isMixerRequest, isOwn, isPageRole, isRelation, isRole, isSelf, isTenant, isUndecoratedNavItem, keyWithRequest, localeGet, localizeCollection, localizeItem, log, logMissingTranslations, menuDetailGet, menuIndexGet, mergeCollections, mergeFields, mergeGlobals, modalSlug, optinGet, options, optoutGet, pageDetailGet, pageIndexGet, parseDepth, redirectParser, richTextAfterReadHook, roles, rolesEndUser, rolesUser, routeChangesPost, routeGet, routePost, routePostHandler, setMixerContext, slugToLabel, slugToLabels, sortByGroup, sortCollection, staticCollectionLoaders, staticCollections, staticDetailGet, staticIndexGet, storeGet, toBlock, toCollection, toField, toGlobal, toTab, translateBlock, translateBlocks, translateCollection, translateField, translateFields, translateGlobal, translateTab, translateTabs, webpack, whereCollection, withAbstract, withAbstractRequired, withAction, withAddress, withBlock, withCategory, withCategoryRequired, withCheckbox, withCheckboxRequired, withCollection, withColor, withColorRequired, withComponentBlock, withComponents, withDate, withDateRequired, withDescription, withDescriptionRequired, withEndUser, withGlobal, withId, withIdRequired, withIsActive, withIsActiveRequired, withIsDefault, withIsDefaultRequired, withLink, withLocalizedDescription, withMarkets, withMarketsRequired, withMedia, withMediaRequired, withMedias, withMediasRequired, withMenu, withName, withNameRequired, withOrder, withOrderRequired, withPage, withRelated, withRichText, withRichTextRequired, withRoles, withSelect, withSelectRequired, withSlug, withSlugRequired, withStaticCollection, withTemplate, withTemplateRequired, withTenants, withText, withTextRequired, withTitle, withTitleRequired, withUIStatic, withUser };