@galadrim/galadmin 0.2.9 → 0.2.11-alpha.1.1

package/tests/integration/routes.upload.integration.test.ts

@@ -3,6 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import * as request from "supertest";
 import { generateUniqueIdForObject } from "../../src/api";
+import { uploadFile } from "../../src/api/uploadFile";
 import { buildAppForManager } from "../helpers/app";
 import { baseConfig, fruitView } from "../helpers/fixtures";
 import {
@@ -119,7 +120,49 @@ describeIntegration("upload routes against real databases", () => {
           contentType: "image/png",
         });
 
+    it.each([
+      { s3Config: { host: "s3.example.com", accessKeyId: "k", secretAccessKey: "s", bucket: "b" } },
+      { gcpConfig: { host: "storage.googleapis.com", bucket: "b" } },
+      { publicPath: "/srv/public", sftpConfig: { host: "h", user: "u", password: "p" } },
+      { publicPath: os.tmpdir(), subdirectory: "" },
+    ])("rejects a missing file for storage config %j", async (storage) => {
+      const { app, colId } = appWithColumn(fileColumn(storage));
+      const res = await request(app)
+        .post("/api/uploadFile")
+        .query({ viewIndex: 0, columnId: colId })
+        .field("description", "no file")
+        .expect(400);
+      expect(res.text).toBe("Missing upload file");
+      expect(jest.requireMock("@aws-sdk/client-s3").S3Client).not.toHaveBeenCalled();
+      expect(jest.requireMock("@google-cloud/storage").Storage).not.toHaveBeenCalled();
+      expect(jest.requireMock("ssh2-sftp-client").__sftp.connect).not.toHaveBeenCalled();
+    });
+
     describe("S3 backend", () => {
+      it.each(["view", "panel"])("finds %s upload columns and prefers view columns for duplicate IDs", async (location) => {
+        const sharedId = "upload-target";
+        const storage = (bucket: string) => ({
+          host: "s3.example.com", accessKeyId: "k", secretAccessKey: "s", bucket,
+        });
+        const mainColumn = fileColumn({
+          __id__: location === "view" ? sharedId : "different-view-column",
+          s3Config: storage("view-bucket"),
+        });
+        const panelColumn = fileColumn({ __id__: sharedId, s3Config: storage("panel-bucket") });
+        const instance = buildAppForManager(harness.manager, baseConfig({ views: [fruitView({
+          primaryId: "id", columns: [mainColumn],
+          recordViewPanels: [
+            { type: "table", label: "No creation", query: "SELECT * FROM fruits" },
+            { type: "table", label: "Creation", query: "SELECT * FROM fruits",
+              createConfig: { label: "Create", recordIdKey: "id", columns: [panelColumn] } },
+          ],
+        })] }));
+        await s3Request(instance, sharedId).expect(200);
+        expect(jest.requireMock("@aws-sdk/client-s3").PutObjectCommand).toHaveBeenCalledWith(
+          expect.objectContaining({ Bucket: `${location}-bucket` }),
+        );
+      });
+
       it("uploads with a public-read PutObjectCommand and returns the public URL", async () => {
         const s3Mock = jest.requireMock("@aws-sdk/client-s3");
         const column = fileColumn({
@@ -162,6 +205,83 @@ describeIntegration("upload routes against real databases", () => {
         expect(Buffer.isBuffer(sentCommand.Body)).toBe(true);
       });
 
+      it("lets the SDK resolve credentials when no accessKeyId is configured", async () => {
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            bucket: "b",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(200);
+        expect(s3Mock.S3Client.mock.calls[0][0]).not.toHaveProperty(
+          "credentials",
+        );
+      });
+
+      it("lets the SDK resolve credentials when accessKeyId is an empty string", async () => {
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            accessKeyId: "",
+            secretAccessKey: "",
+            bucket: "b",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(200);
+        expect(s3Mock.S3Client.mock.calls[0][0]).not.toHaveProperty(
+          "credentials",
+        );
+      });
+
+      it("lets the SDK resolve credentials in the signed-URL flow when no accessKeyId is configured", async () => {
+        const presignerMock = jest.requireMock("@aws-sdk/s3-request-presigner");
+        const s3Mock = jest.requireMock("@aws-sdk/client-s3");
+        const column = fileColumn({
+          s3Config: {
+            host: "s3.example.com",
+            bucket: "b",
+            signedUrlNeeded: true,
+            region: "eu-west-3",
+          },
+        });
+        const { app, colId } = appWithColumn(column);
+        await s3Request(app, colId).expect(200);
+        expect(s3Mock.S3Client.mock.calls[0][0]).not.toHaveProperty(
+          "credentials",
+        );
+        expect(presignerMock.getSignedUrl).toHaveBeenCalledWith(
+          s3Mock.S3Client.mock.results[0].value,
+          expect.anything(),
+          { expiresIn: 150 },
+        );
+      });
+
+      it.each([
+        ["document", Buffer.from("text"), /^document-\d+\.undefined$/, "application/octet-stream"],
+        ["broken.png", Buffer.from("not an image"), /^broken-\d+\.png$/, "image/png"],
+        ["empty.txt", Buffer.alloc(0), /^empty-\d+\.txt$/, "text/plain"],
+        ["photo.PNG", PNG_BUFFER, /^photo-\d+\.PNG$/, "image/png"],
+      ])("preserves filename and image handling for %s", async (filename, content, expectedPath, contentType) => {
+        const { app, colId } = appWithColumn(fileColumn({
+          s3Config: { host: "s3.example.com", accessKeyId: "k", secretAccessKey: "s", bucket: "b" },
+        }));
+        const res = await request(app)
+          .post("/api/uploadFile")
+          .query({ viewIndex: 0, columnId: colId })
+          .attach("file", content, { filename })
+          .expect(200);
+        expect(res.body.originalFilename).toBe(filename);
+        expect(res.body.path).toMatch(expectedPath);
+        expect(res.body.aspectRatio).toBeNull();
+        expect(jest.requireMock("@aws-sdk/client-s3").PutObjectCommand).toHaveBeenCalledWith(
+          expect.objectContaining({ ContentType: contentType, Body: content }),
+        );
+      });
+
       it("prefixes https:// to hosts missing a scheme", async () => {
         const s3Mock = jest.requireMock("@aws-sdk/client-s3");
         const column = fileColumn({
@@ -303,6 +423,18 @@ describeIntegration("upload routes against real databases", () => {
         expect(res.body.aspectRatio).toBe(1); // PNG_BUFFER is a real 1x1 PNG header
       });
 
+      it("prefers GCP when all remote storage settings are present", async () => {
+        const { app, colId } = appWithColumn(fileColumn({
+          s3Config: { host: "s3.example.com", accessKeyId: "k", secretAccessKey: "s", bucket: "s3" },
+          gcpConfig: { host: "storage.googleapis.com", bucket: "gcp" },
+          sftpConfig: { host: "sftp.example.com", user: "u", password: "p" },
+        }));
+        await s3Request(app, colId).expect(200);
+        expect(jest.requireMock("@google-cloud/storage").__bucket).toHaveBeenCalledWith("gcp");
+        expect(jest.requireMock("@aws-sdk/client-s3").S3Client).not.toHaveBeenCalled();
+        expect(jest.requireMock("ssh2-sftp-client").__sftp.connect).not.toHaveBeenCalled();
+      });
+
       it("returns 500 when the upload fails", async () => {
         const gcpMock = jest.requireMock("@google-cloud/storage");
         gcpMock.__upload.mockRejectedValueOnce(new Error("gcp down"));
@@ -324,6 +456,30 @@ describeIntegration("upload routes against real databases", () => {
         expect(res.text).toContain("publicPath");
       });
 
+      it("reads the current SFTP config once per credential inside the callback", async () => {
+        const column = fileColumn({ publicPath: "/srv/public" });
+        const { app } = appWithColumn(column);
+        let reads = 0;
+        Object.defineProperty(column, "sftpConfig", {
+          get: () => {
+            reads += 1;
+            return { host: `host-${reads}`, user: `user-${reads}`, password: `password-${reads}` };
+          },
+        });
+        app.post("/upload-read-order", (req, res) => {
+          uploadFile(column, "file", req, res);
+          reads = 0;
+        });
+        await request(app)
+          .post("/upload-read-order")
+          .attach("file", PNG_BUFFER, { filename: "photo.png" })
+          .expect(200);
+        expect(reads).toBe(3);
+        expect(jest.requireMock("ssh2-sftp-client").__sftp.connect).toHaveBeenCalledWith({
+          host: "host-1", port: 22, username: "user-2", password: "password-3",
+        });
+      });
+
       it("fastPuts the temp file to the remote path and cleans it up", async () => {
         const sftpMock = jest.requireMock("ssh2-sftp-client");
         const column = fileColumn({
@@ -380,6 +536,18 @@ describeIntegration("upload routes against real databases", () => {
         expect(fs.existsSync(stored)).toBe(true);
       });
 
+      it("uses the default temporary directory when both path properties are absent", async () => {
+        const { app, colId } = appWithColumn(fileColumn());
+        const res = await s3Request(app, colId).expect(200);
+        try {
+          expect(path.dirname(res.body.path)).toBe(os.tmpdir());
+          expect(res.body.originalFilename).toBe("photo.png");
+          expect(fs.readFileSync(res.body.path)).toEqual(PNG_BUFFER);
+        } finally {
+          fs.rmSync(res.body.path, { force: true });
+        }
+      });
+
       it("fails without a subdirectory (publicPath + undefined concat — documented quirk)", async () => {
         // uploadDir becomes "<publicPath>undefined", which never exists, so
         // the multipart parse fails with 500. A subdirectory is effectively
@@ -500,6 +668,16 @@ describeIntegration("upload routes against real databases", () => {
         expectNoStorage();
       });
 
+      it("rejects a role-restricted panel column when the session has no user", async () => {
+        const column = richColumn({ roles: ["editor"] });
+        const app = buildAppForManager(harness.manager, baseConfig({ views: [fruitView({
+          recordViewPanels: [{ type: "table", label: "Notes", query: "SELECT * FROM fruit_notes",
+            createConfig: { tableName: "fruit_notes", recordIdKey: "fruitId", columns: [column] } }],
+        })] }), null);
+        await upload(app, { viewIndex: 0, columnId: generateUniqueIdForObject(column) }).expect(403);
+        expectNoStorage();
+      });
+
       it("uses indexes from the role-filtered views", async () => {
         const column = richColumn();
         const app = buildAppForManager(harness.manager, baseConfig({ views: [

package/tests/integration/userFilters.integration.test.ts

@@ -0,0 +1,225 @@
+import * as express from "express";
+import * as request from "supertest";
+import type { RequestHandler } from "express";
+import createRecordQueries from "../../src/api/queries";
+import recordsRoute from "../../src/api/routes/records";
+import exportRoute from "../../src/api/routes/recordsExport";
+import foreignRoute from "../../src/api/routes/foreignSelectRecords";
+import { baseConfig, fruitView } from "../helpers/fixtures";
+import { buildAppForManager } from "../helpers/app";
+import { DbHarness, describeIntegration, getMysqlHarness, getMysql2Harness, getPgHarness, resetTables } from "./dbHarness";
+
+type CallbackUser = { role: string; userId?: string | number };
+type Filter = (user: CallbackUser) => string;
+type RouteName = "records" | "recordsExport" | "foreignSelectRecords";
+
+// The forwarding recorder below runs the real query helper and database. It
+// observes whether a data query was invoked; it does not replace query results.
+describeIntegration("configured user filters against real databases", () => {
+  let harnesses: DbHarness[];
+  beforeAll(async () => { harnesses = [await getMysqlHarness(), await getMysql2Harness(), await getPgHarness()]; });
+  afterAll(async () => { for (const harness of harnesses || []) await harness.stop(); });
+
+  describe.each([0, 1, 2])("backend %s", (backend) => {
+    let harness: DbHarness;
+    beforeEach(async () => { harness = harnesses[backend]; await resetTables(harness); });
+
+    const literal = (value: string | number) => "'" + (harness.dbType === "POSTGRESQL"
+      ? String(value).replace(/'/g, "''")
+      : String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")) + "'";
+    const scoped = (user: CallbackUser) => user.role === "root" ? ""
+      : user.userId === undefined ? "1 = 0" : `slug = ${literal(user.userId)}`;
+
+    const seed = async (id: string | number) => {
+      for (const row of [
+        ["keep mine", String(id), 1], ["keep other", "someone-else", 1],
+        ["blocked mine", String(id), 1], ["keep inactive", String(id), 0],
+      ]) {
+        const { err } = await harness.query("INSERT INTO fruits (fruitName, slug, acidity) VALUES (?, ?, ?)", row);
+        expect(err).toBeNull();
+      }
+    };
+
+    const build = (route: RouteName, user: unknown, filter?: Filter, events: string[] = []) => {
+      const column = {
+        __id__: "foreign", label: "Name", dataType: "foreign", name: "fruitName",
+        table: "fruits", foreignName: "id", searchableName: "fruitName", filters: "acidity > 0",
+      };
+      const view = fruitView({
+        tableName: "fruits", primaryId: "id", filters: "acidity > 0", columns: [column],
+      });
+      const target = route === "foreignSelectRecords" ? column : view;
+      if (filter) Object.defineProperty(target, "filtersFromUser", { value: filter, configurable: true });
+      const config = baseConfig({ enriched: true, views: [view] });
+      const session = { user };
+      const actual = createRecordQueries(harness.manager).getRecords;
+      let queries = 0;
+      const getRecords: typeof actual = async (...args) => {
+        queries++;
+        events.push("query");
+        return actual(...args);
+      };
+      const handler = route === "records" ? recordsRoute(getRecords)
+        : route === "recordsExport" ? exportRoute(getRecords)
+        : foreignRoute(harness.manager, getRecords);
+      const errors: unknown[] = [];
+      const app = express();
+      app.use(express.json());
+      app.use((req, _res, next) => {
+        req.config = config;
+        Object.defineProperty(req, "session", { value: session });
+        next();
+      });
+      const observe: RequestHandler = async (req, res, next) => {
+        try { await handler(req, res, next); }
+        catch (error) { errors.push(error); res.sendStatus(599); }
+      };
+      app.post("/filter", observe);
+      const send = () => request(app).post("/filter").send({
+        viewIndex: 0, columnId: "foreign", page: 1,
+        filters: route === "records" ? ["fruitName LIKE 'keep%'"] : "fruitName LIKE 'keep%'",
+        ...(route === "foreignSelectRecords" ? { query: "keep" } : {}),
+      });
+      return { target, session, errors, send, queries: () => queries };
+    };
+
+    const names = (route: RouteName, body: { records?: { fruitName: string }[]; content?: string } | { label: string }[]) => {
+      if (Array.isArray(body)) return body.map((row) => row.label);
+      return route === "records" ? body.records?.map((row) => row.fruitName) : body.content?.split("\r\n").slice(1);
+    };
+
+    describe.each<RouteName>(["records", "recordsExport", "foreignSelectRecords"])("route %s", (route) => {
+      it.each([
+        ["number", 2], ["zero", 0], ["numeric string", "002"],
+        ["UUID", "00000000-0000-4000-8000-000000000001"], ["SQL punctuation", "owner' OR '1'='1"],
+      ])("FILTER USER POLICY: scopes an exact %s ID and keeps the session", async (_label, id) => {
+        await seed(id);
+        const user = Object.freeze({ role: "editor", userId: id, extra: "stored-only" });
+        const received: unknown[] = [];
+        const instance = build(route, user, function (input) {
+          expect(this).toBe(instance.target);
+          expect(arguments).toHaveLength(1);
+          received.push(input);
+          return scoped(input);
+        });
+        const response = await instance.send();
+        expect(response.status).toBe(200);
+        expect(received).toEqual([{ role: "editor", userId: id }]);
+        expect(received[0]).not.toBe(user);
+        expect(instance.session.user).toBe(user);
+        expect(names(route, response.body)).toEqual(["keep mine"]);
+        expect(instance.queries()).toBe(1);
+      });
+
+      it("FILTER USER POLICY: invokes root filters without reading or forwarding an ID", async () => {
+        await seed(2);
+        let idReads = 0;
+        const user = { role: "root", get userId() { idReads++; throw new Error("root ID read"); } };
+        let calls = 0;
+        const instance = build(route, user, function (input) {
+          expect(this).toBe(instance.target);
+          expect(arguments).toHaveLength(1);
+          expect(input).toEqual({ role: "root" });
+          calls++;
+          return "fruitName = 'keep other'";
+        });
+        const response = await instance.send();
+        expect(response.status).toBe(200);
+        expect(names(route, response.body)).toEqual(["keep other"]);
+        expect({ calls, idReads, queries: instance.queries() }).toEqual({ calls: 1, idReads: 0, queries: 1 });
+        expect(instance.session.user).toBe(user);
+      });
+
+      it.each([{}, { userId: undefined }])("FILTER USER POLICY: lets a regular user without an ID choose a role policy %j", async (idFields) => {
+        await seed(2);
+        const user = Object.freeze({ role: "editor", ...idFields });
+        let calls = 0;
+        const instance = build(route, user, (input) => {
+          expect(input).toEqual({ role: "editor" });
+          expect(Object.prototype.hasOwnProperty.call(input, "userId")).toBe(false);
+          calls++;
+          return "fruitName = 'keep mine'";
+        });
+        const response = await instance.send();
+        expect(response.status).toBe(200);
+        expect(names(route, response.body)).toEqual(["keep mine"]);
+        expect(calls).toBe(1);
+        expect(instance.session.user).toBe(user);
+      });
+
+      it("FILTER USER POLICY: accepts unnormalized numeric values and empty identifiers", async () => {
+        for (const id of [-2.5, NaN, Infinity, ""]) {
+          let received: unknown;
+          const instance = build(route, { role: "", userId: id }, (input) => {
+            received = input;
+            return "1 = 0";
+          });
+          await instance.send().expect(200);
+          expect(received).toEqual({ role: "", userId: id });
+        }
+      });
+
+      it("FILTER USER POLICY: rejects malformed sessions before callback or data query", async () => {
+        const invalid: unknown[] = [undefined, null, [], "editor", 7, false, () => {}, {},
+          { role: null }, { role: 1 }, { role: [] },
+          ...[null, true, [], {}, BigInt(1), Symbol("id"), () => {}].map((userId) => ({ role: "editor", userId }))];
+        for (const user of invalid) {
+          let calls = 0;
+          const instance = build(route, user, () => { calls++; return ""; });
+          const response = await instance.send();
+          expect({ status: response.status, calls, queries: instance.queries(), errors: instance.errors }).toEqual({
+            status: 401, calls: 0, queries: 0, errors: [],
+          });
+          expect(instance.session.user).toBe(user);
+        }
+      });
+
+      it("does not read or validate the session when no user filter is configured", async () => {
+        await seed(2);
+        const instance = build(route, null);
+        Object.defineProperty(instance.session, "user", { get() { throw new Error("unexpected session read"); } });
+        const response = await instance.send().expect(200);
+        expect(names(route, response.body)).toEqual(["keep mine", "keep other"]);
+        expect(instance.queries()).toBe(1);
+      });
+
+      it("preserves callback receiver, count, thrown error and no-query behavior", async () => {
+        const failure = new Error("filter failure");
+        let calls = 0;
+        const instance = build(route, { role: "editor", userId: 2 }, function () {
+          expect(this).toBe(instance.target);
+          calls++;
+          throw failure;
+        });
+        await instance.send().expect(599);
+        expect(instance.errors).toEqual([failure]);
+        expect(instance.errors[0]).toBe(failure);
+        expect(calls).toBe(1);
+        expect(instance.queries()).toBe(0);
+      });
+
+      it("preserves table/filter/callback property evaluation order", async () => {
+        const events: string[] = [];
+        const filter = function () { events.push("callback"); return "1 = 0"; };
+        const instance = build(route, { role: "editor", userId: 2 }, filter, events);
+        Object.defineProperty(instance.target, route === "foreignSelectRecords" ? "table" : "tableName", {
+          get() { events.push("table"); return "fruits"; },
+        });
+        Object.defineProperty(instance.target, "filters", { get() { events.push("filters"); return "acidity > 0"; } });
+        Object.defineProperty(instance.target, "filtersFromUser", { get() { events.push("filter property"); return filter; } });
+        await instance.send().expect(200);
+        expect(events).toEqual(["table", "filters", "filter property", "filter property", "callback", "query"]);
+      });
+    });
+
+    it("keeps API request-filter authorization before a configured user filter", async () => {
+      let calls = 0;
+      const app = buildAppForManager(harness.manager, baseConfig({ views: [fruitView({
+        filtersFromUser: () => { calls++; return ""; },
+      })] }), null);
+      await request(app).post("/api/records").send({ viewIndex: 0, page: 1, filters: ["1=1; DROP TABLE fruits"] }).expect(400);
+      expect(calls).toBe(0);
+      expect((await harness.query("SELECT * FROM fruits")).rows).toEqual([]);
+    });
+  });
+});

package/tsconfig.json

@@ -17,4 +17,4 @@
   "include": [
     "src/"
   ]
-}
+}

package/tsconfig.strict.json

@@ -0,0 +1,45 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "include": [
+    "src/types/**/*.ts",
+    "src/utils/imageDimensions.ts",
+    "src/utils/dbManager.ts",
+    "src/api/config.ts",
+    "src/api/queries.ts",
+    "src/api/authorization.ts",
+    "src/api/uploadFile.ts",
+    "src/api/request.ts",
+    "src/api/routes/adjacentRecordId.ts",
+    "src/api/routes/config.ts",
+    "src/api/routes/customAction.ts",
+    "src/api/routes/customComponent.ts",
+    "src/api/routes/customQuery.ts",
+    "src/api/routes/deleteRecords.ts",
+    "src/api/routes/duplicateRecord.ts",
+    "src/api/routes/notificationBadges.ts",
+    "src/api/routes/record.ts",
+    "src/api/routes/searchCompanies.ts",
+    "src/api/routes/uploadFile.ts",
+    "src/api/routes/createRecord.ts",
+    "src/api/routes/deleteRecord.ts",
+    "src/api/routes/deleteRecordFromPanel.ts",
+    "src/api/routes/updateRecord.ts",
+    "src/api/values.ts",
+    "src/api/importRecords.ts",
+    "src/api/routes/recordsImport.ts",
+    "src/api/routes/subrecordsImport.ts",
+    "src/api/routes/uploadFileFromBetterRichTextInput.ts",
+    "src/api/filterUser.ts",
+    "src/api/routes/records.ts",
+    "src/api/routes/recordsExport.ts",
+    "src/api/routes/foreignSelectRecords.ts",
+    "src/api.ts",
+    "src/index.ts"
+  ],
+  "exclude": [
+    "src/front"
+  ]
+}

package/dist/front/ckeditor5-build/src/ckeditor.d.ts

@@ -1,43 +0,0 @@
-import { ClassicEditor } from '@ckeditor/ckeditor5-editor-classic';
-import { Alignment } from '@ckeditor/ckeditor5-alignment';
-import { Autoformat } from '@ckeditor/ckeditor5-autoformat';
-import { Bold, Italic, Strikethrough, Underline } from '@ckeditor/ckeditor5-basic-styles';
-import { BlockQuote } from '@ckeditor/ckeditor5-block-quote';
-import { CloudServices } from '@ckeditor/ckeditor5-cloud-services';
-import { Essentials } from '@ckeditor/ckeditor5-essentials';
-import { FindAndReplace } from '@ckeditor/ckeditor5-find-and-replace';
-import { FontBackgroundColor, FontColor } from '@ckeditor/ckeditor5-font';
-import { Heading } from '@ckeditor/ckeditor5-heading';
-import { Highlight } from '@ckeditor/ckeditor5-highlight';
-import { HorizontalLine } from '@ckeditor/ckeditor5-horizontal-line';
-import { HtmlEmbed } from '@ckeditor/ckeditor5-html-embed';
-import { AutoImage, Image, ImageCaption, ImageInsert, ImageResize, ImageStyle, ImageToolbar, ImageUpload } from '@ckeditor/ckeditor5-image';
-import { Indent, IndentBlock } from '@ckeditor/ckeditor5-indent';
-import { AutoLink, Link, LinkImage } from '@ckeditor/ckeditor5-link';
-import { List } from '@ckeditor/ckeditor5-list';
-import { MediaEmbed } from '@ckeditor/ckeditor5-media-embed';
-import { Paragraph } from '@ckeditor/ckeditor5-paragraph';
-import { PasteFromOffice } from '@ckeditor/ckeditor5-paste-from-office';
-import { RemoveFormat } from '@ckeditor/ckeditor5-remove-format';
-import { SelectAll } from '@ckeditor/ckeditor5-select-all';
-import { SourceEditing } from '@ckeditor/ckeditor5-source-editing';
-import { Table, TableToolbar } from '@ckeditor/ckeditor5-table';
-import { TextTransformation } from '@ckeditor/ckeditor5-typing';
-import { SimpleUploadAdapter } from '@ckeditor/ckeditor5-upload';
-import { WordCount } from '@ckeditor/ckeditor5-word-count';
-declare class Editor extends ClassicEditor {
-    static builtinPlugins: (typeof Alignment | typeof AutoImage | typeof AutoLink | typeof Autoformat | typeof BlockQuote | typeof Bold | typeof CloudServices | typeof Essentials | typeof FindAndReplace | typeof FontBackgroundColor | typeof FontColor | typeof Heading | typeof Highlight | typeof HorizontalLine | typeof HtmlEmbed | typeof Image | typeof ImageCaption | typeof ImageInsert | typeof ImageResize | typeof ImageStyle | typeof ImageToolbar | typeof ImageUpload | typeof Indent | typeof IndentBlock | typeof Italic | typeof Link | typeof LinkImage | typeof List | typeof MediaEmbed | typeof Paragraph | typeof PasteFromOffice | typeof RemoveFormat | typeof SelectAll | typeof SimpleUploadAdapter | typeof SourceEditing | typeof Strikethrough | typeof Table | typeof TableToolbar | typeof TextTransformation | typeof Underline | typeof WordCount)[];
-    static defaultConfig: {
-        toolbar: {
-            items: string[];
-        };
-        language: string;
-        image: {
-            toolbar: string[];
-        };
-        table: {
-            contentToolbar: string[];
-        };
-    };
-}
-export default Editor;