Checklists

Manage checklist templates and instances with the de.iterate SDK.

Overview

The checklists resource provides operations for managing reusable checklist templates and their instances, commonly used for compliance activities, audits, and assurance tasks.

Templates

List Templates

const templates = await client.checklists.listTemplates();

console.log(`Found ${templates.length} templates`);
for (const template of templates) {
  console.log(`  • ${template.title} (${template.items.length} items)`);
}

Get Template

const template = await client.checklists.getTemplate('template-123');

console.log(template.title);
console.log(`Items: ${template.items.length}`);
for (const item of template.items) {
  console.log(`  • ${item.title} (${item.type})`);
}

Create Template

const template = await client.checklists.createTemplate({
  title: 'Monthly Security Review',
  description: 'Standard security review checklist',
  standard: 'ISO 27001',
  isReusable: true,
  items: [
    {
      title: 'Review access logs',
      description: 'Check for anomalous access patterns',
      type: 'checkbox',
      required: true,
    },
    {
      title: 'Verify backup completion',
      type: 'checkbox',
      required: true,
    },
    {
      title: 'Notes',
      type: 'text',
      required: false,
    },
  ],
  repeat: {
    frequency: 'monthly',
    interval: 1,
  },
});

CreateTemplateInput

Field	Type	Required	Description
title	string	✅	Template title
description	string	❌	Description
standard	string	❌	Associated standard (ISO 27001, SOC 2, etc.)
standards	string[]	❌	Multiple standards
items	ChecklistItem[]	✅	Checklist items
isReusable	boolean	❌	Can be reused
isAssuranceTask	boolean	❌	Links to assurance
repeat	object	❌	Recurrence settings
reviewDate	string	❌	Review date

Update Template

await client.checklists.updateTemplate('template-123', {
  title: 'Updated Security Review',
  items: [...existingItems, newItem],
});

Delete Template

await client.checklists.deleteTemplate('template-123');

Checklists (Instances)

List Checklists

// List all checklists
const checklists = await client.checklists.list();

// Filter by template
const fromTemplate = await client.checklists.list({
  templateId: 'template-123'
});

// Filter by status
const completed = await client.checklists.list({
  status: 'completed'
});

Get Checklist

const checklist = await client.checklists.get('checklist-456');

console.log(checklist.title);
console.log(`Status: ${checklist.status}`);
console.log(`Items: ${checklist.items.length}`);

Create Checklist

// Create from scratch
const checklist = await client.checklists.create({
  title: 'Q1 2025 Security Review',
  description: 'Quarterly security review for Q1',
  items: [
    { title: 'Review access logs', type: 'checkbox', required: true },
    { title: 'Check firewall rules', type: 'checkbox', required: true },
  ],
});

// Create from template
const fromTemplate = await client.checklists.createFromTemplate('template-123');

Update Checklist

await client.checklists.update('checklist-456', {
  status: 'in-progress',
  items: updatedItems,
});

Submit/Complete Checklist

await client.checklists.submit('checklist-456', {
  signature: 'John Doe',
  values: {
    'item-1': true,
    'item-2': true,
    'item-3': 'No issues found',
  },
  findings: [
    {
      title: 'Minor configuration issue',
      severity: 'low',
    },
  ],
});

SubmitChecklistInput

Field	Type	Description
signature	string	Submitter's signature/name
values	Record<string, any>	Item responses
findings	any[]	Any findings discovered

Delete Checklist

await client.checklists.delete('checklist-456');

Types

ChecklistTemplate

interface ChecklistTemplate {
  id: string;
  title: string;
  description?: string;
  standard?: string;
  standards?: string[];
  items: ChecklistItem[];
  isReusable?: boolean;
  isAssuranceTask?: boolean;
  badgeClass?: string;
  repeat?: {
    frequency?: string;
    interval?: number;
    startDate?: string;
    endDate?: string | null;
  };
  reviewDate?: string | null;
  tenantId?: string;
  createdBy?: string;
  createdAt?: string;
  updatedAt?: string;
}

Checklist

interface Checklist {
  id: string;
  title: string;
  description?: string;
  templateId?: string;
  standard?: string;
  standards?: string[];
  items: ChecklistItem[];
  status: 'draft' | 'in-progress' | 'completed' | string;
  isAssuranceTask?: boolean;
  isReusable?: boolean;
  repeat?: {
    frequency?: string;
    interval?: number;
    startDate?: string;
    endDate?: string | null;
  };
  reviewDate?: string | null;
  createdAt?: string;
  updatedAt?: string;
  completedAt?: string | null;
  completedBy?: string | null;
  completionHistory?: Array<{
    completedAt: string;
    completedBy: string;
    values?: Record<string, any>;
    signature?: string;
    findings?: any[];
  }>;
  findings?: any[];
}

ChecklistItem

interface ChecklistItem {
  id?: string;
  title: string;
  description?: string;
  type?: string;  // 'checkbox', 'text', 'select', 'date', etc.
  required?: boolean;
  options?: string[];  // For select type
}

Examples

Checklist Dashboard

async function checklistDashboard() {
  const checklists = await client.checklists.list();
  
  const byStatus = {
    draft: 0,
    'in-progress': 0,
    completed: 0,
  };
  
  for (const checklist of checklists) {
    const status = checklist.status || 'draft';
    if (status in byStatus) {
      byStatus[status as keyof typeof byStatus]++;
    }
  }
  
  console.log('Checklist Dashboard');
  console.log('===================');
  console.log(`📝 Draft: ${byStatus.draft}`);
  console.log(`🔄 In Progress: ${byStatus['in-progress']}`);
  console.log(`✅ Completed: ${byStatus.completed}`);
}

Create Weekly Checklists

async function createWeeklyChecklists() {
  const templates = await client.checklists.listTemplates();
  
  // Find weekly templates
  const weeklyTemplates = templates.filter(
    t => t.repeat?.frequency === 'weekly'
  );
  
  for (const template of weeklyTemplates) {
    const checklist = await client.checklists.createFromTemplate(template.id);
    console.log(`Created: ${checklist.title}`);
  }
}

Bulk Complete Checklists

async function bulkComplete(checklistIds: string[], submitter: string) {
  for (const id of checklistIds) {
    const checklist = await client.checklists.get(id);
    
    // Auto-complete all checkbox items
    const values: Record<string, any> = {};
    for (const item of checklist.items) {
      if (item.type === 'checkbox') {
        values[item.id!] = true;
      }
    }
    
    await client.checklists.submit(id, {
      signature: submitter,
      values,
    });
    
    console.log(`Completed: ${checklist.title}`);
  }
}

Next Steps

• Assurance Tasks - Link to assurance activities
• Audits - Audit checklists
• Findings - Checklist findings