diff --git a/.github/workflows/cypress.yml b/.github/workflows/cypress.yml
index 971a684..930b219 100644
--- a/.github/workflows/cypress.yml
+++ b/.github/workflows/cypress.yml
@@ -1,21 +1,13 @@
-name: Cypress
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
+name: Frontend tests
 env:
-  NODE_VERSION: '16'
+  NODE_VERSION: '20'
   PYTHON_VERSION: '3.9'
 
 permissions:
   contents: read
 
 jobs:
-  cypress:
+  frontend-test:
     runs-on: ubuntu-latest
     services:
       ckan-postgres:
@@ -48,6 +40,11 @@ jobs:
 
     steps:
       - uses: actions/checkout@v3
+      - name: Install Cypress deps
+        run: |
+            apt update
+            apt install -y libgtk2.0-0 libgtk-3-0 libgbm-dev libnotify-dev libnss3 libxss1 libasound2 libxtst6 xauth xvfb
+
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -56,18 +53,18 @@ jobs:
           node-version: ${{ env.NODE_VERSION }}
 
       - name: Install python deps
-        run: pip install 'ckan[requirements,dev]' -e.
+        run: |
+            git clone --depth 1 --branch ckan-2.10.4 https://github.com/ckan/ckan ../ckan
+            pip install '../ckan[requirements,dev]' -e.
 
       - name: Init environment
         run: |
-            sed -i -e 's/use = config:.*/use = config:\/srv\/app\/src\/ckan\/test-core.ini/' test.ini
-            ckan -c test.ini db upgrade
-            yes | ckan -c test.ini sysadmin add admin password=password123 email=admin@test.net
+          ckan -c test.ini db upgrade
 
       - name: Run Cypress
         uses: cypress-io/github-action@v6
         with:
-          start: ckan -c test-core-cypress.ini run
+          start: ckan -c test.ini run
 
       - uses: actions/upload-artifact@v3
         if: failure()
diff --git a/.github/workflows/typing.yml b/.github/workflows/typing.yml
index 13e309c..6f68dd9 100644
--- a/.github/workflows/typing.yml
+++ b/.github/workflows/typing.yml
@@ -1,5 +1,8 @@
 name: Typing
-on: [pull_request]
+on:
+  pull_request:
+    branches:
+      - master
 env:
   NODE_VERSION: '20'
   PYTHON_VERSION: '3.9'
diff --git a/Makefile b/Makefile
index 5c128c4..c1a3ed1 100644
--- a/Makefile
+++ b/Makefile
@@ -10,4 +10,7 @@ changelog:  ## compile changelog
 
 
 test-server:
+	yes | ckan -c test.ini db clean
+	ckan -c test.ini db upgrade
+	yes | ckan -ctest.ini sysadmin add admin password=password123 email=admin@test.net
 	ckan -c test.ini run -t
diff --git a/README.md b/README.md
index b04562c..eb4aebb 100644
--- a/README.md
+++ b/README.md
@@ -957,6 +957,140 @@ Now file can be used normally. You can transfer file ownership to someone,
 stream or modify it. Pay attention to ID: completed file has its own unique ID,
 which is different from ID of the upload.
 
+### JavaScript utilities
+
+None: ckanext-files does not provide stable CKAN JS modules at the moment. Try
+creating your own widgets and share with us your examples or
+requirements. We'll consider creating and including widgets into ckanext-files
+if they are generic enough for majority of the users.
+
+ckanext-files registers few utilities inside CKAN JS namespace to help with
+building UI components.
+
+First group of utilities registered inside CKAN Sandbox. Inside CKAN JS modules
+it's accessible as `this.sandbox`. If you are writing code outside of JS
+modules, Sandbox can be initialized via call to `ckan.sandbox()`
+
+```js
+const sandbox = ckan.sandbox()
+```
+
+When `files` plugin loaded, sandbox contains `files` attribute with two
+members:
+
+* `upload`: high-level helper for uploding files.
+* `makeUploader`: factory for uploader-objects that gives more control over
+  upload process.
+
+The simplest way to upload the file is using `upload` helper.
+
+```js
+await sandbox.files.upload(
+    new File(["file content"], "name.txt", {type: "text/plain"}),
+)
+```
+
+This function uploads file to `default` storage via `files_file_create`
+action. Extra parameters for API call can be passed using second argument of
+upload. Use an object with `requestParams` key. Value of this key will be added
+to standard API request parameters. For example, if you want to use `storage`
+with name `memory` and `field` with value `custom`:
+
+```js
+await sandbox.files.upload(
+    new File(["file content"], "name.txt", {type: "text/plain"}),
+    {requestParams: {storage: "memory", field: "custom"}}
+)
+```
+
+If you need more control over upload, you can create an **uploader** and
+interact with it directly, instead of using `upload` helper.
+
+*Uploader* is an object that extends base uploader, which defines standard
+interface for this object. Uploader perfroms all the API calls internally and
+returns uploaded file details. Out of the box you can use `Standard` and
+`Multipart` uploaders. `Standard` uses `files_file_create` API action and
+specializes on normal uploads. `Multipart` relies on `files_multipart_*`
+actions and can be used to pause and continue upload.
+
+To create uploader instance, pass its name as a string to `makeUploader`. And
+then you can call `upload` method of the uploader to perform the actual
+upload. This method requires two arguments:
+
+* the file object
+* object with additional parameters of API request, the same as `requestParams`
+  from example above. If you want to use default parameters, pass an empty
+  object. If you want to use `memory` storage, pass `{storage: "memory"}`, etc.
+
+```js
+const uploader = sandbox.files.makeUploader("Standard")
+await uploader.upload(new File(["file content"], "name.txt", {type: "text/plain"}), {})
+```
+
+One of the reasons to use manually created uploader is progress
+tracking. Uploader supports event subscriptions via
+`uploader.addEventListener(event, callback)` and here's the list of possible
+upload events:
+
+* `start`: file upload started. Event has `detail` property with object that
+  contains uploaded file as `file`.
+* `progress`: another chunk of file was transferred to server. Event has
+  `detail` property with object that contains uploaded file as `file`, number
+  of loaded bytes as `loaded` and total number of bytes that must be
+  transferred as `total`.
+* `finish`: file upload successfully finished. Event has `detail` property with
+  object that contains uploaded file as `file` and file details from API
+  response as `result`.
+* `fail`: file upload failed. Event has `detail` property with object that
+  contains uploaded file as `file` and object with CKAN validation errors as
+  `reasons`.
+* `error`: error unrelated to validation happened during upload, like call to
+  non-existing action. Event has `detail` property with object that contains
+  uploaded file as `file` and error as `message`.
+
+
+If you want to use `upload` helper with customized uploader, there are two ways
+to do it.
+
+* pass `adapter` property with uploader name inside second argument of `upload`
+  helper:
+  ```js
+  await sandbox.files.upload(new File(...), {adapter: "My"})
+  ```
+* pass `uploader` property with uploader instance inside second argument of `upload`
+  helper:
+  ```js
+  const uploader = sandbox.files.makeUploader("Multipart")
+  await sandbox.files.upload(new File(...), {uploader})
+  ```
+
+The second group of ckanext-files utilities is available as
+`ckan.CKANEXT_FILES` object. This object mainly serves as extension and
+configuration point for `sandbox.files`.
+
+`ckan.CKANEXT_FILES.adapters` is a collection of all classes that can be used
+to initialize uploader. It contains `Standard`, `Multipart` and `Base`
+classes. `Standard` and `Multipart` can be used as is, while `Base` must be
+extended by your custom uploader class. Add your custom uploader classes to
+`adapters`, to make them available application-wide:
+
+```js
+
+class MyUploader extends Base { ... }
+
+ckan.CKANEXT_FILES.adapters["My"] = MyUploader;
+
+await sandbox.files.upload(new File(...), {adapter: "My"})
+```
+
+`ckan.CKANEXT_FILES.defaultSettings` contain the object with default settings
+available as `this.settings` inside any uploader. You can change the name of
+the storage used by all uploaders using this object. Note, changes will apply
+only to uploaders initialized after modification.
+
+```js
+ckan.CKANEXT_FILES.defaultSettings.storage = "memory"
+```
 
 ## File upload strategies
 
diff --git a/ckanext/files/assets/scripts/files--modules.js b/ckanext/files/assets/scripts/files--modules.js
index 0a05dc8..f0c5320 100644
--- a/ckanext/files/assets/scripts/files--modules.js
+++ b/ckanext/files/assets/scripts/files--modules.js
@@ -78,7 +78,7 @@ ckan.module("files--auto-upload", function ($) {
                 this.queue.add(file);
                 this.refreshFormState();
                 const options = {
-                    uploaderParams: [{ uploadAction: this.options.action }],
+                    uploaderArgs: [{ uploadAction: this.options.action }],
                 };
                 this.sandbox.files
                     .upload(file, options)
@@ -261,7 +261,6 @@ ckan.module("files--queue", function ($) {
             this.widgets.set(widget[0], info);
             widget.on("click", "[data-upload-resume]", this._onWidgetResume);
             widget.on("click", "[data-upload-pause]", this._onWidgetPause);
-            info.uploader.addEventListener("commit", (event) => (info.id = event.detail.id));
             info.uploader.addEventListener("fail", ({ detail: { reasons, file }, }) => {
                 this.sandbox.notify(file.name, Object.entries(reasons)
                     .filter(([k, v]) => k[0] !== "_")
@@ -347,4 +346,4 @@ ckan.module("files--queue", function ($) {
         },
     };
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files--modules.js","sourceRoot":"","sources":["../ts/files--modules.ts"],"names":[],"mappings":"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","sourcesContent":["ckan.module(\"files--resource-select\", function ($) {\n    return {\n        options: {\n            successEvent: \"files-file-created\",\n            errorEvent: \"files-file-failed\",\n            select: null,\n            initialValue: null,\n        },\n\n        initialize() {\n            if (!this.options.select) {\n                console.error(\n                    \"files--resource-select cannot be initialized without `select` option\",\n                );\n                return;\n            }\n\n            $.proxyAll(this, /_on/);\n            this.el.on({\n                [this.options.successEvent]: this._onSuccess,\n                [this.options.errorEvent]: this._onError,\n            });\n\n            this.url = document.getElementById(\"field-resource-url\");\n            this.select = $(this.options.select);\n            if (this.options.initialValue) {\n                this.select.select2(\"data\", this.options.initialValue);\n            }\n        },\n        _onSuccess({ detail }: { detail: any }) {\n            this.select.select2(\"data\", { id: detail.id, text: detail.name });\n        },\n        _onError({\n            detail: err,\n        }: {\n            detail: string | { [key: string]: string[] };\n        }) {\n            if (typeof err === \"string\") {\n                this.reportError(\"Error\", err);\n            } else {\n                for (let [field, problems] of Object.entries(\n                    err as { [key: string]: string[] },\n                )) {\n                    if (field.startsWith(\"__\")) continue;\n                    this.reportError(field, problems.join(\",\"));\n                }\n            }\n        },\n        reportError(label: string, message: string) {\n            const box = this.sandbox.notify.initialize(\n                this.sandbox.notify.create(label, message),\n            );\n            this.el.closest(\"label\").parent().after(box);\n        },\n    };\n});\n/**\n * Upload file and trigger event with file data on specified element.\n *\n */\nckan.module(\"files--auto-upload\", function ($) {\n    return {\n        options: {\n            spinner: null,\n            action: null,\n            successEvent: \"files-file-created\",\n            errorEvent: \"files-file-failed\",\n            eventTarget: null,\n            copyIdInto: null,\n        },\n        queue: null,\n\n        initialize() {\n            if (!this.options.action) {\n                console.error(\n                    \"files--auto-upload cannot be initialized without `action` option\",\n                );\n                return;\n            }\n            $.proxyAll(this, /_on/);\n\n            this.queue = new Set();\n\n            this.el.on(\"change\", (event: Event) =>\n                this.upload(...(event.target as HTMLInputElement).files!),\n            );\n            this.spinner = $(this.options.spinner);\n            this.field = $(this.options.field);\n            this.submits = this.el\n                .closest(\"form\")\n                .find(\"input[type=submit],button[type=submit]\");\n            this.idTarget = $(this.options.copyIdInto);\n        },\n\n        upload(...files: File[]) {\n            files.forEach(async (file) => {\n                this.queue.add(file);\n                this.refreshFormState();\n                const options: ckan.CKANEXT_FILES.UploadOptions = {\n                    uploaderParams: [{ uploadAction: this.options.action }],\n                };\n\n                this.sandbox.files\n                    .upload(file, options)\n                    .then(\n                        (result: any) => {\n                            this.idTarget.val(result.id);\n                            this.dispatchResult(\n                                this.options.successEvent,\n                                result,\n                            );\n                        },\n                        (err: any) =>\n                            this.dispatchResult(this.options.errorEvent, err),\n                    )\n                    .then(() => {\n                        this.queue.delete(file);\n                        this.refreshFormState();\n                    });\n            });\n        },\n\n        dispatchResult(event: string, detail: any) {\n            const target = this.options.eventTarget\n                ? $(this.options.eventTarget)\n                : this.el;\n            target[0].dispatchEvent(new CustomEvent(event, { detail }));\n        },\n\n        refreshFormState() {\n            this.spinner.prop(\"hidden\", !this.queue.size);\n            this.submits.prop(\"disabled\", !!this.queue.size);\n        },\n    };\n});\n\n/**\n * Add selected file to upload queue whenever `[data-queue-scheduler]`\n * dispatches `change` event.\n *\n */\nckan.module(\"files--scheduler\", function ($) {\n    return {\n        options: {\n            immediate: false,\n        },\n        initialize() {\n            const scheduler = this.$(\"[data-queue-scheduler]\");\n            scheduler.on(\"drop\", (event: Event) => event.preventDefault());\n            scheduler.on(\"change\", (event: Event) =>\n                this.push(...(event.target as HTMLInputElement).files!),\n            );\n        },\n\n        push(...files: File[]) {\n            files.forEach((file) =>\n                this.sandbox.publish(\n                    ckan.CKANEXT_FILES.topics.addFileToQueue,\n                    file,\n                    { immediate: this.options.immediate },\n                ),\n            );\n        },\n    };\n});\n\n/**\n * Add file/directories to upload queue via drag'n'drop.\n *\n */\nckan.module(\"files--dropzone\", function ($) {\n    return {\n        options: {\n            immediate: false,\n        },\n\n        initialize() {\n            $.proxyAll(this, /_on/);\n            const element = this.el[0];\n\n            element.addEventListener(\"dragover\", this._onDragOver);\n            element.addEventListener(\"dragenter\", this._onDragEnter);\n            element.addEventListener(\"dragleave\", this._onDragLeave);\n            element.addEventListener(\"drop\", this._onDrop);\n        },\n\n        _onDragOver(event: DragEvent) {\n            event.preventDefault();\n        },\n        _onDragEnter(event: DragEvent) {},\n        _onDragLeave(event: DragEvent) {},\n\n        _onDrop(event: DragEvent) {\n            event.preventDefault();\n            if (!event.dataTransfer) {\n                return;\n            }\n\n            for (let entry of event.dataTransfer.items) {\n                this.scanEntry(entry.webkitGetAsEntry(), (file: File) =>\n                    this.push(file),\n                );\n            }\n        },\n\n        scanEntry(\n            entry: FileSystemFileEntry | FileSystemDirectoryEntry,\n            cb: (file: File) => void,\n        ) {\n            if (entry.isFile) {\n                (entry as FileSystemFileEntry).file(cb);\n            } else {\n                (entry as FileSystemDirectoryEntry)\n                    .createReader()\n                    .readEntries((entries) =>\n                        entries.forEach((e) => this.scanEntry(e, cb)),\n                    );\n            }\n        },\n\n        push(file: File) {\n            this.sandbox.publish(\n                ckan.CKANEXT_FILES.topics.addFileToQueue,\n                file,\n                { immediate: this.options.immediate },\n            );\n        },\n    };\n});\n\n/**\n * Add to queue a file, that has associated incomplete upload.\n *\n * Supports a number of properties to verify that the new file matches\n * previously uploaded file.\n *\n *\n */\nckan.module(\"files--restorer\", function ($) {\n    return {\n        options: {\n            name: \"\",\n            size: 0,\n            uploaded: 0,\n            id: \"\",\n            immediate: false,\n        },\n\n        initialize() {\n            $.proxyAll(this, /_on/);\n            this.el.on(\"change\", this._onChange);\n        },\n\n        _onChange(event: Event) {\n            const file = (event.target as HTMLInputElement).files?.[0];\n\n            if (!file) {\n                return;\n            }\n\n            if (this.options.name && file.name !== this.options.name) {\n                this.sandbox.notify(\n                    \"Name mismatch.\",\n                    `Expected name: ${this.options.name}`,\n                );\n                this.sandbox.notify.el[0].scrollIntoView();\n                return;\n            }\n\n            if (this.options.size && file.size !== this.options.size) {\n                this.sandbox.notify(\n                    \"Size mismatch.\",\n                    `Expected size: ${this.options.size.toLocaleString()} bytes`,\n                );\n                this.sandbox.notify.el[0].scrollIntoView();\n                return;\n            }\n\n            this.sandbox.publish(\n                ckan.CKANEXT_FILES.topics.restoreFileInQueue,\n                file,\n                {\n                    id: this.options.id,\n                    uploaded: this.options.uploaded,\n                    immediate: this.options.immediate,\n                },\n            );\n        },\n    };\n});\n\nckan.module(\"files--shared-queue\", function ($) {\n    return {\n        initialize() {\n            $.proxyAll(this, /_on/);\n\n            this.worker = new SharedWorker(\n                this.sandbox.url(\n                    \"ckanext-files/scripts/files--shared-uploader.js\",\n                ),\n            );\n\n            this.worker.port.onmessage = console.debug;\n        },\n    };\n});\n\nckan.module(\"files--queue\", function ($) {\n    return {\n        options: {\n            storage: \"default\",\n            uploader: \"Standard\",\n        },\n\n        initialize() {\n            $.proxyAll(this, /_on/);\n            ckan.pubsub.subscribe(\n                ckan.CKANEXT_FILES.topics.addFileToQueue,\n                this._onFile,\n            );\n            ckan.pubsub.subscribe(\n                ckan.CKANEXT_FILES.topics.restoreFileInQueue,\n                this._onFile,\n            );\n\n            this.tpl = this.$(\"[data-upload-template]\")\n                .remove()\n                .removeAttr(\"data-upload-template hidden\");\n\n            this.widgets = new WeakMap();\n        },\n\n        teardown() {\n            ckan.pubsub.unsubscribe(\n                ckan.CKANEXT_FILES.topics.addFileToQueue,\n                this._onFile,\n            );\n            ckan.pubsub.unsubscribe(\n                ckan.CKANEXT_FILES.topics.restoreFileInQueue,\n                this._onFile,\n            );\n        },\n\n        _onFile(\n            file: File,\n            options = {\n                immediate: false,\n                id: \"\",\n                uploaded: 0,\n                uploaderInstance: null,\n                uploader: null,\n                storage: null,\n            },\n        ) {\n            const widget = this.tpl.clone(true).appendTo(this.el);\n            const info = {\n                file,\n                id: options.id,\n                uploaded: options.uploaded || 0,\n                uploader:\n                    options.uploaderInstance ||\n                    this.sandbox.files.makeUploader(\n                        options.uploader || this.options.uploader,\n                        { storage: options.storage || this.options.storage },\n                    ),\n            };\n\n            this.widgets.set(widget[0], info);\n\n            widget.on(\"click\", \"[data-upload-resume]\", this._onWidgetResume);\n            widget.on(\"click\", \"[data-upload-pause]\", this._onWidgetPause);\n\n            info.uploader.addEventListener(\n                \"commit\",\n                (event: CustomEvent) => (info.id = event.detail.id),\n            );\n            info.uploader.addEventListener(\n                \"fail\",\n                ({\n                    detail: { reasons, file },\n                }: CustomEvent<{\n                    reasons: { [key: string]: string[] };\n                    file: File;\n                }>) => {\n                    this.sandbox.notify(\n                        file.name,\n                        Object.entries(reasons)\n                            .filter(([k, v]) => k[0] !== \"_\")\n                            .map(([k, v]) =>\n                                Array.isArray(v) ? v.join(\"; \") : v,\n                            )\n                            .join(\"; \"),\n                    );\n                    this.sandbox.notify.el[0].scrollIntoView();\n\n                    this.toggleAnimation(widget, false);\n\n                    widget\n                        .find(\"[data-upload-progress]\")\n                        .removeClass(\"bg-primary bg-secondary\")\n                        .addClass(\"bg-danger progress-bar-danger\");\n                },\n            );\n            info.uploader.addEventListener(\n                \"error\",\n                ({\n                    detail: { message, file },\n                }: CustomEvent<{ message: string; file: File }>) => {\n                    this.sandbox.notify(file.name, message);\n                    this.sandbox.notify.el[0].scrollIntoView();\n\n                    this.toggleAnimation(widget, false);\n                    widget\n                        .find(\"[data-upload-progress]\")\n                        .removeClass(\"bg-primary bg-secondary\")\n                        .addClass(\"bg-danger progress-bar-danger\");\n                },\n            );\n\n            info.uploader.addEventListener(\n                \"progress\",\n                ({ detail: { loaded, total } }: CustomEvent) =>\n                    this.setWidgetCompletion(widget, loaded, total),\n            );\n            info.uploader.addEventListener(\n                \"finish\",\n                ({ detail: { file, result } }: CustomEvent) => {\n                    this.toggleAnimation(widget, false);\n                    widget\n                        .find(\"[data-upload-progress]\")\n                        .removeClass(\"bg-primary bg-secondary\")\n                        .addClass(\"bg-success progress-bar-success\");\n                    this.sandbox.publish(\n                        ckan.CKANEXT_FILES.topics.queueItemUploaded,\n                        file,\n                        result,\n                    );\n                },\n            );\n\n            this.setWidgetName(widget, info.file.name);\n            this.setWidgetCompletion(widget, info.uploaded, info.file.size);\n\n            if (options.immediate) {\n                widget.find(\"[data-upload-resume]\").trigger(\"click\");\n            }\n        },\n\n        setWidgetName(widget: JQuery, name: string) {\n            widget.find(\"[data-item-name]\").text(name);\n        },\n\n        setWidgetCompletion(widget: JQuery, uploaded: number, total: number) {\n            const value = (uploaded * 100) / total;\n            const info = this.widgets.get(widget[0]);\n            info.uploaded = uploaded;\n\n            const completion = value.toFixed(0) + \"%\";\n            widget\n                .find(\"[data-upload-progress]\")\n                .text(completion)\n                .css(\"width\", completion);\n        },\n\n        toggleAnimation(widget: JQuery, state: boolean) {\n            widget\n                .find(\"[data-upload-progress]\")\n                .toggleClass(\"progress-bar-animated active\", state);\n        },\n\n        _onWidgetResume(event: JQuery.TriggeredEvent) {\n            const info = this.widgets.get(event.delegateTarget);\n            if (info.uploaded >= info.total) return;\n\n            const widget = $(event.delegateTarget);\n            widget\n                .find(\"[data-upload-progress]\")\n                .removeClass(\"bg-secondary\")\n                .addClass(\"bg-primary\");\n\n            if (info.id) {\n                info.uploader.resume(info.file, info.id);\n            } else {\n                info.uploader.upload(info.file);\n            }\n\n            this.toggleAnimation(widget, true);\n        },\n\n        _onWidgetPause(event: JQuery.TriggeredEvent) {\n            const info = this.widgets.get(event.delegateTarget);\n            if (info.uploaded >= info.total) return;\n\n            const widget = $(event.delegateTarget);\n            widget\n                .find(\"[data-upload-progress]\")\n                .removeClass(\"bg-primary\")\n                .addClass(\"bg-secondary\");\n\n            info.uploader.pause(info.file);\n            this.toggleAnimation(widget, false);\n        },\n    };\n});\n"]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files--modules.js","sourceRoot":"","sources":["../ts/files--modules.ts"],"names":[],"mappings":"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","sourcesContent":["ckan.module(\"files--resource-select\", function ($) {\n    return {\n        options: {\n            successEvent: \"files-file-created\",\n            errorEvent: \"files-file-failed\",\n            select: null,\n            initialValue: null,\n        },\n\n        initialize() {\n            if (!this.options.select) {\n                console.error(\n                    \"files--resource-select cannot be initialized without `select` option\",\n                );\n                return;\n            }\n\n            $.proxyAll(this, /_on/);\n            this.el.on({\n                [this.options.successEvent]: this._onSuccess,\n                [this.options.errorEvent]: this._onError,\n            });\n\n            this.url = document.getElementById(\"field-resource-url\");\n            this.select = $(this.options.select);\n            if (this.options.initialValue) {\n                this.select.select2(\"data\", this.options.initialValue);\n            }\n        },\n        _onSuccess({ detail }: { detail: any }) {\n            this.select.select2(\"data\", { id: detail.id, text: detail.name });\n        },\n        _onError({\n            detail: err,\n        }: {\n            detail: string | { [key: string]: string[] };\n        }) {\n            if (typeof err === \"string\") {\n                this.reportError(\"Error\", err);\n            } else {\n                for (let [field, problems] of Object.entries(\n                    err as { [key: string]: string[] },\n                )) {\n                    if (field.startsWith(\"__\")) continue;\n                    this.reportError(field, problems.join(\",\"));\n                }\n            }\n        },\n        reportError(label: string, message: string) {\n            const box = this.sandbox.notify.initialize(\n                this.sandbox.notify.create(label, message),\n            );\n            this.el.closest(\"label\").parent().after(box);\n        },\n    };\n});\n/**\n * Upload file and trigger event with file data on specified element.\n *\n */\nckan.module(\"files--auto-upload\", function ($) {\n    return {\n        options: {\n            spinner: null,\n            action: null,\n            successEvent: \"files-file-created\",\n            errorEvent: \"files-file-failed\",\n            eventTarget: null,\n            copyIdInto: null,\n        },\n        queue: null,\n\n        initialize() {\n            if (!this.options.action) {\n                console.error(\n                    \"files--auto-upload cannot be initialized without `action` option\",\n                );\n                return;\n            }\n            $.proxyAll(this, /_on/);\n\n            this.queue = new Set();\n\n            this.el.on(\"change\", (event: Event) =>\n                this.upload(...(event.target as HTMLInputElement).files!),\n            );\n            this.spinner = $(this.options.spinner);\n            this.field = $(this.options.field);\n            this.submits = this.el\n                .closest(\"form\")\n                .find(\"input[type=submit],button[type=submit]\");\n            this.idTarget = $(this.options.copyIdInto);\n        },\n\n        upload(...files: File[]) {\n            files.forEach(async (file) => {\n                this.queue.add(file);\n                this.refreshFormState();\n                const options: ckan.CKANEXT_FILES.UploadOptions = {\n                    uploaderArgs: [{ uploadAction: this.options.action }],\n                };\n\n                this.sandbox.files\n                    .upload(file, options)\n                    .then(\n                        (result: any) => {\n                            this.idTarget.val(result.id);\n                            this.dispatchResult(\n                                this.options.successEvent,\n                                result,\n                            );\n                        },\n                        (err: any) =>\n                            this.dispatchResult(this.options.errorEvent, err),\n                    )\n                    .then(() => {\n                        this.queue.delete(file);\n                        this.refreshFormState();\n                    });\n            });\n        },\n\n        dispatchResult(event: string, detail: any) {\n            const target = this.options.eventTarget\n                ? $(this.options.eventTarget)\n                : this.el;\n            target[0].dispatchEvent(new CustomEvent(event, { detail }));\n        },\n\n        refreshFormState() {\n            this.spinner.prop(\"hidden\", !this.queue.size);\n            this.submits.prop(\"disabled\", !!this.queue.size);\n        },\n    };\n});\n\n/**\n * Add selected file to upload queue whenever `[data-queue-scheduler]`\n * dispatches `change` event.\n *\n */\nckan.module(\"files--scheduler\", function ($) {\n    return {\n        options: {\n            immediate: false,\n        },\n        initialize() {\n            const scheduler = this.$(\"[data-queue-scheduler]\");\n            scheduler.on(\"drop\", (event: Event) => event.preventDefault());\n            scheduler.on(\"change\", (event: Event) =>\n                this.push(...(event.target as HTMLInputElement).files!),\n            );\n        },\n\n        push(...files: File[]) {\n            files.forEach((file) =>\n                this.sandbox.publish(\n                    ckan.CKANEXT_FILES.topics.addFileToQueue,\n                    file,\n                    { immediate: this.options.immediate },\n                ),\n            );\n        },\n    };\n});\n\n/**\n * Add file/directories to upload queue via drag'n'drop.\n *\n */\nckan.module(\"files--dropzone\", function ($) {\n    return {\n        options: {\n            immediate: false,\n        },\n\n        initialize() {\n            $.proxyAll(this, /_on/);\n            const element = this.el[0];\n\n            element.addEventListener(\"dragover\", this._onDragOver);\n            element.addEventListener(\"dragenter\", this._onDragEnter);\n            element.addEventListener(\"dragleave\", this._onDragLeave);\n            element.addEventListener(\"drop\", this._onDrop);\n        },\n\n        _onDragOver(event: DragEvent) {\n            event.preventDefault();\n        },\n        _onDragEnter(event: DragEvent) {},\n        _onDragLeave(event: DragEvent) {},\n\n        _onDrop(event: DragEvent) {\n            event.preventDefault();\n            if (!event.dataTransfer) {\n                return;\n            }\n\n            for (let entry of event.dataTransfer.items) {\n                this.scanEntry(entry.webkitGetAsEntry(), (file: File) =>\n                    this.push(file),\n                );\n            }\n        },\n\n        scanEntry(\n            entry: FileSystemFileEntry | FileSystemDirectoryEntry,\n            cb: (file: File) => void,\n        ) {\n            if (entry.isFile) {\n                (entry as FileSystemFileEntry).file(cb);\n            } else {\n                (entry as FileSystemDirectoryEntry)\n                    .createReader()\n                    .readEntries((entries) =>\n                        entries.forEach((e) => this.scanEntry(e, cb)),\n                    );\n            }\n        },\n\n        push(file: File) {\n            this.sandbox.publish(\n                ckan.CKANEXT_FILES.topics.addFileToQueue,\n                file,\n                { immediate: this.options.immediate },\n            );\n        },\n    };\n});\n\n/**\n * Add to queue a file, that has associated incomplete upload.\n *\n * Supports a number of properties to verify that the new file matches\n * previously uploaded file.\n *\n *\n */\nckan.module(\"files--restorer\", function ($) {\n    return {\n        options: {\n            name: \"\",\n            size: 0,\n            uploaded: 0,\n            id: \"\",\n            immediate: false,\n        },\n\n        initialize() {\n            $.proxyAll(this, /_on/);\n            this.el.on(\"change\", this._onChange);\n        },\n\n        _onChange(event: Event) {\n            const file = (event.target as HTMLInputElement).files?.[0];\n\n            if (!file) {\n                return;\n            }\n\n            if (this.options.name && file.name !== this.options.name) {\n                this.sandbox.notify(\n                    \"Name mismatch.\",\n                    `Expected name: ${this.options.name}`,\n                );\n                this.sandbox.notify.el[0].scrollIntoView();\n                return;\n            }\n\n            if (this.options.size && file.size !== this.options.size) {\n                this.sandbox.notify(\n                    \"Size mismatch.\",\n                    `Expected size: ${this.options.size.toLocaleString()} bytes`,\n                );\n                this.sandbox.notify.el[0].scrollIntoView();\n                return;\n            }\n\n            this.sandbox.publish(\n                ckan.CKANEXT_FILES.topics.restoreFileInQueue,\n                file,\n                {\n                    id: this.options.id,\n                    uploaded: this.options.uploaded,\n                    immediate: this.options.immediate,\n                },\n            );\n        },\n    };\n});\n\nckan.module(\"files--shared-queue\", function ($) {\n    return {\n        initialize() {\n            $.proxyAll(this, /_on/);\n\n            this.worker = new SharedWorker(\n                this.sandbox.url(\n                    \"ckanext-files/scripts/files--shared-uploader.js\",\n                ),\n            );\n\n            this.worker.port.onmessage = console.debug;\n        },\n    };\n});\n\nckan.module(\"files--queue\", function ($) {\n    return {\n        options: {\n            storage: \"default\",\n            uploader: \"Standard\",\n        },\n\n        initialize() {\n            $.proxyAll(this, /_on/);\n            ckan.pubsub.subscribe(\n                ckan.CKANEXT_FILES.topics.addFileToQueue,\n                this._onFile,\n            );\n            ckan.pubsub.subscribe(\n                ckan.CKANEXT_FILES.topics.restoreFileInQueue,\n                this._onFile,\n            );\n\n            this.tpl = this.$(\"[data-upload-template]\")\n                .remove()\n                .removeAttr(\"data-upload-template hidden\");\n\n            this.widgets = new WeakMap();\n        },\n\n        teardown() {\n            ckan.pubsub.unsubscribe(\n                ckan.CKANEXT_FILES.topics.addFileToQueue,\n                this._onFile,\n            );\n            ckan.pubsub.unsubscribe(\n                ckan.CKANEXT_FILES.topics.restoreFileInQueue,\n                this._onFile,\n            );\n        },\n\n        _onFile(\n            file: File,\n            options = {\n                immediate: false,\n                id: \"\",\n                uploaded: 0,\n                uploaderInstance: null,\n                uploader: null,\n                storage: null,\n            },\n        ) {\n            const widget = this.tpl.clone(true).appendTo(this.el);\n            const info = {\n                file,\n                id: options.id,\n                uploaded: options.uploaded || 0,\n                uploader:\n                    options.uploaderInstance ||\n                    this.sandbox.files.makeUploader(\n                        options.uploader || this.options.uploader,\n                        { storage: options.storage || this.options.storage },\n                    ),\n            };\n\n            this.widgets.set(widget[0], info);\n\n            widget.on(\"click\", \"[data-upload-resume]\", this._onWidgetResume);\n            widget.on(\"click\", \"[data-upload-pause]\", this._onWidgetPause);\n\n            info.uploader.addEventListener(\n                \"fail\",\n                ({\n                    detail: { reasons, file },\n                }: CustomEvent<{\n                    reasons: { [key: string]: string[] };\n                    file: File;\n                }>) => {\n                    this.sandbox.notify(\n                        file.name,\n                        Object.entries(reasons)\n                            .filter(([k, v]) => k[0] !== \"_\")\n                            .map(([k, v]) =>\n                                Array.isArray(v) ? v.join(\"; \") : v,\n                            )\n                            .join(\"; \"),\n                    );\n                    this.sandbox.notify.el[0].scrollIntoView();\n\n                    this.toggleAnimation(widget, false);\n\n                    widget\n                        .find(\"[data-upload-progress]\")\n                        .removeClass(\"bg-primary bg-secondary\")\n                        .addClass(\"bg-danger progress-bar-danger\");\n                },\n            );\n            info.uploader.addEventListener(\n                \"error\",\n                ({\n                    detail: { message, file },\n                }: CustomEvent<{ message: string; file: File }>) => {\n                    this.sandbox.notify(file.name, message);\n                    this.sandbox.notify.el[0].scrollIntoView();\n\n                    this.toggleAnimation(widget, false);\n                    widget\n                        .find(\"[data-upload-progress]\")\n                        .removeClass(\"bg-primary bg-secondary\")\n                        .addClass(\"bg-danger progress-bar-danger\");\n                },\n            );\n\n            info.uploader.addEventListener(\n                \"progress\",\n                ({ detail: { loaded, total } }: CustomEvent) =>\n                    this.setWidgetCompletion(widget, loaded, total),\n            );\n            info.uploader.addEventListener(\n                \"finish\",\n                ({ detail: { file, result } }: CustomEvent) => {\n                    this.toggleAnimation(widget, false);\n                    widget\n                        .find(\"[data-upload-progress]\")\n                        .removeClass(\"bg-primary bg-secondary\")\n                        .addClass(\"bg-success progress-bar-success\");\n                    this.sandbox.publish(\n                        ckan.CKANEXT_FILES.topics.queueItemUploaded,\n                        file,\n                        result,\n                    );\n                },\n            );\n\n            this.setWidgetName(widget, info.file.name);\n            this.setWidgetCompletion(widget, info.uploaded, info.file.size);\n\n            if (options.immediate) {\n                widget.find(\"[data-upload-resume]\").trigger(\"click\");\n            }\n        },\n\n        setWidgetName(widget: JQuery, name: string) {\n            widget.find(\"[data-item-name]\").text(name);\n        },\n\n        setWidgetCompletion(widget: JQuery, uploaded: number, total: number) {\n            const value = (uploaded * 100) / total;\n            const info = this.widgets.get(widget[0]);\n            info.uploaded = uploaded;\n\n            const completion = value.toFixed(0) + \"%\";\n            widget\n                .find(\"[data-upload-progress]\")\n                .text(completion)\n                .css(\"width\", completion);\n        },\n\n        toggleAnimation(widget: JQuery, state: boolean) {\n            widget\n                .find(\"[data-upload-progress]\")\n                .toggleClass(\"progress-bar-animated active\", state);\n        },\n\n        _onWidgetResume(event: JQuery.TriggeredEvent) {\n            const info = this.widgets.get(event.delegateTarget);\n            if (info.uploaded >= info.total) return;\n\n            const widget = $(event.delegateTarget);\n            widget\n                .find(\"[data-upload-progress]\")\n                .removeClass(\"bg-secondary\")\n                .addClass(\"bg-primary\");\n\n            if (info.id) {\n                info.uploader.resume(info.file, info.id);\n            } else {\n                info.uploader.upload(info.file);\n            }\n\n            this.toggleAnimation(widget, true);\n        },\n\n        _onWidgetPause(event: JQuery.TriggeredEvent) {\n            const info = this.widgets.get(event.delegateTarget);\n            if (info.uploaded >= info.total) return;\n\n            const widget = $(event.delegateTarget);\n            widget\n                .find(\"[data-upload-progress]\")\n                .removeClass(\"bg-primary\")\n                .addClass(\"bg-secondary\");\n\n            info.uploader.pause(info.file);\n            this.toggleAnimation(widget, false);\n        },\n    };\n});\n"]}
\ No newline at end of file
diff --git a/ckanext/files/assets/scripts/files--shared.js b/ckanext/files/assets/scripts/files--shared.js
index 7b7d43a..a445ce2 100644
--- a/ckanext/files/assets/scripts/files--shared.js
+++ b/ckanext/files/assets/scripts/files--shared.js
@@ -10,9 +10,9 @@ var ckan;
         CKANEXT_FILES.defaultSettings = {
             storage: "default",
         };
-        function upload(file, options) {
+        function upload(file, options = {}) {
             const uploader = options.uploader ||
-                makeUploader(options.adapter || "Standard", ...(options.uploaderParams || []));
+                makeUploader(options.adapter || "Standard", ...(options.uploaderArgs || []));
             return uploader.upload(file, options.requestParams || {});
         }
         function makeUploader(adapter, ...options) {
@@ -51,9 +51,6 @@ var ckan;
                 dispatchStart(file) {
                     this.dispatchEvent(new CustomEvent("start", { detail: { file } }));
                 }
-                dispatchCommit(file, id) {
-                    this.dispatchEvent(new CustomEvent("commit", { detail: { file, id } }));
-                }
                 dispatchProgress(file, loaded, total) {
                     this.dispatchEvent(new CustomEvent("progress", {
                         detail: { file, loaded, total },
@@ -90,7 +87,6 @@ var ckan;
                                 fail(result);
                             }
                             else if (result.success) {
-                                this.dispatchCommit(file, result.result.id);
                                 this.dispatchFinish(file, result.result);
                                 done(result.result);
                             }
@@ -141,7 +137,7 @@ var ckan;
                     this._active.add(file);
                     let info;
                     try {
-                        info = await this._initializeUpload(file);
+                        info = await this._initializeUpload(file, params);
                     }
                     catch (err) {
                         if (typeof err === "string") {
@@ -152,7 +148,6 @@ var ckan;
                         }
                         return;
                     }
-                    this.dispatchCommit(file, info.id);
                     this.dispatchStart(file);
                     this._doUpload(file, info);
                 }
@@ -199,13 +194,13 @@ var ckan;
                     }
                     this.dispatchFinish(file, info);
                 }
-                _initializeUpload(file) {
+                _initializeUpload(file, params) {
                     return new Promise((done, fail) => this.sandbox.client.call("POST", this.initializeAction, Object.assign({}, {
                         storage: this.settings.storage,
                         name: file.name,
                         size: file.size,
                         content_type: file.type,
-                    }, this.settings.initializePayload || {}), (data) => {
+                    }, params), (data) => {
                         done(data.result);
                     }, (resp) => {
                         fail(typeof resp.responseJSON === "string"
@@ -270,4 +265,4 @@ var ckan;
         })(adapters = CKANEXT_FILES.adapters || (CKANEXT_FILES.adapters = {}));
     })(CKANEXT_FILES = ckan.CKANEXT_FILES || (ckan.CKANEXT_FILES = {}));
 })(ckan || (ckan = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files--shared.js","sourceRoot":"","sources":["../ts/files--shared.ts"],"names":[],"mappings":"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","sourcesContent":["namespace ckan {\n    export var sandbox: any;\n    export var pubsub: any;\n    export var module: (name: string, initializer: ($: any) => any) => any;\n    export namespace CKANEXT_FILES {\n        export type UploaderSettings = {\n            storage: string;\n            [key: string]: any;\n        };\n\n        export interface UploadOptions {\n            uploader?: adapters.Base;\n            adapter?: string;\n            uploaderParams?: any[];\n            requestParams?: { [key: string]: any };\n        }\n\n        export const topics = {\n            addFileToQueue: \"ckanext:files:queue:file:add\",\n            restoreFileInQueue: \"ckanext:files:queue:file:restore\",\n            queueItemUploaded: \"ckanext:files:queue:file:uploaded\",\n        };\n\n        export const defaultSettings = {\n            storage: \"default\",\n        };\n\n        function upload(file: File, options: UploadOptions) {\n            const uploader =\n                options.uploader ||\n                makeUploader(\n                    options.adapter || \"Standard\",\n                    ...(options.uploaderParams || []),\n                );\n            return uploader.upload(file, options.requestParams || {});\n        }\n\n        function makeUploader(adapter: string, ...options: any) {\n            const factory = (<{ [key: string]: typeof adapters.Base }>adapters)[\n                adapter\n            ];\n            if (!factory) {\n                throw new Error(`Uploader ${adapter} is not registered`);\n            }\n            return new factory(...options);\n        }\n\n        ckan.sandbox.extend({ files: { upload, makeUploader } });\n\n        export namespace adapters {\n            export type StorageData = { [key: string]: any };\n\n            export type UploadInfo = {\n                id: string;\n                storage_data: StorageData;\n                location: string;\n                hash: string;\n                content_type: string;\n                size: number;\n            };\n\n            export class Base extends EventTarget {\n                static defaultSettings: Object = {};\n                protected settings: UploaderSettings;\n                protected sandbox: any;\n                protected csrfToken: string;\n\n                constructor(settings = {}) {\n                    super();\n                    this.settings = {\n                        ...defaultSettings,\n                        ...(this.constructor as typeof Base).defaultSettings,\n                        ...settings,\n                    };\n                    this.sandbox = ckan.sandbox();\n\n                    const csrfField =\n                        document\n                            .querySelector(\"meta[name=csrf_field_name]\")\n                            ?.getAttribute(\"content\") ?? \"_csrf_token\";\n                    this.csrfToken =\n                        document\n                            .querySelector(`meta[name=${csrfField}]`)\n                            ?.getAttribute(\"content\") || \"\";\n                }\n\n                upload(file: File, params: { [key: string]: any }) {\n                    throw new Error(\"Base.upload is not implemented\");\n                }\n\n                resume(file: File, id: string) {\n                    throw new Error(\"Base.resume is not implemented\");\n                }\n\n                dispatchStart(file: File) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"start\", { detail: { file } }),\n                    );\n                }\n                dispatchCommit(file: File, id: string) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"commit\", { detail: { file, id } }),\n                    );\n                }\n                dispatchProgress(file: File, loaded: number, total: number) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"progress\", {\n                            detail: { file, loaded, total },\n                        }),\n                    );\n                }\n                dispatchFinish(file: File, result: Object) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"finish\", { detail: { file, result } }),\n                    );\n                }\n                dispatchFail(file: File, reasons: { [key: string]: string[] }) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"fail\", { detail: { file, reasons } }),\n                    );\n                }\n                dispatchError(file: File, message: string) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"error\", { detail: { file, message } }),\n                    );\n                }\n            }\n\n            export class Standard extends Base {\n                static defaultSettings = {\n                    uploadAction: \"files_file_create\",\n                };\n\n                upload(file: File, params: { [key: string]: any }) {\n                    const request = new XMLHttpRequest();\n                    const promise = this._addListeners(request, file);\n                    this._prepareRequest(request, file);\n                    this._sendRequest(request, file, params);\n                    return promise;\n                }\n\n                _addListeners(\n                    request: XMLHttpRequest,\n                    file: File,\n                ): Promise<UploadInfo> {\n                    request.upload.addEventListener(\"loadstart\", (event) =>\n                        this.dispatchStart(file),\n                    );\n\n                    request.upload.addEventListener(\"progress\", (event) =>\n                        this.dispatchProgress(file, event.loaded, event.total),\n                    );\n\n                    return new Promise((done, fail) => {\n                        request.addEventListener(\"load\", (event) => {\n                            const result = JSON.parse(request.responseText);\n                            if (typeof result === \"string\") {\n                                this.dispatchError(file, result);\n                                fail(result);\n                            } else if (result.success) {\n                                this.dispatchCommit(file, result.result.id);\n                                this.dispatchFinish(file, result.result);\n                                done(result.result);\n                            } else {\n                                this.dispatchFail(file, result.error);\n\n                                fail(result.error);\n                            }\n                        });\n\n                        request.addEventListener(\"error\", (event) => {\n                            this.dispatchError(file, request.responseText);\n                            fail(request.responseText);\n                        });\n                    });\n                }\n\n                _prepareRequest(request: XMLHttpRequest, file: File) {\n                    request.open(\n                        \"POST\",\n                        this.sandbox.client.url(\n                            `/api/action/${this.settings.uploadAction}`,\n                        ),\n                    );\n\n                    if (this.csrfToken) {\n                        request.setRequestHeader(\"X-CSRFToken\", this.csrfToken);\n                    }\n                }\n\n                _sendRequest(\n                    request: XMLHttpRequest,\n                    file: File,\n                    params: { [key: string]: any },\n                ) {\n                    const data = new FormData();\n                    data.append(\"upload\", file);\n                    if (!params.storage) {\n                        data.append(\"storage\", this.settings.storage);\n                    }\n                    for (let [field, value] of Object.entries(params)) {\n                        data.append(field, value);\n                    }\n                    request.send(data);\n                }\n            }\n\n            export class Multipart extends Base {\n                static defaultSettings = { chunkSize: 1024 * 1024 * 5 };\n                protected initializeAction = \"files_multipart_start\";\n\n                private _active = new Set<File>();\n\n                constructor(settings: Object) {\n                    super(settings);\n                }\n\n                async upload(file: File, params: { [key: string]: any }) {\n                    if (this._active.has(file)) {\n                        console.warn(\"File upload in progress\");\n                        return;\n                    }\n                    this._active.add(file);\n\n                    let info;\n\n                    try {\n                        info = await this._initializeUpload(file);\n                    } catch (err) {\n                        if (typeof err === \"string\") {\n                            this.dispatchError(file, err);\n                        } else {\n                            this.dispatchFail(file, err as any);\n                        }\n                        return;\n                    }\n\n                    this.dispatchCommit(file, info.id);\n                    this.dispatchStart(file);\n\n                    this._doUpload(file, info);\n                }\n\n                async resume(file: File, id: string) {\n                    if (this._active.has(file)) {\n                        console.warn(\"File upload in progress\");\n                        return;\n                    }\n                    this._active.add(file);\n\n                    let info = await this._showUpload(id);\n                    this.dispatchStart(file);\n\n                    this._doUpload(file, info);\n                }\n\n                pause(file: File) {\n                    this._active.delete(file);\n                }\n\n                async _doUpload(file: File, info: UploadInfo) {\n                    let start = info.storage_data[\"uploaded\"] || 0;\n\n                    while (start < file.size) {\n                        if (!this._active.has(file)) {\n                            console.info(\"File upload is paused\");\n                            return;\n                        }\n\n                        info = await this._uploadChunk(\n                            info,\n                            file.slice(start, start + this.settings.chunkSize),\n                            start,\n                        );\n\n                        const uploaded = info.storage_data.uploaded;\n                        if (uploaded <= start) {\n                            throw new Error(\"Uploaded size is reduced\");\n                        }\n\n                        this.dispatchProgress(file, uploaded, file.size);\n                        start = uploaded;\n                    }\n\n                    this.dispatchProgress(file, file.size, file.size);\n                    try {\n                        info = await this._completeUpload(info);\n                    } catch (err) {\n                        if (typeof err === \"string\") {\n                            this.dispatchError(file, err);\n                        } else {\n                            this.dispatchFail(file, err as any);\n                        }\n\n                        return;\n                    }\n                    this.dispatchFinish(file, info);\n                }\n\n                _initializeUpload(file: File): Promise<UploadInfo> {\n                    return new Promise((done, fail) =>\n                        this.sandbox.client.call(\n                            \"POST\",\n                            this.initializeAction,\n                            Object.assign(\n                                {},\n                                {\n                                    storage: this.settings.storage,\n                                    name: file.name,\n                                    size: file.size,\n                                    content_type: file.type,\n                                },\n                                this.settings.initializePayload || {},\n                            ),\n                            (data: any) => {\n                                done(data.result);\n                            },\n                            (resp: any) => {\n                                fail(\n                                    typeof resp.responseJSON === \"string\"\n                                        ? resp.responseText\n                                        : resp.responseJSON.error,\n                                );\n                            },\n                        ),\n                    );\n                }\n\n                _showUpload(id: string): Promise<UploadInfo> {\n                    return new Promise((done, fail) =>\n                        this.sandbox.client.call(\n                            \"GET\",\n                            \"files_multipart_refresh\",\n                            `?id=${id}`,\n                            (data: any) => {\n                                done(data.result);\n                            },\n                            (resp: any) => {\n                                fail(\n                                    typeof resp.responseJSON === \"string\"\n                                        ? resp.responseText\n                                        : resp.responseJSON.error,\n                                );\n                            },\n                        ),\n                    );\n                }\n\n                _uploadChunk(\n                    info: UploadInfo,\n                    part: Blob,\n                    start: number,\n                ): Promise<UploadInfo> {\n                    if (!part.size) {\n                        throw new Error(\"0-length chunks are not allowed\");\n                    }\n                    const request = new XMLHttpRequest();\n\n                    const result = new Promise<UploadInfo>((done, fail) => {\n                        request.addEventListener(\"load\", (event) => {\n                            const result = JSON.parse(request.responseText);\n                            if (result.success) {\n                                done(result.result);\n                            } else {\n                                fail(result.error);\n                            }\n                        });\n\n                        request.addEventListener(\"error\", (event) =>\n                            fail(request.responseText),\n                        );\n                    });\n\n                    request.open(\n                        \"POST\",\n                        this.sandbox.client.url(\n                            \"/api/action/files_multipart_update\",\n                        ),\n                    );\n\n                    if (this.csrfToken) {\n                        request.setRequestHeader(\"X-CSRFToken\", this.csrfToken);\n                    }\n\n                    this._sendRequest(request, part, start, info.id);\n\n                    return result;\n                }\n\n                _sendRequest(\n                    request: XMLHttpRequest,\n                    part: Blob,\n                    position: number,\n                    id: string,\n                ) {\n                    const form = new FormData();\n                    form.append(\"upload\", part);\n                    form.append(\"position\", String(position));\n                    form.append(\"id\", id);\n                    request.send(form);\n                }\n\n                _completeUpload(info: UploadInfo): Promise<UploadInfo> {\n                    return new Promise((done, fail) =>\n                        this.sandbox.client.call(\n                            \"POST\",\n                            \"files_multipart_complete\",\n                            Object.assign(\n                                {},\n                                this.settings.completePayload || {},\n                                {\n                                    id: info.id,\n                                },\n                            ),\n                            (data: any) => {\n                                done(data.result);\n                            },\n                            (resp: any) => {\n                                fail(\n                                    typeof resp.responseJSON === \"string\"\n                                        ? resp.responseText\n                                        : resp.responseJSON.error,\n                                );\n                            },\n                        ),\n                    );\n                }\n            }\n        }\n    }\n}\n"]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"files--shared.js","sourceRoot":"","sources":["../ts/files--shared.ts"],"names":[],"mappings":"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","sourcesContent":["namespace ckan {\n    export var sandbox: any;\n    export var pubsub: any;\n    export var module: (name: string, initializer: ($: any) => any) => any;\n    export namespace CKANEXT_FILES {\n        export type UploaderSettings = {\n            storage: string;\n            [key: string]: any;\n        };\n\n        export interface UploadOptions {\n            uploader?: adapters.Base;\n            adapter?: string;\n            uploaderArgs?: any[];\n            requestParams?: { [key: string]: any };\n        }\n\n        export const topics = {\n            addFileToQueue: \"ckanext:files:queue:file:add\",\n            restoreFileInQueue: \"ckanext:files:queue:file:restore\",\n            queueItemUploaded: \"ckanext:files:queue:file:uploaded\",\n        };\n\n        export const defaultSettings = {\n            storage: \"default\",\n        };\n\n        function upload(file: File, options: UploadOptions = {}) {\n            const uploader =\n                options.uploader ||\n                makeUploader(\n                    options.adapter || \"Standard\",\n                    ...(options.uploaderArgs || []),\n                );\n            return uploader.upload(file, options.requestParams || {});\n        }\n\n        function makeUploader(adapter: string, ...options: any) {\n            const factory = (<{ [key: string]: typeof adapters.Base }>adapters)[\n                adapter\n            ];\n            if (!factory) {\n                throw new Error(`Uploader ${adapter} is not registered`);\n            }\n            return new factory(...options);\n        }\n\n        ckan.sandbox.extend({ files: { upload, makeUploader } });\n\n        export namespace adapters {\n            export type StorageData = { [key: string]: any };\n\n            export type UploadInfo = {\n                id: string;\n                storage_data: StorageData;\n                location: string;\n                hash: string;\n                content_type: string;\n                size: number;\n            };\n\n            export class Base extends EventTarget {\n                static defaultSettings: Object = {};\n                protected settings: UploaderSettings;\n                protected sandbox: any;\n                protected csrfToken: string;\n\n                constructor(settings = {}) {\n                    super();\n                    this.settings = {\n                        ...defaultSettings,\n                        ...(this.constructor as typeof Base).defaultSettings,\n                        ...settings,\n                    };\n                    this.sandbox = ckan.sandbox();\n\n                    const csrfField =\n                        document\n                            .querySelector(\"meta[name=csrf_field_name]\")\n                            ?.getAttribute(\"content\") ?? \"_csrf_token\";\n                    this.csrfToken =\n                        document\n                            .querySelector(`meta[name=${csrfField}]`)\n                            ?.getAttribute(\"content\") || \"\";\n                }\n\n                upload(file: File, params: { [key: string]: any }) {\n                    throw new Error(\"Base.upload is not implemented\");\n                }\n\n                resume(file: File, id: string) {\n                    throw new Error(\"Base.resume is not implemented\");\n                }\n\n                dispatchStart(file: File) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"start\", { detail: { file } }),\n                    );\n                }\n                dispatchProgress(file: File, loaded: number, total: number) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"progress\", {\n                            detail: { file, loaded, total },\n                        }),\n                    );\n                }\n                dispatchFinish(file: File, result: Object) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"finish\", { detail: { file, result } }),\n                    );\n                }\n                dispatchFail(file: File, reasons: { [key: string]: string[] }) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"fail\", { detail: { file, reasons } }),\n                    );\n                }\n                dispatchError(file: File, message: string) {\n                    this.dispatchEvent(\n                        new CustomEvent(\"error\", { detail: { file, message } }),\n                    );\n                }\n            }\n\n            export class Standard extends Base {\n                static defaultSettings = {\n                    uploadAction: \"files_file_create\",\n                };\n\n                upload(file: File, params: { [key: string]: any }) {\n                    const request = new XMLHttpRequest();\n                    const promise = this._addListeners(request, file);\n                    this._prepareRequest(request, file);\n                    this._sendRequest(request, file, params);\n                    return promise;\n                }\n\n                _addListeners(\n                    request: XMLHttpRequest,\n                    file: File,\n                ): Promise<UploadInfo> {\n                    request.upload.addEventListener(\"loadstart\", (event) =>\n                        this.dispatchStart(file),\n                    );\n\n                    request.upload.addEventListener(\"progress\", (event) =>\n                        this.dispatchProgress(file, event.loaded, event.total),\n                    );\n\n                    return new Promise((done, fail) => {\n                        request.addEventListener(\"load\", (event) => {\n                            const result = JSON.parse(request.responseText);\n                            if (typeof result === \"string\") {\n                                this.dispatchError(file, result);\n                                fail(result);\n                            } else if (result.success) {\n                                this.dispatchFinish(file, result.result);\n                                done(result.result);\n                            } else {\n                                this.dispatchFail(file, result.error);\n\n                                fail(result.error);\n                            }\n                        });\n\n                        request.addEventListener(\"error\", (event) => {\n                            this.dispatchError(file, request.responseText);\n                            fail(request.responseText);\n                        });\n                    });\n                }\n\n                _prepareRequest(request: XMLHttpRequest, file: File) {\n                    request.open(\n                        \"POST\",\n                        this.sandbox.client.url(\n                            `/api/action/${this.settings.uploadAction}`,\n                        ),\n                    );\n\n                    if (this.csrfToken) {\n                        request.setRequestHeader(\"X-CSRFToken\", this.csrfToken);\n                    }\n                }\n\n                _sendRequest(\n                    request: XMLHttpRequest,\n                    file: File,\n                    params: { [key: string]: any },\n                ) {\n                    const data = new FormData();\n                    data.append(\"upload\", file);\n                    if (!params.storage) {\n                        data.append(\"storage\", this.settings.storage);\n                    }\n                    for (let [field, value] of Object.entries(params)) {\n                        data.append(field, value);\n                    }\n                    request.send(data);\n                }\n            }\n\n            export class Multipart extends Base {\n                static defaultSettings = { chunkSize: 1024 * 1024 * 5 };\n                protected initializeAction = \"files_multipart_start\";\n\n                private _active = new Set<File>();\n\n                constructor(settings: Object) {\n                    super(settings);\n                }\n\n                async upload(file: File, params: { [key: string]: any }) {\n                    if (this._active.has(file)) {\n                        console.warn(\"File upload in progress\");\n                        return;\n                    }\n                    this._active.add(file);\n\n                    let info;\n\n                    try {\n                        info = await this._initializeUpload(file, params);\n                    } catch (err) {\n                        if (typeof err === \"string\") {\n                            this.dispatchError(file, err);\n                        } else {\n                            this.dispatchFail(file, err as any);\n                        }\n                        return;\n                    }\n\n                    this.dispatchStart(file);\n\n                    this._doUpload(file, info);\n                }\n\n                async resume(file: File, id: string) {\n                    if (this._active.has(file)) {\n                        console.warn(\"File upload in progress\");\n                        return;\n                    }\n                    this._active.add(file);\n\n                    let info = await this._showUpload(id);\n                    this.dispatchStart(file);\n\n                    this._doUpload(file, info);\n                }\n\n                pause(file: File) {\n                    this._active.delete(file);\n                }\n\n                async _doUpload(file: File, info: UploadInfo) {\n                    let start = info.storage_data[\"uploaded\"] || 0;\n\n                    while (start < file.size) {\n                        if (!this._active.has(file)) {\n                            console.info(\"File upload is paused\");\n                            return;\n                        }\n\n                        info = await this._uploadChunk(\n                            info,\n                            file.slice(start, start + this.settings.chunkSize),\n                            start,\n                        );\n\n                        const uploaded = info.storage_data.uploaded;\n                        if (uploaded <= start) {\n                            throw new Error(\"Uploaded size is reduced\");\n                        }\n\n                        this.dispatchProgress(file, uploaded, file.size);\n                        start = uploaded;\n                    }\n\n                    this.dispatchProgress(file, file.size, file.size);\n                    try {\n                        info = await this._completeUpload(info);\n                    } catch (err) {\n                        if (typeof err === \"string\") {\n                            this.dispatchError(file, err);\n                        } else {\n                            this.dispatchFail(file, err as any);\n                        }\n\n                        return;\n                    }\n                    this.dispatchFinish(file, info);\n                }\n\n                _initializeUpload(file: File, params: {[key: string]: any}): Promise<UploadInfo> {\n                    return new Promise((done, fail) =>\n                        this.sandbox.client.call(\n                            \"POST\",\n                            this.initializeAction,\n                            Object.assign(\n                                {},\n                                {\n                                    storage: this.settings.storage,\n                                    name: file.name,\n                                    size: file.size,\n                                    content_type: file.type,\n                                },\n                                params,\n                            ),\n                            (data: any) => {\n                                done(data.result);\n                            },\n                            (resp: any) => {\n                                fail(\n                                    typeof resp.responseJSON === \"string\"\n                                        ? resp.responseText\n                                        : resp.responseJSON.error,\n                                );\n                            },\n                        ),\n                    );\n                }\n\n                _showUpload(id: string): Promise<UploadInfo> {\n                    return new Promise((done, fail) =>\n                        this.sandbox.client.call(\n                            \"GET\",\n                            \"files_multipart_refresh\",\n                            `?id=${id}`,\n                            (data: any) => {\n                                done(data.result);\n                            },\n                            (resp: any) => {\n                                fail(\n                                    typeof resp.responseJSON === \"string\"\n                                        ? resp.responseText\n                                        : resp.responseJSON.error,\n                                );\n                            },\n                        ),\n                    );\n                }\n\n                _uploadChunk(\n                    info: UploadInfo,\n                    part: Blob,\n                    start: number,\n                ): Promise<UploadInfo> {\n                    if (!part.size) {\n                        throw new Error(\"0-length chunks are not allowed\");\n                    }\n                    const request = new XMLHttpRequest();\n\n                    const result = new Promise<UploadInfo>((done, fail) => {\n                        request.addEventListener(\"load\", (event) => {\n                            const result = JSON.parse(request.responseText);\n                            if (result.success) {\n                                done(result.result);\n                            } else {\n                                fail(result.error);\n                            }\n                        });\n\n                        request.addEventListener(\"error\", (event) =>\n                            fail(request.responseText),\n                        );\n                    });\n\n                    request.open(\n                        \"POST\",\n                        this.sandbox.client.url(\n                            \"/api/action/files_multipart_update\",\n                        ),\n                    );\n\n                    if (this.csrfToken) {\n                        request.setRequestHeader(\"X-CSRFToken\", this.csrfToken);\n                    }\n\n                    this._sendRequest(request, part, start, info.id);\n\n                    return result;\n                }\n\n                _sendRequest(\n                    request: XMLHttpRequest,\n                    part: Blob,\n                    position: number,\n                    id: string,\n                ) {\n                    const form = new FormData();\n                    form.append(\"upload\", part);\n                    form.append(\"position\", String(position));\n                    form.append(\"id\", id);\n                    request.send(form);\n                }\n\n                _completeUpload(info: UploadInfo): Promise<UploadInfo> {\n                    return new Promise((done, fail) =>\n                        this.sandbox.client.call(\n                            \"POST\",\n                            \"files_multipart_complete\",\n                            Object.assign(\n                                {},\n                                this.settings.completePayload || {},\n                                {\n                                    id: info.id,\n                                },\n                            ),\n                            (data: any) => {\n                                done(data.result);\n                            },\n                            (resp: any) => {\n                                fail(\n                                    typeof resp.responseJSON === \"string\"\n                                        ? resp.responseText\n                                        : resp.responseJSON.error,\n                                );\n                            },\n                        ),\n                    );\n                }\n            }\n        }\n    }\n}\n"]}
\ No newline at end of file
diff --git a/ckanext/files/assets/ts/files--modules.ts b/ckanext/files/assets/ts/files--modules.ts
index 903b49d..b1383d4 100644
--- a/ckanext/files/assets/ts/files--modules.ts
+++ b/ckanext/files/assets/ts/files--modules.ts
@@ -97,7 +97,7 @@ ckan.module("files--auto-upload", function ($) {
                 this.queue.add(file);
                 this.refreshFormState();
                 const options: ckan.CKANEXT_FILES.UploadOptions = {
-                    uploaderParams: [{ uploadAction: this.options.action }],
+                    uploaderArgs: [{ uploadAction: this.options.action }],
                 };
 
                 this.sandbox.files
@@ -370,10 +370,6 @@ ckan.module("files--queue", function ($) {
             widget.on("click", "[data-upload-resume]", this._onWidgetResume);
             widget.on("click", "[data-upload-pause]", this._onWidgetPause);
 
-            info.uploader.addEventListener(
-                "commit",
-                (event: CustomEvent) => (info.id = event.detail.id),
-            );
             info.uploader.addEventListener(
                 "fail",
                 ({
diff --git a/ckanext/files/assets/ts/files--shared.ts b/ckanext/files/assets/ts/files--shared.ts
index b59bb78..30b3d86 100644
--- a/ckanext/files/assets/ts/files--shared.ts
+++ b/ckanext/files/assets/ts/files--shared.ts
@@ -11,7 +11,7 @@ namespace ckan {
         export interface UploadOptions {
             uploader?: adapters.Base;
             adapter?: string;
-            uploaderParams?: any[];
+            uploaderArgs?: any[];
             requestParams?: { [key: string]: any };
         }
 
@@ -25,12 +25,12 @@ namespace ckan {
             storage: "default",
         };
 
-        function upload(file: File, options: UploadOptions) {
+        function upload(file: File, options: UploadOptions = {}) {
             const uploader =
                 options.uploader ||
                 makeUploader(
                     options.adapter || "Standard",
-                    ...(options.uploaderParams || []),
+                    ...(options.uploaderArgs || []),
                 );
             return uploader.upload(file, options.requestParams || {});
         }
@@ -97,11 +97,6 @@ namespace ckan {
                         new CustomEvent("start", { detail: { file } }),
                     );
                 }
-                dispatchCommit(file: File, id: string) {
-                    this.dispatchEvent(
-                        new CustomEvent("commit", { detail: { file, id } }),
-                    );
-                }
                 dispatchProgress(file: File, loaded: number, total: number) {
                     this.dispatchEvent(
                         new CustomEvent("progress", {
@@ -158,7 +153,6 @@ namespace ckan {
                                 this.dispatchError(file, result);
                                 fail(result);
                             } else if (result.success) {
-                                this.dispatchCommit(file, result.result.id);
                                 this.dispatchFinish(file, result.result);
                                 done(result.result);
                             } else {
@@ -225,7 +219,7 @@ namespace ckan {
                     let info;
 
                     try {
-                        info = await this._initializeUpload(file);
+                        info = await this._initializeUpload(file, params);
                     } catch (err) {
                         if (typeof err === "string") {
                             this.dispatchError(file, err);
@@ -235,7 +229,6 @@ namespace ckan {
                         return;
                     }
 
-                    this.dispatchCommit(file, info.id);
                     this.dispatchStart(file);
 
                     this._doUpload(file, info);
@@ -297,7 +290,7 @@ namespace ckan {
                     this.dispatchFinish(file, info);
                 }
 
-                _initializeUpload(file: File): Promise<UploadInfo> {
+                _initializeUpload(file: File, params: {[key: string]: any}): Promise<UploadInfo> {
                     return new Promise((done, fail) =>
                         this.sandbox.client.call(
                             "POST",
@@ -310,7 +303,7 @@ namespace ckan {
                                     size: file.size,
                                     content_type: file.type,
                                 },
-                                this.settings.initializePayload || {},
+                                params,
                             ),
                             (data: any) => {
                                 done(data.result);
diff --git a/cypress/e2e/sandbox.cy.ts b/cypress/e2e/sandbox.cy.ts
index 72e59ea..28df4f5 100644
--- a/cypress/e2e/sandbox.cy.ts
+++ b/cypress/e2e/sandbox.cy.ts
@@ -2,6 +2,23 @@ const ckan = () => cy.window({ log: false }).then((win) => win["ckan"]);
 
 const sandbox = () => ckan().invoke({ log: false }, "sandbox");
 
+const intercept = (
+    action: string,
+    success: boolean = true,
+    result: any = {},
+    alias: string = "request",
+) =>
+    cy
+        .intercept("/api/action/" + action, (req) =>
+            req.reply(
+                Object.assign(
+                    { success },
+                    success ? { result } : { error: result },
+                ),
+            ),
+        )
+        .as(alias);
+
 beforeEach(() => {
     cy.login();
     cy.visit("/about");
@@ -30,6 +47,7 @@ describe("Sandbox extension", () => {
 describe("sandbox.files.upload", () => {
     it("uses Standard uploader by default", () => {
         const file = new File(["hello"], "test.txt");
+
         const upload = cy.stub().log(false);
         ckan().then(
             ({
@@ -46,6 +64,40 @@ describe("sandbox.files.upload", () => {
             .then(() => expect(upload).to.be.calledWith(file));
     });
 
+    it("accepts different adapter name", () => {
+        const file = new File(["hello"], "test.txt");
+        const upload = cy.stub().log(false);
+        ckan().then(
+            ({
+                CKANEXT_FILES: {
+                    adapters: { Multipart },
+                },
+            }) => {
+                Multipart.prototype.upload = upload;
+            },
+        );
+
+        sandbox()
+            .then(({ files }) => files.upload(file, { adapter: "Multipart" }))
+            .then(() => expect(upload).to.be.calledWith(file));
+    });
+
+    it("passes parameters to adapter", () => {
+        const file = new File(["hello"], "test.txt");
+        const uploader = { upload: () => {} };
+        const adapter = cy.stub().log(false).returns(uploader);
+
+        ckan().then(({ CKANEXT_FILES: { adapters } }) => {
+            adapters.Standard = adapter;
+        });
+
+        sandbox()
+            .then(({ files }) =>
+                files.upload(file, { uploaderArgs: ["a", "b", "c"] }),
+            )
+            .then(() => expect(adapter).to.be.calledWith("a", "b", "c"));
+    });
+
     it("accepts external uploader", () => {
         const file = new File(["hello"], "test.txt");
         const upload = cy.stub().log(false);
@@ -86,11 +138,8 @@ describe("sandbox.files.upload", () => {
             });
     });
 
-    it.only("accepts parameters for API action", () => {
-        cy.intercept("/api/action/files_file_create", (req) =>
-            req.reply({ success: true, result: {} }),
-        ).as("makeFile");
-
+    it("accepts parameters for API action", () => {
+        intercept("files_file_create");
         sandbox().then(({ files }) => {
             files.upload(new File(["test"], "test.txt"), {
                 requestParams: {
@@ -101,11 +150,57 @@ describe("sandbox.files.upload", () => {
             });
         });
 
-        cy.wait("@makeFile").interceptFormData((data) => {
+        cy.wait("@request").interceptFormData((data) => {
             expect(data).includes({
                 storage: "memory",
                 hello: "world",
-                value: 42,
+                value: "42",
+            });
+        });
+    });
+});
+
+describe("Standard uploader", () => {
+    beforeEach(() =>
+        ckan()
+            .then(
+                ({
+                    CKANEXT_FILES: {
+                        adapters: { Standard },
+                    },
+                }) => Standard,
+            )
+            .as("adapter"),
+    );
+
+    it("uploads files", () => {
+        intercept("files_file_create");
+        cy.get("@adapter").then((adapter: any) =>
+            new adapter().upload(new File(["test"], "test.txt"), {}),
+        );
+
+        cy.wait("@request").interceptFormData((data) => {
+            expect(data).deep.equal({
+                storage: "default",
+                upload: "test.txt",
+            });
+        });
+    });
+
+    it.only("accepts params and even can override storage", () => {
+        intercept("files_file_create");
+        cy.get("@adapter").then((adapter: any) =>
+            new adapter().upload(new File(["test"], "test.txt"), {
+                storage: "memory",
+                field: "value",
+            }),
+        );
+
+        cy.wait("@request").interceptFormData((data) => {
+            expect(data).deep.equal({
+                storage: "memory",
+                field: "value",
+                upload: "test.txt",
             });
         });
     });
diff --git a/cypress/support/commands.ts b/cypress/support/commands.ts
index b1dc953..21b3bbd 100644
--- a/cypress/support/commands.ts
+++ b/cypress/support/commands.ts
@@ -36,10 +36,6 @@
 //   }
 // }
 
-Cypress.Commands.add("resetDb", () => {
-    cy.exec("yes | ckan -ctest.ini db clean");
-    cy.exec("ckan -ctest.ini db upgrade");
-});
 Cypress.Commands.add("seedUsers", () => {
     for (let name in users) {
         const info = users[name];
@@ -81,11 +77,6 @@ declare namespace Cypress {
          */
         login(user?: string): Chainable<void>;
 
-        /**
-         * Clean and re-initialize the database.
-         */
-        resetDb(): Chainable<void>;
-
         /**
          * Create all default user accounts.
          */