@doist/todoist-sdk 9.0.0 → 9.1.0-next.2

package/dist/cjs/clients/section-client.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SectionClient = void 0;
+const zod_1 = require("zod");
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const request_helpers_1 = require("../utils/request-helpers");
+const validators_1 = require("../utils/validators");
+const base_client_1 = require("./base-client");
+/**
+ * Internal sub-client handling all section-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public section method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+class SectionClient extends base_client_1.BaseClient {
+    async getSections(args) {
+        const { data: { results, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_SECTIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: (0, validators_1.validateSectionArray)(results),
+            nextCursor,
+        };
+    }
+    async searchSections(args) {
+        const { data: { results, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_SECTIONS_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: (0, validators_1.validateSectionArray)(results),
+            nextCursor,
+        };
+    }
+    async getSection(id) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_SECTIONS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return (0, validators_1.validateSection)(response.data);
+    }
+    async addSection(args, requestId) {
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_SECTIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return (0, validators_1.validateSection)(response.data);
+    }
+    async updateSection(id, args, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_SECTIONS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return (0, validators_1.validateSection)(response.data);
+    }
+    async deleteSection(id, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_SECTIONS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return (0, http_client_1.isSuccess)(response);
+    }
+    async archiveSection(id, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_SECTIONS, id, endpoints_1.SECTION_ARCHIVE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return (0, validators_1.validateSection)(response.data);
+    }
+    async unarchiveSection(id, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_SECTIONS, id, endpoints_1.SECTION_UNARCHIVE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return (0, validators_1.validateSection)(response.data);
+    }
+}
+exports.SectionClient = SectionClient;

package/dist/cjs/clients/task-client.js

@@ -0,0 +1,255 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskClient = void 0;
+const uuid_1 = require("uuid");
+const zod_1 = require("zod");
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const sync_request_1 = require("../transport/sync-request");
+const types_1 = require("../types");
+const request_helpers_1 = require("../utils/request-helpers");
+const uncompletable_helpers_1 = require("../utils/uncompletable-helpers");
+const validators_1 = require("../utils/validators");
+const base_client_1 = require("./base-client");
+const MAX_COMMAND_COUNT = 100;
+/**
+ * Internal sub-client handling all task-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public task method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+class TaskClient extends base_client_1.BaseClient {
+    async getTask(id) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_TASKS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return (0, validators_1.validateTask)(response.data);
+    }
+    async getTasks(args = {}) {
+        const { data: { results, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: (0, validators_1.validateTaskArray)(results),
+            nextCursor,
+        };
+    }
+    async getTasksByFilter(args) {
+        const { data: { results, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS_FILTER,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: (0, validators_1.validateTaskArray)(results),
+            nextCursor,
+        };
+    }
+    async getCompletedTasksByCompletionDate(args) {
+        const { data: { items, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS_COMPLETED_BY_COMPLETION_DATE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            items: (0, validators_1.validateTaskArray)(items),
+            nextCursor,
+        };
+    }
+    async getCompletedTasksByDueDate(args) {
+        const { data: { items, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS_COMPLETED_BY_DUE_DATE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            items: (0, validators_1.validateTaskArray)(items),
+            nextCursor,
+        };
+    }
+    async searchCompletedTasks(args) {
+        const { data: { items, nextCursor }, } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS_COMPLETED_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            items: (0, validators_1.validateTaskArray)(items),
+            nextCursor,
+        };
+    }
+    async getAllCompletedTasks(args = {}) {
+        const { since, until } = args, rest = __rest(args, ["since", "until"]);
+        const { data } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS_COMPLETED,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign(Object.assign({}, rest), (since ? { since: since.toISOString() } : {})), (until ? { until: until.toISOString() } : {})),
+        });
+        return {
+            projects: data.projects,
+            sections: data.sections,
+            items: (0, validators_1.validateTaskArray)(data.items),
+        };
+    }
+    async addTask(args, requestId) {
+        // Process content based on isUncompletable flag
+        const processedArgs = Object.assign(Object.assign({}, args), { content: (0, uncompletable_helpers_1.processTaskContent)(args.content, args.isUncompletable) });
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TASKS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: processedArgs,
+            requestId: requestId,
+        });
+        return (0, validators_1.validateTask)(response.data);
+    }
+    async quickAddTask(args) {
+        // Process text based on isUncompletable flag
+        const processedArgs = Object.assign(Object.assign({}, args), { text: (0, uncompletable_helpers_1.processTaskContent)(args.text, args.isUncompletable) });
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_SYNC_QUICK_ADD,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: processedArgs,
+        });
+        return (0, validators_1.validateTask)(response.data);
+    }
+    async updateTask(id, args, requestId) {
+        zod_1.z.string().parse(id);
+        // Translate SDK alias for due-date clearing to Todoist's accepted payload value.
+        const normalizedArgs = args.dueString === null ? Object.assign(Object.assign({}, args), { dueString: 'no date' }) : args;
+        // Process content if both content and isUncompletable are provided
+        const processedArgs = normalizedArgs.content && normalizedArgs.isUncompletable !== undefined
+            ? Object.assign(Object.assign({}, normalizedArgs), { content: (0, uncompletable_helpers_1.processTaskContent)(normalizedArgs.content, normalizedArgs.isUncompletable) }) : normalizedArgs;
+        // Remap `order` → `childOrder` so snakeCaseKeys() produces `child_order`
+        const { order } = processedArgs, argsWithoutOrder = __rest(processedArgs, ["order"]);
+        const remappedArgs = order !== undefined ? Object.assign(Object.assign({}, argsWithoutOrder), { childOrder: order }) : argsWithoutOrder;
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_TASKS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: remappedArgs,
+            requestId: requestId,
+        });
+        return (0, validators_1.validateTask)(response.data);
+    }
+    async moveTasks(ids, args, requestId) {
+        var _a;
+        if (ids.length > MAX_COMMAND_COUNT) {
+            throw new types_1.TodoistRequestError(`Maximum number of items is ${MAX_COMMAND_COUNT}`, 400);
+        }
+        const commands = ids.map((id) => ({
+            type: 'item_move',
+            uuid: (0, uuid_1.v4)(),
+            args: Object.assign(Object.assign(Object.assign({ id }, (0, request_helpers_1.spreadIfDefined)(args.projectId, (v) => ({ projectId: v }))), (0, request_helpers_1.spreadIfDefined)(args.sectionId, (v) => ({ sectionId: v }))), (0, request_helpers_1.spreadIfDefined)(args.parentId, (v) => ({ parentId: v }))),
+        }));
+        const syncRequest = {
+            commands,
+            resourceTypes: ['items'],
+        };
+        const syncResponse = await (0, sync_request_1.performSyncRequest)(this.syncContext, syncRequest, {
+            requestId,
+            hasSyncCommands: true,
+        });
+        if (!((_a = syncResponse.items) === null || _a === void 0 ? void 0 : _a.length)) {
+            throw new types_1.TodoistRequestError('Tasks not found', 404);
+        }
+        const syncTasks = syncResponse.items.filter((task) => ids.includes(task.id));
+        if (!syncTasks.length) {
+            throw new types_1.TodoistRequestError('Tasks not found', 404);
+        }
+        return (0, validators_1.validateTaskArray)(syncTasks);
+    }
+    async moveTask(id, args, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_TASKS, id, endpoints_1.ENDPOINT_REST_TASK_MOVE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign(Object.assign({}, (0, request_helpers_1.spreadIfDefined)(args.projectId, (v) => ({ project_id: v }))), (0, request_helpers_1.spreadIfDefined)(args.sectionId, (v) => ({ section_id: v }))), (0, request_helpers_1.spreadIfDefined)(args.parentId, (v) => ({ parent_id: v }))),
+            requestId: requestId,
+        });
+        return (0, validators_1.validateTask)(response.data);
+    }
+    async closeTask(id, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_TASKS, id, endpoints_1.ENDPOINT_REST_TASK_CLOSE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return (0, http_client_1.isSuccess)(response);
+    }
+    async reopenTask(id, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_TASKS, id, endpoints_1.ENDPOINT_REST_TASK_REOPEN),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return (0, http_client_1.isSuccess)(response);
+    }
+    async deleteTask(id, requestId) {
+        zod_1.z.string().parse(id);
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: (0, request_helpers_1.generatePath)(endpoints_1.ENDPOINT_REST_TASKS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return (0, http_client_1.isSuccess)(response);
+    }
+}
+exports.TaskClient = TaskClient;

package/dist/cjs/clients/template-client.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateClient = void 0;
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const case_conversion_1 = require("../utils/case-conversion");
+const multipart_upload_1 = require("../utils/multipart-upload");
+const validators_1 = require("../utils/validators");
+const base_client_1 = require("./base-client");
+/**
+ * Internal sub-client handling all template-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public template method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+class TemplateClient extends base_client_1.BaseClient {
+    async exportTemplateAsFile(args) {
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TEMPLATES_FILE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return response.data;
+    }
+    async exportTemplateAsUrl(args) {
+        const { data } = await (0, http_client_1.request)({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TEMPLATES_URL,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return data;
+    }
+    async createProjectFromTemplate(args, requestId) {
+        const { file, fileName, name, workspaceId } = args;
+        const additionalFields = { name };
+        if (workspaceId !== undefined && workspaceId !== null) {
+            additionalFields.workspace_id = workspaceId;
+        }
+        const data = await (0, multipart_upload_1.uploadMultipartFile)({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: endpoints_1.ENDPOINT_REST_TEMPLATES_CREATE_FROM_FILE,
+            file,
+            fileName,
+            additionalFields,
+            customFetch: this.customFetch,
+            requestId,
+        });
+        return this.validateTemplateResponse((0, case_conversion_1.camelCaseKeys)(data));
+    }
+    async importTemplateIntoProject(args, requestId) {
+        const { file, fileName, projectId } = args;
+        const data = await (0, multipart_upload_1.uploadMultipartFile)({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: endpoints_1.ENDPOINT_REST_TEMPLATES_IMPORT_FROM_FILE,
+            file,
+            fileName,
+            additionalFields: { project_id: projectId },
+            customFetch: this.customFetch,
+            requestId,
+        });
+        return this.validateTemplateResponse((0, case_conversion_1.camelCaseKeys)(data));
+    }
+    async importTemplateFromId(args, requestId) {
+        const { data } = await (0, http_client_1.request)({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_TEMPLATES_IMPORT_FROM_ID,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return this.validateTemplateResponse(data);
+    }
+    validateTemplateResponse(data) {
+        var _a, _b, _c, _d;
+        return Object.assign(Object.assign({}, data), { projects: (0, validators_1.validateProjectArray)((_a = data.projects) !== null && _a !== void 0 ? _a : []), sections: (0, validators_1.validateSectionArray)((_b = data.sections) !== null && _b !== void 0 ? _b : []), tasks: (0, validators_1.validateTaskArray)((_c = data.tasks) !== null && _c !== void 0 ? _c : []), comments: (0, validators_1.validateCommentArray)((_d = data.comments) !== null && _d !== void 0 ? _d : []) });
+    }
+}
+exports.TemplateClient = TemplateClient;

package/dist/cjs/clients/upload-client.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadClient = void 0;
+const endpoints_1 = require("../consts/endpoints");
+const http_client_1 = require("../transport/http-client");
+const headers_1 = require("../utils/headers");
+const multipart_upload_1 = require("../utils/multipart-upload");
+const validators_1 = require("../utils/validators");
+const base_client_1 = require("./base-client");
+/**
+ * Internal sub-client handling upload + attachment endpoints
+ * (file upload, upload delete, attachment view).
+ *
+ * Instantiated by `TodoistApi`; every public upload method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+class UploadClient extends base_client_1.BaseClient {
+    async uploadFile(args, requestId) {
+        const additionalFields = {};
+        if (args.projectId) {
+            additionalFields.project_id = args.projectId;
+        }
+        const data = await (0, multipart_upload_1.uploadMultipartFile)({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: endpoints_1.ENDPOINT_REST_UPLOADS,
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: additionalFields,
+            requestId: requestId,
+            customFetch: this.customFetch,
+        });
+        return (0, validators_1.validateAttachment)(data);
+    }
+    async deleteUpload(args, requestId) {
+        const response = await (0, http_client_1.request)({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: endpoints_1.ENDPOINT_REST_UPLOADS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return (0, http_client_1.isSuccess)(response);
+    }
+    async viewAttachment(commentOrUrl) {
+        var _a;
+        let fileUrl;
+        if (typeof commentOrUrl === 'string') {
+            fileUrl = commentOrUrl;
+        }
+        else {
+            if (!((_a = commentOrUrl.fileAttachment) === null || _a === void 0 ? void 0 : _a.fileUrl)) {
+                throw new Error('Comment does not have a file attachment');
+            }
+            fileUrl = commentOrUrl.fileAttachment.fileUrl;
+        }
+        // Validate the URL belongs to Todoist to prevent leaking the auth token
+        const urlHostname = new URL(fileUrl).hostname;
+        if (!urlHostname.endsWith('.todoist.com')) {
+            throw new Error('Attachment URLs must be on a todoist.com domain');
+        }
+        const fetchOptions = {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${this.authToken}` },
+        };
+        if (this.customFetch) {
+            const response = await this.customFetch(fileUrl, fetchOptions);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch attachment: ${response.status} ${response.statusText}`);
+            }
+            // Convert text to ArrayBuffer for custom fetch implementations that lack arrayBuffer()
+            const text = await response.text();
+            const buffer = new TextEncoder().encode(text).buffer;
+            return {
+                ok: response.ok,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                text: () => Promise.resolve(text),
+                json: () => response.json(),
+                arrayBuffer: () => Promise.resolve(buffer),
+            };
+        }
+        const response = await fetch(fileUrl, fetchOptions);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch attachment: ${response.status} ${response.statusText}`);
+        }
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers: (0, headers_1.headersToRecord)(response.headers),
+            text: () => response.text(),
+            json: () => response.json(),
+            arrayBuffer: () => response.arrayBuffer(),
+        };
+    }
+}
+exports.UploadClient = UploadClient;