import { Access, AccessArgs, AdminViewConfig, ArrayField, Block, BlocksField, CheckboxField, ClientUser, CollapsibleField, CollectionAfterChangeHook, CollectionAfterDeleteHook, CollectionAfterOperationHook, CollectionAfterReadHook, CollectionBeforeChangeHook, CollectionBeforeOperationHook, CollectionBeforeValidateHook, CollectionConfig, CollectionSlug, Config, DateField, Endpoint, Field, FieldHook, GlobalConfig, GroupField, Locale, NamedGroupField, NumberField, Option as Option$1, PaginatedDocs, Payload, PayloadRequest, RelationshipField, RequestContext, RichTextField, RowField, SanitizedCollectionConfig, SanitizedConfig, SanitizedGlobalConfig, SelectField, Tab, TabsField, TaskHandlerResult, TextField, TypeWithID, TypedUser, UnnamedGroupField, UploadField, Where } from "payload";
import React, { ReactNode } from "react";
import { acceptedLanguages } from "@payloadcms/translations";
import { Resource, UploadNode } from "@websolutespa/payload-utils";
import * as _websolutespa_bom_core0 from "@websolutespa/bom-core";
import { ICategorized, ICategory, IEntity, IEquatable, ILocale, ILocalizable, IMarket, IMedia, IMemoryStore, IMenu, IMenuGroup, IMenuItem, IMenuLink, IMenuPage, IMenuRoute, IPageRelation, IRoute, ISchema, MenuCategoryStrategy, UserWithRoles } from "@websolutespa/bom-core";
import { TreeItem, TreeItemIndex } from "react-complex-tree";

//#region src/core/access/access.d.ts
type UserWithRoles$1 = TypedUser & {
  roles: BowlRole[];
};
declare const hasRole: (user_?: ClientUser | TypedUser | null, ...roles: BowlRole[]) => user_ is UserWithRoles$1;
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: string | number;
  };
};
declare const isOwn: (args: AccessArgs) => false | {
  'user.id': {
    equals: string | number;
  };
};
declare const isAdminOrSelf: (args: AccessArgs) => boolean | {
  id: {
    equals: string | number;
  };
};
declare const isAdminOrOwn: (args: AccessArgs) => boolean | {
  'user.id': {
    equals: string | number;
  };
};
declare const isTenant: (slug: CollectionSlug) => (args: AccessArgs) => false | {
  id: {
    in: (string | undefined)[];
  };
} | {
  and: {
    or: ({
      [x: string]: {
        in: (string | undefined)[];
      };
    } | {
      [x: string]: {
        exists: boolean;
      };
    } | {
      [x: string]: {
        equals: string;
      };
    } | {
      [x: string]: {
        equals: null;
      };
    } | {
      [x: string]: {
        equals: never[];
      };
    })[];
  }[];
};
declare const orAccess: (...access: Access[]) => Access;
//#endregion
//#region src/core/api/action.service.d.ts
type IEndUserConsentPreference = {
  consentPreference: string;
  date: string | Date;
};
type IEndUserData = UserWithRoles & {
  consentPreferences?: IEndUserConsentPreference[];
};
declare const optinGet: Endpoint;
declare const optoutGet: Endpoint;
/**
   * beforeValidateActionHook:
   * check existing email address if createEndUser == 'user'
   */
declare const beforeValidateActionHook: (collectionConfig: CollectionConfig) => CollectionBeforeValidateHook;
/**
 * beforeChangeActionHook:
 * assigning endUser id if user is logged in
 */
declare const beforeChangeActionHook: (collectionConfig: CollectionConfig) => CollectionBeforeChangeHook;
/**
 * afterChangeActionHook:
 * on operation create, send emails if the post data contains an emailData array
 */
declare const afterChangeActionHook: (collectionConfig: CollectionConfig) => CollectionAfterChangeHook;
//# sourceMappingURL=action.service.d.ts.map
//#endregion
//#region src/core/api/cache.service.d.ts
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): string;
//# sourceMappingURL=cache.service.d.ts.map
//#endregion
//#region src/components/DataTree/DataTreeProvider.d.ts
type TreeItemData = {
  title: string;
  extra?: ReactNode;
};
//#endregion
//#region src/components/DataTree/DataTree.d.ts
type TreeItems<T extends TreeItemData> = Record<TreeItemIndex, TreeItem<T>>;
//#endregion
//#region src/core/api/category.service.d.ts
/**
 * 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_core0.IEquatable;
  schema?: string;
  category?: _websolutespa_bom_core0.IEquatable | ICategory;
  media?: _websolutespa_bom_core0.IMedia;
  order?: number;
  slug: _websolutespa_bom_core0.ILocalizable;
  title: _websolutespa_bom_core0.ILocalizable;
  isHidden?: boolean;
}[];
//# sourceMappingURL=category.service.d.ts.map
//#endregion
//#region src/core/api/collection.service.d.ts
declare function parseDepth(depth: unknown, defaultDepth?: number): number;
declare function getCollectionItems<T extends TypeWithID & Record<string, unknown>>(req: PayloadRequest, slug: CollectionSlug, depth?: number): Promise<T[]>;
declare function getCollectionItem<T extends TypeWithID & Record<string, unknown>>(req: PayloadRequest, slug: CollectionSlug, id: string, depth?: number): Promise<T>;
declare function getGlobalItems<T extends TypeWithID & Record<string, unknown>>(req: PayloadRequest, slug: CollectionSlug, 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);
/**
 * Rest api collection import post handler.
 */
declare const collectionImportPost: ((slug: string) => Endpoint);
/**
 * Decorate Mixer context.
 */
declare const beforeOperationHook: CollectionBeforeOperationHook;
/**
 * Decorate record with static collection data.
 */
declare const afterCollectionReadHook: (collectionConfig: CollectionConfig) => CollectionAfterReadHook;
/**
 * !!! removed from v3
 * Enforce unique field values during duplication.

export const beforeDuplicateCollectionHook: BeforeDuplicate = async ({
  data,
  collection,
}) => {
  data = {
    ...data,
  };
  collection.fields.forEach(field => {
    if (isDataField(field) && field.unique) {
      data[field.name] = `${data[field.name]}-${uuid()}`;
    }
  });
  return data;
};
*/
//# sourceMappingURL=collection.service.d.ts.map
//#endregion
//#region src/core/api/locale.service.d.ts
declare function getLocale(req: PayloadRequest): Promise<ILocale[]>;
declare const localeGet: Endpoint;
//# sourceMappingURL=locale.service.d.ts.map
//#endregion
//#region src/core/api/menu.service.d.ts
/**
 * 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) => CollectionAfterReadHook;
//# sourceMappingURL=menu.service.d.ts.map
//#endregion
//#region src/core/api/page.service.d.ts
/**
 * 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) => CollectionAfterOperationHook;
/**
 * Decorate record for Mixer when queried by market and locale.
 */
declare const afterPageReadHook: (collectionConfig: CollectionConfig) => CollectionAfterReadHook;
/**
 * 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;
//# sourceMappingURL=page.service.d.ts.map
//#endregion
//#region src/core/api/pagination.service.d.ts
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>>;
//# sourceMappingURL=pagination.service.d.ts.map
//#endregion
//#region src/core/api/route.service.d.ts
declare function getRoutes(req: PayloadRequest): Promise<IRoute[]>;
declare function getRoute(req: PayloadRequest, id: string): Promise<IRoute | null>;
declare function getRouteByItemAndLocale(req: PayloadRequest, item: ICategorized, localeId: string, slug: string): Promise<IRoute[]>;
declare function getRouteByCategoryAndLocale(req: PayloadRequest, item: ICategory, localeId: string, slug: string): Promise<IRoute[]>;
declare const routeGet: Endpoint;
declare const routePost: Endpoint;
declare const routeChangesPost: Endpoint;
declare function routePostHandler(req: PayloadRequest): Promise<Response>;
declare function getEachMarketLocale(req: PayloadRequest, callback: (market: IMarket, locale: ILocale, markets: IMarket[], locales: ILocale[]) => void): Promise<void>;
declare function getPages(req: PayloadRequest): Promise<IMemoryStore<ICategorized>>;
//# sourceMappingURL=route.service.d.ts.map
//#endregion
//#region src/core/api/static.service.d.ts
declare const TASK_NAME = "bowlStaticTask";
declare const QUEUE_NAME = "bowlStaticQueue";
declare const USE_EXPIRE_DATE = false;
type CronConfig = {
  /**
   * The cron schedule for the job.
   * @default '* * * * *' (every minute).
   *
   * @example
   *     ┌───────────── (optional) second (0 - 59)
   *     │ ┌───────────── minute (0 - 59)
   *     │ │ ┌───────────── hour (0 - 23)
   *     │ │ │ ┌───────────── day of the month (1 - 31)
   *     │ │ │ │ ┌───────────── month (1 - 12)
   *     │ │ │ │ │ ┌───────────── day of the week (0 - 6) (Sunday to Saturday)
   *     │ │ │ │ │ │
   *     │ │ │ │ │ │
   *  - '* 0 * * * *' every hour at minute 0
   *  - '* 0 0 * * *' daily at midnight
   *  - '* 0 0 * * 0' weekly at midnight on Sundays
   *  - '* 0 0 1 * *' monthly at midnight on the 1st day of the month
   *  - '* 0/5 * * * *' every 5 minutes
   *  - '* * * * * *' every second
   */
  cron?: string;
  /**
   * The limit for the job. This can be overridden by the user. Defaults to 10.
   */
  limit?: number;
  /**
   * The queue name for the job.
   */
  queue?: string;
};
type Option = {
  id: string;
  name: string;
  [key: string]: unknown;
};
type KeyMapper = {
  [key: string]: string;
} | ((item: Option) => Option);
declare const TASK_OUTPUT_SCHEMA: Field[];
declare const staticCollections: string[];
declare function seedStatic(payload: Payload): Promise<void>;
declare function getStaticTaskHandler(props: any): ({
  req
}: {
  req: PayloadRequest;
}) => Promise<TaskHandlerResult<typeof TASK_NAME>>;
declare function enqueueTask({
  payload
}: {
  payload: Payload;
}): Promise<void>;
declare function configureStaticJobs(sourceConfig: SanitizedBowlConfig, cron?: string): SanitizedBowlConfig;
//# sourceMappingURL=static.service.d.ts.map
//#endregion
//#region src/core/api/store.service.d.ts
type FindOptions = {
  collection: CollectionSlug;
  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;
};
type FindGlobalOptions = {
  context?: RequestContext;
  depth?: number;
  draft?: boolean;
  fallbackLocale?: string;
  locale?: string;
  overrideAccess?: boolean;
  req?: PayloadRequest;
  showHiddenFields?: boolean;
  slug: string;
  user?: any;
};
declare function findCollection<T>(req: PayloadRequest, slug: CollectionSlug, findOptions?: Partial<Omit<FindOptions, 'req'>>): Promise<T[]>;
declare function findGlobal<T>(req: PayloadRequest, slug: string, findOptions?: Omit<FindGlobalOptions, 'req'>): Promise<T>;
declare function getSearchUrl(req: PayloadRequest, overrideQuery?: {}): string;
declare const storeGet: Endpoint;
//# sourceMappingURL=store.service.d.ts.map
//#endregion
//#region src/core/api/types.d.ts
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 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",
}
//# sourceMappingURL=types.d.ts.map
//#endregion
//#region src/core/api/utils.d.ts
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;
  };
};
//# sourceMappingURL=utils.d.ts.map
//#endregion
//#region src/core/api/where.service.d.ts
declare function whereCollection<T = IEntity>(items: T[], where?: {
  [key: string]: any;
}): Promise<T[]>;
declare function sortCollection<T = IEntity>(items: T[], sort?: string): Promise<T[]>;
//# sourceMappingURL=where.service.d.ts.map
//#endregion
//#region src/core/collections/withAction.d.ts
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, AdminViewConfig>;
  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;
//# sourceMappingURL=withAction.d.ts.map
//#endregion
//#region src/core/collections/withAddress.d.ts
type WithAddressProps = (Omit<CollectionConfig, 'fields'> & {
  fields: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
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;
//# sourceMappingURL=withAddress.d.ts.map
//#endregion
//#region src/core/collections/withBlock.d.ts
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;
//# sourceMappingURL=withBlock.d.ts.map
//#endregion
//#region src/core/collections/withCollection.d.ts
type WithCollectionProps = (Omit<CollectionConfig, 'fields'> & {
  fields: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
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;
//# sourceMappingURL=withCollection.d.ts.map
//#endregion
//#region src/core/collections/withEndUser.d.ts
type WithEndUserProps = (Omit<CollectionConfig, 'fields'> & {
  fields?: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
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: CollectionSlug) => Endpoint);
declare const withEndUser: (config: WithEndUserProps) => CollectionConfig;
//# sourceMappingURL=withEndUser.d.ts.map
//#endregion
//#region src/core/collections/withGlobal.d.ts
type WithGlobalProps = (Omit<GlobalConfig, 'fields'> & {
  fields: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
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;
//# sourceMappingURL=withGlobal.d.ts.map
//#endregion
//#region src/core/collections/withMenu.d.ts
type WithMenuProps = (Omit<CollectionConfig, 'fields'> & {
  fields: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
type WithMenu = WithMenuProps & {
  type: 'withMenu';
};
declare const withMenu: (config: WithMenuProps) => CollectionConfig;
//# sourceMappingURL=withMenu.d.ts.map
//#endregion
//#region src/core/collections/withPage.d.ts
type WithPageProps = (Omit<CollectionConfig, 'fields'> & {
  fields: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
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;
//# sourceMappingURL=withPage.d.ts.map
//#endregion
//#region src/core/collections/withStaticCollection.d.ts
type WithStaticProps = (Omit<CollectionConfig, 'fields'> & StaticCollectionConfig & {
  fields: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
type WithStatic = WithStaticProps & {
  type: 'withStatic';
};
type StaticCollectionSrc = string | Option[] | ((config: CollectionConfig) => Option[]) | ((config: CollectionConfig) => Promise<Option[]>);
type StaticCollectionConfig = {
  src: StaticCollectionSrc;
  map?: KeyMapper;
  duration?: number;
};
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;
//#endregion
//#region src/core/collections/withUser.d.ts
type WithUserProps = (Omit<CollectionConfig, 'fields'> & {
  fields?: BowlField[];
  views?: Record<string, AdminViewConfig>;
});
type WithUser = WithUserProps & {
  type: 'withUser';
};
declare const UserDefault: Partial<CollectionConfig>;
declare const withUser: (config: WithUserProps) => CollectionConfig;
//# sourceMappingURL=withUser.d.ts.map
//#endregion
//#region src/core/decorators/category.d.ts
declare function decorateCategory_<T extends ICategorized = ICategorized>(item: T, slug: string, context: Required<MixerContext>): Promise<T | T & {
  category: ICategory;
}>;
declare function decorateCategories_<T extends ICategorized = ICategorized>(items: T[], slug: string, context: Required<MixerContext>): Promise<(T | T & {
  category: ICategory;
})[]>;
//# sourceMappingURL=category.d.ts.map
//#endregion
//#region src/core/decorators/components.d.ts
declare function decorateComponents_<T extends ICategorized = ICategorized>(item: T, slug: string, context: Required<MixerContext>): Promise<T>;
//# sourceMappingURL=components.d.ts.map
//#endregion
//#region src/core/decorators/href.d.ts
declare function decorateHref_<T extends ISchema = ISchema>(item: T, slug: string, context: Required<MixerContext>): Promise<T & {
  href: string | null;
}>;
declare function decorateHrefs_<T extends ISchema = ISchema>(items: T[], slug: string, context: Required<MixerContext>): Promise<(T & {
  href: string | null;
})[]>;
//# sourceMappingURL=href.d.ts.map
//#endregion
//#region src/core/decorators/localize.d.ts
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[]>;
//# sourceMappingURL=localize.d.ts.map
//#endregion
//#region src/core/decorators/menu.d.ts
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: Required<MixerContext>): Promise<IMenu>;
//# sourceMappingURL=menu.d.ts.map
//#endregion
//#region src/core/decorators/nav.d.ts
declare function decorateNav_<T extends ISchema = ISchema>(item: T, slug: string, context: Required<MixerContext>): Promise<T>;
declare function decorateNavs_<T extends ISchema = ISchema>(items: T[], slug: string, context: Required<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[];
};
//# sourceMappingURL=nav.d.ts.map
//#endregion
//#region src/core/decorators/rich-text.d.ts
declare function decorateRichText_<T extends ISchema = ISchema>(item: T, fields: Field[], context: MixerContext, config: SanitizedConfig): Promise<T>;
declare function decorateRichTexts_<T extends ISchema = ISchema>(items: T[], fields: Field[], context: MixerContext, config: SanitizedConfig): Promise<T[]>;
//# sourceMappingURL=rich-text.d.ts.map
//#endregion
//#region src/core/decorators/schema.d.ts
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;
})[]>;
//# sourceMappingURL=schema.d.ts.map
//#endregion
//#region src/core/decorators/upload.d.ts
declare function decorateUpload_<T extends ISchema = ISchema>(item: T, slug: string, context: MixerContext, fields: Field[]): Promise<T>;
declare function decorateUploads_<T extends ISchema = ISchema>(items: T[], slug: string, context: MixerContext, fields: Field[], config: SanitizedConfig): Promise<T[]>;
declare const afterReadUpload: FieldHook;
//# sourceMappingURL=upload.d.ts.map
//#endregion
//#region src/core/encryption/encryption.d.ts
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;
//# sourceMappingURL=encryption.d.ts.map
//#endregion
//#region src/core/fields/withAbstract.d.ts
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;
//# sourceMappingURL=withAbstract.d.ts.map
//#endregion
//#region src/core/fields/withCategory.d.ts
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;
//# sourceMappingURL=withCategory.d.ts.map
//#endregion
//#region src/core/fields/withCheckbox.d.ts
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;
//# sourceMappingURL=withCheckbox.d.ts.map
//#endregion
//#region src/core/fields/withComponents.d.ts
type WithComponentsProps = Omit<Partial<BlocksField>, 'type' | 'name' | 'blocks'> & {
  name?: string;
  blocks: BowlBlock[];
};
type WithComponents = WithComponentsProps & {
  type: 'withComponents';
};
declare const ComponentsDefaults: BlocksField;
declare const withComponents: (options: WithComponentsProps) => BlocksField;
//# sourceMappingURL=withComponents.d.ts.map
//#endregion
//#region src/core/fields/withDate.d.ts
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;
//# sourceMappingURL=withDate.d.ts.map
//#endregion
//#region src/core/fields/withDescription.d.ts
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;
//# sourceMappingURL=withDescription.d.ts.map
//#endregion
//#region src/core/fields/withId.d.ts
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;
//# sourceMappingURL=withId.d.ts.map
//#endregion
//#region src/core/fields/withIsActive.d.ts
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;
//# sourceMappingURL=withIsActive.d.ts.map
//#endregion
//#region src/core/fields/withIsDefault.d.ts
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;
//# sourceMappingURL=withIsDefault.d.ts.map
//#endregion
//#region src/core/fields/withLink.d.ts
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) => GroupField;
//# sourceMappingURL=withLink.d.ts.map
//#endregion
//#region src/core/fields/withMarkets.d.ts
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;
//# sourceMappingURL=withMarkets.d.ts.map
//#endregion
//#region src/core/fields/withMedia.d.ts
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;
//# sourceMappingURL=withMedia.d.ts.map
//#endregion
//#region src/core/fields/withMedias.d.ts
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;
//# sourceMappingURL=withMedias.d.ts.map
//#endregion
//#region src/core/fields/withName.d.ts
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;
//# sourceMappingURL=withName.d.ts.map
//#endregion
//#region src/core/fields/withNav.d.ts
type WithNavProps = (Omit<GroupField, 'type' | 'name' | 'fields'> & {
  name?: string;
  maxDepth?: number;
  disallow?: string | string[];
});
type WithNav = WithNavProps & {
  type: 'withNav';
};
declare const NavDefaults: GroupField;
declare const withNav: ({
  maxDepth,
  disallow,
  ...options
}?: WithNavProps) => CollapsibleField;
//# sourceMappingURL=withNav.d.ts.map
//#endregion
//#region src/core/fields/withNavs.d.ts
type WithNavsProps = (Omit<ArrayField, 'type' | 'name' | 'fields'> & {
  name?: string;
  maxDepth?: number;
  disallow?: string | string[];
});
type WithNavs = WithNavsProps & {
  type: 'withNavs';
};
declare const NavsDefaults: ArrayField;
declare const withNavs: ({
  maxDepth,
  disallow,
  ...options
}: WithNavsProps) => CollapsibleField;
declare function navFields(props?: {
  pages?: string[];
  blocks?: BowlBlock[];
  maxDepth?: number;
  disallow?: string | string[];
}): BowlField[];
//# sourceMappingURL=withNavs.d.ts.map
//#endregion
//#region src/core/fields/withOrder.d.ts
type WithOrderProps = (Omit<NumberField, 'type' | 'name'> & {
  name?: string;
  slug: CollectionSlug;
});
type WithOrder = WithOrderProps & {
  type: 'withOrder';
};
declare const beforeValidate: (slug: CollectionSlug) => FieldHook;
declare const OrderDefaults: NumberField;
declare const withOrder: ({
  slug,
  ...options
}: WithOrderProps) => NumberField;
declare const withOrderRequired: ({
  slug,
  ...options
}: WithOrderProps) => NumberField;
/**
 *
 * !!! validation function should return true or string error message
 */
//# sourceMappingURL=withOrder.d.ts.map
//#endregion
//#region src/core/fields/withRelated.d.ts
type WithRelatedProps = Omit<Partial<BlocksField>, 'type' | 'name' | 'blocks'> & {
  name?: string;
  blocks: BowlBlock[];
};
type WithRelated = WithRelatedProps & {
  type: 'withRelated';
};
declare const RelatedDefaults: BlocksField;
declare const withRelated: (options: WithRelatedProps) => BlocksField;
//# sourceMappingURL=withRelated.d.ts.map
//#endregion
//#region src/core/fields/withRichText.d.ts
declare function getMedia(payload: Payload): (node: UploadNode) => Promise<IMedia | null>;
type WithRichTextProps = (Omit<RichTextField, 'type' | 'name'> & {
  name?: string;
});
type WithRichText = WithRichTextProps & {
  type: 'withRichText';
};
declare const richTextAfterReadHook: FieldHook;
declare const RichTextDefaults: RichTextField;
declare const withRichText: (options?: Partial<RichTextField>) => RichTextField;
declare const withRichTextRequired: (options?: Partial<RichTextField>) => RichTextField;
//# sourceMappingURL=withRichText.d.ts.map
//#endregion
//#region src/core/fields/withRoles.d.ts
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;
//# sourceMappingURL=withRoles.d.ts.map
//#endregion
//#region src/core/fields/withSelect.d.ts
type WithSelectProps = (Omit<SelectField, 'type' | 'name'> & {
  name?: string;
});
type WithSelect = WithSelectProps & {
  type: 'withSelect';
};
declare const SelectDefaults: SelectField;
declare const withSelect: (options?: Partial<WithSelectProps>) => SelectField;
declare const withSelectRequired: (options?: Partial<WithSelectProps>) => SelectField;
//# sourceMappingURL=withSelect.d.ts.map
//#endregion
//#region src/core/fields/withSlug.d.ts
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;
//# sourceMappingURL=withSlug.d.ts.map
//#endregion
//#region src/core/fields/withTemplate.d.ts
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;
//# sourceMappingURL=withTemplate.d.ts.map
//#endregion
//#region src/core/fields/withTenants.d.ts
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;
//# sourceMappingURL=withTenants.d.ts.map
//#endregion
//#region src/core/fields/withText.d.ts
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;
//# sourceMappingURL=withText.d.ts.map
//#endregion
//#region src/core/fields/withTitle.d.ts
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;
//# sourceMappingURL=withTitle.d.ts.map
//#endregion
//#region src/core/logger/logger.d.ts
declare function log(...rest: unknown[]): void;
//# sourceMappingURL=logger.d.ts.map
//#endregion
//#region src/core/translations/translations.d.ts
declare const locales: string[];
type Locale$1 = typeof locales[number];
type LocalizedText = { [key in Locale$1]?: string };
declare function getTranslation(path: string, defaultText: string | undefined, locale: Locale$1, 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): Field;
declare function translateFields(fields: Field[]): Field[];
declare function translateCollection(config: CollectionConfig | Block): Block | CollectionConfig;
declare function translateGlobal(config: GlobalConfig): GlobalConfig;
declare function logMissingTranslations(): void;
//#endregion
//#region src/core/utils/getPreviewURL.d.ts
type PublicURL = {
  marketId: string;
  localeId: string;
  templateId: string;
  documentId: string;
  _status?: string;
  _live?: boolean;
  _token?: string;
};
declare function getPreviewPublicURL(qs: PublicURL): string;
declare function getPreviewURL(doc: Record<string, any>, locale: string, _token?: string): string;
declare function getLivePreviewURL(args: {
  collectionConfig?: SanitizedCollectionConfig;
  data: Record<string, any>;
  globalConfig?: SanitizedGlobalConfig;
  locale: Locale;
  req: PayloadRequest;
}): Promise<string> | string;
//# sourceMappingURL=getPreviewURL.d.ts.map
//#endregion
//#region src/core/utils/mergeCollections.d.ts
declare function mergeCollections(source?: (BowlCollection | BowlCollectionFunction)[], target?: (BowlCollection | BowlCollectionFunction)[]): (BowlCollection | BowlCollectionFunction)[];
//# sourceMappingURL=mergeCollections.d.ts.map
//#endregion
//#region src/core/utils/mergeFields.d.ts
declare function mergeFields(source?: Field[], target?: Field[], reverse?: boolean): Field[];
//# sourceMappingURL=mergeFields.d.ts.map
//#endregion
//#region src/core/utils/mergeGlobals.d.ts
declare function mergeGlobals(source?: (BowlGlobal | BowlGlobalFunction)[], target?: (BowlGlobal | BowlGlobalFunction)[]): (BowlGlobal | BowlGlobalFunction)[];
//# sourceMappingURL=mergeGlobals.d.ts.map
//#endregion
//#region src/core/utils/sortByGroup.d.ts
type GroupKey = {
  id: string;
  key?: string;
  value?: string;
};
declare function sortByGroup<T extends (CollectionConfig | GlobalConfig) = CollectionConfig | GlobalConfig>(collectionsOrGlobals: T[]): T[];
//# sourceMappingURL=sortByGroup.d.ts.map
//#endregion
//#region src/core/fields/withAnchor.d.ts
type WithAnchorProps = (Omit<GroupField, 'type' | 'name' | 'fields'> & {
  name?: string;
});
type WithAnchor = WithAnchorProps & {
  type: 'withAnchor';
};
//#endregion
//#region src/core/fields/withSeoWeight.d.ts
type WithSeoWeightProps = (Omit<SelectField, 'type' | 'name' | 'options'> & {
  name?: string;
  options?: Option$1[];
});
type WithSeoWeight = WithSeoWeightProps & {
  type: 'withSeoWeight';
};
//#endregion
//#region src/fields/color-picker/index.d.ts
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;
//# sourceMappingURL=index.d.ts.map
//#endregion
//#region src/types.d.ts
type AcceptedLanguages = (typeof acceptedLanguages)[number];
type BowlTab = Omit<Tab, 'fields'> & {
  fields: BowlField[];
  name?: string;
};
type BowlArrayField = Omit<ArrayField, 'fields'> & {
  fields: BowlField[];
};
type BowlBlocksField = Omit<BlocksField, 'blocks'> & {
  blocks: BowlBlock[];
};
type BowlCollapsibleField = Omit<CollapsibleField, 'fields'> & {
  fields: BowlField[];
};
type BowlGroupField = Omit<NamedGroupField, 'fields'> & {
  fields: BowlField[];
} | Omit<UnnamedGroupField, 'fields'> & {
  fields: BowlField[];
};
type BowlRowField = Omit<RowField, 'fields'> & {
  fields: BowlField[];
};
type BowlTabsField = Omit<TabsField, 'tabs'> & {
  tabs: BowlTab[];
};
type BowlField = Exclude<Field, ArrayField | BlocksField | CollapsibleField | GroupField | RowField | TabsField> | BowlArrayField | BowlBlocksField | BowlCollapsibleField | BowlGroupField | BowlRowField | BowlTabsField | WithAbstract | WithAnchor | WithCategory | WithCheckbox | WithColor | WithComponents | WithDate | WithDescription | WithId | WithIsActive | WithIsDefault | WithLink | WithMarkets | WithMedia | WithMedias | WithName | WithNav | WithNavs | 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 | Omit<CollectionConfig, 'fields'> & {
  fields: BowlField[];
  type?: string;
  views?: Record<string, AdminViewConfig>;
};
type BowlGlobal = WithGlobal | GlobalConfig & {
  type?: string;
  views?: Record<string, AdminViewConfig>;
};
type BowlCollectionFunction = ((options: BowlOptions) => BowlCollection);
type BowlGlobalFunction = (options: BowlOptions) => BowlGlobal;
type BowlConfig = (Omit<Config, 'collections' | 'globals'> & {
  collections?: (BowlCollection | BowlCollectionFunction)[];
  globals?: (BowlGlobal | BowlGlobalFunction)[];
});
type BowlSlug = Record<string, CollectionSlug> & {
  address: CollectionSlug;
  app: CollectionSlug;
  category: CollectionSlug;
  consentPreference: CollectionSlug;
  emailConfig: CollectionSlug;
  endUsers: CollectionSlug;
  label: CollectionSlug;
  legalNotice: CollectionSlug;
  locale: CollectionSlug;
  market: CollectionSlug;
  media: CollectionSlug;
  menu: CollectionSlug;
  redirect: CollectionSlug;
  template: CollectionSlug;
  users: CollectionSlug;
  continent: CollectionSlug;
  country: CollectionSlug;
  countryZone: CollectionSlug;
  language: CollectionSlug;
  municipality: CollectionSlug;
  province: CollectionSlug;
  region: CollectionSlug;
  subContinent: CollectionSlug;
};
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$1: {
  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$1> | string;
type BowlOptions = {
  actions: CollectionSlug[];
  bowlCollections: BowlCollection[];
  bowlGlobals: BowlGlobal[];
  collections: CollectionSlug[];
  defaultLocale: string;
  defaultMarket: string;
  group: BowlGroup;
  locales: string[] | Locale[];
  menu: {
    blocks: BowlBlock[];
  };
  pages: CollectionSlug[];
  plugins: BowlPlugin[];
  roles: typeof roles$1 & Record<string, string>;
  rolesEndUser: BowlRole[];
  rolesList: BowlRole[];
  rolesUser: BowlRole[];
  slug: BowlSlug;
  translations: Resource;
  users: CollectionSlug[];
};
type BowlInitOptions = {
  defaultMarket?: string;
  group?: Partial<BowlGroup>;
  menu?: {
    blocks: BowlBlock[];
  };
  slug?: Partial<BowlSlug>;
  plugins?: BowlPlugin[];
  roles?: typeof roles$1 & Record<string, string>;
  rolesUser?: BowlRole[];
  rolesEndUser?: BowlRole[];
};
type BowlPlugin = (config: BowlConfig, bowlOptions: BowlInitOptions) => BowlConfig;
type SanitizedBowlConfig = Omit<Config, 'custom'> & {
  custom: Record<string, any> & {
    bowl: BowlOptions;
  };
};
//#endregion
//#region src/blocks/MenuItem.d.ts
declare const MenuItem: (pages: CollectionSlug[], customBlocks?: BowlBlock[], depth?: number, maxDepth?: number) => BowlBlock;
//# sourceMappingURL=MenuItem.d.ts.map
//#endregion
//#region src/blocks/withComponentBlock.d.ts
declare function withComponentBlock({
  slug,
  fields,
  optionsFields
}: {
  slug: string;
  fields?: BowlField[];
  optionsFields?: BowlField[];
}): BowlBlock;
//# sourceMappingURL=withComponentBlock.d.ts.map
//#endregion
//#region src/bowl.d.ts
declare const bowl: (sourceOptions?: BowlInitOptions) => (sourceConfig: BowlConfig) => Promise<Config>;
//# sourceMappingURL=bowl.d.ts.map
//#endregion
//#region src/mapper.d.ts
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;
//# sourceMappingURL=mapper.d.ts.map
//#endregion
//#region src/options.d.ts
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[];
//# sourceMappingURL=options.d.ts.map

//#endregion
export { AcceptedLanguages, ActionDefault, AddressDefault, AfterOptHook, BlockDefaults, BowlArrayField, BowlBlock, BowlBlocksField, BowlCollapsibleField, BowlCollection, BowlCollectionFunction, BowlConfig, BowlField, BowlGlobal, BowlGlobalFunction, BowlGroup, BowlGroupField, BowlInitOptions, BowlOptions, BowlPlugin, BowlRole, BowlRowField, BowlSlug, BowlTab, BowlTabsField, CategoryDefaults, CategoryTreeItem, CategoryTreeItems, CheckboxDefaults, CollectionDefault, ColorConfig, ComponentsDefaults, CronConfig, DateDefaults, EndUserDefault, FindGlobalOptions, FindOptions, GlobalDefault, GroupKey, ICache, IEndUserConsentPreference, IEndUserData, IPage, IPageFull, IPagination, IRelation, IUndecoratedMenu, IUndecoratedMenuBase, IUndecoratedMenuCategory, IUndecoratedMenuCustom, IUndecoratedMenuGroup, IUndecoratedMenuItem, IUndecoratedMenuLink, IUndecoratedMenuPage, IUndecoratedNavItem, ImportLogInvalidTypes, ImportLogType, ImportMode, InMemoryCache, InMemoryCacheOptions, KeyMapper, MAX_INT, MarketDefaults, MediaDefaults, MediasDefaults, MenuItem, MixerContext, NavDefaults, NavsDefaults, Option, OrderDefaults, PageDefault, PublicURL, QUEUE_NAME, ROOT_ITEM, RelatedDefaults, RichTextDefaults, SanitizedBowlConfig, SelectDefaults, StaticCollectionConfig, StaticCollectionDefault, TASK_NAME, TASK_OUTPUT_SCHEMA, TemplateDefaults, TenantsDefault, TextDefaults, USE_EXPIRE_DATE, 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, WithNav, WithNavProps, WithNavs, WithNavsProps, 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, afterReadUpload, appearanceOptions, beforeChangeActionHook, beforeOperationHook, beforeValidate, beforeValidateActionHook, bowl, collectionBulkPatch, collectionDetailGet, collectionExportGet, collectionImportPost, collectionIndexGet, collectionUpdatePatch, configureStaticJobs, decorateCategories_, decorateCategory_, decorateComponents_, decorateHref_, decorateHrefs_, decorateMenuCategory_, decorateMenuGroup_, decorateMenuItem_, decorateMenuLink_, decorateMenuPage_, decorateMenuRoute_, decorateMenu_, decorateNavItem_, decorateNav_, decorateNavs_, decorateRichText_, decorateRichTexts_, decorateSchema_, decorateSchemas_, decorateUpload_, decorateUploads_, decrypt, decryptField, bowl as default, defaultGroup, defaultLocale, defaultLocales, defaultMarket, defaultSlug, encrypt, encryptData, encryptField, endUserExistPost, endUserForgotPost, endUserPasswordPost, endUserResetPost, enqueueTask, filterRoutes, findCollection, findGlobal, getCollectionItem, getCollectionItems, getEachMarketLocale, getGlobalItems, getLivePreviewURL, getLocale, getMedia, getNewCategoriesFromChanges, getNumericParam, getObjectParam, getPages, getPagination, getPreviewPublicURL, getPreviewURL, getRoute, getRouteByCategoryAndLocale, getRouteByItemAndLocale, getRoutes, getSearchUrl, getStaticTaskHandler, getStringParam, getSubRequest, getTranslation, getTranslations, hasMarket, hasRole, internalSlugs, isAdmin, isAdminOrOwn, isAdminOrSelf, isMixerRequest, isOwn, isPageRole, isRelation, isRole, isSelf, isTenant, isUndecoratedNavItem, keyWithRequest, localeGet, localizeCollection, localizeItem, log, logMissingTranslations, menuDetailGet, menuIndexGet, mergeCollections, mergeFields, mergeGlobals, navFields, optinGet, options, optoutGet, orAccess, pageDetailGet, pageIndexGet, parseDepth, richTextAfterReadHook, roles$1 as roles, rolesEndUser, rolesUser, routeChangesPost, routeGet, routePost, routePostHandler, seedStatic, setMixerContext, slugToLabel, slugToLabels, sortByGroup, sortCollection, staticCollections, storeGet, toBlock, toCollection, toField, toGlobal, toTab, translateBlock, translateBlocks, translateCollection, translateField, translateFields, translateGlobal, translateTab, translateTabs, 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, withMarkets, withMarketsRequired, withMedia, withMediaRequired, withMedias, withMediasRequired, withMenu, withName, withNameRequired, withNav, withNavs, withOrder, withOrderRequired, withPage, withRelated, withRichText, withRichTextRequired, withRoles, withSelect, withSelectRequired, withSlug, withSlugRequired, withStaticCollection, withTemplate, withTemplateRequired, withTenants, withText, withTextRequired, withTitle, withTitleRequired, withUser };
//# sourceMappingURL=index.d.ts.map