@dichovsky/testrail-api-client 1.0.0 → 2.1.0

package/src/constants.ts

@@ -13,3 +13,4 @@ export const DEFAULT_CACHE_CLEANUP_INTERVAL_MS = 60000; // 1 minute
 export const DEFAULT_MAX_CACHE_SIZE = 1000;
 export const DEFAULT_RATE_LIMIT_MAX_REQUESTS = 100;
 export const DEFAULT_RATE_LIMIT_WINDOW_MS = 60000; // 1 minute
+export const DEFAULT_DNS_VALIDATION_MAX_WAIT_MS = 2000;

package/src/errors.ts

@@ -1,18 +1,15 @@
+import { ZodError } from 'zod';
+
 /**
  * Thrown when the TestRail API returns a non-2xx response or a network error occurs.
- *
- * @property status - HTTP status code (if available)
- * @property statusText - HTTP status text (if available)
- * @property response - Raw response body (if available)
  */
 export class TestRailApiError extends Error {
     constructor(
-        message: string,
-        public readonly status?: number,
-        public readonly statusText?: string,
-        public readonly response?: string,
+        public readonly status: number,
+        public readonly statusText: string,
+        public readonly response?: unknown,
     ) {
-        super(message);
+        super(`TestRail API error: ${status} ${statusText}`);
         this.name = 'TestRailApiError';
     }
 }
@@ -21,8 +18,18 @@ export class TestRailApiError extends Error {
  * Thrown when client configuration or method parameters fail validation.
  */
 export class TestRailValidationError extends Error {
-    constructor(message: string) {
-        super(message);
+    constructor(
+        message: string,
+        public readonly details?: unknown,
+    ) {
+        super(`TestRail Validation Error: ${message}`);
         this.name = 'TestRailValidationError';
     }
 }
+
+/**
+ * Utility to convert ZodError into TestRailValidationError.
+ */
+export function handleZodError(error: ZodError): TestRailValidationError {
+    return new TestRailValidationError('Schema validation failed', error.format());
+}

package/src/index.ts

@@ -1,5 +1,54 @@
 export { TestRailClient } from './client.js';
-export { TestRailApiError, TestRailValidationError } from './errors.js';
+export { TestRailApiError, TestRailValidationError, handleZodError } from './errors.js';
+export {
+    TestRailConfigSchema,
+    PaginationSchema,
+    UserSchema,
+    RoleSchema,
+    GroupSchema,
+    ProjectSchema,
+    SuiteSchema,
+    CaseSchema,
+    SectionSchema,
+    RunSchema,
+    PlanEntrySchema,
+    PlanSchema,
+    TestSchema,
+    ResultSchema,
+    MilestoneSchema,
+    StatusSchema,
+    PrioritySchema,
+    CaseFieldConfigSchema,
+    CaseFieldSchema,
+    ResultFieldConfigSchema,
+    ResultFieldSchema,
+    CaseTypeSchema,
+    TemplateSchema,
+    ConfigurationSchema,
+    ConfigurationGroupSchema,
+    AttachmentSchema,
+    SharedStepSchema,
+    VariableSchema,
+    DatasetSchema,
+    ReportSchema,
+    ReportResultSchema,
+    AddCasePayloadSchema,
+    UpdateCasePayloadSchema,
+    AddRunPayloadSchema,
+    UpdateRunPayloadSchema,
+    AddResultPayloadSchema,
+    AddResultForCasePayloadSchema,
+    AddResultsForCasesPayloadSchema,
+} from './schemas.js';
+export type {
+    AddCasePayload,
+    UpdateCasePayload,
+    AddRunPayload,
+    UpdateRunPayload,
+    AddResultPayload,
+    AddResultForCasePayload,
+    AddResultsForCasesPayload,
+} from './schemas.js';
 export type {
     TestRailConfig,
     RateLimiterConfig,
@@ -18,17 +67,10 @@ export type {
     User,
     Status,
     Priority,
-    AddCasePayload,
-    UpdateCasePayload,
     AddPlanPayload,
     UpdatePlanPayload,
     AddPlanEntryPayload,
     UpdatePlanEntryPayload,
-    AddRunPayload,
-    UpdateRunPayload,
-    AddResultPayload,
-    AddResultsForCasesPayload,
-    AddResultForCasePayload,
     AddSectionPayload,
     UpdateSectionPayload,
     AddMilestonePayload,

package/src/modules/attachments.ts

@@ -0,0 +1,125 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Attachment } from '../types.js';
+import { z } from 'zod';
+import { AttachmentSchema } from '../schemas.js';
+
+export class AttachmentModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getAttachmentsForCase(caseId: number): Promise<Attachment[]> {
+        this.client.validateId(caseId, 'caseId');
+        const raw = await this.client.request<unknown>('GET', `get_attachments_for_case/${caseId}`);
+        return (
+            this.client.parse<{ attachments?: Attachment[] }>(
+                z.object({ attachments: z.array(AttachmentSchema).optional() }),
+                raw,
+            ).attachments ?? []
+        );
+    }
+
+    async getAttachmentsForRun(runId: number): Promise<Attachment[]> {
+        this.client.validateId(runId, 'runId');
+        const raw = await this.client.request<unknown>('GET', `get_attachments_for_run/${runId}`);
+        return (
+            this.client.parse<{ attachments?: Attachment[] }>(
+                z.object({ attachments: z.array(AttachmentSchema).optional() }),
+                raw,
+            ).attachments ?? []
+        );
+    }
+
+    async getAttachmentsForTest(testId: number): Promise<Attachment[]> {
+        this.client.validateId(testId, 'testId');
+        const raw = await this.client.request<unknown>('GET', `get_attachments_for_test/${testId}`);
+        return (
+            this.client.parse<{ attachments?: Attachment[] }>(
+                z.object({ attachments: z.array(AttachmentSchema).optional() }),
+                raw,
+            ).attachments ?? []
+        );
+    }
+
+    async getAttachmentsForPlan(planId: number): Promise<Attachment[]> {
+        this.client.validateId(planId, 'planId');
+        const raw = await this.client.request<unknown>('GET', `get_attachments_for_plan/${planId}`);
+        return (
+            this.client.parse<{ attachments?: Attachment[] }>(
+                z.object({ attachments: z.array(AttachmentSchema).optional() }),
+                raw,
+            ).attachments ?? []
+        );
+    }
+
+    async getAttachmentsForPlanEntry(planId: number, entryId: number): Promise<Attachment[]> {
+        this.client.validateId(planId, 'planId');
+        this.client.validateId(entryId, 'entryId');
+        const raw = await this.client.request<unknown>('GET', `get_attachments_for_plan_entry/${planId}/${entryId}`);
+        return (
+            this.client.parse<{ attachments?: Attachment[] }>(
+                z.object({ attachments: z.array(AttachmentSchema).optional() }),
+                raw,
+            ).attachments ?? []
+        );
+    }
+
+    async getAttachment(attachmentId: number): Promise<ArrayBuffer> {
+        this.client.validateId(attachmentId, 'attachmentId');
+        return this.client.requestBinary(`get_attachment/${attachmentId}`);
+    }
+
+    async addAttachmentToCase(
+        caseId: number,
+        file: globalThis.Blob | Uint8Array | globalThis.File,
+        filename: string,
+    ): Promise<Attachment> {
+        this.client.validateId(caseId, 'caseId');
+        return this.client.requestMultipart<Attachment>(`add_attachment_to_case/${caseId}`, file, filename);
+    }
+
+    async addAttachmentToResult(
+        resultId: number,
+        file: globalThis.Blob | Uint8Array | globalThis.File,
+        filename: string,
+    ): Promise<Attachment> {
+        this.client.validateId(resultId, 'resultId');
+        return this.client.requestMultipart<Attachment>(`add_attachment_to_result/${resultId}`, file, filename);
+    }
+
+    async addAttachmentToRun(
+        runId: number,
+        file: globalThis.Blob | Uint8Array | globalThis.File,
+        filename: string,
+    ): Promise<Attachment> {
+        this.client.validateId(runId, 'runId');
+        return this.client.requestMultipart<Attachment>(`add_attachment_to_run/${runId}`, file, filename);
+    }
+
+    async addAttachmentToPlan(
+        planId: number,
+        file: globalThis.Blob | Uint8Array | globalThis.File,
+        filename: string,
+    ): Promise<Attachment> {
+        this.client.validateId(planId, 'planId');
+        return this.client.requestMultipart<Attachment>(`add_attachment_to_plan/${planId}`, file, filename);
+    }
+
+    async addAttachmentToPlanEntry(
+        planId: number,
+        entryId: number,
+        file: globalThis.Blob | Uint8Array | globalThis.File,
+        filename: string,
+    ): Promise<Attachment> {
+        this.client.validateId(planId, 'planId');
+        this.client.validateId(entryId, 'entryId');
+        return this.client.requestMultipart<Attachment>(
+            `add_attachment_to_plan_entry/${planId}/${entryId}`,
+            file,
+            filename,
+        );
+    }
+
+    async deleteAttachment(attachmentId: number): Promise<void> {
+        this.client.validateId(attachmentId, 'attachmentId');
+        await this.client.request<void>('POST', `delete_attachment/${attachmentId}`);
+    }
+}

package/src/modules/cases.ts

@@ -0,0 +1,78 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Case, GetCasesOptions } from '../types.js';
+import type { AddCasePayload, UpdateCasePayload } from '../schemas.js';
+import { CaseSchema } from '../schemas.js';
+import { z } from 'zod';
+
+export class CaseModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getCase(caseId: number): Promise<Case> {
+        this.client.validateId(caseId, 'caseId');
+        return this.client.parse<Case>(CaseSchema, await this.client.request<unknown>('GET', `get_case/${caseId}`));
+    }
+
+    async getCases(projectId: number, options?: GetCasesOptions): Promise<Case[]> {
+        this.client.validateId(projectId, 'projectId');
+        const {
+            suiteId,
+            sectionId,
+            typeId,
+            priorityId,
+            templateId,
+            milestoneId,
+            createdAfter,
+            createdBefore,
+            updatedAfter,
+            updatedBefore,
+            limit,
+            offset,
+        } = options ?? {};
+        if (suiteId !== undefined) this.client.validateId(suiteId, 'suiteId');
+        if (sectionId !== undefined) this.client.validateId(sectionId, 'sectionId');
+        if (typeId !== undefined) this.client.validateId(typeId, 'typeId');
+        if (priorityId !== undefined) this.client.validateId(priorityId, 'priorityId');
+        if (templateId !== undefined) this.client.validateId(templateId, 'templateId');
+        if (milestoneId !== undefined) this.client.validateId(milestoneId, 'milestoneId');
+        this.client.validatePaginationParams(limit, offset);
+        const endpoint = this.client.buildEndpoint(`get_cases/${projectId}`, {
+            suite_id: suiteId,
+            section_id: sectionId,
+            type_id: typeId,
+            priority_id: priorityId,
+            template_id: templateId,
+            milestone_id: milestoneId,
+            created_after: createdAfter,
+            created_before: createdBefore,
+            updated_after: updatedAfter,
+            updated_before: updatedBefore,
+            limit,
+            offset,
+        });
+        const raw = await this.client.request<unknown>('GET', endpoint);
+        return (
+            this.client.parse<{ cases?: Case[] }>(z.object({ cases: z.array(CaseSchema).optional() }), raw).cases ?? []
+        );
+    }
+
+    async addCase(sectionId: number, payload: AddCasePayload): Promise<Case> {
+        this.client.validateId(sectionId, 'sectionId');
+        return this.client.parse<Case>(
+            CaseSchema,
+            await this.client.request<unknown>('POST', `add_case/${sectionId}`, payload),
+        );
+    }
+
+    async updateCase(caseId: number, payload: UpdateCasePayload): Promise<Case> {
+        this.client.validateId(caseId, 'caseId');
+        return this.client.parse<Case>(
+            CaseSchema,
+            await this.client.request<unknown>('POST', `update_case/${caseId}`, payload),
+        );
+    }
+
+    async deleteCase(caseId: number): Promise<void> {
+        this.client.validateId(caseId, 'caseId');
+        await this.client.request<void>('POST', `delete_case/${caseId}`);
+    }
+}

package/src/modules/configurations.ts

@@ -0,0 +1,68 @@
+import { TestRailClientCore } from '../client-core.js';
+import type {
+    ConfigurationGroup,
+    Configuration,
+    AddConfigurationGroupPayload,
+    UpdateConfigurationGroupPayload,
+    AddConfigurationPayload,
+    UpdateConfigurationPayload,
+} from '../types.js';
+import { ConfigurationGroupSchema, ConfigurationSchema } from '../schemas.js';
+import { z } from 'zod';
+
+export class ConfigurationModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getConfigurations(projectId: number): Promise<ConfigurationGroup[]> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<ConfigurationGroup[]>(
+            z.array(ConfigurationGroupSchema),
+            await this.client.request<unknown>('GET', `get_configs/${projectId}`),
+        );
+    }
+
+    async addConfigurationGroup(projectId: number, payload: AddConfigurationGroupPayload): Promise<ConfigurationGroup> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<ConfigurationGroup>(
+            ConfigurationGroupSchema,
+            await this.client.request<unknown>('POST', `add_config_group/${projectId}`, payload),
+        );
+    }
+
+    async updateConfigurationGroup(
+        configGroupId: number,
+        payload: UpdateConfigurationGroupPayload,
+    ): Promise<ConfigurationGroup> {
+        this.client.validateId(configGroupId, 'configGroupId');
+        return this.client.parse<ConfigurationGroup>(
+            ConfigurationGroupSchema,
+            await this.client.request<unknown>('POST', `update_config_group/${configGroupId}`, payload),
+        );
+    }
+
+    async deleteConfigurationGroup(configGroupId: number): Promise<void> {
+        this.client.validateId(configGroupId, 'configGroupId');
+        await this.client.request<void>('POST', `delete_config_group/${configGroupId}`);
+    }
+
+    async addConfiguration(configGroupId: number, payload: AddConfigurationPayload): Promise<Configuration> {
+        this.client.validateId(configGroupId, 'configGroupId');
+        return this.client.parse<Configuration>(
+            ConfigurationSchema,
+            await this.client.request<unknown>('POST', `add_config/${configGroupId}`, payload),
+        );
+    }
+
+    async updateConfiguration(configId: number, payload: UpdateConfigurationPayload): Promise<Configuration> {
+        this.client.validateId(configId, 'configId');
+        return this.client.parse<Configuration>(
+            ConfigurationSchema,
+            await this.client.request<unknown>('POST', `update_config/${configId}`, payload),
+        );
+    }
+
+    async deleteConfiguration(configId: number): Promise<void> {
+        this.client.validateId(configId, 'configId');
+        await this.client.request<void>('POST', `delete_config/${configId}`);
+    }
+}

package/src/modules/datasets.ts

@@ -0,0 +1,44 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Dataset, AddDatasetPayload, UpdateDatasetPayload } from '../types.js';
+import { DatasetSchema } from '../schemas.js';
+
+export class DatasetModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getDataset(datasetId: number): Promise<Dataset> {
+        this.client.validateId(datasetId, 'datasetId');
+        return this.client.parse<Dataset>(
+            DatasetSchema,
+            await this.client.request<unknown>('GET', `get_dataset/${datasetId}`),
+        );
+    }
+
+    async getDatasets(projectId: number): Promise<Dataset[]> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<Dataset[]>(
+            DatasetSchema.array(),
+            await this.client.request<unknown>('GET', `get_datasets/${projectId}`),
+        );
+    }
+
+    async addDataset(projectId: number, payload: AddDatasetPayload): Promise<Dataset> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<Dataset>(
+            DatasetSchema,
+            await this.client.request<unknown>('POST', `add_dataset/${projectId}`, payload),
+        );
+    }
+
+    async updateDataset(datasetId: number, payload: UpdateDatasetPayload): Promise<Dataset> {
+        this.client.validateId(datasetId, 'datasetId');
+        return this.client.parse<Dataset>(
+            DatasetSchema,
+            await this.client.request<unknown>('POST', `update_dataset/${datasetId}`, payload),
+        );
+    }
+
+    async deleteDataset(datasetId: number): Promise<void> {
+        this.client.validateId(datasetId, 'datasetId');
+        await this.client.request<void>('POST', `delete_dataset/${datasetId}`);
+    }
+}

package/src/modules/metadata.ts

@@ -0,0 +1,63 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Status, Priority, ResultField, CaseField, CaseType, Template, Role } from '../types.js';
+import {
+    StatusSchema,
+    PrioritySchema,
+    ResultFieldSchema,
+    CaseFieldSchema,
+    CaseTypeSchema,
+    TemplateSchema,
+    RoleSchema,
+} from '../schemas.js';
+import { z } from 'zod';
+
+export class MetadataModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getStatuses(): Promise<Status[]> {
+        return this.client.parse<Status[]>(
+            z.array(StatusSchema),
+            await this.client.request<unknown>('GET', 'get_statuses'),
+        );
+    }
+
+    async getPriorities(): Promise<Priority[]> {
+        return this.client.parse<Priority[]>(
+            z.array(PrioritySchema),
+            await this.client.request<unknown>('GET', 'get_priorities'),
+        );
+    }
+
+    async getResultFields(): Promise<ResultField[]> {
+        return this.client.parse<ResultField[]>(
+            z.array(ResultFieldSchema),
+            await this.client.request<unknown>('GET', 'get_result_fields'),
+        );
+    }
+
+    async getCaseFields(): Promise<CaseField[]> {
+        return this.client.parse<CaseField[]>(
+            z.array(CaseFieldSchema),
+            await this.client.request<unknown>('GET', 'get_case_fields'),
+        );
+    }
+
+    async getCaseTypes(): Promise<CaseType[]> {
+        return this.client.parse<CaseType[]>(
+            z.array(CaseTypeSchema),
+            await this.client.request<unknown>('GET', 'get_case_types'),
+        );
+    }
+
+    async getTemplates(projectId: number): Promise<Template[]> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<Template[]>(
+            z.array(TemplateSchema),
+            await this.client.request<unknown>('GET', `get_templates/${projectId}`),
+        );
+    }
+
+    async getRoles(): Promise<Role[]> {
+        return this.client.parse<Role[]>(z.array(RoleSchema), await this.client.request<unknown>('GET', 'get_roles'));
+    }
+}

package/src/modules/milestones.ts

@@ -0,0 +1,54 @@
+import { TestRailClientCore } from '../client-core.js';
+import type { Milestone, GetMilestonesOptions, AddMilestonePayload, UpdateMilestonePayload } from '../types.js';
+import { MilestoneSchema } from '../schemas.js';
+import { z } from 'zod';
+
+export class MilestoneModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getMilestone(milestoneId: number): Promise<Milestone> {
+        this.client.validateId(milestoneId, 'milestoneId');
+        return this.client.parse<Milestone>(
+            MilestoneSchema,
+            await this.client.request<unknown>('GET', `get_milestone/${milestoneId}`),
+        );
+    }
+
+    async getMilestones(projectId: number, options?: GetMilestonesOptions): Promise<Milestone[]> {
+        this.client.validateId(projectId, 'projectId');
+        this.client.validatePaginationParams(options?.limit, options?.offset);
+        const endpoint = this.client.buildEndpoint(`get_milestones/${projectId}`, {
+            is_completed: options?.is_completed,
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+        const raw = await this.client.request<unknown>('GET', endpoint);
+        return (
+            this.client.parse<{ milestones?: Milestone[] }>(
+                z.object({ milestones: z.array(MilestoneSchema).optional() }),
+                raw,
+            ).milestones ?? []
+        );
+    }
+
+    async addMilestone(projectId: number, payload: AddMilestonePayload): Promise<Milestone> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<Milestone>(
+            MilestoneSchema,
+            await this.client.request<unknown>('POST', `add_milestone/${projectId}`, payload),
+        );
+    }
+
+    async updateMilestone(milestoneId: number, payload: UpdateMilestonePayload): Promise<Milestone> {
+        this.client.validateId(milestoneId, 'milestoneId');
+        return this.client.parse<Milestone>(
+            MilestoneSchema,
+            await this.client.request<unknown>('POST', `update_milestone/${milestoneId}`, payload),
+        );
+    }
+
+    async deleteMilestone(milestoneId: number): Promise<void> {
+        this.client.validateId(milestoneId, 'milestoneId');
+        await this.client.request<void>('POST', `delete_milestone/${milestoneId}`);
+    }
+}

package/src/modules/plans.ts

@@ -0,0 +1,89 @@
+import { TestRailClientCore } from '../client-core.js';
+import type {
+    Plan,
+    PlanEntry,
+    GetPlansOptions,
+    AddPlanPayload,
+    UpdatePlanPayload,
+    AddPlanEntryPayload,
+    UpdatePlanEntryPayload,
+} from '../types.js';
+import { PlanSchema, PlanEntrySchema } from '../schemas.js';
+import { serializeIdList } from '../utils.js';
+import { z } from 'zod';
+
+export class PlanModule {
+    constructor(private readonly client: TestRailClientCore) {}
+
+    async getPlan(planId: number): Promise<Plan> {
+        this.client.validateId(planId, 'planId');
+        return this.client.parse<Plan>(PlanSchema, await this.client.request<unknown>('GET', `get_plan/${planId}`));
+    }
+
+    async getPlans(projectId: number, options?: GetPlansOptions): Promise<Plan[]> {
+        this.client.validateId(projectId, 'projectId');
+        this.client.validatePaginationParams(options?.limit, options?.offset);
+        const endpoint = this.client.buildEndpoint(`get_plans/${projectId}`, {
+            created_after: options?.created_after,
+            created_before: options?.created_before,
+            created_by: serializeIdList(options?.created_by),
+            is_completed: options?.is_completed,
+            milestone_id: serializeIdList(options?.milestone_id),
+            limit: options?.limit,
+            offset: options?.offset,
+        });
+        const raw = await this.client.request<unknown>('GET', endpoint);
+        return (
+            this.client.parse<{ plans?: Plan[] }>(z.object({ plans: z.array(PlanSchema).optional() }), raw).plans ?? []
+        );
+    }
+
+    async addPlan(projectId: number, payload: AddPlanPayload): Promise<Plan> {
+        this.client.validateId(projectId, 'projectId');
+        return this.client.parse<Plan>(
+            PlanSchema,
+            await this.client.request<unknown>('POST', `add_plan/${projectId}`, payload),
+        );
+    }
+
+    async updatePlan(planId: number, payload: UpdatePlanPayload): Promise<Plan> {
+        this.client.validateId(planId, 'planId');
+        return this.client.parse<Plan>(
+            PlanSchema,
+            await this.client.request<unknown>('POST', `update_plan/${planId}`, payload),
+        );
+    }
+
+    async closePlan(planId: number): Promise<Plan> {
+        this.client.validateId(planId, 'planId');
+        return this.client.parse<Plan>(PlanSchema, await this.client.request<unknown>('POST', `close_plan/${planId}`));
+    }
+
+    async deletePlan(planId: number): Promise<void> {
+        this.client.validateId(planId, 'planId');
+        await this.client.request<void>('POST', `delete_plan/${planId}`);
+    }
+
+    async addPlanEntry(planId: number, payload: AddPlanEntryPayload): Promise<PlanEntry> {
+        this.client.validateId(planId, 'planId');
+        return this.client.parse<PlanEntry>(
+            PlanEntrySchema,
+            await this.client.request<unknown>('POST', `add_plan_entry/${planId}`, payload),
+        );
+    }
+
+    async updatePlanEntry(planId: number, entryId: string, payload: UpdatePlanEntryPayload): Promise<PlanEntry> {
+        this.client.validateId(planId, 'planId');
+        this.client.validateEntryId(entryId);
+        return this.client.parse<PlanEntry>(
+            PlanEntrySchema,
+            await this.client.request<unknown>('POST', `update_plan_entry/${planId}/${entryId}`, payload),
+        );
+    }
+
+    async deletePlanEntry(planId: number, entryId: string): Promise<void> {
+        this.client.validateId(planId, 'planId');
+        this.client.validateEntryId(entryId);
+        await this.client.request<void>('POST', `delete_plan_entry/${planId}/${entryId}`);
+    }
+}