@websolutespa/payload-plugin-bowl/dist/index.d.ts

Bowl PayloadCms plugin of the BOM Repository

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[];
//# sourceMappi