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

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

@@ -0,0 +1,343 @@
+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_APPS, ENDPOINT_REST_APPS_INSTALLATIONS, ENDPOINT_REST_USER_AUTHORIZATIONS, ENDPOINT_REST_USER_AUTHORIZATIONS_DELETE, getAppByDistributionTokenEndpoint, getAppClientSecretEndpoint, getAppDistributionTokenEndpoint, getAppEndpoint, getAppIconEndpoint, getAppInstallationEndpoint, getAppSecretsEndpoint, getAppTestTokenEndpoint, getAppTokensEndpoint, getAppVerificationTokenEndpoint, getAppWebhookEndpoint, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { webhookEventToWireName } from '../types/apps/index.js';
+import { camelCaseKeys } from '../utils/case-conversion.js';
+import { uploadMultipartFile } from '../utils/multipart-upload.js';
+import { validateApp, validateAppArray, validateAppByDistributionToken, validateAppDistributionToken, validateAppInstallation, validateAppInstallationArray, validateAppSecrets, validateAppTestToken, validateAppVerificationToken, validateAppWebhook, validateAppWithUserCount, validateUserAuthorizationArray, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all developer-app management endpoints
+ * (apps, secrets, tokens, webhooks, installations, user authorizations).
+ * All endpoints require the `dev:app_console` OAuth scope.
+ *
+ * Instantiated by `TodoistApi`; every public app-management method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing JSDoc.
+ */
+export class AppClient extends BaseClient {
+    async getApps(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: ENDPOINT_REST_APPS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppArray(response.data);
+    }
+    async getApp(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppWithUserCount(response.data);
+    }
+    async addApp(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.apiRootBase,
+            relativePath: ENDPOINT_REST_APPS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateApp(response.data);
+    }
+    async updateApp(appId, args, requestId) {
+        z.string().parse(appId);
+        const { appTokenScopes } = args, rest = __rest(args, ["appTokenScopes"]);
+        const payload = Object.assign({}, rest);
+        if (appTokenScopes !== undefined) {
+            payload.appTokenScopes = appTokenScopes === null ? null : appTokenScopes.join(',');
+        }
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.apiRootBase,
+            relativePath: getAppEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: payload,
+            requestId: requestId,
+        });
+        return validateAppWithUserCount(response.data);
+    }
+    async deleteApp(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.apiRootBase,
+            relativePath: getAppEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getAppSecrets(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppSecretsEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppSecrets(response.data);
+    }
+    async resetAppClientSecret(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.apiRootBase,
+            relativePath: getAppClientSecretEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppWithUserCount(response.data);
+    }
+    async revokeAppTokens(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.apiRootBase,
+            relativePath: getAppTokensEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppWithUserCount(response.data);
+    }
+    async uploadAppIcon(args, requestId) {
+        var _a, _b;
+        if (Buffer.isBuffer(args.file) && args.file.length === 0) {
+            throw new Error('Cannot upload empty image file');
+        }
+        const size = (_a = args.size) !== null && _a !== void 0 ? _a : 'medium';
+        const data = await uploadMultipartFile({
+            baseUrl: this.apiRootBase,
+            authToken: this.authToken,
+            endpoint: getAppIconEndpoint(args.appId, size),
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: { file_name: (_b = args.fileName) !== null && _b !== void 0 ? _b : '' },
+            requestId: requestId,
+            customFetch: this.customFetch,
+        });
+        return validateAppWithUserCount(camelCaseKeys(data));
+    }
+    async getAppTestToken(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppTestTokenEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppTestToken(response.data);
+    }
+    async createAppTestToken(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.apiRootBase,
+            relativePath: getAppTestTokenEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppTestToken(response.data);
+    }
+    async getAppDistributionToken(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppDistributionTokenEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppDistributionToken(response.data);
+    }
+    async getAppVerificationToken(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppVerificationTokenEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppVerificationToken(response.data);
+    }
+    async resetAppVerificationToken(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.apiRootBase,
+            relativePath: getAppVerificationTokenEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppVerificationToken(response.data);
+    }
+    async getAppByDistributionToken(distributionToken, requestId) {
+        z.string().parse(distributionToken);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppByDistributionTokenEndpoint(distributionToken),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppByDistributionToken(response.data);
+    }
+    // --- App webhooks ---
+    async getAppWebhook(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppWebhookEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return response.data ? validateAppWebhook(response.data) : null;
+    }
+    async updateAppWebhook(args, requestId) {
+        const { appId, events } = args, rest = __rest(args, ["appId", "events"]);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.apiRootBase,
+            relativePath: getAppWebhookEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign({}, rest), { events: events.map(webhookEventToWireName) }),
+            requestId: requestId,
+        });
+        return validateAppWebhook(response.data);
+    }
+    async deleteAppWebhook(appId, requestId) {
+        z.string().parse(appId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.apiRootBase,
+            relativePath: getAppWebhookEndpoint(appId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    // --- App installations ---
+    async getAppInstallations(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: ENDPOINT_REST_APPS_INSTALLATIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppInstallationArray(response.data);
+    }
+    async installApp(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.apiRootBase,
+            relativePath: ENDPOINT_REST_APPS_INSTALLATIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateAppInstallation(response.data);
+    }
+    async getAppInstallation(installationId, requestId) {
+        z.string().parse(installationId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: getAppInstallationEndpoint(installationId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateAppInstallation(response.data);
+    }
+    async updateAppInstallation(installationId, args, requestId) {
+        z.string().parse(installationId);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.apiRootBase,
+            relativePath: getAppInstallationEndpoint(installationId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateAppInstallation(response.data);
+    }
+    async uninstallApp(installationId, requestId) {
+        z.string().parse(installationId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.apiRootBase,
+            relativePath: getAppInstallationEndpoint(installationId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    // --- User authorizations ---
+    async getUserAuthorizations(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.apiRootBase,
+            relativePath: ENDPOINT_REST_USER_AUTHORIZATIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateUserAuthorizationArray(response.data);
+    }
+    async revokeUserAuthorization(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.apiRootBase,
+            relativePath: ENDPOINT_REST_USER_AUTHORIZATIONS_DELETE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

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

@@ -14,6 +14,7 @@ export class BaseClient {
     constructor(context) {
         this.authToken = context.authToken;
         this.syncApiBase = context.syncApiBase;
+        this.apiRootBase = new URL('/', context.syncApiBase).toString();
         this.customFetch = context.customFetch;
     }
     get syncContext() {

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.apiRootBase,
+            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.apiRootBase,
+            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.apiRootBase,
+            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.apiRootBase,
+            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.apiRootBase,
+            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.apiRootBase,
+            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.apiRootBase,
+            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/consts/endpoints.js

@@ -9,6 +9,9 @@ const API_AUTHORIZATION_BASE_URI = '/oauth/';
 export function getSyncBaseUri(domainBase = BASE_URI) {
     return new URL(API_BASE_URI, domainBase).toString();
 }
+export function getApiRootBaseUri(domainBase = BASE_URI) {
+    return new URL('/', domainBase).toString();
+}
 export function getAuthBaseUri(domainBase = TODOIST_URI) {
     return new URL(API_AUTHORIZATION_BASE_URI, domainBase).toString();
 }
@@ -67,11 +70,6 @@ export const ENDPOINT_GET_TOKEN = 'access_token';
 export const ENDPOINT_REVOKE = 'revoke';
 export const ENDPOINT_REGISTER = 'register';
 export const ENDPOINT_REST_FOLDERS = 'folders';
-export const ENDPOINT_REST_GOALS = 'goals';
-export const ENDPOINT_REST_GOALS_SEARCH = ENDPOINT_REST_GOALS + '/search';
-export const GOAL_COMPLETE = 'complete';
-export const GOAL_UNCOMPLETE = 'uncomplete';
-export const GOAL_TASKS = 'items';
 // Workspace endpoints
 export const ENDPOINT_REST_WORKSPACES = 'workspaces';
 export const ENDPOINT_WORKSPACE_INVITATIONS = 'workspaces/invitations';
@@ -126,3 +124,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}`;
+}

package/dist/esm/test-utils/test-defaults.js

@@ -277,30 +277,81 @@ export const DEFAULT_COLLABORATOR_STATE = {
     state: 'active',
     isDeleted: false,
 };
-export const DEFAULT_GOAL_ID = '550e8400-e29b-41d4-a716-446655440000';
-export const DEFAULT_GOAL = {
-    id: DEFAULT_GOAL_ID,
-    ownerType: 'USER',
-    ownerId: DEFAULT_USER_ID,
-    name: 'Ship v2',
-    description: 'Launch the new version',
-    deadline: '2026-04-03',
-    parentGoalId: null,
-    childOrder: 0,
-    isCompleted: false,
-    completedAt: null,
-    responsibleUid: null,
-    isDeleted: false,
-    progress: {
-        totalTaskCount: 5,
-        completedTaskCount: 2,
-        percentage: 40,
-    },
-    creatorUid: DEFAULT_USER_ID,
+export const DEFAULT_APP_ID = '42';
+export const DEFAULT_INSTALLATION_ID = '1001';
+export const DEFAULT_UI_EXTENSION_ID = '2002';
+export const DEFAULT_DISTRIBUTION_TOKEN = 'dist-token-abc';
+export const DEFAULT_ACCESS_TOKEN_ID = '3003';
+export const DEFAULT_APP = {
+    id: DEFAULT_APP_ID,
+    status: 'public',
+    displayName: 'Sample App',
+    userId: DEFAULT_USER_ID,
     createdAt: defaultDate(),
-    updatedAt: defaultDate(),
+    serviceUrl: 'https://example.com',
+    oauthRedirectUri: 'https://example.com/callback',
+    description: 'A sample app',
+    iconSm: 'https://example.com/icon-sm.png',
+    iconMd: 'https://example.com/icon-md.png',
+    iconLg: 'https://example.com/icon-lg.png',
+    appTokenScopes: ['data:read', 'task:add'],
+};
+export const DEFAULT_APP_WITH_USER_COUNT = Object.assign(Object.assign({}, DEFAULT_APP), { userCount: 12 });
+export const DEFAULT_APP_SECRETS = {
+    clientId: 'client-id-xyz',
+    clientSecret: 'client-secret-xyz',
+};
+export const DEFAULT_APP_VERIFICATION_TOKEN = {
+    verificationToken: 'verif-token-abc',
+};
+export const DEFAULT_APP_TEST_TOKEN = {
+    accessToken: 'test-token-xyz',
+};
+export const DEFAULT_APP_DISTRIBUTION_TOKEN = {
+    distributionToken: DEFAULT_DISTRIBUTION_TOKEN,
+};
+export const DEFAULT_APP_WEBHOOK = {
+    status: 'active',
+    callbackUrl: 'https://example.com/webhook',
+    version: '1',
+    events: ['item:added', 'item:completed'],
+};
+export const DEFAULT_APP_INSTALLATION = {
+    id: DEFAULT_INSTALLATION_ID,
+    creator: DEFAULT_USER_ID,
+    createdTs: 1700000000,
+    installationType: 'user',
+    appTokenScopesValidated: true,
+    integration: DEFAULT_APP,
+};
+export const DEFAULT_USER_AUTHORIZATION = {
+    accessTokenId: DEFAULT_ACCESS_TOKEN_ID,
+    scope: ['data:read', 'task:add'],
+    scopeDescriptions: ['Read data', 'Add tasks'],
+    createdAt: new Date('2025-01-01T00:00:00Z'),
+    app: {
+        id: DEFAULT_APP_ID,
+        displayName: 'Sample App',
+        description: 'A sample app',
+        serviceUrl: 'https://example.com',
+        iconMd: 'https://example.com/icon-md.png',
+    },
+};
+export const DEFAULT_UI_EXTENSION = {
+    id: DEFAULT_UI_EXTENSION_ID,
+    integrationId: DEFAULT_APP_ID,
+    extensionId: 'ext-guid-1',
+    extensionType: 'context-menu',
+    contextType: 'task',
+    url: 'https://example.com/extension',
+    icon: 'https://example.com/icon.png',
+    name: 'My Extension',
+    description: 'Does things in the task context menu',
+    width: 400,
+    height: 600,
+    defVersion: 2,
+    minimumCardistVersion: '0.60',
 };
-export const DEFAULT_GOAL_NO_PROGRESS = Object.assign(Object.assign({}, DEFAULT_GOAL), { id: 'e5f6g7h8-e29b-41d4-a716-446655440001', progress: undefined });
 export const DEFAULT_NOTE = {
     id: DEFAULT_COMMENT_ID,
     projectId: DEFAULT_PROJECT_ID,