@nascentdigital/funnel-editor 4.6.7 → 5.0.1

package/dist/core/repository/ICollectionRepository.d.ts

@@ -0,0 +1,62 @@
+import { CollectionClient } from '@nascentdigital/funnel-cms';
+import { EventBus, FieldModel, Schema } from '@nascentdigital/funnel-core';
+import { CollectionFieldProxy, ICollection } from '../domain';
+export interface ICollectionRepository {
+    create(args: ICollectionRepository.Create.Args): Promise<ICollectionRepository.Create.Result>;
+    createRaw(args: ICollectionRepository.CreateRaw.Args): Promise<ICollectionRepository.CreateRaw.Result>;
+    createLanguage(args: ICollectionRepository.CreateLang.Args): Promise<ICollectionRepository.CreateLang.Result>;
+    save(collection: ICollection): Promise<ICollection>;
+    unpublish(collection: ICollection): Promise<void>;
+    getOverview(args: ICollectionRepository.GetOverview.Args): Promise<ICollectionRepository.GetOverview.Result>;
+    getItems(args: ICollectionRepository.GetItems.Args): Promise<ICollectionRepository.GetItems.Result>;
+    get(args: ICollectionRepository.Get.Args): Promise<ICollectionRepository.Get.Result>;
+    update(args: ICollectionRepository.Update.Args): Promise<ICollectionRepository.Update.Result>;
+    serializeUpdate(collection: ICollection | CollectionFieldProxy, savables: ICollectionRepository.Savable[]): ICollectionRepository.SerializeUpdates.Result;
+}
+export declare namespace ICollectionRepository {
+    type Savable = FieldModel;
+    namespace Create {
+        type Args = Omit<CollectionClient.Create.NewArgs, 'brand' | 'type' | 'version'> & {
+            template: Schema.Collection;
+            eventBus?: EventBus;
+        };
+        type Result = ICollection.WithGroup;
+    }
+    namespace CreateRaw {
+        type Args = Omit<CollectionClient.Create.NewArgs, 'brand' | 'type' | 'version'> & {
+            template: Schema.Collection;
+        };
+        type Result = Schema.Collection.Data.AsGroup;
+    }
+    namespace CreateLang {
+        type Args = Omit<CollectionClient.Create.NewLanguageArgs, 'brand'> & {
+            template: Schema.Collection;
+            eventBus: EventBus;
+        };
+        type Result = ICollection.WithGroup;
+    }
+    namespace GetOverview {
+        type Args = Omit<CollectionClient.GetOverview.Args, 'brand'>;
+        type Item = {
+            template: Schema.Collection;
+            type: Schema.Collection.Type;
+            count: number;
+        };
+        type Result = Item[];
+    }
+    namespace GetItems {
+        type Args = Omit<CollectionClient.GetItems.Args, 'brand'>;
+        type Result = CollectionClient.GetItems.Result;
+    }
+    namespace Get {
+        type Args = Omit<CollectionClient.Get.Args, 'brand'>;
+        type Result = CollectionClient.Get.Result;
+    }
+    namespace Update {
+        type Args = CollectionClient.Update.Args;
+        type Result = CollectionClient.Update.Result;
+    }
+    namespace SerializeUpdates {
+        type Result = CollectionClient.Update.Args;
+    }
+}

package/dist/core/repository/ICollectionRepository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/repository/IPageRepository.d.ts

@@ -0,0 +1,40 @@
+import { PageClient, Pagination } from '@nascentdigital/funnel-cms';
+import { EventBus, PartialBy, Schema } from '@nascentdigital/funnel-core';
+import { IPage, PageOverview } from '../domain';
+export interface IPageRepository {
+    search(args: IPageRepository.Search.Args): Promise<IPageRepository.Search.Result>;
+    create(args: IPageRepository.Create.Args): Promise<IPageRepository.Create.Result>;
+    createLanguage(args: IPageRepository.CreateLang.Args): Promise<IPageRepository.CreateLang.Result>;
+    save(page: IPage): Promise<IPage>;
+    unpublish(page: IPage): Promise<void>;
+    getOverview(args: IPageRepository.GetOverview.Args): Promise<IPageRepository.GetOverview.Result>;
+}
+export declare namespace IPageRepository {
+    namespace Search {
+        type Args = Omit<PageClient.Search.Args, 'version' | 'brand' | 'type' | 'region'> & {
+            template: Schema.Page;
+            region: string;
+        };
+        type Result = Pagination.Paginated<IPage.Ref>;
+    }
+    namespace Create {
+        type Args = PartialBy<Omit<PageClient.Create.NewArgs, 'brand' | 'type' | 'route'>, 'name'> & {
+            template: Schema.Page;
+            eventBus?: EventBus;
+        };
+        type Result = IPage.WithSummary;
+    }
+    namespace CreateLang {
+        type Args = Omit<PageClient.Create.NewLanguageArgs, 'brand' | 'route'> & {
+            template: Schema.Page;
+            eventBus: EventBus;
+        };
+        type Result = IPage.WithSummary;
+    }
+    namespace GetOverview {
+        type Args = {
+            region: string;
+        };
+        type Result = PageOverview[];
+    }
+}

package/dist/core/repository/IPageRepository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/repository/PageRepository.d.ts

@@ -1,9 +1,10 @@
 import { PageClient, Pagination } from '@nascentdigital/funnel-cms';
 import { EventBus, PartialBy } from '@nascentdigital/funnel-core';
 import { EditorApiClient } from '../client';
-import { Page, IPage } from '../domain';
+import { IPage, Page } from '../domain';
+import { IPageRepository } from './IPageRepository';
 import { PageTarget } from './PageTarget';
-export declare class PageRepository {
+export declare class PageRepository implements IPageRepository {
     readonly editorApi: EditorApiClient;
     constructor(editorApi: EditorApiClient);
     search(args: PageRepository.SearchArgs): Promise<Pagination.Paginated<IPage.Ref>>;
@@ -12,13 +13,8 @@ export declare class PageRepository {
     createLanguage(args: PageRepository.CreateLanguageArgs): Promise<Page.WithSummary>;
     save(page: Page): Promise<Page>;
     unpublish(page: Page): Promise<void>;
+    getOverview(args: IPageRepository.GetOverview.Args): Promise<IPageRepository.GetOverview.Result>;
     private serializePageUpdate;
-    private serializeSectionUpdate;
-    private serializeBlockUpdate;
-    private serializeFieldsUpdate;
-    private serializeObjectFieldUpdate;
-    private serializeFieldUpdate;
-    private serializeListUpdate;
 }
 export declare namespace PageRepository {
     type SearchArgs = Omit<PageClient.Search.Args, 'version' | 'brand' | 'type' | 'region'> & Pick<Page.ConstructorArgs, 'template' | 'region'>;
@@ -29,4 +25,5 @@ export declare namespace PageRepository {
     type CreateLanguageArgs = Omit<PageClient.Create.NewLanguageArgs, 'brand' | 'route'> & Pick<Page.ConstructorArgs, 'template'> & {
         eventBus: EventBus;
     };
+    type GetOverviewArgs = Omit<PageClient.GetOverview.Args, 'brand'>;
 }

package/dist/core/repository/PageRepository.js

@@ -15,6 +15,7 @@ exports.PageRepository = void 0;
 const funnel_core_1 = require("@nascentdigital/funnel-core");
 const domain_1 = require("../domain");
 const PageSerializer_1 = require("./PageSerializer");
+const SerializePageUpdate_1 = require("./SerializePageUpdate");
 // class
 class PageRepository {
     constructor(editorApi) {
@@ -91,6 +92,9 @@ class PageRepository {
         // unpublish page
         await this.editorApi.unpublishPage(page.id);
     }
+    async getOverview(args) {
+        return this.editorApi.getPagesOverview(Object.assign(Object.assign({}, args), { version: 'draft' }));
+    }
     serializePageUpdate(page, savables) {
         var _a, _b;
         // root page updates
@@ -158,18 +162,18 @@ class PageRepository {
                 ...rootPageUpdates,
                 ...discover.reduce((updates, block) => {
                     // try to update block
-                    this.serializeBlockUpdate(updates, block, 'discover', savables);
+                    SerializePageUpdate_1.SerializePageUpdate.serializeBlockUpdate(updates, block, 'discover', savables);
                     // keep reducing
                     return updates;
                 }, []),
                 ...content.reduce((updates, item) => {
                     // handle block
                     if (item instanceof domain_1.Block) {
-                        this.serializeBlockUpdate(updates, item, 'content', savables);
+                        SerializePageUpdate_1.SerializePageUpdate.serializeBlockUpdate(updates, item, 'content', savables);
                     }
                     // or section
                     else {
-                        this.serializeSectionUpdate(updates, item, 'content', savables);
+                        SerializePageUpdate_1.SerializePageUpdate.serializeSectionUpdate(updates, item, 'content', savables);
                     }
                     // keep reducing
                     return updates;
@@ -181,282 +185,5 @@ class PageRepository {
             ]
         };
     }
-    serializeSectionUpdate(updates, section, parentPath, savables) {
-        // track insert/update
-        let sectionChanged = false;
-        const path = [parentPath, section.key];
-        const { blocks, initialBlocks = [] } = section;
-        const blockIds = [];
-        blocks.forEach((sectionBlock, index) => {
-            // track id
-            const { id, block } = sectionBlock;
-            blockIds.push(id);
-            // track insert
-            const originalIndex = initialBlocks.findIndex(item => item.id === id);
-            if (originalIndex < 0) {
-                // add as insertion
-                updates.push({
-                    type: 'section.insert',
-                    path,
-                    index,
-                    section: {
-                        type: 'section',
-                        version: section.schema.version
-                    },
-                    block: sectionBlock.value
-                });
-                // mark changed
-                sectionChanged = true;
-                // track nested savables for section-block insertion
-                const fields = [...block.config, ...block.fields];
-                fields.forEach(field => {
-                    if (field.modified) {
-                        savables.push(field);
-                    }
-                });
-            }
-            // recurse update if it's set
-            else if (block.modified) {
-                // track name field
-                if (block.nameField.modified) {
-                    // send update
-                    updates.push({
-                        type: 'section.blockName',
-                        path,
-                        id,
-                        value: funnel_core_1.Schema.TextField.Value.fromData(block.nameField.value) || null
-                    });
-                    // track change
-                    savables.push(block.nameField);
-                }
-                // serialize config fields
-                this.serializeFieldsUpdate(updates, block.config, [...path, id, 'config'], savables);
-                // serialize content fields
-                this.serializeFieldsUpdate(updates, block.fields, [...path, id, 'fields'], savables);
-            }
-        });
-        // track delete/reorder
-        let reordered = false;
-        initialBlocks.forEach(({ id }, index) => {
-            // add to deleted list if the original doesn't exist anymore
-            const blockIndex = blockIds.findIndex(blockId => blockId === id);
-            if (blockIndex < 0) {
-                // delete
-                updates.push({
-                    type: 'section.delete',
-                    path,
-                    id
-                });
-                // track reorder
-                sectionChanged = true;
-            }
-            // or mark reorder if index isn't the same
-            else if (blockIndex !== index) {
-                reordered = true;
-                sectionChanged = true;
-            }
-        });
-        // track reorder
-        if (reordered) {
-            updates.push({
-                type: 'section.reorder',
-                path,
-                ids: blockIds
-            });
-        }
-        // track section change (if any)
-        if (sectionChanged) {
-            savables.push(section);
-        }
-    }
-    serializeBlockUpdate(updates, block, parentPath, savables) {
-        // ignore if block isn't activated
-        if (!block.activated) {
-            return;
-        }
-        // create a new block if it's new
-        else if (block.isNew) {
-            // create update
-            updates.push({
-                type: 'block.create',
-                path: [parentPath, block.key],
-                block: block.value
-            });
-            // track block
-            savables.push(block);
-            // track nested savables for block insertion
-            const fields = [...block.config, ...block.fields];
-            fields.forEach(field => {
-                if (field.modified) {
-                    savables.push(field);
-                }
-            });
-        }
-        // or just track updated fields
-        else {
-            // serialize config fields
-            this.serializeFieldsUpdate(updates, block.config, [parentPath, block.key, 'config'], savables);
-            // serialize content fields
-            this.serializeFieldsUpdate(updates, block.fields, [parentPath, block.key, 'fields'], savables);
-        }
-    }
-    serializeFieldsUpdate(updates, fields, parentPath, savables) {
-        // handle fields in block
-        fields.forEach(field => {
-            if (field instanceof funnel_core_1.Field) {
-                this.serializeFieldUpdate(updates, field, parentPath, savables);
-            }
-            else if (field instanceof funnel_core_1.ObjectField) {
-                this.serializeObjectFieldUpdate(updates, field, parentPath, savables);
-            }
-            else {
-                this.serializeListUpdate(updates, field, parentPath, savables);
-            }
-        });
-        // return changes (for chaining)
-        return updates;
-    }
-    serializeObjectFieldUpdate(updates, field, parentPath, savables) {
-        var _a;
-        // create object if it's new
-        if (field.isNew) {
-            // add insert
-            updates.push({
-                type: 'object.insert',
-                path: [...parentPath, field.id],
-                value: (_a = field.value) !== null && _a !== void 0 ? _a : null
-            });
-            // track save
-            savables.push(field);
-        }
-        // or process subfields
-        else if (field.exists) {
-            // save fields
-            this.serializeFieldsUpdate(updates, field.fields, [...parentPath, field.id], savables);
-            // track save
-            savables.push(field);
-        }
-        // or process opted out field
-        else if (field.optedOut) {
-            // remove field
-            updates.push({
-                type: 'value',
-                path: [...parentPath, field.id],
-                value: null
-            });
-            // track save
-            savables.push(field);
-        }
-    }
-    serializeFieldUpdate(updates, field, parentPath, savables) {
-        var _a;
-        // track change if modified (ignore if field is sandboxed)
-        if (field.modified && !field.sandboxed) {
-            // set field
-            updates.push({
-                type: 'value',
-                path: [...parentPath, field.id],
-                value: ((_a = field.value) !== null && _a !== void 0 ? _a : null)
-            });
-            // track save
-            savables.push(field);
-        }
-    }
-    serializeListUpdate(updates, list, parentPath, savables) {
-        var _a, _b;
-        // create list if it's new
-        if (list.isNew) {
-            // add new list
-            updates.push({
-                type: 'value',
-                path: [...parentPath, list.id],
-                value: funnel_core_1.Schema.Field.Data.newValue('list')
-            });
-            // track save
-            savables.push(list);
-        }
-        // or drop list on opt-out
-        else if (list.optedOut) {
-            // drop list
-            updates.push({
-                type: 'value',
-                path: [...parentPath, list.id],
-                value: null
-            });
-            // track save
-            savables.push(list);
-        }
-        // or if it is modified (otherwise ignore)
-        else if (list.modified) {
-            // add new list if there's nothing and it's new
-            const path = [...parentPath, list.id];
-            const { value: currentValue, items: fields, initialValue } = list;
-            const currentItems = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.value) !== null && _a !== void 0 ? _a : [];
-            const initialItems = (_b = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _b !== void 0 ? _b : [];
-            const fieldIds = [];
-            // track inserts/updates of elements
-            currentItems.forEach((item, index) => {
-                // track id
-                const { id, field } = fields[index];
-                fieldIds.push(item.id);
-                // track insert
-                const originalIndex = initialItems.findIndex(initialItem => initialItem.id === id);
-                if (originalIndex < 0) {
-                    updates.push({
-                        type: 'array.insert',
-                        path,
-                        index,
-                        id,
-                        value: item
-                    });
-                }
-                // track update
-                else if (field.modified) {
-                    // object field updates should be recursed and indexed
-                    if (field instanceof funnel_core_1.ObjectField) {
-                        this.serializeFieldsUpdate(updates, field.fields, [...path, id], savables);
-                    }
-                    // basic field updates can be done inline
-                    else {
-                        updates.push({
-                            type: 'value',
-                            path: [...path, id],
-                            value: item
-                        });
-                    }
-                }
-            });
-            // track delete/reorder
-            let reordered = false;
-            let deleted = 0;
-            initialItems.forEach(({ id }, index) => {
-                // add to deleted list if the original doesn't exist anymore
-                const fieldIndex = fieldIds.findIndex(fieldId => fieldId === id) + deleted;
-                if (fieldIndex < 0) {
-                    updates.push({
-                        type: 'array.delete',
-                        path,
-                        id
-                    });
-                    // track deletion
-                    ++deleted;
-                }
-                // or mark reorder if index isn't the same
-                else if (fieldIndex !== index) {
-                    reordered = true;
-                }
-            });
-            // track reorder
-            if (reordered) {
-                updates.push({
-                    type: 'array.reorder',
-                    path,
-                    ids: fieldIds
-                });
-            }
-            // track save
-            savables.push(list);
-        }
-    }
 }
 exports.PageRepository = PageRepository;

package/dist/core/repository/SerializeCollectionUpdate.d.ts

@@ -0,0 +1,8 @@
+import { Field, FieldList, FieldModel, ObjectField, Schema } from '@nascentdigital/funnel-core';
+import { ICollectionRepository } from './ICollectionRepository';
+export declare namespace SerializeCollectionUpdate {
+    function serializeFieldsUpdate(updates: Schema.Collection.Update[], fields: ReadonlyArray<FieldModel>, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): Schema.Collection.Update[];
+    function serializeObjectFieldUpdate(updates: Schema.Collection.Update[], field: ObjectField, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): void;
+    function serializeFieldUpdate(updates: Schema.Collection.Update[], field: Field, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): void;
+    function serializeListUpdate(updates: Schema.Collection.Update[], list: FieldList, parentPath: ReadonlyArray<string>, savables: ICollectionRepository.Savable[]): void;
+}

package/dist/core/repository/SerializeCollectionUpdate.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeCollectionUpdate = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// namespace
+var SerializeCollectionUpdate;
+(function (SerializeCollectionUpdate) {
+    // helper
+    function serializeFieldsUpdate(updates, fields, parentPath, savables) {
+        // handle fields in block
+        fields.forEach(field => {
+            if (field instanceof funnel_core_1.Field) {
+                serializeFieldUpdate(updates, field, parentPath, savables);
+            }
+            else if (field instanceof funnel_core_1.ObjectField) {
+                serializeObjectFieldUpdate(updates, field, parentPath, savables);
+            }
+            else {
+                serializeListUpdate(updates, field, parentPath, savables);
+            }
+        });
+        // return changes (for chaining)
+        return updates;
+    }
+    SerializeCollectionUpdate.serializeFieldsUpdate = serializeFieldsUpdate;
+    function serializeObjectFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // create object if it's new
+        if (field.isNew) {
+            updates.push({
+                type: 'object.insert',
+                path: [...parentPath, field.id],
+                value: (_a = field.value) !== null && _a !== void 0 ? _a : null
+            });
+            // track save
+            savables.push(field);
+        }
+        // or process subfields
+        else if (field.exists) {
+            // save fields
+            serializeFieldsUpdate(updates, field.fields, [...parentPath, field.id], savables);
+            // track save
+            savables.push(field);
+        }
+        // or process opted out field
+        else if (field.optedOut) {
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: null
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    SerializeCollectionUpdate.serializeObjectFieldUpdate = serializeObjectFieldUpdate;
+    function serializeFieldUpdate(updates, field, parentPath, savables) {
+        var _a;
+        // track change if modified (ignore if field is sandboxed)
+        if (field.modified && !field.sandboxed) {
+            // set field
+            updates.push({
+                type: 'value',
+                path: [...parentPath, field.id],
+                value: ((_a = field.value) !== null && _a !== void 0 ? _a : null)
+            });
+            // track save
+            savables.push(field);
+        }
+    }
+    SerializeCollectionUpdate.serializeFieldUpdate = serializeFieldUpdate;
+    function serializeListUpdate(updates, list, parentPath, savables) {
+        var _a, _b;
+        // create list if it's new
+        if (list.isNew) {
+            // add new list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: funnel_core_1.Schema.Field.Data.newValue('list')
+            });
+            // track save
+            savables.push(list);
+        }
+        // or drop list on opt-out
+        else if (list.optedOut) {
+            // drop list
+            updates.push({
+                type: 'value',
+                path: [...parentPath, list.id],
+                value: null
+            });
+            // track save
+            savables.push(list);
+        }
+        // or skip if not modified
+        else if (list.modified) {
+            // track insert/update
+            const path = [...parentPath, list.id];
+            const { value: currentValue, items: fields, initialValue } = list;
+            const currentItems = (_a = currentValue === null || currentValue === void 0 ? void 0 : currentValue.value) !== null && _a !== void 0 ? _a : [];
+            const initialItems = (_b = initialValue === null || initialValue === void 0 ? void 0 : initialValue.value) !== null && _b !== void 0 ? _b : [];
+            const fieldIds = [];
+            currentItems.forEach((item, index) => {
+                // track id
+                const { id, field } = fields[index];
+                fieldIds.push(item.id);
+                // track insert
+                const originalIndex = initialItems.findIndex(initialItem => initialItem.id === id);
+                if (originalIndex < 0) {
+                    updates.push({
+                        type: 'array.insert',
+                        path,
+                        index,
+                        id,
+                        value: item
+                    });
+                }
+                // track update
+                else if (field.modified) {
+                    // object field updates should be recursed and indexed
+                    if (field instanceof funnel_core_1.ObjectField) {
+                        serializeFieldsUpdate(updates, field.fields, [...path, id], savables);
+                    }
+                    // basic field updates can be done inline
+                    else {
+                        updates.push({
+                            type: 'value',
+                            path: [...path, id],
+                            value: item
+                        });
+                    }
+                }
+            });
+            // track delete/reorder
+            let reordered = false;
+            let deleted = 0;
+            initialItems.forEach(({ id }, index) => {
+                // add to deleted list if the original doesn't exist anymore
+                const fieldIndex = fieldIds.findIndex(fieldId => fieldId === id) + deleted;
+                if (fieldIndex < 0) {
+                    updates.push({
+                        type: 'array.delete',
+                        path,
+                        id
+                    });
+                    // track deletion
+                    ++deleted;
+                }
+                // or mark reorder if index isn't the same
+                else if (fieldIndex !== index) {
+                    reordered = true;
+                }
+            });
+            // track reorder
+            if (reordered) {
+                updates.push({
+                    type: 'array.reorder',
+                    path,
+                    ids: fieldIds
+                });
+            }
+            // track save
+            savables.push(list);
+        }
+    }
+    SerializeCollectionUpdate.serializeListUpdate = serializeListUpdate;
+})(SerializeCollectionUpdate || (exports.SerializeCollectionUpdate = SerializeCollectionUpdate = {}));

package/dist/core/repository/SerializePageUpdate.d.ts

@@ -0,0 +1,11 @@
+import { Field, FieldList, FieldModel, ObjectField, Schema } from '@nascentdigital/funnel-core';
+import type { Block, Section } from '../domain';
+export declare namespace SerializePageUpdate {
+    type Savable = Section | Block | FieldModel;
+    function serializeSectionUpdate(updates: Schema.Page.Update[], section: Section, parentPath: string, savables: Savable[]): void;
+    function serializeBlockUpdate(updates: Schema.Page.Update[], block: Block, parentPath: string, savables: Savable[]): void;
+    function serializeFieldsUpdate(updates: Schema.Page.Update[], fields: ReadonlyArray<FieldModel>, parentPath: ReadonlyArray<string>, savables: Savable[]): Schema.Page.Update[];
+    function serializeObjectFieldUpdate(updates: Schema.Page.Update[], field: ObjectField, parentPath: ReadonlyArray<string>, savables: Savable[]): void;
+    function serializeFieldUpdate(updates: Schema.Page.Update[], field: Field, parentPath: ReadonlyArray<string>, savables: Savable[]): void;
+    function serializeListUpdate(updates: Schema.Page.Update[], list: FieldList, parentPath: ReadonlyArray<string>, savables: Savable[]): void;
+}