@doist/todoist-sdk 9.0.0 → 9.1.0

package/dist/esm/clients/ui-extension-client.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_APPS_UI_EXTENSIONS, ENDPOINT_REST_APPS_UI_EXTENSIONS_INSTALLED, getUiExtensionEndpoint, getUiExtensionIconEndpoint, getUiExtensionsByIntegrationEndpoint, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { camelCaseKeys } from '../utils/case-conversion.js';
+import { uploadMultipartFile } from '../utils/multipart-upload.js';
+import { validateUiExtension, validateUiExtensionArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all UI-extension endpoints for developer
+ * applications. All endpoints require the `dev:app_console` OAuth scope.
+ *
+ * Instantiated by `TodoistApi`; every public UI-extension method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing JSDoc.
+ */
+export class UiExtensionClient extends BaseClient {
+    async getUiExtension(uiExtensionId, requestId) {
+        z.string().parse(uiExtensionId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getUiExtensionEndpoint(uiExtensionId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateUiExtension(response.data);
+    }
+    async getInstalledUiExtensions(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_APPS_UI_EXTENSIONS_INSTALLED,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateUiExtensionArray(response.data);
+    }
+    async getUiExtensionsForApp(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getUiExtensionsByIntegrationEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateUiExtensionArray(response.data);
+    }
+    async addUiExtension(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_APPS_UI_EXTENSIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateUiExtension(response.data);
+    }
+    async updateUiExtension(uiExtensionId, args, requestId) {
+        z.string().parse(uiExtensionId);
+        const response = await request({
+            httpMethod: 'PATCH',
+            baseUri: this.syncApiBase,
+            relativePath: getUiExtensionEndpoint(uiExtensionId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateUiExtension(response.data);
+    }
+    async deleteUiExtension(uiExtensionId, requestId) {
+        z.string().parse(uiExtensionId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: getUiExtensionEndpoint(uiExtensionId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async uploadUiExtensionIcon(args, requestId) {
+        var _a;
+        if (Buffer.isBuffer(args.file) && args.file.length === 0) {
+            throw new Error('Cannot upload empty image file');
+        }
+        const data = await uploadMultipartFile({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: getUiExtensionIconEndpoint(args.uiExtensionId),
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: { file_name: (_a = args.fileName) !== null && _a !== void 0 ? _a : '' },
+            requestId: requestId,
+            customFetch: this.customFetch,
+        });
+        return validateUiExtension(camelCaseKeys(data));
+    }
+}

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

@@ -0,0 +1,98 @@
+import { ENDPOINT_REST_UPLOADS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { headersToRecord } from '../utils/headers.js';
+import { uploadMultipartFile } from '../utils/multipart-upload.js';
+import { validateAttachment } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * 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.
+ */
+export class UploadClient extends BaseClient {
+    async uploadFile(args, requestId) {
+        const additionalFields = {};
+        if (args.projectId) {
+            additionalFields.project_id = args.projectId;
+        }
+        const data = await uploadMultipartFile({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: ENDPOINT_REST_UPLOADS,
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: additionalFields,
+            requestId: requestId,
+            customFetch: this.customFetch,
+        });
+        return validateAttachment(data);
+    }
+    async deleteUpload(args, requestId) {
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_UPLOADS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return 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: headersToRecord(response.headers),
+            text: () => response.text(),
+            json: () => response.json(),
+            arrayBuffer: () => response.arrayBuffer(),
+        };
+    }
+}

package/dist/esm/clients/workspace-client.js

@@ -0,0 +1,363 @@
+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;
+};
+import { z } from 'zod';
+import { ENDPOINT_REST_WORKSPACES, ENDPOINT_WORKSPACE_INVITATIONS, ENDPOINT_WORKSPACE_INVITATIONS_ALL, ENDPOINT_WORKSPACE_INVITATIONS_DELETE, ENDPOINT_WORKSPACE_JOIN, ENDPOINT_WORKSPACE_LOGO, ENDPOINT_WORKSPACE_MEMBERS, ENDPOINT_WORKSPACE_PLAN_DETAILS, ENDPOINT_WORKSPACE_USERS, getWorkspaceActiveProjectsEndpoint, getWorkspaceArchivedProjectsEndpoint, getWorkspaceInvitationAcceptEndpoint, getWorkspaceInvitationRejectEndpoint, getWorkspaceInviteUsersEndpoint, getWorkspaceUserEndpoint, getWorkspaceUserTasksEndpoint, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { uploadMultipartFile } from '../utils/multipart-upload.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateJoinWorkspaceResult, validateMemberActivityInfoArray, validateProject, validateWorkspace, validateWorkspaceArray, validateWorkspaceInvitation, validateWorkspaceInvitationArray, validateWorkspacePlanDetails, validateWorkspaceUserArray, validateWorkspaceUserTaskArray, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all workspace-domain endpoints —
+ * workspaces, invitations, users, plans, logos, and workspace project
+ * pagination.
+ *
+ * Instantiated by `TodoistApi`; every public workspace method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class WorkspaceClient extends BaseClient {
+    async getWorkspaceInvitations(args, requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: { workspace_id: args.workspaceId },
+            requestId: requestId,
+        });
+        return response.data;
+    }
+    async getAllWorkspaceInvitations(args = {}, requestId) {
+        const queryParams = {};
+        if (args.workspaceId) {
+            queryParams.workspace_id = args.workspaceId;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS_ALL,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitationArray(response.data);
+    }
+    async deleteWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS_DELETE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: {
+                workspace_id: args.workspaceId,
+                user_email: args.userEmail,
+            },
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async acceptWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInvitationAcceptEndpoint(args.inviteCode),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async rejectWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInvitationRejectEndpoint(args.inviteCode),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async joinWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_JOIN,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: {
+                invite_code: args.inviteCode,
+                workspace_id: args.workspaceId,
+            },
+            requestId: requestId,
+        });
+        return validateJoinWorkspaceResult(response.data);
+    }
+    async uploadWorkspaceLogo(args, requestId) {
+        if (args.delete) {
+            // Delete logo
+            const data = await uploadMultipartFile({
+                baseUrl: this.syncApiBase,
+                authToken: this.authToken,
+                endpoint: ENDPOINT_WORKSPACE_LOGO,
+                file: Buffer.alloc(0), // Empty buffer for delete
+                fileName: 'delete',
+                additionalFields: {
+                    workspace_id: args.workspaceId,
+                    delete: true,
+                },
+                requestId: requestId,
+                customFetch: this.customFetch,
+            });
+            return data;
+        }
+        if (!args.file) {
+            throw new Error('file is required when not deleting logo');
+        }
+        // Validate buffer is not empty if it's a Buffer
+        if (Buffer.isBuffer(args.file) && args.file.length === 0) {
+            throw new Error('Cannot upload empty image file');
+        }
+        const additionalFields = {
+            workspace_id: args.workspaceId,
+        };
+        const data = await uploadMultipartFile({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: ENDPOINT_WORKSPACE_LOGO,
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: additionalFields,
+            requestId: requestId,
+            customFetch: this.customFetch,
+        });
+        return data;
+    }
+    async getWorkspacePlanDetails(args, requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_PLAN_DETAILS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: { workspace_id: args.workspaceId },
+            requestId: requestId,
+        });
+        return validateWorkspacePlanDetails(response.data);
+    }
+    async getWorkspaceUsers(args = {}, requestId) {
+        const queryParams = {};
+        if (args.workspaceId !== undefined && args.workspaceId !== null) {
+            queryParams.workspace_id = args.workspaceId;
+        }
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_USERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return {
+            hasMore: response.data.hasMore || false,
+            nextCursor: response.data.nextCursor,
+            workspaceUsers: validateWorkspaceUserArray(response.data.workspaceUsers || []),
+        };
+    }
+    async getWorkspaces(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_WORKSPACES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspaceArray(response.data);
+    }
+    async getWorkspace(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async addWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_WORKSPACES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async updateWorkspace(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async deleteWorkspace(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getWorkspaceMembersActivity(args, requestId) {
+        const { workspaceId } = args, queryParams = __rest(args, ["workspaceId"]);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_MEMBERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign({ workspaceId }, queryParams),
+            requestId: requestId,
+        });
+        return {
+            members: validateMemberActivityInfoArray(data.members),
+        };
+    }
+    async getWorkspaceUserTasks(args, requestId) {
+        const { workspaceId, userId } = args, queryParams = __rest(args, ["workspaceId", "userId"]);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserTasksEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return {
+            tasks: validateWorkspaceUserTaskArray(data.tasks),
+        };
+    }
+    async inviteWorkspaceUsers(args, requestId) {
+        const { workspaceId } = args, payload = __rest(args, ["workspaceId"]);
+        const { data } = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInviteUsersEndpoint(workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: payload,
+            requestId: requestId,
+        });
+        return data;
+    }
+    async updateWorkspaceUser(args, requestId) {
+        const { workspaceId, userId } = args, payload = __rest(args, ["workspaceId", "userId"]);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: payload,
+            requestId: requestId,
+        });
+        return validateJoinWorkspaceResult(response.data);
+    }
+    async removeWorkspaceUser(args, requestId) {
+        const { workspaceId, userId } = args;
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getWorkspaceActiveProjects(args, requestId) {
+        var _a;
+        const queryParams = {};
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceActiveProjectsEndpoint(args.workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        // oxlint-disable-next-line no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access
+        const validatedProjects = (_a = response.data.results) === null || _a === void 0 ? void 0 : _a.map((project) => validateProject(project));
+        return Object.assign(Object.assign({}, response.data), { 
+            // oxlint-disable-next-line no-unsafe-assignment
+            results: validatedProjects || [] });
+    }
+    async getWorkspaceArchivedProjects(args, requestId) {
+        var _a;
+        const queryParams = {};
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceArchivedProjectsEndpoint(args.workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        // oxlint-disable-next-line no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access
+        const validatedProjects = (_a = response.data.results) === null || _a === void 0 ? void 0 : _a.map((project) => validateProject(project));
+        return Object.assign(Object.assign({}, response.data), { 
+            // oxlint-disable-next-line no-unsafe-assignment
+            results: validatedProjects || [] });
+    }
+}

package/dist/esm/consts/endpoints.js

@@ -121,3 +121,54 @@ export function getWorkspaceActiveProjectsEndpoint(workspaceId) {
 export function getWorkspaceArchivedProjectsEndpoint(workspaceId) {
     return `workspaces/${workspaceId}/projects/archived`;
 }
+// App management endpoints (dev:app_console scope)
+export const ENDPOINT_REST_APPS = 'apps';
+export const ENDPOINT_REST_APPS_INSTALLATIONS = 'apps/installations';
+export const ENDPOINT_REST_APPS_UI_EXTENSIONS = 'apps/ui_extensions';
+export const ENDPOINT_REST_APPS_UI_EXTENSIONS_INSTALLED = 'apps/ui_extensions/installed';
+export const ENDPOINT_REST_USER_AUTHORIZATIONS = 'user/authorizations';
+export const ENDPOINT_REST_USER_AUTHORIZATIONS_DELETE = 'user/authorizations/delete';
+/** Available app icon sizes (small 60x60, medium 300x300, large 600x600). */
+export const APP_ICON_SIZES = ['small', 'medium', 'large'];
+export function getAppEndpoint(appId) {
+    return `apps/${appId}`;
+}
+export function getAppSecretsEndpoint(appId) {
+    return `apps/${appId}/secrets`;
+}
+export function getAppClientSecretEndpoint(appId) {
+    return `apps/${appId}/client_secret`;
+}
+export function getAppTokensEndpoint(appId) {
+    return `apps/${appId}/tokens`;
+}
+export function getAppTestTokenEndpoint(appId) {
+    return `apps/${appId}/test_token`;
+}
+export function getAppDistributionTokenEndpoint(appId) {
+    return `apps/${appId}/distribution_token`;
+}
+export function getAppVerificationTokenEndpoint(appId) {
+    return `apps/${appId}/verification_token`;
+}
+export function getAppWebhookEndpoint(appId) {
+    return `apps/${appId}/webhook`;
+}
+export function getAppIconEndpoint(appId, size) {
+    return size === 'medium' ? `apps/${appId}/icon` : `apps/${appId}/icon/${size}`;
+}
+export function getAppInstallationEndpoint(installationId) {
+    return `apps/installations/${installationId}`;
+}
+export function getAppByDistributionTokenEndpoint(distributionToken) {
+    return `apps/by_distribution_token/${distributionToken}`;
+}
+export function getUiExtensionEndpoint(uiExtensionId) {
+    return `apps/ui_extensions/${uiExtensionId}`;
+}
+export function getUiExtensionIconEndpoint(uiExtensionId) {
+    return `apps/ui_extensions/${uiExtensionId}/icon`;
+}
+export function getUiExtensionsByIntegrationEndpoint(integrationId) {
+    return `apps/ui_extensions/integration/${integrationId}`;
+}