@stackbit/cms-core 0.1.29 → 0.1.30-alpha.0

package/src/utils/search-utils.ts

@@ -1,11 +1,9 @@
 import _ from 'lodash';
 import { ImageModel, Model } from '@stackbit/sdk';
-import * as ContentSourceInterface from '@stackbit/types';
-import { getLocalizedFieldForLocale } from '@stackbit/types';
 
+import * as ContentStoreTypes from '../types';
 import { SearchFilter, SearchFilterItem } from '../types/search-filter';
-import { ContentStoreTypes } from '..';
-import { getContentSourceId } from '../content-store-utils';
+import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 
 const META_FIELD = {
     createdAt: {
@@ -91,7 +89,7 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
             case 'text':
             case 'markdown':
             case 'html':
-                value = getLocalizedFieldForLocale(field, locale)?.value;
+                value = getDocumentFieldForLocale(field, locale)?.value;
                 break;
         }
 
@@ -105,13 +103,14 @@ const isDocumentMatchesPattern = (document: ContentStoreTypes.Document, query: s
 
 const getFieldForFilter = (document: ContentStoreTypes.Document, filter: SearchFilterItem): ContentStoreTypes.DocumentField => {
     if (filter.isMeta) {
-        const fieldDef = META_FIELD[filter.field as keyof typeof META_FIELD];
-        if (!fieldDef) {
+        if (filter.field !== 'createdAt' && filter.field !== 'updatedAt') {
             throw new Error(`Unsupported meta field ${filter.field}`);
         }
+        const fieldDef = META_FIELD[filter.field];
+        const dateValue = document[filter.field];
         return {
             ...fieldDef,
-            value: document[filter.field as keyof typeof document]
+            value: dateValue
         };
     } else {
         const documentField = document.fields[filter.field];
@@ -180,7 +179,7 @@ const isStringFieldMatches = ({
     locale?: string;
 }) => {
     // ignoring case
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value?.toLowerCase();
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value?.toLowerCase();
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -202,9 +201,9 @@ const isStringFieldMatches = ({
                 case 'neq':
                     return fieldValue !== filterValue;
                 case 'includes':
-                    return fieldValue.includes(filterValue);
+                    return Boolean(fieldValue?.includes(filterValue));
                 case 'not-includes':
-                    return !fieldValue.includes(filterValue);
+                    return !Boolean(fieldValue?.includes(filterValue));
             }
         }
     }
@@ -213,7 +212,7 @@ const isStringFieldMatches = ({
 };
 
 const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTypes.DocumentFieldForType<'number'>; filter: SearchFilterItem; locale?: string }) => {
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -234,9 +233,9 @@ const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTy
                 case 'neq':
                     return fieldValue !== filter.value;
                 case 'gte':
-                    return fieldValue >= filter.value;
+                    return Boolean(fieldValue && fieldValue >= filter.value);
                 case 'lte':
-                    return fieldValue <= filter.value;
+                    return Boolean(fieldValue && fieldValue <= filter.value);
             }
         }
 
@@ -246,7 +245,7 @@ const isNumberFieldMatches = ({ field, filter, locale }: { field: ContentStoreTy
                 throw new Error(`Filter startValue and endValue should be number for field ${filter.field}`);
             }
 
-            return fieldValue >= filter.startValue && fieldValue <= filter.endValue;
+            return Boolean(fieldValue && fieldValue >= filter.startValue && fieldValue <= filter.endValue);
         }
     }
 
@@ -262,7 +261,7 @@ const isBooleanFieldMatches = ({
     filter: SearchFilterItem;
     locale?: string;
 }) => {
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -311,7 +310,7 @@ const isDateFieldMatches = ({
     filter: SearchFilterItem;
     locale?: string;
 }) => {
-    const origValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const origValue = getDocumentFieldForLocale(field, locale)?.value;
     const fieldValue = parseDateValue(origValue);
     if (origValue && !fieldValue) {
         throw new Error(`Can't parse value ${origValue} for field ${filter.field}`);
@@ -374,7 +373,7 @@ const isDateFieldMatches = ({
 };
 
 const isEnumFieldMatches = ({ field, filter, locale }: { field: ContentStoreTypes.DocumentFieldForType<'enum'>; filter: SearchFilterItem; locale?: string }) => {
-    const fieldValue = getLocalizedFieldForLocale(field, locale)?.value;
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.value;
 
     switch (filter.operator) {
         case 'is-undefined': return fieldValue === undefined;
@@ -415,7 +414,7 @@ const isListFieldMatches = ({
         throw new Error(`Unsupported filter for list field ${filter.field} with children ${listItemsType}`);
     }
 
-    const fieldValue = getLocalizedFieldForLocale(field as ContentSourceInterface.DocumentFieldForType<'list'>, locale)?.items?.map((item) =>
+    const fieldValue = getDocumentFieldForLocale(field, locale)?.items?.map((item) =>
         'value' in item ? item.value : undefined
     );
 

package/src/utils/site-map.ts

@@ -3,7 +3,7 @@ import { Config } from '@stackbit/sdk';
 import { append } from '@stackbit/utils';
 import { SiteMapEntry } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 import { mapStoreDocumentsToCSIDocumentsWithSource } from './store-to-csi-docs-converter';
 import { getContentSourceId, getDocumentFieldForLocale } from '../content-store-utils';
 

package/src/utils/store-to-api-docs-converter.ts

@@ -1,6 +1,7 @@
 import _ from 'lodash';
 import { omitByNil } from '@stackbit/utils';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
+import { DocumentStringLikeFieldAPI } from '../types';
 
 export function mapDocumentsToLocalizedApiObjects(documents: ContentStoreTypes.Document[], locale?: string): ContentStoreTypes.APIDocumentObject[] {
     return documents.map((document) => documentToLocalizedApiObject(document, locale));
@@ -51,25 +52,46 @@ function toLocalizedAPIField(docField: ContentStoreTypes.DocumentField, locale?:
         case 'date':
         case 'datetime':
         case 'color':
-        case 'style':
+        case 'style': {
+            if (docField.localized) {
+                const { localized, locales, ...base } = docField;
+                const localeProps = locales && locale ? locales[locale] : undefined;
+                return {
+                    ...base,
+                    ...localeProps,
+                    ...localeFields(localized)
+                } as ContentStoreTypes.DocumentStringLikeFieldAPI;
+            }
+            return {
+                ...docField,
+                ...localeFields(docField.localized)
+            };
+        }
         case 'file':
         case 'json':
         case 'markdown':
-        case 'richText':
+        case 'richText': {
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
                 const localeProps = locales && locale ? locales[locale] : undefined;
+                if (localeProps) {
+                    return {
+                        ...base,
+                        ...localeProps,
+                        ...localeFields(localized)
+                    };
+                }
                 return {
                     ...base,
-                    ...(localeProps ?? { value: null }),
-                    ...localeFields(localized),
-                    ...(['file', 'json', 'markdown', 'richText'].includes(docField.type) && !localeProps ? { isUnset: true } : null)
+                    isUnset: true,
+                    ...localeFields(localized)
                 };
             }
             return {
                 ...docField,
                 ...localeFields(docField.localized)
             };
+        }
         case 'image':
             if (docField.localized) {
                 const { localized, locales, ...base } = docField;
@@ -265,9 +287,12 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
     const titleField = assetFields.title;
     if (titleField.localized) {
         if (locale) {
-            fields.title.value = titleField.locales?.[locale]?.value ?? null;
-            fields.title.localized = true;
-            fields.title.locale = locale;
+            fields.title = {
+                type: 'string',
+                value: titleField.locales?.[locale]?.value ?? null,
+                localized: true,
+                locale: locale
+            };
         }
     } else {
         fields.title.value = titleField.value;
@@ -275,9 +300,12 @@ function localizeAssetFields(assetFields: ContentStoreTypes.AssetFields, locale?
     const assetFileField = assetFields.file;
     if (assetFileField.localized) {
         if (locale) {
-            fields.url.value = assetFileField.locales?.[locale]?.url ?? null;
-            fields.url.localized = true;
-            fields.url.locale = locale;
+            fields.url = {
+                type: 'string',
+                value: assetFileField.locales?.[locale]?.url ?? null,
+                localized: true,
+                locale: locale
+            };
         }
     } else {
         fields.url.value = assetFileField.url;
@@ -302,7 +330,7 @@ function storeAssetToAPIAsset(asset: ContentStoreTypes.Asset, locale?: string):
         createdAt: asset.createdAt,
         url: localizedFileField.url,
         ...omitByNil({
-            title: localizedTitleField?.value ?? null,
+            title: localizedTitleField?.value ?? undefined,
             fileName: localizedFileField.fileName,
             contentType: localizedFileField.contentType,
             size: localizedFileField.size,

package/src/utils/store-to-csi-docs-converter.ts

@@ -1,6 +1,6 @@
 import _ from 'lodash';
 import * as CSITypes from '@stackbit/types';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 
 export function mapStoreDocumentsToCSIDocumentsWithSource(documents: ContentStoreTypes.Document[]): CSITypes.DocumentWithSource[] {
     return documents.map((document) => mapStoreDocumentToCSIDocumentWithSource(document));

package/src/utils/timer.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../content-store-types';
+import { Logger } from '@stackbit/types';
 
 export class Timer {
     private readonly timerCallback: () => void;

package/dist/content-store-types.d.ts

@@ -1,413 +0,0 @@
-import { DocumentStatus, FieldType } from '@stackbit/types';
-import { Model } from '@stackbit/sdk';
-import * as CSITypes from '@stackbit/types';
-export { FieldType, DocumentStatus, Logger } from '@stackbit/types';
-export interface ContentSourceData {
-    id: string;
-    instance: CSITypes.ContentSourceInterface;
-    srcType: string;
-    srcProjectId: string;
-    locales?: CSITypes.Locale[];
-    defaultLocaleCode?: string;
-    models: Model[];
-    modelMap: Record<string, Model>;
-    csiModels: CSITypes.Model[];
-    csiModelMap: Record<string, CSITypes.Model>;
-    csiDocuments: CSITypes.Document[];
-    csiDocumentMap: Record<string, CSITypes.Document>;
-    documents: Document[];
-    documentMap: Record<string, Document>;
-    csiAssets: CSITypes.Asset[];
-    csiAssetMap: Record<string, CSITypes.Asset>;
-    assets: Asset[];
-    assetMap: Record<string, Asset>;
-}
-export interface Document {
-    type: 'document';
-    srcType: string;
-    srcProjectId: string;
-    srcProjectUrl: string;
-    srcEnvironment: string;
-    srcObjectId: string;
-    srcObjectUrl: string;
-    srcObjectLabel: string;
-    srcModelName: string;
-    srcModelLabel: string;
-    isChanged: boolean;
-    status: DocumentStatus;
-    createdAt: string;
-    createdBy?: string;
-    updatedAt: string;
-    updatedBy?: string[];
-    locale?: string;
-    fields: Record<string, DocumentField>;
-}
-export interface Asset {
-    type: 'asset';
-    srcType: string;
-    srcProjectId: string;
-    srcProjectUrl: string;
-    srcEnvironment: string;
-    srcObjectId: string;
-    srcObjectUrl: string;
-    srcObjectLabel: string;
-    srcModelName: string;
-    srcModelLabel: string;
-    isChanged: boolean;
-    status: DocumentStatus;
-    createdAt: string;
-    createdBy?: string;
-    updatedAt: string;
-    updatedBy?: string[];
-    locale?: string;
-    fields: AssetFields;
-}
-export declare type AssetFields = {
-    title: DocumentValueFieldForType<'string'>;
-    file: AssetFileField;
-};
-export interface UploadAssetData {
-    url: string;
-    data?: string;
-    metadata: {
-        name: string;
-        type: string;
-    };
-}
-export interface ContentChangeResultItem {
-    srcType: string;
-    srcProjectId: string;
-    srcObjectId: string;
-}
-export interface ContentChangeResult {
-    updatedDocuments: ContentChangeResultItem[];
-    updatedAssets: ContentChangeResultItem[];
-    deletedDocuments: ContentChangeResultItem[];
-    deletedAssets: ContentChangeResultItem[];
-}
-export declare type APIObject = APIDocumentObject | APIImageObject;
-export interface APIDocumentObject extends Omit<Document, 'fields' | 'type'> {
-    type: 'object';
-    fields: Record<string, DocumentFieldAPI>;
-}
-export interface APIImageObject extends Omit<Asset, 'fields' | 'type'> {
-    type: 'image';
-    fields: AssetFieldsAPI;
-}
-export declare type AssetFieldsAPI = {
-    title: DocumentFieldAPIForType<'string'>;
-    url: DocumentFieldAPIForType<'string'>;
-};
-export interface APIAsset {
-    objectId: string;
-    createdAt: string;
-    url: string;
-    title?: string;
-    fileName?: string;
-    contentType?: string;
-    size?: number;
-    width?: number;
-    height?: number;
-}
-export declare type DocumentField = DocumentValueField | DocumentObjectField | DocumentModelField | DocumentReferenceField | DocumentCrossReferenceField | DocumentListField | DocumentMarkdownField | DocumentRichTextField | DocumentImageField;
-export declare type DocumentFieldLocalized = DocumentValueFieldLocalized | DocumentObjectFieldLocalized | DocumentModelFieldLocalized | DocumentReferenceFieldLocalized | DocumentCrossReferenceFieldLocalized | DocumentMarkdownFieldLocalized | DocumentRichTextFieldLocalized | DocumentListFieldLocalized | DocumentImageFieldLocalized;
-export declare type DocumentFieldNonLocalized = DocumentValueFieldNonLocalized | DocumentObjectFieldNonLocalized | DocumentModelFieldNonLocalized | DocumentReferenceFieldNonLocalized | DocumentCrossReferenceFieldNonLocalized | DocumentMarkdownFieldNonLocalized | DocumentRichTextFieldNonLocalized | DocumentListFieldNonLocalized | DocumentImageFieldNonLocalized;
-export declare type DocumentFieldAPI = DocumentValueFieldAPI | DocumentObjectFieldAPI | DocumentModelFieldAPI | DocumentReferenceFieldAPI | DocumentCrossReferenceFieldAPI | DocumentMarkdownFieldAPI | DocumentRichTextFieldAPI | DocumentListFieldAPI | DocumentImageFieldAPI;
-export declare type DocumentFieldBaseProps = DocumentValueFieldBaseProps | DocumentObjectFieldBase | DocumentModelFieldBase | DocumentReferenceFieldBase | DocumentCrossReferenceFieldBase | DocumentListFieldBase | DocumentRichTextFieldBase | DocumentImageFieldBase;
-export declare type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
-export declare type Simplify<T> = {
-    [K in keyof T]: T[K];
-};
-export declare type FindByType<Union extends {
-    type: FieldType | 'unresolved_reference';
-}, Type> = Union extends {
-    type: Type;
-} ? Union : never;
-export declare type DocumentFieldForType<Type extends FieldType> = FindByType<DocumentField, Type>;
-export declare type DocumentFieldLocalizedForType<Type extends FieldType> = FindByType<DocumentFieldLocalized, Type>;
-export declare type DocumentFieldNonLocalizedForType<Type extends FieldType> = FindByType<DocumentFieldNonLocalized, Type>;
-export declare type DocumentFieldAPIForType<Type extends FieldType | 'unresolved_reference'> = FindByType<DocumentFieldAPI, Type>;
-export declare type DocumentFieldBasePropsForType<Type extends FieldType> = FindByType<DocumentFieldBaseProps, Type>;
-export declare type DocumentFieldSpecificPropsForType<Type extends FieldType> = Simplify<DistributiveOmit<DocumentFieldNonLocalizedForType<Type>, keyof DocumentFieldBasePropsForType<Type> | 'label' | 'locale' | 'localized'>>;
-export declare type DocumentFieldTypeLocalized<BaseFieldProps, LocalizedFieldProps> = Simplify<BaseFieldProps & {
-    label?: string;
-    localized: true;
-    locales: Record<string, {
-        locale: string;
-    } & Omit<Exclude<LocalizedFieldProps, DocumentFieldUnsetProps>, 'isUnset'>>;
-}>;
-export declare type DocumentFieldTypeNonLocalized<BaseFieldProps, LocalizedFieldProps> = Simplify<BaseFieldProps & LocalizedFieldProps & {
-    label?: string;
-    localized?: false;
-}>;
-export declare type DocumentFieldTypeAPI<BaseFieldProps, LocalizedFieldProps> = BaseFieldProps & LocalizedFieldProps & {
-    label?: string;
-    description?: string;
-    locale?: string;
-    localized?: boolean;
-} & ({
-    localized?: false;
-} | {
-    localized: true;
-    locale: string;
-});
-export declare type DocumentValueFieldType = Exclude<FieldType, 'object' | 'model' | 'reference' | 'cross-reference' | 'markdown' | 'richText' | 'list' | 'image'>;
-export declare type DocumentValueFieldForType<Type> = Type extends DocumentValueFieldType ? DocumentValueFieldLocalizedForType<Type> | DocumentValueFieldNonLocalizedForType<Type> : never;
-export declare type DocumentValueField = DocumentValueFieldForType<DocumentValueFieldType>;
-export declare type DocumentValueFieldLocalizedForType<Type> = Type extends DocumentValueFieldType ? DocumentFieldTypeLocalized<DocumentValueFieldBase<Type>, DocumentValueFieldProps> : never;
-export declare type DocumentValueFieldLocalized = DocumentValueFieldLocalizedForType<DocumentValueFieldType>;
-export declare type DocumentValueFieldNonLocalizedForType<Type> = Type extends DocumentValueFieldType ? DocumentFieldTypeNonLocalized<DocumentValueFieldBase<Type>, DocumentValueFieldProps> : never;
-export declare type DocumentValueFieldNonLocalized = DocumentValueFieldNonLocalizedForType<DocumentValueFieldType>;
-export declare type DocumentValueFieldAPIForType<Type> = Type extends DocumentValueFieldType ? DocumentFieldTypeAPI<DocumentValueFieldBase<Type>, DocumentValueFieldProps> : never;
-export declare type DocumentValueFieldAPI = DocumentValueFieldAPIForType<DocumentValueFieldType>;
-export declare type DocumentValueFieldBasePropsForType<Type> = Type extends DocumentValueFieldType ? DocumentValueFieldBase<Type> : never;
-export declare type DocumentValueFieldBaseProps = DocumentValueFieldBasePropsForType<DocumentValueFieldType>;
-export declare type DocumentValueFieldBase<Type extends DocumentValueFieldType> = {
-    type: Type;
-};
-export declare type DocumentValueFieldProps = {
-    value: any;
-};
-export declare type DocumentFieldUnsetProps = {
-    isUnset: true;
-};
-export declare type DocumentObjectField = DocumentObjectFieldLocalized | DocumentObjectFieldNonLocalized;
-export declare type DocumentObjectFieldLocalized = DocumentFieldTypeLocalized<DocumentObjectFieldBase, DocumentObjectFieldProps>;
-export declare type DocumentObjectFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentObjectFieldBase, DocumentObjectFieldProps>;
-export declare type DocumentObjectFieldAPI = DocumentFieldTypeAPI<DocumentObjectFieldBase, DocumentObjectFieldPropsAPI>;
-export declare type DocumentObjectFieldBase = {
-    type: 'object';
-};
-export declare type DocumentObjectFieldPropsCommon = {
-    srcObjectLabel: string;
-};
-export declare type DocumentObjectFieldProps = DocumentFieldUnsetProps | ({
-    isUnset?: false;
-    fields: Record<string, DocumentField>;
-} & DocumentObjectFieldPropsCommon);
-export declare type DocumentObjectFieldPropsAPI = DocumentFieldUnsetProps | ({
-    isUnset?: false;
-    fields: Record<string, DocumentFieldAPI>;
-} & DocumentObjectFieldPropsCommon);
-export declare type DocumentModelField = DocumentModelFieldLocalized | DocumentModelFieldNonLocalized;
-export declare type DocumentModelFieldLocalized = DocumentFieldTypeLocalized<DocumentModelFieldBase, DocumentModelFieldProps>;
-export declare type DocumentModelFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentModelFieldBase, DocumentModelFieldProps>;
-export declare type DocumentModelFieldAPI = DocumentFieldTypeAPI<{
-    type: 'object';
-}, DocumentModelFieldPropsAPI>;
-export declare type DocumentModelFieldBase = {
-    type: 'model';
-};
-export declare type DocumentModelFieldPropsCommon = {
-    srcObjectLabel: string;
-    srcModelName: string;
-    srcModelLabel: string;
-};
-export declare type DocumentModelFieldProps = DocumentFieldUnsetProps | ({
-    isUnset?: false;
-    fields: Record<string, DocumentField>;
-} & DocumentModelFieldPropsCommon);
-export declare type DocumentModelFieldPropsAPI = DocumentFieldUnsetProps | ({
-    isUnset?: false;
-    fields: Record<string, DocumentFieldAPI>;
-} & DocumentModelFieldPropsCommon);
-export declare type DocumentReferenceField = DocumentReferenceFieldLocalized | DocumentReferenceFieldNonLocalized;
-export declare type DocumentReferenceFieldLocalized = DocumentFieldTypeLocalized<DocumentReferenceFieldBase, DocumentReferenceFieldProps>;
-export declare type DocumentReferenceFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentReferenceFieldBase, DocumentReferenceFieldProps>;
-export declare type DocumentReferenceFieldAPI = DocumentFieldTypeAPI<DocumentReferenceFieldBaseAPI, DocumentReferenceFieldProps>;
-export declare type DocumentReferenceFieldBase = {
-    type: 'reference';
-    refType: 'document' | 'asset';
-};
-export declare type DocumentReferenceFieldProps = DocumentFieldUnsetProps | {
-    isUnset?: false;
-    refId: string;
-};
-export declare type DocumentReferenceFieldBaseAPI = {
-    type: 'unresolved_reference';
-    refType: 'object' | 'image';
-};
-export declare type DocumentCrossReferenceField = DocumentCrossReferenceFieldLocalized | DocumentCrossReferenceFieldNonLocalized;
-export declare type DocumentCrossReferenceFieldLocalized = DocumentFieldTypeLocalized<DocumentCrossReferenceFieldBase, DocumentCrossReferenceFieldProps>;
-export declare type DocumentCrossReferenceFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentCrossReferenceFieldBase, DocumentCrossReferenceFieldProps>;
-export declare type DocumentCrossReferenceFieldAPI = DocumentFieldTypeAPI<DocumentCrossReferenceFieldBase, DocumentCrossReferenceFieldProps>;
-export declare type DocumentCrossReferenceFieldBase = {
-    type: 'cross-reference';
-    refType: 'document' | 'asset';
-};
-export declare type DocumentCrossReferenceFieldProps = DocumentFieldUnsetProps | {
-    isUnset?: false;
-    refId: string;
-    refSrcType: string;
-    refProjectId: string;
-};
-export declare type DocumentMarkdownField = DocumentMarkdownFieldLocalized | DocumentMarkdownFieldNonLocalized;
-export declare type DocumentMarkdownFieldLocalized = DocumentFieldTypeLocalized<DocumentMarkdownFieldBase, DocumentMarkdownFieldProps>;
-export declare type DocumentMarkdownFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentMarkdownFieldBase, DocumentMarkdownFieldProps>;
-export declare type DocumentMarkdownFieldAPI = DocumentFieldTypeAPI<DocumentMarkdownFieldBase, DocumentMarkdownFieldProps>;
-export declare type DocumentMarkdownFieldBase = {
-    type: 'markdown';
-};
-export declare type DocumentMarkdownFieldProps = {
-    isUnset?: boolean;
-    multiElement?: boolean;
-    value: any;
-};
-export declare type DocumentRichTextField = DocumentRichTextFieldLocalized | DocumentRichTextFieldNonLocalized;
-export declare type DocumentRichTextFieldLocalized = DocumentFieldTypeLocalized<DocumentRichTextFieldBase, DocumentRichTextFieldProps>;
-export declare type DocumentRichTextFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentRichTextFieldBase, DocumentRichTextFieldProps>;
-export declare type DocumentRichTextFieldAPI = DocumentFieldTypeAPI<DocumentRichTextFieldBase, DocumentRichTextFieldProps>;
-export declare type DocumentRichTextFieldBase = {
-    type: 'richText';
-};
-export declare type DocumentRichTextFieldProps = {
-    isUnset?: boolean;
-    hint?: string;
-    multiElement?: boolean;
-    value: any;
-};
-export declare type DocumentListField = DocumentListFieldLocalized | DocumentListFieldNonLocalized;
-export declare type DocumentListFieldLocalized = DocumentFieldTypeLocalized<DocumentListFieldBase, DocumentListFieldProps>;
-export declare type DocumentListFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentListFieldBase, DocumentListFieldProps>;
-export declare type DocumentListFieldAPI = DocumentFieldTypeAPI<DocumentListFieldBase, DocumentListFieldPropsAPI>;
-export declare type DocumentListFieldBase = {
-    type: 'list';
-};
-export declare type DocumentListFieldItems = Exclude<DocumentFieldNonLocalized, DocumentListFieldNonLocalized>;
-export declare type DocumentListFieldProps = {
-    items: DocumentListFieldItems[];
-};
-export declare type DocumentListFieldItemsAPI = Exclude<DocumentFieldAPI, DocumentListFieldAPI>;
-export declare type DocumentListFieldPropsAPI = {
-    items: DocumentListFieldItemsAPI[];
-};
-export declare type DocumentImageField = DocumentImageFieldLocalized | DocumentImageFieldNonLocalized;
-export declare type DocumentImageFieldLocalized = DocumentFieldTypeLocalized<DocumentImageFieldBase, DocumentImageFieldProps>;
-export declare type DocumentImageFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentImageFieldBase, DocumentImageFieldProps>;
-export declare type DocumentImageFieldAPI = DocumentFieldTypeAPI<DocumentImageFieldBase, DocumentImageFieldPropsAPI>;
-export declare type DocumentImageFieldBase = {
-    type: 'image';
-    source?: string;
-    sourceData?: any;
-};
-export declare type DocumentImageFieldProps = DocumentFieldUnsetProps | {
-    isUnset?: false;
-    fields: ImageFields;
-};
-export declare type DocumentImageFieldPropsAPI = DocumentFieldUnsetProps | {
-    isUnset?: false;
-    fields: ImageFieldsAPI;
-};
-export declare type ImageFields = {
-    title: DocumentFieldForType<'string'>;
-    url: DocumentFieldForType<'string'>;
-};
-export declare type ImageFieldsAPI = AssetFieldsAPI;
-export declare type AssetFileField = AssetFileFieldLocalized | AssetFileFieldNonLocalized;
-export declare type AssetFileFieldLocalized = DocumentFieldTypeLocalized<AssetFileFieldBase, AssetFileFieldProps>;
-export declare type AssetFileFieldNonLocalized = DocumentFieldTypeNonLocalized<AssetFileFieldBase, AssetFileFieldProps>;
-export declare type AssetFileFieldBase = {
-    type: 'assetFile';
-};
-export declare type AssetFileFieldProps = {
-    url: string;
-    fileName?: string;
-    contentType?: string;
-    size?: number;
-    dimensions?: {
-        width?: number;
-        height?: number;
-    };
-};
-export declare type UpdateOperation = UpdateOperationSet | UpdateOperationUnset | UpdateOperationInsert | UpdateOperationRemove | UpdateOperationReorder;
-export interface UpdateOperationBase {
-    opType: string;
-    fieldPath: (string | number)[];
-    locale?: string;
-}
-export interface UpdateOperationSet extends UpdateOperationBase {
-    opType: 'set';
-    field: UpdateOperationField;
-}
-export interface UpdateOperationUnset extends UpdateOperationBase {
-    opType: 'unset';
-}
-export interface UpdateOperationInsert extends UpdateOperationBase {
-    opType: 'insert';
-    index?: number;
-    item: Exclude<UpdateOperationField, UpdateOperationListField>;
-}
-export interface UpdateOperationRemove extends UpdateOperationBase {
-    opType: 'remove';
-    index: number;
-}
-export interface UpdateOperationReorder extends UpdateOperationBase {
-    opType: 'reorder';
-    order: number[];
-}
-export declare type UpdateOperationField = UpdateOperationValueField | UpdateOperationObjectField | UpdateOperationModelField | UpdateOperationReferenceField | UpdateOperationCrossReferenceField | UpdateOperationListField;
-export declare type UpdateOperationValueFieldType = Exclude<FieldType, 'object' | 'model' | 'reference' | 'cross-reference' | 'list'>;
-export declare type UpdateOperationValueField = DistributeUpdateOperationValueField<UpdateOperationValueFieldType>;
-export declare type DistributeUpdateOperationValueField<Type extends UpdateOperationValueFieldType> = Type extends UpdateOperationValueFieldType ? UpdateOperationValueFieldForType<Type> : never;
-export declare type UpdateOperationValueFieldForType<Type extends UpdateOperationValueFieldType> = {
-    type: Type;
-    value: any;
-};
-export declare type UpdateOperationObjectField = {
-    type: 'object';
-    object: Record<string, any>;
-};
-export declare type UpdateOperationModelField = {
-    type: 'model';
-    modelName: string;
-    object: Record<string, any>;
-};
-export declare type UpdateOperationReferenceField = {
-    type: 'reference';
-    refType: 'document' | 'asset';
-    refId: string;
-};
-export declare type UpdateOperationCrossReferenceField = {
-    type: 'cross-reference';
-    refType: 'document' | 'asset';
-    refId: string;
-    refSrcType: string;
-    refProjectId: string;
-};
-export declare type UpdateOperationListField = {
-    type: 'list';
-    items: any[];
-};
-export declare type User = {
-    name: string;
-    email: string;
-    connections: {
-        type: string;
-        [key: string]: any;
-    }[];
-};
-export declare type ValidationError = {
-    message: string;
-    srcType: string;
-    srcProjectId: string;
-    srcObjectType: string;
-    srcObjectId: string;
-    fieldPath: (string | number)[];
-    isUniqueValidation?: boolean;
-};
-export declare type HasAccessResult = {
-    hasConnection: boolean;
-    hasPermissions: boolean;
-    contentSources: {
-        srcType: string;
-        srcProjectId: string;
-        hasConnection: boolean;
-        hasPermissions: boolean;
-    }[];
-};
-export interface CrossReferenceData {
-    refId: string;
-    refSrcType: string;
-    refProjectId: string;
-}
-//# sourceMappingURL=content-store-types.d.ts.map