@stackbit/cms-core 0.0.15 → 0.0.18-alpha.0

package/dist/utils/index.d.ts

@@ -50,16 +50,16 @@ export function copyFilesRecursively(sourceDir: string, targetDir: string, optio
 export function copy(sourceObject: Object, sourcePath: string, targetObject: Object, targetPath: string, transform?: Function | undefined): void;
 export function copyDefault(sourceObject: any, sourcePath: any, targetObject: any, targetPath: any, transform: any): void;
 export function mergeAtPath(object: any, path: any, source: any): any;
-export function omitByNil(object: any): any;
+export function omitByNil(object: any): Partial<any>;
 export function rename(object: any, oldPath: any, newPath: any): void;
 export function append(object: any, path: any, value: any): void;
 export function concat(object: any, path: any, value: any): void;
 export function indent(str: any, indent: any, indentFirst?: boolean): any;
-export function pascalCase(str: any): any;
-export function readDirRec(dir: any, options: any): Promise<any>;
+export function pascalCase(str: any): string;
+export function readDirRec(dir: any, options: any): Promise<any[]>;
 export function readDirRecSync(dir: any, options: any): any[];
 export function readDirGlob(dir: any, options: any): Promise<any>;
-export function fieldPathToString(fieldPath: any): any;
+export function fieldPathToString(fieldPath: any): string;
 export function hrtimeAndPrint(time: any): string | undefined;
 export function printHRTime(time: any): string | undefined;
 /**
@@ -93,7 +93,7 @@ export function mapDeep(value: any, iteratee: Function, options?: object | undef
 export function getFirst(object: Object, paths: Array<string | Array<string>>, defaultValue?: any): any;
 export function getFirstExistingFile(fileNames: any, inputDir: any): Promise<any>;
 export function parseFirstExistingFile(fileNames: any, inputDir: any): Promise<any>;
-export function getFirstExistingFileSync(fileNames: any, inputDir: any): any;
+export function getFirstExistingFileSync(fileNames: any, inputDir: any): string;
 export function parseFirstExistingFileSync(fileNames: any, inputDir: any): any;
 export function parseFile(filePath: any): any;
 export function parseFileSync(filePath: any): any;
@@ -111,8 +111,8 @@ export function failFunctionWithTag(tag: any): (message: any) => never;
 export function assertFunctionWithFail(fail: any): (value: any, message: any) => void;
 export function createLogger(scope: any, transport: any): {};
 export function logObject(object: any, title: any): void;
-export function joinPathAndGlob(pathStr: any, glob: any): any;
-export function globToArray(glob: any): any;
+export function joinPathAndGlob(pathStr: any, glob: any): string[];
+export function globToArray(glob: any): never[];
 /**
  * Inverse of _.toPath()
  *
@@ -171,3 +171,4 @@ export function decodeJsx(data: any): any;
 export function replaceInRange(str: any, range: any, stringToInsert: any): any;
 export function isRelevantReactData(data: any): any;
 export function convertToPosixFilePath(filePath: any): any;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;GAWG;AACH,8FAFY,QAAQ,GAAG,CAAC,CAoBvB;AAED,kFAsBC;AAED,qGAmBC;AAyBD,mFAwBC;AAED,gHAsEC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,gDARW,MAAM,aACN,MAAM;;iBAIN,MAAM;4CAmDhB;AAED;;;;;;;;GAQG;AACH,mCANW,MAAM,oCAEN,MAAM,8DAYhB;AAED,0HAIC;AAED,sEAQC;AAED,qDAEC;AAED,sEASC;AAED,iEAKC;AAED,iEAKC;AAED,0EAKC;AAED,6CAEC;AAED,mEAuBC;AA2BD,8DAoBC;AA7CD,kEAuBC;AAwBD,0DAmBC;AAED,8DAGC;AAED,2DAWC;AAED;;;;;;;GAOG;AACH,iEAHW,MAAM,GAAC,MAAM,UACb,MAAM,QAahB;AAgBD;;;;;;;;GAQG;AACH,6HAsBC;AA7CD;;;;;;;;GAQG;AACH,iCALW,MAAM,SACN,MAAM,SAAS,aAAa,CAAC,2BAOvC;AAmCD,kFAKC;AAED,oFAOC;AAED,gFAKC;AAED,+EAOC;AAED,8CAIC;AAED,kDAGC;AAED,qEA4BC;AAED,0DAGC;AAaD,+DAGC;AAdD,+EASC;AAOD,uEA2BC;AAED;;;EA+DC;AAED,0CAeC;AAED,uEAIC;AAED,sFAMC;AAED,6DAaC;AAED,yDAUC;AAED,mEAGC;AAED,gDASC;AAED;;;;;;;;GAQG;AACH,mDAWC;AAED,uDAOC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAJW,QAAM,MAAM,0BAEX;IAAC,IAAI,EAAE,QAAM,MAAM,CAAC;IAAC,MAAM,QAAO;CAAC,CAuB9C;AAED;;;;;;GAMG;AACH,kCAJW,QAAM,MAAM,0BAEX;IAAC,IAAI,EAAE,QAAM,MAAM,CAAC;IAAC,MAAM,QAAO;CAAC,CAwB9C;AAUD,0CAOC;AAED,0CAOC;AAED,+EAEC;AAED,oDAMC;AAED,2DAYC"}

package/dist/utils/schema-utils.d.ts

@@ -3,12 +3,12 @@ export function isObjectField(field: any): boolean;
 export function isModelField(field: any): boolean;
 export function isModelsField(field: any): boolean;
 export function isReferenceField(field: any): boolean;
-export function isCustomModelField(field: any, modelsByName: any): any;
+export function isCustomModelField(field: any, modelsByName: any): boolean;
 export function isListField(field: any): boolean;
 export function isListOfObjectsField(field: any): boolean;
 export function isListOfModelField(field: any): boolean;
 export function isListOfModelsField(field: any): boolean;
-export function isListOfCustomModelField(field: any): any;
+export function isListOfCustomModelField(field: any): boolean;
 export function isListOfReferenceField(field: any): boolean;
 /**
  * Gets a list field and returns its items field. If list field does not define
@@ -84,3 +84,4 @@ export function resolveLabelFieldForModel(model: any, modelLabelFieldPath: any,
 export function resolveLabelFieldFromFields(fields: any): any;
 export function getUrlPath(stackbitModel: any): any;
 export function getNormalizedModelType(stackbitModel: any): any;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/utils/schema-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-utils.d.ts","sourceRoot":"","sources":["../../src/utils/schema-utils.js"],"names":[],"mappings":"AAEA,mCAuBE;AA6CF,mDAEC;AAUD,kDAEC;AAED,mDAEC;AAdD,sDAEC;AAED,2EAEC;AAUD,iDAEC;AAED,0DAEC;AAED,wDAEC;AAED,yDAEC;AAED,8DAEC;AAED,4DAEC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAHW,MAAM,GACL,MAAM,CAKjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qDAJW,MAAM,2DAgBhB;AAtJD,kGAMC;AAED,8DAWC;AAqID,oDAMC;AAED,gEAEC"}

package/dist/utils/timer.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from '../content-store-types';
+export declare class Timer {
+    private readonly timerCallback;
+    private readonly timerMs;
+    private readonly logger?;
+    private timeout;
+    constructor({ timerCallback, timerMs, logger }: {
+        timerCallback: () => void;
+        timerMs?: number;
+        logger?: Logger;
+    });
+    isRunning(): boolean;
+    startTimer(): void;
+    resetTimer(): void;
+    stopTimer(): void;
+    handleTimeout(): void;
+}
+//# sourceMappingURL=timer.d.ts.map

package/dist/utils/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/utils/timer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD,qBAAa,KAAK;IACd,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAa;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,OAAO,CAAwB;gBAE3B,EAAE,aAAa,EAAE,OAAwB,EAAE,MAAM,EAAE,EAAE;QAAE,aAAa,EAAE,MAAM,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAQjI,SAAS;IAIT,UAAU;IAIV,UAAU;IAKV,SAAS;IAOT,aAAa;CAKhB"}

package/dist/utils/timer.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+class Timer {
+    constructor({ timerCallback, timerMs = 30 * 60 * 1000, logger }) {
+        this.timerCallback = timerCallback;
+        this.timerMs = timerMs;
+        this.logger = logger === null || logger === void 0 ? void 0 : logger.createLogger({ label: 'timer' });
+        this.timeout = null;
+        this.handleTimeout = this.handleTimeout.bind(this);
+    }
+    isRunning() {
+        return !!this.timeout;
+    }
+    startTimer() {
+        this.resetTimer();
+    }
+    resetTimer() {
+        this.stopTimer();
+        this.timeout = setTimeout(this.handleTimeout, this.timerMs);
+    }
+    stopTimer() {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+            this.timeout = null;
+        }
+    }
+    handleTimeout() {
+        var _a;
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug('timer reached');
+        this.timeout = null;
+        this.timerCallback();
+    }
+}
+exports.Timer = Timer;
+//# sourceMappingURL=timer.js.map

package/dist/utils/timer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.js","sourceRoot":"","sources":["../../src/utils/timer.ts"],"names":[],"mappings":";;;AAEA,MAAa,KAAK;IAMd,YAAY,EAAE,aAAa,EAAE,OAAO,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,MAAM,EAAoE;QAC7H,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,YAAY,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,CAAC;IAED,SAAS;QACL,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;IAC1B,CAAC;IAED,UAAU;QACN,IAAI,CAAC,UAAU,EAAE,CAAC;IACtB,CAAC;IAED,UAAU;QACN,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAChE,CAAC;IAED,SAAS;QACL,IAAI,IAAI,CAAC,OAAO,EAAE;YACd,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;SACvB;IACL,CAAC;IAED,aAAa;;QACT,MAAA,IAAI,CAAC,MAAM,0CAAE,KAAK,CAAC,eAAe,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,aAAa,EAAE,CAAC;IACzB,CAAC;CACJ;AAvCD,sBAuCC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbit/cms-core",
-  "version": "0.0.15",
+  "version": "0.0.18-alpha.0",
   "description": "stackbit-dev",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,6 +18,7 @@
   "author": "Stackbit Inc.",
   "license": "MIT",
   "devDependencies": {
+    "@types/lodash": "^4.14.182",
     "jest": "^27.4.7",
     "prettier": "^2.5.1",
     "ts-jest": "^27.1.3",
@@ -27,7 +28,8 @@
     "@babel/parser": "^7.11.5",
     "@babel/traverse": "^7.11.5",
     "@iarna/toml": "^2.2.3",
-    "@stackbit/sdk": "^0.2.33",
+    "@stackbit/sdk": "^0.2.36-alpha.0",
+    "@stackbit/utils": "^0.2.4-alpha.0",
     "chalk": "^4.0.1",
     "esm": "^3.2.25",
     "fs-extra": "^8.1.0",
@@ -37,7 +39,9 @@
     "lodash": "^4.17.20",
     "micromatch": "^4.0.2",
     "moment": "^2.29.1",
-    "parse5": "^6.0.1"
+    "parse5": "^6.0.1",
+    "sanitize-filename": "^1.6.3",
+    "slugify": "^1.6.5"
   },
-  "gitHead": "ab310b516daf58c88b67f1fb8fbc6ec815a7f44d"
+  "gitHead": "4f0d10545fffc1b66b9774786949362ecfd06fbe"
 }

package/src/common/common-schema.ts

@@ -0,0 +1,12 @@
+import type { ImageModel } from '@stackbit/sdk';
+
+export const IMAGE_MODEL: ImageModel = {
+    type: 'image',
+    name: '__image_model',
+    label: 'Image',
+    labelField: 'title',
+    fields: [
+        { name: 'title', type: 'string' },
+        { name: 'url', type: 'string' }
+    ]
+};

package/src/content-source-interface.ts

@@ -0,0 +1,417 @@
+import type { Model, Field } from '@stackbit/sdk';
+
+export type DocumentStatus = 'added' | 'modified' | 'published' | 'deleted';
+
+export interface LeveledLogMethod {
+    (message: string): void;
+    (message: string, ...meta: any[]): void;
+    (message: any): void;
+}
+
+export interface Logger {
+    error: LeveledLogMethod;
+    warn: LeveledLogMethod;
+    info: LeveledLogMethod;
+    debug: LeveledLogMethod;
+    createLogger: ({ label }: { label: string }) => Logger;
+}
+
+export interface Locale {
+    code: string;
+    default?: boolean;
+}
+
+export interface Document {
+    type: 'document';
+    id: string;
+    manageUrl: string;
+    modelName: string;
+    status: DocumentStatus;
+    createdAt: string;
+    createdBy?: string;
+    updatedAt: string;
+    updatedBy?: string[];
+    fields: Record<string, DocumentField>;
+}
+
+export interface Asset {
+    type: 'asset';
+    id: string;
+    manageUrl: string;
+    status: DocumentStatus;
+    createdAt: string;
+    createdBy?: string;
+    updatedAt: string;
+    updatedBy?: string[];
+    fields: AssetFields;
+}
+
+export type AssetFields = {
+    title: DocumentValueFieldForType<'string'>;
+    file: AssetFileField;
+};
+
+export type DocumentField = DocumentValueField | DocumentObjectField | DocumentModelField | DocumentReferenceField | DocumentListField | DocumentRichTextField;
+
+export type DocumentFieldLocalized =
+    | DocumentValueFieldLocalized
+    | DocumentObjectFieldLocalized
+    | DocumentModelFieldLocalized
+    | DocumentReferenceFieldLocalized
+    | DocumentListFieldLocalized
+    | DocumentRichTextFieldLocalized;
+
+export type DocumentFieldNonLocalized =
+    | DocumentValueFieldNonLocalized
+    | DocumentObjectFieldNonLocalized
+    | DocumentModelFieldNonLocalized
+    | DocumentReferenceFieldNonLocalized
+    | DocumentListFieldNonLocalized
+    | DocumentRichTextFieldNonLocalized;
+
+export type DocumentFieldBaseProps =
+    | DocumentValueFieldBaseProps
+    | DocumentObjectFieldBase
+    | DocumentModelFieldBase
+    | DocumentReferenceFieldBase
+    | DocumentListFieldBase
+    | DocumentRichTextFieldBase;
+
+export type DocumentFieldSpecificProps =
+    | DocumentValueFieldProps
+    | DocumentObjectFieldProps
+    | DocumentModelFieldProps
+    | DocumentReferenceFieldProps
+    | DocumentListFieldProps
+    | DocumentRichTextFieldProps;
+
+export function isLocalizedField(field: DocumentField | AssetFileField): field is DocumentFieldLocalized | AssetFileFieldLocalized {
+    return 'localized' in field;
+}
+
+export function getLocalizedFieldForLocale<Type extends FieldType>(
+    field: DocumentFieldForType<Type>,
+    locale?: string
+): DocumentFieldNonLocalizedForType<Type> | null {
+    if (field.localized) {
+        if (!locale) {
+            return null;
+        }
+        const { localized, locales, ...base } = field;
+        const localizedField = locales[locale];
+        if (!localizedField) {
+            return null;
+        }
+        return ({
+            ...base,
+            ...localizedField
+        } as unknown) as DocumentFieldNonLocalizedForType<Type>;
+    } else {
+        return field;
+    }
+}
+
+export type FieldType =
+    | 'string'
+    | 'url'
+    | 'slug'
+    | 'text'
+    | 'markdown'
+    | 'html'
+    | 'number'
+    | 'boolean'
+    | 'enum'
+    | 'date'
+    | 'datetime'
+    | 'color'
+    | 'image'
+    | 'file'
+    | 'json'
+    | 'richText'
+    | 'object'
+    | 'model'
+    | 'reference'
+    | 'style'
+    | 'list';
+
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+
+export type FindByType<Union extends { type: FieldType }, Type> = Union extends { type: Type } ? Union : never;
+export type DocumentFieldForType<Type extends FieldType> = FindByType<DocumentField, Type>;
+export type DocumentFieldLocalizedForType<Type extends FieldType> = FindByType<DocumentFieldLocalized, Type>;
+export type DocumentFieldNonLocalizedForType<Type extends FieldType> = FindByType<DocumentFieldNonLocalized, Type>;
+export type DocumentFieldBasePropsForType<Type extends FieldType> = FindByType<DocumentFieldBaseProps, Type>;
+export type DocumentFieldSpecificPropsForType<Type extends FieldType> = Simplify<
+    Omit<DocumentFieldNonLocalizedForType<Type>, keyof DocumentFieldBasePropsForType<Type> | 'locale' | 'localized'>
+>;
+
+export type DocumentFieldTypeLocalized<BaseFieldProps, LocalizedFieldProps> = Simplify<
+    BaseFieldProps & {
+        localized: true;
+        locales: Record<string, { locale: string } & LocalizedFieldProps>;
+    }
+>;
+
+export type DocumentFieldTypeNonLocalized<BaseFieldProps, LocalizedFieldProps> = Simplify<
+    BaseFieldProps &
+        LocalizedFieldProps & {
+            localized?: false;
+            locale?: string;
+        }
+>;
+
+// any field that is not 'object' | 'model' | 'reference' | 'richText' | 'list'
+export type DocumentValueFieldType = Exclude<FieldType, 'object' | 'model' | 'reference' | 'richText' | 'list'>;
+
+export type DocumentValueFieldForType<Type> = Type extends DocumentValueFieldType
+    ? DocumentValueFieldLocalizedForType<Type> | DocumentValueFieldNonLocalizedForType<Type>
+    : never;
+export type DocumentValueField = DocumentValueFieldForType<DocumentValueFieldType>;
+
+export type DocumentValueFieldLocalizedForType<Type> = Type extends DocumentValueFieldType
+    ? DocumentFieldTypeLocalized<DocumentValueFieldBase<Type>, DocumentValueFieldProps>
+    : never;
+export type DocumentValueFieldLocalized = DocumentValueFieldLocalizedForType<DocumentValueFieldType>;
+
+export type DocumentValueFieldNonLocalizedForType<Type> = Type extends DocumentValueFieldType
+    ? DocumentFieldTypeNonLocalized<DocumentValueFieldBase<Type>, DocumentValueFieldProps>
+    : never;
+export type DocumentValueFieldNonLocalized = DocumentValueFieldNonLocalizedForType<DocumentValueFieldType>;
+
+export type DocumentValueFieldBasePropsForType<Type> = Type extends DocumentValueFieldType ? DocumentValueFieldBase<Type> : never;
+export type DocumentValueFieldBaseProps = DocumentValueFieldBasePropsForType<DocumentValueFieldType>;
+export type DocumentValueFieldBase<Type extends DocumentValueFieldType> = {
+    type: Type;
+};
+export type DocumentValueFieldProps = {
+    value: any;
+};
+
+// object
+export type DocumentObjectField = DocumentObjectFieldLocalized | DocumentObjectFieldNonLocalized;
+export type DocumentObjectFieldLocalized = DocumentFieldTypeLocalized<DocumentObjectFieldBase, DocumentObjectFieldProps>;
+export type DocumentObjectFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentObjectFieldBase, DocumentObjectFieldProps>;
+export type DocumentObjectFieldBase = {
+    type: 'object';
+};
+export type DocumentObjectFieldProps = {
+    fields: Record<string, DocumentField>;
+};
+
+// model
+export type DocumentModelField = DocumentModelFieldLocalized | DocumentModelFieldNonLocalized;
+export type DocumentModelFieldLocalized = DocumentFieldTypeLocalized<DocumentModelFieldBase, DocumentModelFieldProps>;
+export type DocumentModelFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentModelFieldBase, DocumentModelFieldProps>;
+export type DocumentModelFieldBase = {
+    type: 'model';
+};
+export type DocumentModelFieldProps = {
+    modelName: string;
+    fields: Record<string, DocumentField>;
+};
+
+// reference
+export type DocumentReferenceField = DocumentReferenceFieldLocalized | DocumentReferenceFieldNonLocalized;
+export type DocumentReferenceFieldLocalized = DocumentFieldTypeLocalized<DocumentReferenceFieldBase, DocumentReferenceFieldProps>;
+export type DocumentReferenceFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentReferenceFieldBase, DocumentReferenceFieldProps>;
+export type DocumentReferenceFieldBase = {
+    type: 'reference';
+    refType: 'document' | 'asset';
+};
+export type DocumentReferenceFieldProps = {
+    refId: string;
+};
+
+// richText
+export type DocumentRichTextField = DocumentRichTextFieldLocalized | DocumentRichTextFieldNonLocalized;
+export type DocumentRichTextFieldLocalized = DocumentFieldTypeLocalized<DocumentRichTextFieldBase, DocumentRichTextFieldProps>;
+export type DocumentRichTextFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentRichTextFieldBase, DocumentRichTextFieldProps>;
+export type DocumentRichTextFieldBase = {
+    type: 'richText';
+};
+export type DocumentRichTextFieldProps = {
+    hint?: string;
+    value: any;
+};
+
+// list
+export type DocumentListField = DocumentListFieldLocalized | DocumentListFieldNonLocalized;
+export type DocumentListFieldLocalized = DocumentFieldTypeLocalized<DocumentListFieldBase, DocumentListFieldProps>;
+export type DocumentListFieldNonLocalized = DocumentFieldTypeNonLocalized<DocumentListFieldBase, DocumentListFieldProps>;
+export type DocumentListFieldBase = {
+    type: 'list';
+};
+export type DocumentListFieldProps = {
+    items: DocumentFieldNonLocalized[];
+};
+
+// assetFile
+export type AssetFileField = AssetFileFieldLocalized | AssetFileFieldNonLocalized;
+export type AssetFileFieldLocalized = DocumentFieldTypeLocalized<AssetFileFieldBase, AssetFileFieldProps>;
+export type AssetFileFieldNonLocalized = DocumentFieldTypeNonLocalized<AssetFileFieldBase, AssetFileFieldProps>;
+export type AssetFileFieldBase = {
+    type: 'assetFile';
+};
+export type AssetFileFieldProps = {
+    url: string;
+    fileName?: string;
+    contentType?: string;
+    size?: number;
+    dimensions: {
+        width?: number;
+        height?: number;
+    };
+};
+
+export interface InitOptions {
+    logger: Logger;
+    userLogger: Logger;
+    localDev: boolean;
+}
+
+export interface ContentChangeEvent {
+    documents: Document[];
+    assets: Asset[];
+    deletedDocumentIds: string[];
+    deletedAssetIds: string[];
+}
+
+export type UpdateOperation = UpdateOperationSet | UpdateOperationUnset | UpdateOperationInsert | UpdateOperationRemove | UpdateOperationReorder;
+
+export type UpdateOperationBase = {
+    opType: string;
+    fieldPath: (string | number)[];
+    modelField: Field;
+    locale?: string;
+};
+
+export type UpdateOperationSet = Simplify<
+    UpdateOperationBase & {
+        opType: 'set';
+        field: UpdateOperationField;
+    }
+>;
+
+export type UpdateOperationUnset = Simplify<
+    UpdateOperationBase & {
+        opType: 'unset';
+    }
+>;
+
+export type UpdateOperationInsert = Simplify<
+    UpdateOperationBase & {
+        opType: 'insert';
+        index?: number;
+        item: UpdateOperationField;
+    }
+>;
+
+export type UpdateOperationRemove = Simplify<
+    UpdateOperationBase & {
+        opType: 'remove';
+        index: number;
+    }
+>;
+
+export type UpdateOperationReorder = Simplify<
+    UpdateOperationBase & {
+        opType: 'reorder';
+        order: number[];
+    }
+>;
+
+export type UpdateOperationField =
+    | DocumentValueFieldNonLocalized
+    | DocumentObjectFieldNonLocalized
+    | DocumentModelFieldNonLocalized
+    | DocumentReferenceFieldNonLocalized
+    | DocumentRichTextFieldNonLocalized;
+
+export type ValidationError = {
+    message: string;
+    objectType: 'document' | 'asset';
+    objectId: string;
+    fieldPath: (string | number)[];
+    isUniqueValidation?: boolean;
+};
+
+export type ModelMap = Record<string, Model>;
+
+export interface ContentSourceInterface<UserContext = unknown> {
+    /**
+     * This function should return the type of the content source.
+     * The type must be unique among other content sources within the same project.
+     */
+    getContentSourceType(): string;
+
+    /**
+     * This function should return the project ID of the content source.
+     * The ID must be unique among other content sources of the same type.
+     */
+    getProjectId(): string;
+
+    getProjectEnvironment(): string;
+
+    getProjectManageUrl(): string;
+
+    /**
+     * This function should initialize the content source by fetching the schema
+     * and everything else needed to produce the StackbitSchema
+     */
+    init(options: InitOptions): Promise<void>;
+
+    reset(): Promise<void>;
+
+    onFilesChange?({ updatedFiles }: { updatedFiles: string[] }): { schemaChanged?: boolean; contentChangeEvent?: ContentChangeEvent };
+
+    startWatchingContentUpdates(options: {
+        getModelMap: () => ModelMap;
+        onContentChange: (contentChangeEvent: ContentChangeEvent) => void;
+        onSchemaChange: () => void;
+    }): void;
+
+    stopWatchingContentUpdates(): void;
+
+    /**
+     * This function is responsible to fetch and convert content models
+     * to Stackbit models.
+     */
+    getModels(): Promise<Model[]>;
+
+    getLocales(): Promise<Locale[]>;
+
+    /**
+     * This function should fetch the documents and convert them into Stackbit's
+     * Document type
+     */
+    getDocuments(options: { modelMap: ModelMap }): Promise<Document[]>;
+
+    getAssets(): Promise<Asset[]>;
+
+    hasAccess(options: { userContext?: UserContext }): Promise<boolean>;
+
+    createDocument(options: {
+        documentFields: Record<string, DocumentField>;
+        model: Model;
+        modelMap: ModelMap;
+        locale?: string;
+        userContext?: UserContext;
+    }): Promise<Document>;
+
+    updateDocument(options: { documentId: string; operations: UpdateOperation[]; modelMap: ModelMap; userContext?: UserContext }): Promise<Document>;
+
+    deleteDocument(options: { documentId: string; userContext?: UserContext }): Promise<void>;
+
+    uploadAsset(options: { url?: string; base64?: string; fileName: string; mimeType: string; locale?: string; userContext?: UserContext }): Promise<Asset>;
+
+    validateDocuments(options: {
+        documentIds: string[];
+        assetIds: string[];
+        locale?: string;
+        userContext?: UserContext;
+    }): Promise<{ errors: ValidationError[] }>;
+
+    publishDocuments(options: { documentIds: string[]; assetIds: string[]; userContext?: UserContext }): Promise<void>;
+}