@websolutespa/payload-plugin-bowl 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,765 @@
+import { Endpoint, Config } from 'payload/config';
+import { Resource } from 'i18next';
+import * as payload_dist_fields_config_types from 'payload/dist/fields/config/types';
+import { Field, FieldHookArgs, Tab, FieldAffectingData, HookName, FieldHook as FieldHook$1, FieldBase, UIField } from 'payload/dist/fields/config/types';
+import * as payload_types from 'payload/types';
+import { PayloadRequest, Block, CollectionConfig, GlobalConfig, RichTextField, RelationshipField, CheckboxField, BlockField, DateField, TextField, GroupField, Field as Field$1, UploadField, ArrayField, SelectField, FieldHook, CollectionAfterChangeHook, CollectionAfterDeleteHook, CollapsibleField, RowField, TabsField } from 'payload/types';
+import * as payload_dist_admin_components_forms_FieldDescription_types from 'payload/dist/admin/components/forms/FieldDescription/types';
+import * as React from 'react';
+import React__default from 'react';
+import { Props } from 'payload/components/views/Cell';
+import { Props as Props$1 } from 'payload/components/fields/Text';
+import { FieldTypes } from 'payload/dist/admin/components/forms/field-types';
+
+type ICache<T = any> = {
+    timestamp: number;
+    data: T;
+};
+type InMemoryCacheOptions = {
+    duration?: number;
+};
+declare class InMemoryCache<T = any> {
+    duration: number;
+    cache: Map<string, ICache<T>>;
+    constructor(options?: InMemoryCacheOptions);
+    has(key: string): boolean;
+    get(key: string): T;
+    set(key: string, data: T): void;
+}
+declare function keyWithRequest(key: string, req: PayloadRequest<any>): string;
+
+declare const collectionGet: ((slug: string) => Endpoint);
+
+declare function getLocale(req: PayloadRequest<any>): Promise<ILocale[]>;
+declare const localeGet: Endpoint;
+type ILocale = {
+    id: string;
+    title?: string;
+    isActive?: boolean;
+    isDefault?: boolean;
+};
+
+declare function getRoutes(req: PayloadRequest<any>): Promise<IRoute[]>;
+declare function getRoute(req: PayloadRequest<any>, id: string): Promise<IRoute>;
+type IRoute = {
+    id: string;
+    market: string;
+    locale: string;
+    category: string;
+    page: string;
+    schema: string;
+    template?: string;
+};
+type IMarket = {
+    id: string;
+    title?: string;
+    isActive?: boolean;
+    isDefault?: boolean;
+    countries?: string[];
+    languages?: string[];
+    defaultLanguage?: string;
+};
+type ICategory = {
+    id: string;
+    slug?: ILocalizedString | string;
+    title?: ILocalizedString | string;
+    media?: IMedia;
+    schema?: string;
+    page?: string;
+    categoryId?: string;
+    category?: ICategory;
+};
+type ICategoryItem = ICategory & {
+    items: ICategory[];
+};
+type ICategorized = {
+    id: string;
+    slug?: ILocalizedString | string;
+    title?: ILocalizedString | string;
+    media?: IMedia;
+    category?: ICategory;
+    categoryId?: string;
+};
+type IMediaType = 'image' | 'video' | string;
+type IMedia = {
+    src: string;
+    type: IMediaType;
+    alt?: string;
+    title?: string;
+    abstract?: string;
+    width?: number;
+    height?: number;
+};
+type ILocalizedString = {
+    [key: string]: string;
+};
+type IPage = {
+    id: string;
+    content: {
+        value: string;
+        relationTo: string;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+};
+type IPageFull = {
+    id: string;
+    content: {
+        value: {
+            id: string;
+            slug: string | ILocalizedString;
+            category: string;
+            category_index?: boolean;
+            markets: string[];
+            template: string;
+            title: string | ILocalizedString;
+            _status: string;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        relationTo: string;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+};
+type ICollectionItem = {
+    id: string;
+    category: string;
+    isDefault?: boolean;
+    slug: string | ILocalizedString;
+    markets: string[];
+    template: string;
+    title: string | ILocalizedString;
+    _status: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+declare const routeGet: Endpoint;
+
+type IStore = {
+    [key: string]: any[];
+};
+declare function getStore(req: PayloadRequest): Promise<IStore>;
+declare function getApiUrl(req: PayloadRequest): string;
+declare function getSearchUrl(req: PayloadRequest, overrideQuery?: {}): string;
+declare function fetchEndpoint<T>(req: PayloadRequest, endpoint: string, query?: {}): Promise<T>;
+declare function fetchCollection<T = any>(req: PayloadRequest, slug: string, query?: {}): Promise<{
+    docs: T[];
+}>;
+declare function fetchGlobal<T = any>(req: PayloadRequest, slug: string, query?: {}): Promise<{
+    items: T[];
+}>;
+declare function fetchCollectionItems<T = any>(req: PayloadRequest<T>, slug: string, query?: {}): Promise<T[]>;
+declare function fetchGlobalItems<T = any>(req: PayloadRequest, slug: string, query?: {}): Promise<T[]>;
+declare const storeGet: Endpoint;
+
+type WithBlockProps = (Omit<Block, 'fields'> & {
+    fields: BowlField[];
+});
+type WithBlock = WithBlockProps & {
+    type: 'withBlock';
+};
+declare const BlockDefaults: Partial<Block>;
+/**
+ *
+ * @param {Block} config
+ * @returns {Block} Return a `Block` with inherited fields: `id`, `createdAt`, `updatedAt`.
+ */
+declare const withBlock: (options: BowlBlock) => Block;
+
+type WithCollectionProps = (Omit<CollectionConfig, 'fields'> & {
+    fields: BowlField[];
+});
+type WithCollection = WithCollectionProps & {
+    type: 'withCollection';
+};
+declare const CollectionDefault: Partial<CollectionConfig>;
+/**
+ *
+ * @param {CollectionConfig} config
+ * @returns {CollectionConfig} Return a `CollectionConfig` with inherited fields: `id`, `createdAt`, `updatedAt`.
+ */
+declare const withCollection: (config: WithCollectionProps) => CollectionConfig;
+
+type WithGlobalProps = (Omit<GlobalConfig, 'fields'> & {
+    fields: BowlField[];
+});
+type WithGlobal = WithGlobalProps & {
+    type: 'withGlobal';
+    fields: BowlField[];
+};
+declare const GlobalDefault: Partial<GlobalConfig>;
+/**
+ *
+ * @param {GlobalConfig} config
+ * @returns {GlobalConfig} Return a `GlobalConfig` with inherited fields: `id`, `createdAt`, `updatedAt`.
+ */
+declare const withGlobal: (config: WithGlobalProps) => GlobalConfig;
+
+type WithPageProps = (Omit<CollectionConfig, 'fields'> & {
+    fields: BowlField[];
+});
+type WithPage = WithPageProps & {
+    type: 'withPage';
+};
+declare const PageDefault: Partial<CollectionConfig>;
+/**
+ *
+ * @param {CollectionConfig} config
+ * @returns {CollectionConfig} Return a `CollectionConfig` with inherited fields: `id`, `title`, `slug`, `category`, `markets`, `template`, `meta`, `status`, `createdAt`, `updatedAt`.
+ */
+declare const withPage: (config: CollectionConfig) => CollectionConfig;
+
+type WithStaticProps = (Omit<CollectionConfig, 'fields'> & StaticCollectionConfig & {
+    fields: BowlField[];
+});
+type WithStatic = WithStaticProps & {
+    type: 'withStatic';
+};
+type IEntity = {
+    id: string | number;
+};
+type Option = {
+    id: string;
+    name: string;
+    [key: string]: unknown;
+};
+type KeyMapper = {
+    [key: string]: string;
+};
+type StaticCollectionSrc = string | Option[] | ((config: CollectionConfig) => Option[]) | ((config: CollectionConfig) => Promise<Option[]>);
+type StaticCollectionConfig = {
+    src: StaticCollectionSrc;
+    map?: KeyMapper;
+};
+declare function getObjectParam(value: unknown): {} | undefined;
+declare function getNumericParam(value: unknown): number | undefined;
+declare function getStringParam(value: unknown): string | undefined;
+declare function whereCollection<T = IEntity>(items: T[], where?: {
+    [key: string]: any;
+}): Promise<T[]>;
+declare function populateStaticFields<T = IEntity>(item: T, fields: Field[], locale?: string): Promise<T>;
+declare function localizeCollection<T = IEntity>(items: T[], localizedFields: string[], locale?: string): Promise<T[]>;
+declare function getStaticLoader(slug: string): any;
+declare const StaticCollectionDefault: Partial<CollectionConfig>;
+/**
+ * @param {CollectionConfig & StaticCollectionConfig} config
+ * @returns {CollectionConfig} Return a `CollectionConfig` from static or remote dataset.
+ */
+declare const withStaticCollection: ({ src, map, ...config }: WithStaticProps) => CollectionConfig;
+
+type WithAbstractProps = (Omit<RichTextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithAbstract = WithAbstractProps & {
+    type: 'withAbstract';
+};
+declare const withAbstract: (options?: WithAbstractProps) => RichTextField;
+declare const withAbstractRequired: (options?: WithAbstractProps) => RichTextField;
+
+type WithCategoryProps = (Omit<RelationshipField, 'type' | 'name' | 'relationTo'> & {
+    name?: string;
+});
+type WithCategory = WithCategoryProps & {
+    type: 'withCategory';
+};
+declare const CategoryDefaults: RelationshipField;
+declare const withCategory: (options?: WithCategoryProps) => RelationshipField;
+declare const withCategoryRequired: (options?: WithCategoryProps) => RelationshipField;
+
+type WithCheckboxProps = (Omit<CheckboxField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithCheckbox = WithCheckboxProps & {
+    type: 'withCheckbox';
+};
+declare const CheckboxDefaults: CheckboxField;
+declare const withCheckbox: (options?: WithCheckboxProps) => CheckboxField;
+declare const withCheckboxRequired: (options?: WithCheckboxProps) => CheckboxField;
+
+type WithComponentsProps = Omit<Partial<BlockField>, 'type' | 'name' | 'blocks'> & {
+    name?: string;
+    blocks: BowlBlock[];
+};
+type WithComponents = WithComponentsProps & {
+    type: 'withComponents';
+};
+declare const ComponentsDefaults: BlockField;
+declare const withComponents: (options: WithComponentsProps) => BlockField;
+
+type WithDateProps = (Omit<DateField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithDate = WithDateProps & {
+    type: 'withDate';
+};
+declare const DateDefaults: DateField;
+declare const withDate: (options?: WithDateProps) => DateField;
+declare const withDateRequired: (options?: WithDateProps) => DateField;
+
+type WithDescriptionProps = (Omit<RichTextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithDescription = WithDescriptionProps & {
+    type: 'withDescription';
+};
+declare const withDescription: (options?: WithDescriptionProps) => RichTextField;
+declare const withDescriptionRequired: (options?: WithDescriptionProps) => RichTextField;
+
+type WithIdProps = (Omit<TextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithId = WithIdProps & {
+    type: 'withId';
+};
+declare const withId: (options?: WithIdProps) => TextField;
+declare const withIdRequired: (options?: WithIdProps) => TextField;
+
+type WithIsActiveProps = (Omit<CheckboxField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithIsActive = WithIsActiveProps & {
+    type: 'withIsActive';
+};
+declare const withIsActive: (options?: WithIsActiveProps) => CheckboxField;
+declare const withIsActiveRequired: (options?: WithIsActiveProps) => CheckboxField;
+
+type WithIsDefaultProps = (Omit<CheckboxField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithIsDefault = WithIsDefaultProps & {
+    type: 'withIsDefault';
+};
+declare const withIsDefault: (options?: WithIsDefaultProps) => CheckboxField;
+declare const withIsDefaultRequired: (options?: WithIsDefaultProps) => CheckboxField;
+
+type WithLinkOptions = {
+    appearances?: string[] | false;
+    disableLabel?: boolean;
+};
+type WithLinkProps = Omit<GroupField, 'type' | 'name' | 'fields'> & WithLinkOptions;
+type WithLink = WithLinkProps & {
+    type: 'withLink';
+};
+declare const appearanceOptions: {
+    text: {
+        label: string;
+        value: string;
+    };
+    primaryButton: {
+        label: string;
+        value: string;
+    };
+    secondaryButton: {
+        label: string;
+        value: string;
+    };
+};
+declare const withLink: ({ appearances, disableLabel, ...props }?: WithLinkProps) => payload_dist_fields_config_types.FieldBase & {
+    type: "group";
+    fields: Field$1[];
+    admin?: {
+        position?: "sidebar";
+        width?: string;
+        style?: React.CSSProperties;
+        className?: string;
+        readOnly?: boolean;
+        disabled?: boolean;
+        condition?: payload_dist_fields_config_types.Condition<any, any>;
+        description?: payload_dist_admin_components_forms_FieldDescription_types.Description;
+        components?: {
+            Filter?: React.ComponentType<any>;
+            Cell?: React.ComponentType<any>;
+            Field?: React.ComponentType<any>;
+        };
+        hidden?: boolean;
+    } & {
+        hideGutter?: boolean;
+    };
+};
+
+type WithMarketsProps = (Omit<RelationshipField, 'type' | 'name' | 'relationTo'> & {
+    name?: string;
+});
+type WithMarkets = WithMarketsProps & {
+    type: 'withMarkets';
+};
+declare const MarketDefaults: RelationshipField;
+declare const withMarkets: (options?: WithMarketsProps) => RelationshipField;
+declare const withMarketsRequired: (options?: WithMarketsProps) => RelationshipField;
+
+type WithMediaProps = (Omit<UploadField, 'type' | 'name' | 'relationTo'> & {
+    name?: string;
+});
+type WithMedia = WithMediaProps & {
+    type: 'withMedia';
+};
+declare const MediaDefaults: UploadField;
+declare const withMedia: (options?: WithMediaProps) => UploadField;
+declare const withMediaRequired: (options?: WithMediaProps) => UploadField;
+
+type WithMediasProps = (Omit<ArrayField, 'type' | 'name' | 'fields'> & {
+    name?: string;
+});
+type WithMedias = WithMediasProps & {
+    type: 'withMedias';
+};
+declare const MediasDefaults: ArrayField;
+declare const withMedias: (options?: WithMediasProps) => ArrayField;
+declare const withMediasRequired: (options?: WithMediasProps) => ArrayField;
+
+type WithNameProps = (Omit<TextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithName = WithNameProps & {
+    type: 'withName';
+};
+declare const withName: (options?: WithNameProps) => TextField;
+declare const withNameRequired: (options?: WithNameProps) => TextField;
+
+type WithRelatedProps = Omit<Partial<BlockField>, 'type' | 'name' | 'blocks'> & {
+    name?: string;
+    blocks: BowlBlock[];
+};
+type WithRelated = WithRelatedProps & {
+    type: 'withRelated';
+};
+declare const RelatedDefaults: BlockField;
+declare const withRelated: (options: WithRelatedProps) => BlockField;
+
+type WithRichTextProps = (Omit<RichTextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithRichText = WithRichTextProps & {
+    type: 'withRichText';
+};
+declare const richTextAfterReadHook: (args: FieldHookArgs<any, any[], any>) => string | any[];
+declare const RichTextDefaults: RichTextField;
+declare const withRichText: (options?: Partial<RichTextField>) => RichTextField;
+declare const withRichTextRequired: (options?: Partial<RichTextField>) => RichTextField;
+declare function richTextSerialize(children?: any[]): string;
+
+type WithSelectProps = (Omit<SelectField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithSelect = WithSelectProps & {
+    type: 'withSelect';
+};
+declare const SelectDefaults: SelectField;
+declare const withSelect: (options?: Partial<SelectField>) => SelectField;
+declare const withSelectRequired: (options?: Partial<SelectField>) => SelectField;
+
+type WithSlugProps = (Omit<TextField, 'type' | 'name'> & {
+    fieldToUse: string;
+});
+type WithSlug = WithSlugProps & {
+    type: 'withSlug';
+};
+declare const withSlug: ({ fieldToUse, ...options }?: WithSlugProps) => TextField;
+declare const withSlugRequired: ({ fieldToUse, ...options }?: WithSlugProps) => TextField;
+
+type WithTemplateProps = (Omit<RelationshipField, 'type' | 'name' | 'relationTo'> & {
+    slugToUse: string;
+});
+type WithTemplate = WithTemplateProps & {
+    type: 'withTemplate';
+};
+declare const TemplateDefaults: RelationshipField;
+declare const withTemplate: ({ slugToUse, ...options }: WithTemplateProps) => RelationshipField;
+declare const withTemplateRequired: ({ slugToUse, ...options }: WithTemplateProps) => RelationshipField;
+
+type WithTextProps = (Omit<TextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithText = WithTextProps & {
+    type: 'withText';
+};
+declare const TextDefaults: TextField;
+declare const withText: (options?: WithTextProps) => TextField;
+declare const withTextRequired: (options?: WithTextProps) => TextField;
+
+type WithTitleProps = (Omit<TextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithTitle = WithTitleProps & {
+    type: 'withTitle';
+};
+declare const withTitle: (options?: WithTitleProps) => TextField;
+declare const withTitleRequired: (options?: WithTitleProps) => TextField;
+
+declare const defaultSlug: BowlSlug;
+declare const defaultGroup: BowlGroup;
+declare const defaultLocales: string[];
+declare const defaultLocale = "en";
+declare const options: BowlOptions;
+declare const internalSlugs: string[];
+
+type Locale = typeof options.locales[number];
+type LocalizedText = {
+    [key in Locale]?: string;
+};
+declare function getTranslation(path: string, defaultText: string | undefined, locale: Locale, node?: {
+    [key: string]: any;
+}, fullPath?: string): string;
+declare function getTranslations(path: string, defaultText?: string): LocalizedText;
+declare function slugToLabels(slug: string): {
+    singular: LocalizedText;
+    plural: LocalizedText;
+};
+declare function slugToLabel(slug: string): LocalizedText;
+declare function translateTab(tab: Tab): Tab;
+declare function translateTabs(tabs: Tab[]): Tab[];
+declare function translateBlock(block: Block): Block;
+declare function translateBlocks(blocks: Block[]): Block[];
+declare function translateField(field: Field$1): payload_types.UIField | payload_types.TextField | payload_types.NumberField | payload_types.EmailField | payload_types.TextareaField | payload_types.CheckboxField | payload_types.DateField | BlockField | payload_types.GroupField | payload_types.RadioField | payload_types.RelationshipField | payload_types.ArrayField | payload_types.RichTextField | payload_types.SelectField | payload_types.UploadField | payload_types.CodeField | payload_types.PointField | payload_types.RowField | payload_types.CollapsibleField | payload_types.TabsField;
+declare function translateFields(fields: Field$1[]): Field$1[];
+declare function translateCollection(config: CollectionConfig): CollectionConfig;
+declare function translateGlobal(config: GlobalConfig): GlobalConfig;
+declare function logMissingTranslations(): void;
+
+/**
+ * Simple object check.
+ * @param item
+ * @returns {boolean}
+ */
+declare function isObject(item: unknown): boolean;
+/**
+ * Deep merge two objects.
+ * @param target
+ * @param ...sources
+ */
+declare function deepMerge<T, R = T>(target: Partial<T>, source: Partial<R>): T & R;
+
+declare const formatSlug: (fallback: string) => FieldHook;
+
+declare function withCollectionHook(config: CollectionConfig, name: string, hook: (...args: any[]) => unknown | Promise<unknown>): CollectionConfig;
+declare function withGlobalHook(config: GlobalConfig, name: string, hook: (...args: any[]) => unknown | Promise<unknown>): GlobalConfig;
+declare function withFieldHook(field: FieldAffectingData, name: HookName, hook: FieldHook$1): FieldAffectingData;
+
+/**
+ * Create a record of the pages collection related to the created document.
+ */
+declare const afterPageChangeHook: CollectionAfterChangeHook;
+/**
+ * Delete records of the pages collection related to the deleted document.
+ */
+declare const afterPageDeleteHook: CollectionAfterDeleteHook;
+
+type WithColorProps = (Omit<TextField, 'type' | 'name'> & {
+    name?: string;
+});
+type WithColor = WithColorProps & {
+    type: 'withColor';
+};
+declare const validateHexColor: (value?: string) => true | string;
+declare const ColorConfig: TextField;
+declare const withColor: (options?: WithColorProps) => TextField;
+declare const withColorRequired: (options?: WithColorProps) => TextField;
+
+declare const ColorCell: React__default.FC<Props>;
+
+declare const ColorField: React__default.FC<Props$1>;
+
+type FieldPermissions$3 = {
+    create: {
+        permission: boolean;
+    };
+    read: {
+        permission: boolean;
+    };
+    update: {
+        permission: boolean;
+    };
+    fields?: {
+        [field: string]: FieldPermissions$3;
+    };
+};
+type DebugFieldType = FieldBase & {
+    type: keyof FieldTypes;
+};
+type DebugFieldProps = DebugFieldType & {
+    path?: string;
+    fieldTypes: FieldTypes;
+    permissions: FieldPermissions$3;
+    detectLoop?: boolean;
+};
+
+declare const debugField: (options?: Partial<DebugFieldType>) => DebugFieldType;
+
+declare const DebugField: React__default.FC<DebugFieldProps>;
+
+type FieldPermissions$2 = {
+    create: {
+        permission: boolean;
+    };
+    read: {
+        permission: boolean;
+    };
+    update: {
+        permission: boolean;
+    };
+    fields?: {
+        [field: string]: FieldPermissions$2;
+    };
+};
+type LocalizedFieldType = FieldBase & {
+    type: keyof FieldTypes;
+};
+type LocalizedFieldProps = LocalizedFieldType & {
+    path?: string;
+    fieldTypes: FieldTypes;
+    permissions: FieldPermissions$2;
+};
+
+declare const localizedField: (options: FieldAffectingData) => LocalizedFieldType;
+type FieldsConfig = {
+    fields: Field[];
+};
+declare const withLocalized: <T extends Partial<FieldsConfig> = {}>(config: T, first?: boolean) => T;
+
+declare const LocalizedField: React__default.FC<LocalizedFieldProps>;
+
+type FieldPermissions$1 = {
+    create: {
+        permission: boolean;
+    };
+    read: {
+        permission: boolean;
+    };
+    update: {
+        permission: boolean;
+    };
+    fields?: {
+        [field: string]: FieldPermissions$1;
+    };
+};
+type ILanguages = FieldBase & {
+    type: keyof FieldTypes;
+};
+type LanguagesProps = ILanguages & {
+    path?: string;
+    fieldTypes: FieldTypes;
+    permissions: FieldPermissions$1;
+};
+type LanguagesField = UIField & {};
+
+declare const withUILanguages: (options?: Partial<UIField>) => LanguagesField;
+
+declare const UILanguagesCell: React__default.FC<Props>;
+
+declare const UILanguagesField: React__default.FC<LanguagesProps>;
+
+type FieldPermissions = {
+    create: {
+        permission: boolean;
+    };
+    read: {
+        permission: boolean;
+    };
+    update: {
+        permission: boolean;
+    };
+    fields?: {
+        [field: string]: FieldPermissions;
+    };
+};
+type IStatic = FieldBase & {
+    type: keyof FieldTypes;
+};
+type StaticProps = IStatic & {
+    path?: string;
+    fieldTypes: FieldTypes;
+    permissions: FieldPermissions;
+};
+type StaticField = UIField & {};
+
+declare const withUIStatic: (options?: Partial<UIField>) => StaticField;
+
+declare const UIStaticCell: React__default.FC<Props>;
+
+declare const UIStaticField: React__default.FC<StaticProps>;
+
+type BowlTab = Omit<Tab, 'fields'> & {
+    fields: BowlField[];
+};
+type BowlArrayField = Omit<ArrayField, 'fields'> & {
+    fields: BowlField[];
+};
+type BowlBlockField = Omit<BlockField, 'blocks'> & {
+    blocks: BowlBlock[];
+};
+type BowlCollapsibleField = Omit<CollapsibleField, 'fields'> & {
+    fields: BowlField[];
+};
+type BowlGroupField = Omit<GroupField, 'fields'> & {
+    fields: BowlField[];
+};
+type BowlRowField = Omit<RowField, 'fields'> & {
+    fields: BowlField[];
+};
+type BowlTabsField = Omit<TabsField, 'tabs'> & {
+    tabs: BowlTab[];
+};
+type BowlField = Field$1 | BowlArrayField | BowlBlockField | BowlCollapsibleField | BowlGroupField | BowlRowField | BowlTabsField | WithAbstract | WithCategory | WithCheckbox | WithColor | WithComponents | WithDate | WithDescription | WithId | WithIsActive | WithIsDefault | WithLink | WithMarkets | WithMedia | WithMedias | WithName | WithRelated | WithRichText | WithSelect | WithSlug | WithTemplate | WithText | WithTitle;
+type BowlBlock = Block | WithBlock;
+type BowlCollection = WithCollection | WithPage | WithStatic | CollectionConfig & {
+    type?: string;
+};
+type BowlGlobal = WithGlobal | GlobalConfig & {
+    type?: string;
+};
+type CollectionHelper = (options: BowlOptions) => BowlCollection;
+type GlobalHelper = (options: BowlOptions) => BowlGlobal;
+type BowlConfig = (Omit<Config, 'collections' | 'globals'> & {
+    collections?: BowlCollection[];
+    globals?: BowlGlobal[];
+});
+type BowlSlug = {
+    category: string;
+    label: string;
+    locale: string;
+    market: string;
+    media: string;
+    page: string;
+    template: string;
+    continent: string;
+    country: string;
+    countryZone: string;
+    language: string;
+    municipality: string;
+    province: string;
+    region: string;
+    subContinent: string;
+    [key: string]: string;
+};
+type BowlGroup = {
+    content: string;
+    nav: string;
+    config: string;
+    i18n: string;
+    admin: string;
+    [key: string]: string;
+};
+type BowlOptions = {
+    collections: string[];
+    pages: string[];
+    slug: BowlSlug;
+    group: BowlGroup;
+    locales: string[];
+    defaultLocale: string;
+    translations: Resource;
+};
+type BowlInitOptions = {
+    slug?: Partial<BowlSlug>;
+    group?: Partial<BowlGroup>;
+};
+
+declare const bowl: (sourceOptions?: BowlInitOptions) => (sourceConfig: BowlConfig) => Config;
+
+declare function toCollection(collection: BowlCollection): CollectionConfig;
+declare function toGlobal(collection: BowlGlobal): GlobalConfig;
+declare function toField(item: BowlField): Field$1;
+declare function toBlock(item: BowlBlock): Block;
+declare function toTab(item: BowlTab): Tab;
+
+export { BlockDefaults, BowlArrayField, BowlBlock, BowlBlockField, BowlCollapsibleField, BowlCollection, BowlConfig, BowlField, BowlGlobal, BowlGroup, BowlGroupField, BowlInitOptions, BowlOptions, BowlRowField, BowlSlug, BowlTab, BowlTabsField, CategoryDefaults, CheckboxDefaults, CollectionDefault, CollectionHelper, ColorCell, ColorConfig, ColorField, ComponentsDefaults, DateDefaults, DebugField, FieldsConfig, GlobalDefault, GlobalHelper, ICache, ICategorized, ICategory, ICategoryItem, ICollectionItem, IEntity, ILocale, ILocalizedString, IMarket, IMedia, IMediaType, IPage, IPageFull, IRoute, IStore, InMemoryCache, InMemoryCacheOptions, LocalizedField, MarketDefaults, MediaDefaults, MediasDefaults, Option, PageDefault, RelatedDefaults, RichTextDefaults, SelectDefaults, StaticCollectionConfig, StaticCollectionDefault, TemplateDefaults, TextDefaults, UILanguagesCell, UILanguagesField, UIStaticCell, UIStaticField, WithAbstract, WithAbstractProps, WithBlock, WithBlockProps, WithCategory, WithCategoryProps, WithCheckbox, WithCheckboxProps, WithCollection, WithCollectionProps, WithColor, WithColorProps, WithComponents, WithComponentsProps, WithDate, WithDateProps, WithDescription, WithDescriptionProps, WithGlobal, WithGlobalProps, WithId, WithIdProps, WithIsActive, WithIsActiveProps, WithIsDefault, WithIsDefaultProps, WithLink, WithLinkOptions, WithLinkProps, WithMarkets, WithMarketsProps, WithMedia, WithMediaProps, WithMedias, WithMediasProps, WithName, WithNameProps, WithPage, WithPageProps, WithRelated, WithRelatedProps, WithRichText, WithRichTextProps, WithSelect, WithSelectProps, WithSlug, WithSlugProps, WithStatic, WithStaticProps, WithTemplate, WithTemplateProps, WithText, WithTextProps, WithTitle, WithTitleProps, afterPageChangeHook, afterPageDeleteHook, appearanceOptions, bowl, collectionGet, debugField, deepMerge, bowl as default, defaultGroup, defaultLocale, defaultLocales, defaultSlug, fetchCollection, fetchCollectionItems, fetchEndpoint, fetchGlobal, fetchGlobalItems, formatSlug, getApiUrl, getLocale, getNumericParam, getObjectParam, getRoute, getRoutes, getSearchUrl, getStaticLoader, getStore, getStringParam, getTranslation, getTranslations, internalSlugs, isObject, keyWithRequest, localeGet, localizeCollection, localizedField, logMissingTranslations, options, populateStaticFields, richTextAfterReadHook, richTextSerialize, routeGet, slugToLabel, slugToLabels, storeGet, toBlock, toCollection, toField, toGlobal, toTab, translateBlock, translateBlocks, translateCollection, translateField, translateFields, translateGlobal, translateTab, translateTabs, validateHexColor, whereCollection, withAbstract, withAbstractRequired, withBlock, withCategory, withCategoryRequired, withCheckbox, withCheckboxRequired, withCollection, withCollectionHook, withColor, withColorRequired, withComponents, withDate, withDateRequired, withDescription, withDescriptionRequired, withFieldHook, withGlobal, withGlobalHook, withId, withIdRequired, withIsActive, withIsActiveRequired, withIsDefault, withIsDefaultRequired, withLink, withLocalized, withMarkets, withMarketsRequired, withMedia, withMediaRequired, withMedias, withMediasRequired, withName, withNameRequired, withPage, withRelated, withRichText, withRichTextRequired, withSelect, withSelectRequired, withSlug, withSlugRequired, withStaticCollection, withTemplate, withTemplateRequired, withText, withTextRequired, withTitle, withTitleRequired, withUILanguages, withUIStatic };