@proletariat/cli 0.1.4 → 0.3.0

package/dist/lib/pmo/storage/statuses.js

@@ -0,0 +1,404 @@
+/**
+ * Workflow status operations.
+ * Statuses belong to workflows (not projects directly).
+ * Projects reference workflows via workflow_id.
+ */
+import { PMO_TABLES } from '../schema.js';
+import { PMOError, STATE_CATEGORY_ORDER } from '../types.js';
+import { slugify } from '../utils.js';
+const T = PMO_TABLES;
+/**
+ * Convert database row to Workflow object.
+ */
+function rowToWorkflow(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description || undefined,
+        isBuiltin: !!row.is_builtin,
+        createdAt: new Date(row.created_at),
+        updatedAt: new Date(row.updated_at),
+    };
+}
+/**
+ * Convert database row to WorkflowStatus object.
+ */
+function rowToWorkflowStatus(row) {
+    return {
+        id: row.id,
+        workflowId: row.workflow_id,
+        name: row.name,
+        category: row.category,
+        position: row.position,
+        color: row.color || undefined,
+        description: row.description || undefined,
+        isDefault: !!row.is_default,
+        createdAt: new Date(row.created_at),
+    };
+}
+export class StatusStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    // ============================================================================
+    // Workflow Operations
+    // ============================================================================
+    /**
+     * List all workflows.
+     */
+    async listWorkflows(filter) {
+        let sql = `SELECT * FROM ${T.workflows} WHERE 1=1`;
+        const params = [];
+        if (filter?.isBuiltin !== undefined) {
+            sql += ' AND is_builtin = ?';
+            params.push(filter.isBuiltin ? 1 : 0);
+        }
+        if (filter?.search) {
+            sql += ' AND (name LIKE ? OR description LIKE ?)';
+            params.push(`%${filter.search}%`, `%${filter.search}%`);
+        }
+        sql += ' ORDER BY is_builtin DESC, name';
+        const rows = this.ctx.db.prepare(sql).all(...params);
+        return rows.map(rowToWorkflow);
+    }
+    /**
+     * Get a workflow by ID.
+     */
+    async getWorkflow(id) {
+        const row = this.ctx.db.prepare(`
+      SELECT * FROM ${T.workflows} WHERE id = ?
+    `).get(id);
+        if (!row)
+            return null;
+        return rowToWorkflow(row);
+    }
+    /**
+     * Create a new workflow.
+     */
+    async createWorkflow(workflow) {
+        const id = workflow.id || slugify(workflow.name || 'workflow');
+        const now = new Date().toISOString();
+        // Check for duplicate name
+        const existing = this.ctx.db.prepare(`
+      SELECT id FROM ${T.workflows}
+      WHERE LOWER(name) = LOWER(?)
+    `).get(workflow.name);
+        if (existing) {
+            throw new PMOError('CONFLICT', `Workflow with name "${workflow.name}" already exists`);
+        }
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.workflows} (id, name, description, is_builtin, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(id, workflow.name || 'New Workflow', workflow.description || null, workflow.isBuiltin ? 1 : 0, now, now);
+        return {
+            id,
+            name: workflow.name || 'New Workflow',
+            description: workflow.description,
+            isBuiltin: workflow.isBuiltin || false,
+            createdAt: new Date(now),
+            updatedAt: new Date(now),
+        };
+    }
+    /**
+     * Update a workflow.
+     */
+    async updateWorkflow(id, changes) {
+        const existing = await this.getWorkflow(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Workflow not found: ${id}`);
+        }
+        const updates = [];
+        const params = [];
+        if (changes.name !== undefined) {
+            // Check for duplicate name
+            const duplicate = this.ctx.db.prepare(`
+        SELECT id FROM ${T.workflows}
+        WHERE LOWER(name) = LOWER(?) AND id != ?
+      `).get(changes.name, id);
+            if (duplicate) {
+                throw new PMOError('CONFLICT', `Workflow with name "${changes.name}" already exists`);
+            }
+            updates.push('name = ?');
+            params.push(changes.name);
+        }
+        if (changes.description !== undefined) {
+            updates.push('description = ?');
+            params.push(changes.description || null);
+        }
+        if (updates.length > 0) {
+            updates.push('updated_at = ?');
+            params.push(new Date().toISOString());
+            params.push(id);
+            this.ctx.db.prepare(`UPDATE ${T.workflows} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+        }
+        return (await this.getWorkflow(id));
+    }
+    /**
+     * Delete a workflow.
+     */
+    async deleteWorkflow(id) {
+        const existing = await this.getWorkflow(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Workflow not found: ${id}`);
+        }
+        if (existing.isBuiltin) {
+            throw new PMOError('INVALID', `Cannot delete built-in workflow: ${existing.name}`);
+        }
+        // Check if any projects use this workflow
+        const projectCount = this.ctx.db.prepare(`
+      SELECT COUNT(*) as count FROM ${T.projects}
+      WHERE workflow_id = ?
+    `).get(id);
+        if (projectCount.count > 0) {
+            throw new PMOError('CONFLICT', `Cannot delete workflow: ${projectCount.count} project(s) are using it`);
+        }
+        // Delete associated statuses first (cascaded by FK, but explicit for safety)
+        this.ctx.db.prepare(`DELETE FROM ${T.workflow_statuses} WHERE workflow_id = ?`).run(id);
+        this.ctx.db.prepare(`DELETE FROM ${T.workflows} WHERE id = ?`).run(id);
+    }
+    /**
+     * Get the workflow for a project.
+     */
+    async getProjectWorkflow(projectId) {
+        const row = this.ctx.db.prepare(`
+      SELECT w.* FROM ${T.workflows} w
+      JOIN ${T.projects} p ON p.workflow_id = w.id
+      WHERE p.id = ?
+    `).get(projectId);
+        if (!row)
+            return null;
+        return rowToWorkflow(row);
+    }
+    // ============================================================================
+    // Workflow Status Operations
+    // ============================================================================
+    /**
+     * List statuses for a workflow.
+     */
+    async listStatuses(workflowId) {
+        const rows = this.ctx.db.prepare(`
+      SELECT * FROM ${T.workflow_statuses}
+      WHERE workflow_id = ?
+      ORDER BY position
+    `).all(workflowId);
+        return rows.map(rowToWorkflowStatus);
+    }
+    /**
+     * Get a status by ID.
+     */
+    async getStatus(id) {
+        const row = this.ctx.db.prepare(`
+      SELECT * FROM ${T.workflow_statuses} WHERE id = ?
+    `).get(id);
+        if (!row)
+            return null;
+        return rowToWorkflowStatus(row);
+    }
+    /**
+     * Create a new status in a workflow.
+     */
+    async createStatus(workflowId, status) {
+        const id = status.id || `${workflowId}-${slugify(status.name || 'status')}`;
+        const category = status.category || 'backlog';
+        const now = new Date().toISOString();
+        // Validate workflow exists
+        const workflow = await this.getWorkflow(workflowId);
+        if (!workflow) {
+            throw new PMOError('NOT_FOUND', `Workflow not found: ${workflowId}`);
+        }
+        // Validate category
+        if (!STATE_CATEGORY_ORDER.includes(category)) {
+            throw new PMOError('INVALID', `Invalid category: ${category}. Must be one of: ${STATE_CATEGORY_ORDER.join(', ')}`);
+        }
+        // Get next position if not specified
+        let position = status.position;
+        if (position === undefined) {
+            const maxPos = this.ctx.db.prepare(`
+        SELECT COALESCE(MAX(position), -1) as max_pos
+        FROM ${T.workflow_statuses}
+        WHERE workflow_id = ?
+      `).get(workflowId);
+            position = maxPos.max_pos + 1;
+        }
+        // Check for duplicate name in workflow
+        const existing = this.ctx.db.prepare(`
+      SELECT id FROM ${T.workflow_statuses}
+      WHERE workflow_id = ? AND LOWER(name) = LOWER(?)
+    `).get(workflowId, status.name);
+        if (existing) {
+            throw new PMOError('CONFLICT', `Status with name "${status.name}" already exists in this workflow`);
+        }
+        // If this is the default, unset other defaults in the workflow
+        if (status.isDefault) {
+            this.ctx.db.prepare(`
+        UPDATE ${T.workflow_statuses}
+        SET is_default = 0
+        WHERE workflow_id = ?
+      `).run(workflowId);
+        }
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.workflow_statuses} (id, workflow_id, name, category, position, color, description, is_default, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, workflowId, status.name || 'New Status', category, position, status.color || null, status.description || null, status.isDefault ? 1 : 0, now);
+        // Update workflow's updated_at timestamp
+        this.ctx.db.prepare(`UPDATE ${T.workflows} SET updated_at = ? WHERE id = ?`).run(now, workflowId);
+        return {
+            id,
+            workflowId,
+            name: status.name || 'New Status',
+            category,
+            position,
+            color: status.color,
+            description: status.description,
+            isDefault: status.isDefault || false,
+            createdAt: new Date(now),
+        };
+    }
+    /**
+     * Update a status.
+     */
+    async updateStatus(id, changes) {
+        const existing = await this.getStatus(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Status not found: ${id}`);
+        }
+        const updates = [];
+        const params = [];
+        if (changes.name !== undefined) {
+            // Check for duplicate name
+            const duplicate = this.ctx.db.prepare(`
+        SELECT id FROM ${T.workflow_statuses}
+        WHERE workflow_id = ? AND LOWER(name) = LOWER(?) AND id != ?
+      `).get(existing.workflowId, changes.name, id);
+            if (duplicate) {
+                throw new PMOError('CONFLICT', `Status with name "${changes.name}" already exists in this workflow`);
+            }
+            updates.push('name = ?');
+            params.push(changes.name);
+        }
+        if (changes.category !== undefined) {
+            if (!STATE_CATEGORY_ORDER.includes(changes.category)) {
+                throw new PMOError('INVALID', `Invalid category: ${changes.category}`);
+            }
+            updates.push('category = ?');
+            params.push(changes.category);
+        }
+        if (changes.position !== undefined) {
+            updates.push('position = ?');
+            params.push(changes.position);
+        }
+        if (changes.color !== undefined) {
+            updates.push('color = ?');
+            params.push(changes.color || null);
+        }
+        if (changes.description !== undefined) {
+            updates.push('description = ?');
+            params.push(changes.description || null);
+        }
+        if (changes.isDefault !== undefined) {
+            if (changes.isDefault) {
+                // Unset other defaults
+                this.ctx.db.prepare(`
+          UPDATE ${T.workflow_statuses}
+          SET is_default = 0
+          WHERE workflow_id = ?
+        `).run(existing.workflowId);
+            }
+            updates.push('is_default = ?');
+            params.push(changes.isDefault ? 1 : 0);
+        }
+        if (updates.length > 0) {
+            params.push(id);
+            this.ctx.db.prepare(`UPDATE ${T.workflow_statuses} SET ${updates.join(', ')} WHERE id = ?`).run(...params);
+            // Update workflow's updated_at timestamp
+            this.ctx.db.prepare(`UPDATE ${T.workflows} SET updated_at = ? WHERE id = ?`).run(new Date().toISOString(), existing.workflowId);
+        }
+        return (await this.getStatus(id));
+    }
+    /**
+     * Delete a status.
+     */
+    async deleteStatus(id) {
+        const existing = await this.getStatus(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Status not found: ${id}`);
+        }
+        // Check if any tickets use this status
+        const ticketCount = this.ctx.db.prepare(`
+      SELECT COUNT(*) as count FROM ${T.tickets}
+      WHERE status_id = ?
+    `).get(id);
+        if (ticketCount.count > 0) {
+            throw new PMOError('CONFLICT', `Cannot delete status: ${ticketCount.count} ticket(s) are using it`);
+        }
+        this.ctx.db.prepare(`DELETE FROM ${T.workflow_statuses} WHERE id = ?`).run(id);
+        // Reorder remaining statuses
+        this.ctx.db.prepare(`
+      UPDATE ${T.workflow_statuses}
+      SET position = position - 1
+      WHERE workflow_id = ? AND position > ?
+    `).run(existing.workflowId, existing.position);
+        // Update workflow's updated_at timestamp
+        this.ctx.db.prepare(`UPDATE ${T.workflows} SET updated_at = ? WHERE id = ?`).run(new Date().toISOString(), existing.workflowId);
+    }
+    /**
+     * Reorder a status to a new position.
+     */
+    async reorderStatus(id, newPosition) {
+        const existing = await this.getStatus(id);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Status not found: ${id}`);
+        }
+        const oldPosition = existing.position;
+        if (oldPosition === newPosition) {
+            return existing;
+        }
+        // Shift other statuses
+        if (newPosition < oldPosition) {
+            this.ctx.db.prepare(`
+        UPDATE ${T.workflow_statuses}
+        SET position = position + 1
+        WHERE workflow_id = ? AND position >= ? AND position < ?
+      `).run(existing.workflowId, newPosition, oldPosition);
+        }
+        else {
+            this.ctx.db.prepare(`
+        UPDATE ${T.workflow_statuses}
+        SET position = position - 1
+        WHERE workflow_id = ? AND position > ? AND position <= ?
+      `).run(existing.workflowId, oldPosition, newPosition);
+        }
+        // Update the status's position
+        this.ctx.db.prepare(`
+      UPDATE ${T.workflow_statuses}
+      SET position = ?
+      WHERE id = ?
+    `).run(newPosition, id);
+        // Update workflow's updated_at timestamp
+        this.ctx.db.prepare(`UPDATE ${T.workflows} SET updated_at = ? WHERE id = ?`).run(new Date().toISOString(), existing.workflowId);
+        return (await this.getStatus(id));
+    }
+    /**
+     * Get the default status for a workflow.
+     */
+    async getDefaultStatus(workflowId) {
+        const row = this.ctx.db.prepare(`
+      SELECT * FROM ${T.workflow_statuses}
+      WHERE workflow_id = ? AND is_default = 1
+    `).get(workflowId);
+        if (!row) {
+            // If no explicit default, return first status (by position)
+            const fallback = this.ctx.db.prepare(`
+        SELECT * FROM ${T.workflow_statuses}
+        WHERE workflow_id = ?
+        ORDER BY position
+        LIMIT 1
+      `).get(workflowId);
+            if (!fallback)
+                return null;
+            return rowToWorkflowStatus(fallback);
+        }
+        return rowToWorkflowStatus(row);
+    }
+}

package/dist/lib/pmo/storage/subtasks.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Subtask operations for tickets.
+ */
+import { Subtask, AcceptanceCriterion } from '../types.js';
+import { StorageContext } from './types.js';
+export declare class SubtaskStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * Add a subtask to a ticket.
+     */
+    addSubtask(ticketId: string, title: string): Promise<Subtask>;
+    /**
+     * Toggle a subtask's done status.
+     */
+    toggleSubtask(ticketId: string, subtaskId: string): Promise<Subtask>;
+    /**
+     * Remove a subtask from a ticket.
+     */
+    removeSubtask(ticketId: string, subtaskId: string): Promise<void>;
+}
+export declare class AcceptanceCriteriaStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * Add an acceptance criterion to a ticket.
+     */
+    addAcceptanceCriterion(ticketId: string, criterion: string): Promise<AcceptanceCriterion>;
+    /**
+     * Remove an acceptance criterion from a ticket.
+     */
+    removeAcceptanceCriterion(ticketId: string, criterionId: string): Promise<void>;
+    /**
+     * Clear all acceptance criteria from a ticket.
+     */
+    clearAcceptanceCriteria(ticketId: string): Promise<void>;
+}

package/dist/lib/pmo/storage/subtasks.js

@@ -0,0 +1,184 @@
+/**
+ * Subtask operations for tickets.
+ */
+import { PMO_TABLES } from '../schema.js';
+import { PMOError } from '../types.js';
+import { slugify } from '../utils.js';
+const T = PMO_TABLES;
+export class SubtaskStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Add a subtask to a ticket.
+     */
+    async addSubtask(ticketId, title) {
+        // Verify ticket exists and get project_id
+        const ticket = this.ctx.db.prepare(`
+      SELECT id, project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        if (!ticket) {
+            throw new PMOError('NOT_FOUND', `Ticket not found: ${ticketId}`, ticketId);
+        }
+        // Get current max position
+        const maxPos = this.ctx.db.prepare(`
+      SELECT COALESCE(MAX(position), -1) as max_pos
+      FROM ${T.subtasks} WHERE ticket_id = ?
+    `).get(ticketId);
+        const id = slugify(title);
+        const position = maxPos.max_pos + 1;
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.subtasks} (id, ticket_id, title, done, position)
+      VALUES (?, ?, ?, 0, ?)
+    `).run(id, ticketId, title, position);
+        // Update ticket timestamp
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
+    `).run(Date.now(), ticketId);
+        this.ctx.updateBoardTimestamp(ticket.project_id);
+        return {
+            id,
+            title,
+            done: false,
+        };
+    }
+    /**
+     * Toggle a subtask's done status.
+     */
+    async toggleSubtask(ticketId, subtaskId) {
+        // Get ticket's project_id for board timestamp update
+        const ticket = this.ctx.db.prepare(`
+      SELECT project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        const existing = this.ctx.db.prepare(`
+      SELECT * FROM ${T.subtasks}
+      WHERE ticket_id = ? AND id = ?
+    `).get(ticketId, subtaskId);
+        if (!existing) {
+            throw new PMOError('NOT_FOUND', `Subtask not found: ${subtaskId}`);
+        }
+        const newDone = existing.done === 0 ? 1 : 0;
+        this.ctx.db.prepare(`
+      UPDATE ${T.subtasks}
+      SET done = ?
+      WHERE ticket_id = ? AND id = ?
+    `).run(newDone, ticketId, subtaskId);
+        // Update ticket timestamp
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
+    `).run(Date.now(), ticketId);
+        if (ticket) {
+            this.ctx.updateBoardTimestamp(ticket.project_id);
+        }
+        return {
+            id: existing.id,
+            title: existing.title,
+            done: newDone === 1,
+        };
+    }
+    /**
+     * Remove a subtask from a ticket.
+     */
+    async removeSubtask(ticketId, subtaskId) {
+        // Get ticket's project_id for board timestamp update
+        const ticket = this.ctx.db.prepare(`
+      SELECT project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        const result = this.ctx.db.prepare(`
+      DELETE FROM ${T.subtasks}
+      WHERE ticket_id = ? AND id = ?
+    `).run(ticketId, subtaskId);
+        if (result.changes === 0) {
+            throw new PMOError('NOT_FOUND', `Subtask not found: ${subtaskId}`);
+        }
+        // Update ticket timestamp
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
+    `).run(Date.now(), ticketId);
+        if (ticket) {
+            this.ctx.updateBoardTimestamp(ticket.project_id);
+        }
+    }
+}
+export class AcceptanceCriteriaStorage {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    /**
+     * Add an acceptance criterion to a ticket.
+     */
+    async addAcceptanceCriterion(ticketId, criterion) {
+        // Verify ticket exists and get project_id
+        const ticket = this.ctx.db.prepare(`
+      SELECT id, project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        if (!ticket) {
+            throw new PMOError('NOT_FOUND', `Ticket not found: ${ticketId}`, ticketId);
+        }
+        // Get current max position
+        const maxPos = this.ctx.db.prepare(`
+      SELECT COALESCE(MAX(position), -1) as max_pos
+      FROM ${T.ticket_acceptance_criteria} WHERE ticket_id = ?
+    `).get(ticketId);
+        const id = `ac-${Date.now()}`;
+        const position = maxPos.max_pos + 1;
+        this.ctx.db.prepare(`
+      INSERT INTO ${T.ticket_acceptance_criteria} (id, ticket_id, criterion, verifiable, verified, position)
+      VALUES (?, ?, ?, 1, 0, ?)
+    `).run(id, ticketId, criterion, position);
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
+    `).run(Date.now(), ticketId);
+        this.ctx.updateBoardTimestamp(ticket.project_id);
+        return {
+            id,
+            ticketId,
+            criterion,
+            verifiable: true,
+            verified: false,
+            position,
+        };
+    }
+    /**
+     * Remove an acceptance criterion from a ticket.
+     */
+    async removeAcceptanceCriterion(ticketId, criterionId) {
+        // Get ticket's project_id for board timestamp update
+        const ticket = this.ctx.db.prepare(`
+      SELECT project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        const result = this.ctx.db.prepare(`
+      DELETE FROM ${T.ticket_acceptance_criteria}
+      WHERE ticket_id = ? AND id = ?
+    `).run(ticketId, criterionId);
+        if (result.changes === 0) {
+            throw new PMOError('NOT_FOUND', `Acceptance criterion not found: ${criterionId}`);
+        }
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
+    `).run(Date.now(), ticketId);
+        if (ticket) {
+            this.ctx.updateBoardTimestamp(ticket.project_id);
+        }
+    }
+    /**
+     * Clear all acceptance criteria from a ticket.
+     */
+    async clearAcceptanceCriteria(ticketId) {
+        // Get ticket's project_id for board timestamp update
+        const ticket = this.ctx.db.prepare(`
+      SELECT project_id FROM ${T.tickets} WHERE id = ?
+    `).get(ticketId);
+        this.ctx.db.prepare(`
+      DELETE FROM ${T.ticket_acceptance_criteria} WHERE ticket_id = ?
+    `).run(ticketId);
+        this.ctx.db.prepare(`
+      UPDATE ${T.tickets} SET updated_at = ? WHERE id = ?
+    `).run(Date.now(), ticketId);
+        if (ticket) {
+            this.ctx.updateBoardTimestamp(ticket.project_id);
+        }
+    }
+}

package/dist/lib/pmo/storage/templates.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ticket template operations.
+ *
+ * Note: Workflow templates have been removed. Workflows are now used directly
+ * as the source of truth for status configurations. See workflow commands
+ * and StatusStorage for workflow operations.
+ */
+import { TicketTemplate, TicketTemplateFilter } from '../types.js';
+import type { StorageContext } from './types.js';
+export declare class TemplateStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * List ticket templates.
+     */
+    listTicketTemplates(filter?: TicketTemplateFilter): Promise<TicketTemplate[]>;
+    /**
+     * Get a ticket template by ID.
+     */
+    getTicketTemplate(id: string): Promise<TicketTemplate | null>;
+    /**
+     * Create a new ticket template.
+     */
+    createTicketTemplate(template: Partial<TicketTemplate> & {
+        name: string;
+    }): Promise<TicketTemplate>;
+    /**
+     * Create a ticket template from an existing ticket.
+     */
+    createTicketTemplateFromTicket(ticketId: string, name: string, description?: string): Promise<TicketTemplate>;
+    /**
+     * Update a ticket template.
+     */
+    updateTicketTemplate(id: string, changes: Partial<TicketTemplate>): Promise<TicketTemplate>;
+    /**
+     * Delete a ticket template.
+     */
+    deleteTicketTemplate(id: string): Promise<void>;
+    private rowToTicketTemplate;
+}