@calltelemetry/cli 0.6.12 → 0.7.1

package/dist/lib/seed/families.js

@@ -0,0 +1,1541 @@
+import { randomUUID } from 'node:crypto';
+import { copyRows, reserveIds } from './copy.js';
+import { DASHBOARD_TEMPLATE_FIXTURES } from './dashboard-templates.js';
+import { TABLE_COLUMNS, SEED_TABLES } from './schema/index.js';
+const DEVICE_NAMES = ['SEP001122334455', 'SEP00AABBCCDDEE', 'CSFAGENT01', 'TABREMOTE01'];
+const PEER_IPS = ['10.10.10.10', '10.10.10.11', '10.20.20.20', '10.20.20.21'];
+const MEDIA_TYPES = ['audio', 'voice'];
+const FALLBACK_DEVICE_POOLS = ['Default', 'HQ-Pool', 'Remote-Office-East', 'Remote-Office-West'];
+const FALLBACK_LOCATIONS = ['HQ-Floor1', 'HQ-Floor2', 'HQ-Floor3', 'Remote-East'];
+const FALLBACK_MODELS = ['Cisco 8841', 'Cisco 8845', 'Cisco 8861'];
+const FALLBACK_SUBNETS = ['10.10.1.0/24', '10.10.2.0/24', '10.20.1.0/24'];
+function affectedRows(rowCount) {
+    return rowCount ?? 0;
+}
+function chunkSizeFor(count) {
+    if (count >= 100_000)
+        return 10_000;
+    if (count >= 10_000)
+        return 5_000;
+    return 1_000;
+}
+function pick(items, index) {
+    return items[index % items.length];
+}
+function randomPhone(prefix, seed) {
+    return `${prefix}${String(1_000_000 + (seed % 8_999_999)).padStart(7, '0')}`;
+}
+function randomIpv4(seed) {
+    return `10.${10 + (seed % 20)}.${20 + (seed % 30)}.${30 + (seed % 200)}`;
+}
+function randomDuration(seed) {
+    return 30 + (seed % 1800);
+}
+function timeSpread(days, offset) {
+    const now = Date.now();
+    const spanMs = days * 24 * 60 * 60 * 1000;
+    const delta = Math.floor((offset % Math.max(spanMs, 1)) / 1000) * 1000;
+    return new Date(now - delta);
+}
+function chunkRange(total, chunk) {
+    const ranges = [];
+    for (let offset = 0; offset < total; offset += chunk) {
+        ranges.push({ offset, size: Math.min(chunk, total - offset) });
+    }
+    return ranges;
+}
+function tableMeta(key) {
+    return {
+        tableName: SEED_TABLES[key].tableName,
+        sequenceName: SEED_TABLES[key].sequenceName,
+        columns: TABLE_COLUMNS[key],
+    };
+}
+async function insertControlRow(client, sql, values) {
+    const result = await client.query(sql, values);
+    return Number.parseInt(result.rows[0].id, 10);
+}
+async function createCdrIntegration(client, orgId, home, name) {
+    return insertControlRow(client, `
+      INSERT INTO public.cdr_integrations
+        (name, healthy, username, inserted_at, updated_at, org_id, home)
+      VALUES
+        ($1, true, $2, now(), now(), $3, $4)
+      RETURNING id
+    `, [name, name, orgId, home]);
+}
+async function createCallmanager(client, orgId, name) {
+    return insertControlRow(client, `
+      INSERT INTO public.callmanagers
+        (name, org_id, inserted_at, updated_at, enable_axl_sync, enable_ris_sync, enable_phone_query, ris_batch_size)
+      VALUES
+        ($1, $2, now(), now(), false, false, false, 100)
+      RETURNING id
+    `, [name, orgId]);
+}
+async function createCube(client, orgId, name) {
+    return insertControlRow(client, `
+      INSERT INTO public.cubes
+        (name, xcc_hostname, xcc_enabled, xcc_online, org_id, inserted_at, updated_at, application_name, xcc_mode, xcc_emulator)
+      VALUES
+        ($1, $2, true, true, $3, now(), now(), 'ct-seed', 'both', true)
+      RETURNING id
+    `, [name, `${name}.local`, orgId]);
+}
+async function copyChunked(client, key, rows) {
+    const meta = tableMeta(key);
+    await copyRows(client, meta.tableName, meta.columns, rows);
+}
+async function reserveChunkIds(client, key, count) {
+    const sequenceName = tableMeta(key).sequenceName;
+    if (!sequenceName) {
+        throw new Error(`Table '${key}' does not use a numeric sequence.`);
+    }
+    return reserveIds(client, sequenceName, count);
+}
+async function findExistingCallmanagerId(client, orgId) {
+    const result = await client.query(`
+      SELECT id
+      FROM public.callmanagers
+      WHERE org_id = $1
+      ORDER BY id ASC
+      LIMIT 1
+    `, [orgId]);
+    const value = result.rows[0]?.id;
+    return value ? Number.parseInt(value, 10) : null;
+}
+async function getOrCreateCallmanagerId(client, orgId, name) {
+    const existingId = await findExistingCallmanagerId(client, orgId);
+    if (existingId) {
+        return { id: existingId, created: false };
+    }
+    return {
+        id: await createCallmanager(client, orgId, name),
+        created: true,
+    };
+}
+async function queryWeightedDimension(client, sql, params, fallback) {
+    try {
+        const result = await client.query(sql, params);
+        const rows = result.rows.filter((row) => row.value);
+        if (rows.length > 0) {
+            const total = rows.reduce((sum, row) => sum + Number.parseInt(row.count, 10), 0);
+            if (total > 0) {
+                return rows.map((row) => ({
+                    value: row.value,
+                    weight: Number.parseInt(row.count, 10) / total,
+                }));
+            }
+        }
+    }
+    catch {
+        // Fall through to fallback values.
+    }
+    const weight = 1 / fallback.length;
+    return fallback.map((value) => ({ value, weight }));
+}
+async function queryPhoneCount(client, orgId) {
+    try {
+        const result = await client.query('SELECT COUNT(*)::bigint AS count FROM public.phones WHERE org_id = $1', [orgId]);
+        return Number.parseInt(result.rows[0]?.count ?? '0', 10);
+    }
+    catch {
+        return 0;
+    }
+}
+async function seedCurriEvents(client, ctx, plan) {
+    const chunk = chunkSizeFor(plan.count);
+    let inserted = 0;
+    for (const { offset, size } of chunkRange(plan.count, chunk)) {
+        const curriIds = await reserveChunkIds(client, 'curri_events', size);
+        const appIds = await reserveChunkIds(client, 'app_events', size);
+        const signalIds = await reserveChunkIds(client, 'reputation_signals', size);
+        const curriRows = [];
+        const appRows = [];
+        const signalRows = [];
+        for (let index = 0; index < size; index++) {
+            const seed = offset + index + 1;
+            const occurredAt = timeSpread(plan.days, seed * 90_000);
+            const action = seed % 4 === 0 ? 'block' : 'permit';
+            const curriId = curriIds[index];
+            curriRows.push({
+                id: curriId,
+                calling_number: randomPhone('+1408', seed),
+                called_number: randomPhone('+1650', seed * 3),
+                trigger_point_type: seed % 3 === 0 ? 'pre_call' : 'route_request',
+                calling_devicename: pick(DEVICE_NAMES, seed),
+                result: action === 'block' ? 'blocked' : 'permitted',
+                inserted_at: occurredAt,
+                updated_at: occurredAt,
+                action_taken: action,
+                org_id: ctx.orgId,
+                alert_variables: { ct_seed_run_id: ctx.runId, family: 'curri_events' },
+                applied_modifiers: action === 'block' ? {} : { calling_name: `Customer ${seed}` },
+                final_rendered_action: action,
+                response_time: 200_000 + (seed % 50_000),
+                processing_time: 80_000 + (seed % 25_000),
+            });
+            appRows.push({
+                id: appIds[index],
+                policy_action: action,
+                policy_reason: action === 'block' ? 'spam_score' : 'allow_list',
+                policy_destination: action === 'block' ? 'blocked' : 'routed',
+                policy_outcome: action === 'block' ? 'blocked' : 'permitted',
+                result: action === 'block' ? 'blocked' : 'success',
+                message: `ct-seed app event ${ctx.runId}`,
+                provider: 'ct-seed',
+                raw: { ct_seed_run_id: ctx.runId, family: 'curri_events' },
+                debug: { index: seed },
+                data: { callingNumber: randomPhone('+1408', seed) },
+                action,
+                org_id: ctx.orgId,
+                curri_event_id: curriId,
+                inserted_at: occurredAt,
+                updated_at: occurredAt,
+            });
+            signalRows.push({
+                id: signalIds[index],
+                org_id: ctx.orgId,
+                curri_event_id: curriId,
+                app_id: 0,
+                app_name: 'ct-seed',
+                provider_type: 'ct_seed',
+                signal_type: action === 'block' ? 'spam' : 'reputation',
+                score: action === 'block' ? 85 : 12,
+                classification: action === 'block' ? 'block' : 'allow',
+                weight: 1,
+                confidence: 0.9,
+                raw: { ct_seed_run_id: ctx.runId, family: 'curri_events' },
+                occurred_at: occurredAt,
+                inserted_at: occurredAt,
+                updated_at: occurredAt,
+            });
+        }
+        await copyChunked(client, 'curri_events', curriRows);
+        await copyChunked(client, 'app_events', appRows);
+        await copyChunked(client, 'reputation_signals', signalRows);
+        inserted += size;
+    }
+    return {
+        family: 'curri_events',
+        requestedCount: plan.count,
+        insertedCount: inserted,
+        details: {
+            runId: ctx.runId,
+            marker: ctx.marker,
+        },
+    };
+}
+function buildBaseCdrRow(id, integrationId, seed, occurredAt, duration, marker) {
+    const disconnectAt = new Date(occurredAt.getTime() + duration * 1000);
+    return {
+        id,
+        pkid: randomUUID(),
+        cdrRecordType: 1,
+        globalCallID_callManagerId: 1,
+        globalCallID_callId: 2_000_000 + seed,
+        origLegCallIdentifier: `orig-${seed}`,
+        destLegIdentifier: `dest-${seed}`,
+        dateTimeOrigination: occurredAt,
+        dateTimeConnect: occurredAt,
+        dateTimeDisconnect: disconnectAt,
+        duration,
+        callingPartyNumber: randomPhone('+1408', seed),
+        originalCalledPartyNumber: randomPhone('+1650', seed * 5),
+        finalCalledPartyNumber: randomPhone('+1310', seed * 7),
+        origIpAddr: randomIpv4(seed),
+        destIpAddr: randomIpv4(seed * 2),
+        origDeviceName: pick(DEVICE_NAMES, seed),
+        destDeviceName: pick(DEVICE_NAMES, seed + 1),
+        globalCallId_ClusterID: 'ct-seed',
+        comment: marker,
+        authCodeDescription: null,
+        clientMatterCode: null,
+        authorizationCodeValue: null,
+        cdr_integrations_id: integrationId,
+        inserted_at: occurredAt,
+        updated_at: occurredAt,
+    };
+}
+async function seedCdrRecords(client, ctx, plan) {
+    const familyMarker = `${ctx.marker}:cdr_records`;
+    const integrationHome = `/ct-seed/cdr/${ctx.runId}`;
+    const integrationId = await createCdrIntegration(client, ctx.orgId, integrationHome, `ct-seed-cdr-${ctx.runId}`);
+    const chunk = chunkSizeFor(plan.count);
+    let inserted = 0;
+    for (const { offset, size } of chunkRange(plan.count, chunk)) {
+        const ids = await reserveChunkIds(client, 'cdrcalls', size);
+        const rows = ids.map((id, index) => {
+            const seed = offset + index + 1;
+            const occurredAt = timeSpread(plan.days, seed * 150_000);
+            return buildBaseCdrRow(id, integrationId, seed, occurredAt, randomDuration(seed), familyMarker);
+        });
+        await copyChunked(client, 'cdrcalls', rows);
+        inserted += size;
+    }
+    return {
+        family: 'cdr_records',
+        requestedCount: plan.count,
+        insertedCount: inserted,
+        details: {
+            integrationHome,
+            marker: familyMarker,
+        },
+    };
+}
+async function seedMissedCalls(client, ctx, plan) {
+    const syncSource = `${ctx.marker}:missed_calls`;
+    const callmanagerName = `ct-seed-missed-${ctx.runId}`;
+    const callmanagerId = await createCallmanager(client, ctx.orgId, callmanagerName);
+    const userCount = Math.min(Math.max(Math.ceil(plan.count / 5), 10), 300);
+    const userIds = await reserveChunkIds(client, 'endusers', userCount);
+    const userRows = userIds.map((id, index) => {
+        const seed = index + 1;
+        return {
+            id,
+            first_name: `Missed${seed}`,
+            last_name: 'User',
+            extension: String(2000 + seed),
+            uuid: randomUUID(),
+            email: `missed-${ctx.runId}-${seed}@example.test`,
+            sync_source: syncSource,
+            smtp_alerts: true,
+            callmanager_id: callmanagerId,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+            department: 'Support',
+            webex_alerts: false,
+        };
+    });
+    await copyChunked(client, 'endusers', userRows);
+    const chunk = chunkSizeFor(plan.count);
+    let inserted = 0;
+    for (const { offset, size } of chunkRange(plan.count, chunk)) {
+        const ids = await reserveChunkIds(client, 'cdr_event_logs', size);
+        const rows = ids.map((id, index) => {
+            const seed = offset + index + 1;
+            const occurredAt = timeSpread(plan.days, seed * 60_000);
+            return {
+                id,
+                event_type: 'missed_call',
+                calling_number: randomPhone('+1408', seed),
+                called_number: randomPhone('+1650', seed * 2),
+                action_taken: 'alert',
+                result: 'ct_seed',
+                org_id: ctx.orgId,
+                inserted_at: occurredAt,
+                updated_at: occurredAt,
+                end_user_id: pick(userIds, seed),
+            };
+        });
+        await copyChunked(client, 'cdr_event_logs', rows);
+        inserted += size;
+    }
+    return {
+        family: 'missed_calls',
+        requestedCount: plan.count,
+        insertedCount: inserted,
+        details: {
+            callmanagerName,
+            syncSource,
+        },
+    };
+}
+async function seedXccCalls(client, ctx, plan) {
+    const runId = ctx.runId;
+    const cubeName = `ct-seed-cube-${ctx.runId}`;
+    const cubeId = await createCube(client, ctx.orgId, cubeName);
+    const totalLogs = plan.count * 2;
+    const chunk = chunkSizeFor(totalLogs);
+    let insertedLogs = 0;
+    for (const { offset, size } of chunkRange(totalLogs, chunk)) {
+        const ids = await reserveChunkIds(client, 'cube_event_logs', size);
+        const rows = ids.map((id, index) => {
+            const seed = offset + index + 1;
+            const callSeed = Math.floor((offset + index) / 2) + 1;
+            const occurredAt = timeSpread(plan.days, seed * 70_000);
+            const disconnected = seed % 2 === 0;
+            return {
+                id,
+                event_type: disconnected ? 'disconnected' : 'connected',
+                status: disconnected ? 'completed' : 'connected',
+                details: { ct_seed_run_id: runId, family: 'xcc_calls' },
+                ip_address: pick(PEER_IPS, seed),
+                message: ctx.marker,
+                connection_id: `conn-${ctx.runId}-${callSeed}`,
+                call_id: `call-${ctx.runId}-${callSeed}`,
+                calling_number: randomPhone('+1408', callSeed),
+                called_number: randomPhone('+1650', callSeed * 4),
+                media_type: pick(MEDIA_TYPES, seed),
+                disconnect_reason: disconnected ? 'normal_call_clearing' : null,
+                retry_count: 0,
+                cube_id: cubeId,
+                inserted_at: occurredAt,
+                updated_at: occurredAt,
+                registration_id: `reg-${ctx.runId}`,
+                transaction_id: `txn-${ctx.runId}-${seed}`,
+                xcc_response: disconnected ? '<xcc status="ok"/>' : '<xcc status="ringing"/>',
+                new_calling_number: disconnected ? null : randomPhone('+1408', callSeed + 2),
+                xcc_disconnect_code: disconnected ? 16 : null,
+                request: `<request id="${seed}"/>`,
+                direction: callSeed % 2 === 0 ? 'outbound' : 'inbound',
+                curri_event_id: null,
+            };
+        });
+        await copyChunked(client, 'cube_event_logs', rows);
+        insertedLogs += size;
+    }
+    return {
+        family: 'xcc_calls',
+        requestedCount: plan.count,
+        insertedCount: plan.count,
+        details: {
+            cubeName,
+            runId,
+            logCount: insertedLogs,
+        },
+    };
+}
+async function seedFacCalls(client, ctx, plan) {
+    const familyMarker = `${ctx.marker}:fac_calls`;
+    const codes = ['SALES', 'SUPPORT', 'ENG', 'MKTG', 'FIN'];
+    const centerIds = await reserveChunkIds(client, 'fac_cost_centers', codes.length);
+    const assignmentIds = await reserveChunkIds(client, 'fac_code_cost_center_assignments', codes.length);
+    const effectiveFrom = ctx.startedAt;
+    const centerRows = centerIds.map((id, index) => ({
+        id,
+        org_id: ctx.orgId,
+        code: `CTFAC-${ctx.runId}-${index + 1}`,
+        name: `CT Seed FAC ${pick(codes, index)}`,
+        description: `ct-seed cost center ${ctx.runId}`,
+        department: pick(codes, index),
+        business_unit: 'ct-seed',
+        is_active: true,
+        effective_from: effectiveFrom,
+        notes: familyMarker,
+        inserted_at: ctx.startedAt,
+        updated_at: ctx.startedAt,
+        source: 'ct_seed',
+        sync_state: 'in_sync',
+    }));
+    const assignmentRows = assignmentIds.map((id, index) => ({
+        id,
+        fac_code: `FAC-${ctx.runId}-${index + 1}`,
+        cost_center_id: centerIds[index],
+        org_id: ctx.orgId,
+        is_active: true,
+        effective_from: effectiveFrom,
+        notes: familyMarker,
+        inserted_at: ctx.startedAt,
+        updated_at: ctx.startedAt,
+        source: 'ct_seed',
+        sync_state: 'in_sync',
+    }));
+    await copyChunked(client, 'fac_cost_centers', centerRows);
+    await copyChunked(client, 'fac_code_cost_center_assignments', assignmentRows);
+    const integrationHome = `/ct-seed/fac/${ctx.runId}`;
+    const integrationId = await createCdrIntegration(client, ctx.orgId, integrationHome, `ct-seed-fac-${ctx.runId}`);
+    const ids = await reserveChunkIds(client, 'cdrcalls', plan.count);
+    const rows = ids.map((id, index) => {
+        const seed = index + 1;
+        const occurredAt = timeSpread(plan.days, seed * 110_000);
+        const facCode = assignmentRows[index % assignmentRows.length].fac_code;
+        return {
+            ...buildBaseCdrRow(id, integrationId, seed, occurredAt, randomDuration(seed), familyMarker),
+            authCodeDescription: `ct-seed FAC ${facCode}`,
+            authorizationCodeValue: facCode,
+        };
+    });
+    await copyChunked(client, 'cdrcalls', rows);
+    return {
+        family: 'fac_calls',
+        requestedCount: plan.count,
+        insertedCount: plan.count,
+        details: {
+            integrationHome,
+            marker: familyMarker,
+        },
+    };
+}
+async function seedCmcCalls(client, ctx, plan) {
+    const familyMarker = `${ctx.marker}:cmc_calls`;
+    const clientCount = 4;
+    const clientIds = await reserveChunkIds(client, 'clients', clientCount);
+    const clientRows = clientIds.map((id, index) => ({
+        id,
+        org_id: ctx.orgId,
+        client_id: `CTCLIENT-${ctx.runId}-${index + 1}`,
+        client_name: `CT Seed Client ${index + 1}`,
+        description: familyMarker,
+        inserted_at: ctx.startedAt,
+        updated_at: ctx.startedAt,
+    }));
+    await copyChunked(client, 'clients', clientRows);
+    const codeCount = Math.max(8, Math.ceil(plan.count / 20));
+    const cmcIds = await reserveChunkIds(client, 'cmc_codes', codeCount);
+    const cmcRows = cmcIds.map((id, index) => ({
+        id,
+        org_id: ctx.orgId,
+        client_id: pick(clientIds, index),
+        cmc_code: `CMC-${ctx.runId}-${index + 1}`,
+        description: `ct-seed matter ${index + 1}`,
+        project_name: `Project ${index + 1}`,
+        matter_type: 'client_matter',
+        is_active: true,
+        effective_from: ctx.startedAt,
+        notes: familyMarker,
+        inserted_at: ctx.startedAt,
+        updated_at: ctx.startedAt,
+    }));
+    await copyChunked(client, 'cmc_codes', cmcRows);
+    const integrationHome = `/ct-seed/cmc/${ctx.runId}`;
+    const integrationId = await createCdrIntegration(client, ctx.orgId, integrationHome, `ct-seed-cmc-${ctx.runId}`);
+    const cdrIds = await reserveChunkIds(client, 'cdrcalls', plan.count);
+    const rows = cdrIds.map((id, index) => {
+        const seed = index + 1;
+        const occurredAt = timeSpread(plan.days, seed * 100_000);
+        const cmcCode = cmcRows[index % cmcRows.length].cmc_code;
+        return {
+            ...buildBaseCdrRow(id, integrationId, seed, occurredAt, randomDuration(seed), familyMarker),
+            authCodeDescription: `ct-seed CMC ${cmcCode}`,
+            clientMatterCode: cmcCode,
+        };
+    });
+    await copyChunked(client, 'cdrcalls', rows);
+    return {
+        family: 'cmc_calls',
+        requestedCount: plan.count,
+        insertedCount: plan.count,
+        details: {
+            integrationHome,
+            marker: familyMarker,
+        },
+    };
+}
+async function seedCostAllocation(client, ctx, plan) {
+    const familyMarker = `${ctx.marker}:cost_allocation`;
+    const rateTableIds = await reserveChunkIds(client, 'rate_tables', 2);
+    const rateRows = [
+        {
+            id: rateTableIds[0],
+            org_id: ctx.orgId,
+            name: `CT Seed Standard ${ctx.runId}`,
+            description: familyMarker,
+            priority: 100,
+            applies_to: 'all',
+            currency: 'USD',
+            is_active: true,
+            effective_from: ctx.startedAt,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+        },
+        {
+            id: rateTableIds[1],
+            org_id: ctx.orgId,
+            name: `CT Seed Intl ${ctx.runId}`,
+            description: familyMarker,
+            priority: 90,
+            applies_to: 'all',
+            currency: 'USD',
+            is_active: true,
+            effective_from: ctx.startedAt,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+        },
+    ];
+    await copyChunked(client, 'rate_tables', rateRows);
+    const multiplierIds = await reserveChunkIds(client, 'rate_time_multipliers', 4);
+    const multiplierRows = [
+        {
+            id: multiplierIds[0],
+            rate_table_id: rateTableIds[0],
+            name: `peak-${ctx.runId}`,
+            multiplier: 1.25,
+            start_time: '08:00:00',
+            end_time: '18:00:00',
+            days_of_week: [1, 2, 3, 4, 5],
+            priority: 100,
+            is_active: true,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+        },
+        {
+            id: multiplierIds[1],
+            rate_table_id: rateTableIds[0],
+            name: `night-${ctx.runId}`,
+            multiplier: 0.8,
+            start_time: '18:00:00',
+            end_time: '23:59:00',
+            days_of_week: [1, 2, 3, 4, 5],
+            priority: 90,
+            is_active: true,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+        },
+        {
+            id: multiplierIds[2],
+            rate_table_id: rateTableIds[1],
+            name: `weekend-${ctx.runId}`,
+            multiplier: 0.95,
+            start_time: '00:00:00',
+            end_time: '23:59:00',
+            days_of_week: [0, 6],
+            priority: 80,
+            is_active: true,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+        },
+        {
+            id: multiplierIds[3],
+            rate_table_id: rateTableIds[1],
+            name: `intl-peak-${ctx.runId}`,
+            multiplier: 1.5,
+            start_time: '08:00:00',
+            end_time: '17:00:00',
+            days_of_week: [1, 2, 3, 4, 5],
+            priority: 110,
+            is_active: true,
+            inserted_at: ctx.startedAt,
+            updated_at: ctx.startedAt,
+        },
+    ];
+    await copyChunked(client, 'rate_time_multipliers', multiplierRows);
+    const ruleIds = await reserveChunkIds(client, 'costing_rules', 5);
+    const prefixes = ['+1', '+1408', '+1650', '+44', '+81'];
+    const ruleRows = ruleIds.map((id, index) => ({
+        id,
+        org_id: ctx.orgId,
+        dial_prefix: prefixes[index],
+        description: `ct-seed rule ${prefixes[index]}`,
+        rate_per_minute: index < 3 ? 0.03 : 0.09,
+        billing_increment: 60,
+        minimum_charge_duration: 0,
+        effective_from: ctx.startedAt,
+        is_active: true,
+        notes: familyMarker,
+        inserted_at: ctx.startedAt,
+        updated_at: ctx.startedAt,
+        initial_cost: 0,
+        initial_duration_seconds: 0,
+        incremental_cost: index < 3 ? 0.03 : 0.09,
+        rate_table_id: pick(rateTableIds, index),
+    }));
+    await copyChunked(client, 'costing_rules', ruleRows);
+    const integrationHome = `/ct-seed/cost/${ctx.runId}`;
+    const integrationId = await createCdrIntegration(client, ctx.orgId, integrationHome, `ct-seed-cost-${ctx.runId}`);
+    const cdrIds = await reserveChunkIds(client, 'cdrcalls', plan.count);
+    const rows = cdrIds.map((id, index) => {
+        const seed = index + 1;
+        const occurredAt = timeSpread(plan.days, seed * 95_000);
+        return buildBaseCdrRow(id, integrationId, seed, occurredAt, randomDuration(seed), familyMarker);
+    });
+    await copyChunked(client, 'cdrcalls', rows);
+    return {
+        family: 'cost_allocation',
+        requestedCount: plan.count,
+        insertedCount: plan.count,
+        details: {
+            integrationHome,
+            marker: familyMarker,
+            runId: ctx.runId,
+        },
+    };
+}
+function clampCount(value) {
+    return Math.max(0, Math.round(value));
+}
+function registrationNoise(seed) {
+    return 0.96 + ((seed % 11) / 100);
+}
+function registrationTimeMultiplier(hour) {
+    if (hour < 6)
+        return 0.62;
+    if (hour < 9)
+        return 0.82;
+    if (hour < 17)
+        return 1.0;
+    if (hour < 21)
+        return 0.9;
+    return 0.74;
+}
+function registrationWeekendMultiplier(dayIndex) {
+    return dayIndex === 0 || dayIndex === 6 ? 0.84 : 1.0;
+}
+async function seedRegistrationSnapshots(client, ctx, plan) {
+    const batchId = ctx.runId;
+    const callmanager = await getOrCreateCallmanagerId(client, ctx.orgId, `ct-seed-reg-${ctx.runId}`);
+    const callmanagerId = callmanager.id;
+    const phoneCount = await queryPhoneCount(client, ctx.orgId);
+    const basePhoneCount = Math.max(phoneCount, 500);
+    const devicePools = await queryWeightedDimension(client, `
+      SELECT COALESCE(NULLIF(device_pool, ''), 'Unknown') AS value, COUNT(*)::bigint AS count
+      FROM public.phones
+      WHERE org_id = $1
+      GROUP BY 1
+      ORDER BY 2 DESC
+      LIMIT 4
+    `, [ctx.orgId], FALLBACK_DEVICE_POOLS);
+    const locations = await queryWeightedDimension(client, `
+      SELECT COALESCE(NULLIF(location, ''), 'Unknown') AS value, COUNT(*)::bigint AS count
+      FROM public.phones
+      WHERE org_id = $1
+      GROUP BY 1
+      ORDER BY 2 DESC
+      LIMIT 4
+    `, [ctx.orgId], FALLBACK_LOCATIONS);
+    const models = await queryWeightedDimension(client, `
+      SELECT COALESCE(NULLIF(model, ''), 'Unknown') AS value, COUNT(*)::bigint AS count
+      FROM public.phones
+      WHERE org_id = $1
+      GROUP BY 1
+      ORDER BY 2 DESC
+      LIMIT 3
+    `, [ctx.orgId], FALLBACK_MODELS);
+    const subnets = await queryWeightedDimension(client, `
+      SELECT COALESCE(s.subnet_base || '/' || s.prefix::text, 'Unknown') AS value, COUNT(*)::bigint AS count
+      FROM public.phones p
+      LEFT JOIN public.subnets s ON s.id = p.subnet_id
+      WHERE p.org_id = $1
+      GROUP BY 1
+      ORDER BY 2 DESC
+      LIMIT 3
+    `, [ctx.orgId], FALLBACK_SUBNETS);
+    const rows = [];
+    const rowsPerSnapshot = 2 + devicePools.length + locations.length + models.length + subnets.length;
+    const snapshotSlots = Math.max(1, Math.ceil(plan.count / rowsPerSnapshot));
+    const now = new Date();
+    for (let slot = 0; slot < snapshotSlots && rows.length < plan.count; slot++) {
+        const snapshotAt = timeSpread(plan.days, slot * 3_600_000);
+        const hour = snapshotAt.getUTCHours();
+        const dayIndex = snapshotAt.getUTCDay();
+        const timeMultiplier = registrationTimeMultiplier(hour);
+        const weekendMultiplier = registrationWeekendMultiplier(dayIndex);
+        const trendMultiplier = 0.94 + (slot / Math.max(snapshotSlots, 1)) * 0.12;
+        const outageMultiplier = slot % 29 === 0 ? 0.72 : 1.0;
+        const totalCount = clampCount(basePhoneCount * timeMultiplier * weekendMultiplier * trendMultiplier * outageMultiplier * registrationNoise(slot + 1));
+        const registrationRate = outageMultiplier < 1 ? 0.74 : 0.93;
+        const registeredCount = clampCount(totalCount * registrationRate);
+        const unregisteredCount = Math.max(0, totalCount - registeredCount);
+        const slotRows = [];
+        const makeRow = (dimensionType, dimensionValue, countWeight, varianceSeed) => {
+            const weightedTotal = clampCount(totalCount * countWeight * registrationNoise(varianceSeed));
+            const weightedRegistered = clampCount(weightedTotal * registrationRate);
+            return {
+                id: 0,
+                org_id: ctx.orgId,
+                callmanager_id: callmanagerId,
+                batch_id: batchId,
+                dimension_type: dimensionType,
+                dimension_value: dimensionValue,
+                registered_count: weightedRegistered,
+                unregistered_count: Math.max(0, weightedTotal - weightedRegistered),
+                total_count: weightedTotal,
+                snapshot_at: snapshotAt,
+                inserted_at: now,
+                updated_at: now,
+            };
+        };
+        slotRows.push({
+            id: 0,
+            org_id: ctx.orgId,
+            callmanager_id: callmanagerId,
+            batch_id: batchId,
+            dimension_type: 'total',
+            dimension_value: '__all__',
+            registered_count: registeredCount,
+            unregistered_count: unregisteredCount,
+            total_count: totalCount,
+            snapshot_at: snapshotAt,
+            inserted_at: now,
+            updated_at: now,
+        });
+        slotRows.push({
+            id: 0,
+            org_id: ctx.orgId,
+            callmanager_id: callmanagerId,
+            batch_id: batchId,
+            dimension_type: 'callmanager',
+            dimension_value: String(callmanagerId),
+            registered_count: registeredCount,
+            unregistered_count: unregisteredCount,
+            total_count: totalCount,
+            snapshot_at: snapshotAt,
+            inserted_at: now,
+            updated_at: now,
+        });
+        devicePools.forEach((item, index) => {
+            slotRows.push(makeRow('device_pool', item.value, item.weight, slot + index + 10));
+        });
+        locations.forEach((item, index) => {
+            slotRows.push(makeRow('location', item.value, item.weight, slot + index + 20));
+        });
+        models.forEach((item, index) => {
+            slotRows.push(makeRow('model', item.value, item.weight, slot + index + 30));
+        });
+        subnets.forEach((item, index) => {
+            slotRows.push(makeRow('subnet', item.value, item.weight, slot + index + 40));
+        });
+        rows.push(...slotRows.slice(0, Math.max(0, plan.count - rows.length)));
+    }
+    const ids = await reserveChunkIds(client, 'phone_registration_snapshots', rows.length);
+    rows.forEach((row, index) => {
+        row.id = ids[index];
+    });
+    await copyChunked(client, 'phone_registration_snapshots', rows);
+    return {
+        family: 'registration_snapshots',
+        requestedCount: plan.count,
+        insertedCount: rows.length,
+        details: {
+            batchId,
+            callmanagerId,
+            createdCallmanager: callmanager.created,
+        },
+    };
+}
+async function seedDashboardTemplates(client, ctx, plan) {
+    const markerTag = `${ctx.marker}:dashboard_templates`;
+    const dashboardRows = [];
+    const widgetRows = [];
+    const selectedTemplates = DASHBOARD_TEMPLATE_FIXTURES.slice(0, plan.count);
+    for (const [templateIndex, template] of selectedTemplates.entries()) {
+        const dashboardId = randomUUID();
+        const insertedAt = new Date();
+        const shortRun = ctx.runId.slice(0, 8);
+        dashboardRows.push({
+            id: dashboardId,
+            name: `${template.name} (${shortRun})`,
+            description: `${template.description} [${markerTag}]`,
+            org_id: ctx.orgId,
+            created_by: null,
+            is_shared: template.isShared,
+            is_template: true,
+            layout_config: template.layoutConfig,
+            refresh_interval: template.refreshInterval,
+            tags: [...template.tags, 'ct_seed_template', markerTag],
+            lock_version: 1,
+            archived_at: null,
+            inserted_at: insertedAt,
+            updated_at: insertedAt,
+            share_token: null,
+            share_enabled: false,
+        });
+        template.widgets.forEach((widget, widgetIndex) => {
+            widgetRows.push({
+                id: randomUUID(),
+                dashboard_id: dashboardId,
+                title: widget.title,
+                widget_type: widget.widgetType,
+                display_mode: widget.displayMode,
+                layout: widget.layout,
+                report_config: widget.reportConfig,
+                chart_config: widget.chartConfig,
+                table_config: widget.tableConfig,
+                refresh_interval: widget.refreshInterval,
+                ignore_global_filters: widget.ignoreGlobalFilters,
+                sort_order: widget.sortOrder ?? widgetIndex,
+                inserted_at: insertedAt,
+                updated_at: insertedAt,
+                saved_report_id: null,
+            });
+        });
+    }
+    await copyChunked(client, 'dashboards', dashboardRows);
+    await copyChunked(client, 'dashboard_widgets', widgetRows);
+    return {
+        family: 'dashboard_templates',
+        requestedCount: plan.count,
+        insertedCount: dashboardRows.length,
+        details: {
+            markerTag,
+            dashboardIds: dashboardRows.map((row) => row.id),
+        },
+    };
+}
+function seedFamilyMarker(ctx, family) {
+    return `${ctx.marker}:${family}`;
+}
+async function createSeedPolicy(client, orgId, name, notes, defaultAction, tdosSettings) {
+    return insertControlRow(client, `
+      INSERT INTO public.policies (
+        name,
+        notes,
+        hit_count,
+        api_key,
+        inserted_at,
+        updated_at,
+        healthy,
+        type,
+        org_id,
+        block_mcids,
+        realtime_inventory,
+        tdos_settings,
+        default_action,
+        jtapi_enabled,
+        duplicate_call_suppression_enabled,
+        duplicate_call_action,
+        duplicate_call_threshold,
+        duplicate_call_window_ms
+      )
+      VALUES (
+        $1,
+        $2,
+        0,
+        $3,
+        now(),
+        now(),
+        true,
+        'normal',
+        $4,
+        true,
+        false,
+        COALESCE($5::jsonb, '{"tdos_enabled": false, "tdos_expiration_minutes": 60, "tdos_call_count_threshold": 10, "tdos_threshold_milliseconds": 60}'::jsonb),
+        $6,
+        false,
+        false,
+        'block',
+        1,
+        5000
+      )
+      RETURNING id
+    `, [name, notes, randomUUID(), orgId, tdosSettings ? JSON.stringify(tdosSettings) : null, defaultAction]);
+}
+function parseNumberArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => Number.parseInt(String(item), 10))
+        .filter((item) => Number.isFinite(item) && item > 0);
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => String(item))
+        .filter((item) => item.length > 0);
+}
+async function seedBlockRules(client, ctx, plan) {
+    const family = 'block_rules';
+    const marker = seedFamilyMarker(ctx, family);
+    const shortRun = ctx.runId.slice(0, 8);
+    const policyId = await createSeedPolicy(client, ctx.orgId, `CT Seed Block Policy ${shortRun}`, marker, 'permit');
+    const ruleIds = await reserveChunkIds(client, 'rules', plan.count);
+    const rows = ruleIds.map((id, index) => {
+        const seed = index + 1;
+        const occurredAt = timeSpread(plan.days, seed * 600_000);
+        return {
+            id,
+            name: `CT Seed Block Rule ${seed}`,
+            calling_number: randomPhone('+1303', seed),
+            hit_count: seed % 5,
+            last_trigger: occurredAt,
+            policy_action: 'block',
+            policy_id: policyId,
+            user_id: null,
+            inserted_at: occurredAt,
+            updated_at: occurredAt,
+            webhook_id: null,
+            notification_id: null,
+            called_number: randomPhone('+1800', seed * 7),
+            greeting_name: null,
+            greeting_enabled: seed % 4 === 0,
+            new_calling_number: null,
+            new_called_number: null,
+            new_calling_name: seed % 4 === 0 ? 'Blocked Caller' : null,
+            new_called_name: null,
+            mcid_triggered: seed % 6 === 0,
+            teams_alert_id: null,
+            trigger_percentage: 100,
+            alert_templates_id: null,
+            app_id: null,
+            cdr_events: ['block'],
+            cdr_missed_call_alert: false,
+            alert_template: `ct_seed block alert ${ctx.runId}`,
+            attach_debug_messages: false,
+            email_subject: 'CT Seed Block Alert',
+            alert_only_success: false,
+            order: seed,
+            announcement_greetings: seed % 4 === 0 ? ['busy_signal'] : [],
+            jtapi_audio_id: null,
+        };
+    });
+    await copyChunked(client, 'rules', rows);
+    return {
+        family,
+        requestedCount: plan.count,
+        insertedCount: rows.length,
+        details: {
+            marker,
+            policyId,
+            ruleIds,
+        },
+    };
+}
+async function seedPermitRules(client, ctx, plan) {
+    const family = 'permit_rules';
+    const marker = seedFamilyMarker(ctx, family);
+    const shortRun = ctx.runId.slice(0, 8);
+    const policyId = await createSeedPolicy(client, ctx.orgId, `CT Seed Permit Policy ${shortRun}`, marker, 'block');
+    const ruleIds = await reserveChunkIds(client, 'rules', plan.count);
+    const rows = ruleIds.map((id, index) => {
+        const seed = index + 1;
+        const occurredAt = timeSpread(plan.days, seed * 420_000);
+        return {
+            id,
+            name: `CT Seed Permit Rule ${seed}`,
+            calling_number: randomPhone('+1408', seed * 5),
+            hit_count: seed % 7,
+            last_trigger: occurredAt,
+            policy_action: 'permit',
+            policy_id: policyId,
+            user_id: null,
+            inserted_at: occurredAt,
+            updated_at: occurredAt,
+            webhook_id: null,
+            notification_id: null,
+            called_number: randomPhone('+1650', seed * 11),
+            greeting_name: null,
+            greeting_enabled: seed % 3 === 0,
+            new_calling_number: seed % 5 === 0 ? randomPhone('+1408', seed * 17) : null,
+            new_called_number: seed % 4 === 0 ? randomPhone('+1650', seed * 13) : null,
+            new_calling_name: seed % 3 === 0 ? 'Verified Caller' : null,
+            new_called_name: seed % 4 === 0 ? 'Front Desk' : null,
+            mcid_triggered: false,
+            teams_alert_id: null,
+            trigger_percentage: 100,
+            alert_templates_id: null,
+            app_id: null,
+            cdr_events: ['permit'],
+            cdr_missed_call_alert: false,
+            alert_template: `ct_seed permit alert ${ctx.runId}`,
+            attach_debug_messages: false,
+            email_subject: 'CT Seed Permit Alert',
+            alert_only_success: false,
+            order: seed,
+            announcement_greetings: seed % 3 === 0 ? ['welcome'] : [],
+            jtapi_audio_id: null,
+        };
+    });
+    await copyChunked(client, 'rules', rows);
+    return {
+        family,
+        requestedCount: plan.count,
+        insertedCount: rows.length,
+        details: {
+            marker,
+            policyId,
+            ruleIds,
+        },
+    };
+}
+async function seedTdosViolations(client, ctx, plan) {
+    const family = 'tdos_violations';
+    const marker = seedFamilyMarker(ctx, family);
+    const shortRun = ctx.runId.slice(0, 8);
+    const policyId = await createSeedPolicy(client, ctx.orgId, `CT Seed TDOS Policy ${shortRun}`, marker, 'permit', {
+        tdos_enabled: true,
+        tdos_expiration_minutes: 60,
+        tdos_call_count_threshold: 3,
+        tdos_threshold_milliseconds: 1000,
+    });
+    const violationIds = await reserveChunkIds(client, 'tdos_violations', plan.count);
+    const now = new Date();
+    const rows = violationIds.map((id, index) => {
+        const seed = index + 1;
+        const violationAt = seed % 2 === 0
+            ? new Date(now.getTime() - (seed % 45) * 60_000)
+            : timeSpread(plan.days, seed * 780_000);
+        const count = 3 + (seed % 6);
+        const expiresAt = seed % 2 === 0
+            ? new Date(violationAt.getTime() + 60 * 60 * 1000)
+            : new Date(violationAt.getTime() - 60 * 60 * 1000);
+        return {
+            id,
+            policy_id: policyId,
+            calling_number: randomPhone('+1888', seed * 9),
+            violation_count: count,
+            last_violation_at: violationAt,
+            inserted_at: violationAt,
+            updated_at: violationAt,
+            high_water_mark_violations: count + (seed % 3),
+            expires_at: expiresAt,
+        };
+    });
+    await copyChunked(client, 'tdos_violations', rows);
+    return {
+        family,
+        requestedCount: plan.count,
+        insertedCount: rows.length,
+        details: {
+            marker,
+            policyId,
+            violationIds,
+        },
+    };
+}
+async function seedWatchListsFullLifecycle(client, ctx, plan) {
+    const family = 'watch_lists_full_lifecycle';
+    const marker = seedFamilyMarker(ctx, family);
+    const shortRun = ctx.runId.slice(0, 8);
+    const policyId = await createSeedPolicy(client, ctx.orgId, `CT Seed Watch List Policy ${shortRun}`, marker, 'permit');
+    const [watchListId] = await reserveChunkIds(client, 'watch_lists', 1);
+    const [triggerId] = await reserveChunkIds(client, 'watch_list_triggers', 1);
+    const [watchListPolicyId] = await reserveChunkIds(client, 'watch_lists_policies', 1);
+    const [triggerPolicyId] = await reserveChunkIds(client, 'watch_list_triggers_policies', 1);
+    const insertedAt = ctx.startedAt;
+    const permitCallsPerNumber = 4;
+    const blockedCallsPerNumber = 2;
+    const totalCurriEvents = plan.count * (permitCallsPerNumber + blockedCallsPerNumber);
+    await copyChunked(client, 'watch_lists', [{
+            id: watchListId,
+            name: `${marker}:list`,
+            org_id: ctx.orgId,
+            inserted_at: insertedAt,
+            updated_at: insertedAt,
+        }]);
+    await copyChunked(client, 'watch_list_triggers', [{
+            id: triggerId,
+            name: `CT Seed Watch Trigger ${shortRun}`,
+            description: marker,
+            active: true,
+            count: permitCallsPerNumber,
+            minutes: 60,
+            last_run: insertedAt,
+            run_interval: 15,
+            email_addresses: [],
+            email_enabled: false,
+            org_id: ctx.orgId,
+            watch_list_id: watchListId,
+            inserted_at: insertedAt,
+            updated_at: insertedAt,
+            expire_days: 7,
+        }]);
+    await copyChunked(client, 'watch_lists_policies', [{
+            id: watchListPolicyId,
+            watch_list_id: watchListId,
+            policy_id: policyId,
+            org_id: ctx.orgId,
+            inserted_at: insertedAt,
+            updated_at: insertedAt,
+        }]);
+    await copyChunked(client, 'watch_list_triggers_policies', [{
+            id: triggerPolicyId,
+            watch_list_trigger_id: triggerId,
+            policy_id: policyId,
+            org_id: ctx.orgId,
+            inserted_at: insertedAt,
+            updated_at: insertedAt,
+        }]);
+    const numberIds = await reserveChunkIds(client, 'watch_list_numbers', plan.count);
+    const curriIds = await reserveChunkIds(client, 'curri_events', totalCurriEvents);
+    const numberRows = [];
+    const numberJoinRows = [];
+    const violationRows = [];
+    const violationEventRows = [];
+    const curriRows = [];
+    const violationIds = [];
+    let curriIndex = 0;
+    for (let index = 0; index < plan.count; index++) {
+        const seed = index + 1;
+        const callingNumber = randomPhone('+1555', seed * 7);
+        const numberId = numberIds[index];
+        const violationId = randomUUID();
+        const violationTime = timeSpread(plan.days, seed * 2_400_000);
+        const expiresAt = new Date(violationTime.getTime() + 7 * 24 * 60 * 60 * 1000);
+        violationIds.push(violationId);
+        numberRows.push({
+            id: numberId,
+            number: callingNumber,
+            whitelist: false,
+            comments: marker,
+            org_id: ctx.orgId,
+            inserted_at: violationTime,
+            updated_at: violationTime,
+            high_water_mark: permitCallsPerNumber + blockedCallsPerNumber,
+        });
+        numberJoinRows.push({
+            watch_list_id: watchListId,
+            watch_list_number_id: numberId,
+            inserted_at: violationTime,
+            updated_at: violationTime,
+        });
+        violationRows.push({
+            id: violationId,
+            watch_list_number_id: numberId,
+            calling_number: callingNumber,
+            violated_at: violationTime,
+            expires_at: expiresAt,
+            status: index % 4 === 0 ? 'inactive' : 'active',
+            has_event_details: true,
+            trigger_id: triggerId,
+            watch_list_id: watchListId,
+            org_id: ctx.orgId,
+            inserted_at: violationTime,
+            updated_at: violationTime,
+            call_count: permitCallsPerNumber,
+            calling_device: pick(DEVICE_NAMES, seed),
+        });
+        for (let permitIndex = 0; permitIndex < permitCallsPerNumber; permitIndex++) {
+            const eventTime = new Date(violationTime.getTime() - (permitCallsPerNumber - permitIndex) * 5 * 60 * 1000);
+            const curriId = curriIds[curriIndex++];
+            const calledNumber = randomPhone('+1800', seed * 31 + permitIndex);
+            curriRows.push({
+                id: curriId,
+                calling_number: callingNumber,
+                called_number: calledNumber,
+                trigger_point_type: 'translationpattern',
+                calling_devicename: pick(DEVICE_NAMES, seed + permitIndex),
+                result: 'permitted',
+                inserted_at: eventTime,
+                updated_at: eventTime,
+                action_taken: 'permit',
+                org_id: ctx.orgId,
+                alert_variables: { ct_seed_run_id: ctx.runId, family, phase: 'trigger', violation_id: violationId },
+                applied_modifiers: {},
+                final_rendered_action: 'permit',
+                response_time: 150_000 + (seed % 25_000),
+                processing_time: 75_000 + (seed % 20_000),
+            });
+            violationEventRows.push({
+                id: randomUUID(),
+                violation_id: violationId,
+                curri_event_id: curriId,
+                calling_number: callingNumber,
+                called_number: calledNumber,
+                event_timestamp: eventTime,
+                contributed_at: violationTime,
+                org_id: ctx.orgId,
+                inserted_at: violationTime,
+                event_type: 'trigger',
+            });
+        }
+        for (let blockedIndex = 0; blockedIndex < blockedCallsPerNumber; blockedIndex++) {
+            const eventTime = new Date(violationTime.getTime() + (blockedIndex + 1) * 7 * 60 * 1000);
+            const curriId = curriIds[curriIndex++];
+            const calledNumber = randomPhone('+1888', seed * 47 + blockedIndex);
+            curriRows.push({
+                id: curriId,
+                calling_number: callingNumber,
+                called_number: calledNumber,
+                trigger_point_type: 'translationpattern',
+                calling_devicename: pick(DEVICE_NAMES, seed + blockedIndex + 20),
+                result: 'blocked',
+                inserted_at: eventTime,
+                updated_at: eventTime,
+                action_taken: 'block',
+                org_id: ctx.orgId,
+                alert_variables: { ct_seed_run_id: ctx.runId, family, phase: 'block', violation_id: violationId },
+                applied_modifiers: {},
+                final_rendered_action: 'block',
+                response_time: 165_000 + (seed % 35_000),
+                processing_time: 95_000 + (seed % 15_000),
+            });
+            violationEventRows.push({
+                id: randomUUID(),
+                violation_id: violationId,
+                curri_event_id: curriId,
+                calling_number: callingNumber,
+                called_number: calledNumber,
+                event_timestamp: eventTime,
+                contributed_at: eventTime,
+                org_id: ctx.orgId,
+                inserted_at: eventTime,
+                event_type: 'block',
+            });
+        }
+    }
+    await copyChunked(client, 'watch_list_numbers', numberRows);
+    await copyChunked(client, 'watch_list_numbers_have_watch_lists', numberJoinRows);
+    await copyChunked(client, 'curri_events', curriRows);
+    await copyChunked(client, 'watch_list_violations', violationRows);
+    await copyChunked(client, 'watch_list_violation_events', violationEventRows);
+    return {
+        family,
+        requestedCount: plan.count,
+        insertedCount: violationRows.length,
+        details: {
+            marker,
+            runId: ctx.runId,
+            policyId,
+            watchListId: watchListId,
+            triggerId: triggerId,
+            watchListNumberIds: numberIds,
+            violationIds,
+        },
+    };
+}
+async function seedGlobalBlockList(client, ctx, plan) {
+    const family = 'global_block_list';
+    const marker = seedFamilyMarker(ctx, family);
+    const mcidIds = await reserveChunkIds(client, 'mcids', plan.count);
+    const rows = mcidIds.map((id, index) => {
+        const seed = index + 1;
+        const seenAt = timeSpread(plan.days, seed * 300_000);
+        const expires = seed % 3 === 0;
+        return {
+            id,
+            calling_number: randomPhone('+1303', seed * 13),
+            called_number: randomPhone('+1800', seed * 19),
+            description: marker,
+            expires,
+            expires_datetime: expires ? new Date(seenAt.getTime() + 30 * 24 * 60 * 60 * 1000) : null,
+            hit_count: seed % 11,
+            last_seen: seenAt,
+            cdrcall_id: null,
+            cdr_integration_id: null,
+            inserted_at: seenAt,
+            updated_at: seenAt,
+            org_id: ctx.orgId,
+            devicename: pick(DEVICE_NAMES, seed),
+            metadata: { ct_seed_run_id: ctx.runId, family, marker },
+            expired_at: expires ? null : null,
+            enduser_identity_id: null,
+            source: 'admin',
+        };
+    });
+    await copyChunked(client, 'mcids', rows);
+    return {
+        family,
+        requestedCount: plan.count,
+        insertedCount: rows.length,
+        details: {
+            marker,
+            mcidIds,
+        },
+    };
+}
+export async function executeSeedFamily(client, ctx, plan) {
+    switch (plan.family) {
+        case 'curri_events':
+            return seedCurriEvents(client, ctx, plan);
+        case 'cdr_records':
+            return seedCdrRecords(client, ctx, plan);
+        case 'missed_calls':
+            return seedMissedCalls(client, ctx, plan);
+        case 'xcc_calls':
+            return seedXccCalls(client, ctx, plan);
+        case 'fac_calls':
+            return seedFacCalls(client, ctx, plan);
+        case 'cmc_calls':
+            return seedCmcCalls(client, ctx, plan);
+        case 'cost_allocation':
+            return seedCostAllocation(client, ctx, plan);
+        case 'registration_snapshots':
+            return seedRegistrationSnapshots(client, ctx, plan);
+        case 'dashboard_templates':
+            return seedDashboardTemplates(client, ctx, plan);
+        case 'block_rules':
+            return seedBlockRules(client, ctx, plan);
+        case 'permit_rules':
+            return seedPermitRules(client, ctx, plan);
+        case 'tdos_violations':
+            return seedTdosViolations(client, ctx, plan);
+        case 'watch_lists_full_lifecycle':
+            return seedWatchListsFullLifecycle(client, ctx, plan);
+        case 'global_block_list':
+            return seedGlobalBlockList(client, ctx, plan);
+    }
+}
+async function cleanupCurri(client, details) {
+    const runId = String(details.runId ?? '');
+    const signals = await client.query(`DELETE FROM public.reputation_signals WHERE raw->>'ct_seed_run_id' = $1`, [runId]);
+    const apps = await client.query(`DELETE FROM public.app_events WHERE raw->>'ct_seed_run_id' = $1`, [runId]);
+    const curri = await client.query(`DELETE FROM public.curri_events WHERE alert_variables->>'ct_seed_run_id' = $1`, [runId]);
+    return affectedRows(signals.rowCount) + affectedRows(apps.rowCount) + affectedRows(curri.rowCount);
+}
+async function cleanupCdrRecords(client, details) {
+    const marker = String(details.marker ?? '');
+    const integrationHome = String(details.integrationHome ?? '');
+    const cdr = await client.query(`DELETE FROM public.cdrcalls WHERE comment = $1`, [marker]);
+    const integrations = await client.query(`DELETE FROM public.cdr_integrations WHERE home = $1`, [integrationHome]);
+    return affectedRows(cdr.rowCount) + affectedRows(integrations.rowCount);
+}
+async function cleanupMissedCalls(client, details) {
+    const syncSource = String(details.syncSource ?? '');
+    const callmanagerName = String(details.callmanagerName ?? '');
+    const events = await client.query(`
+    DELETE FROM public.cdr_event_logs
+    WHERE end_user_id IN (
+      SELECT id FROM public.endusers WHERE sync_source = $1
+    )
+  `, [syncSource]);
+    const users = await client.query(`DELETE FROM public.endusers WHERE sync_source = $1`, [syncSource]);
+    const managers = await client.query(`DELETE FROM public.callmanagers WHERE name = $1`, [callmanagerName]);
+    return affectedRows(events.rowCount) + affectedRows(users.rowCount) + affectedRows(managers.rowCount);
+}
+async function cleanupXcc(client, details) {
+    const runId = String(details.runId ?? '');
+    const cubeName = String(details.cubeName ?? '');
+    const logs = await client.query(`DELETE FROM public.cube_event_logs WHERE details->>'ct_seed_run_id' = $1`, [runId]);
+    const cubes = await client.query(`DELETE FROM public.cubes WHERE name = $1`, [cubeName]);
+    return affectedRows(logs.rowCount) + affectedRows(cubes.rowCount);
+}
+async function cleanupFac(client, details) {
+    const marker = String(details.marker ?? '');
+    const integrationHome = String(details.integrationHome ?? '');
+    const cdr = await client.query(`DELETE FROM public.cdrcalls WHERE comment = $1`, [marker]);
+    const assignments = await client.query(`DELETE FROM public.fac_code_cost_center_assignments WHERE notes = $1`, [marker]);
+    const centers = await client.query(`DELETE FROM public.fac_cost_centers WHERE notes = $1`, [marker]);
+    const integrations = await client.query(`DELETE FROM public.cdr_integrations WHERE home = $1`, [integrationHome]);
+    return affectedRows(cdr.rowCount) + affectedRows(assignments.rowCount) + affectedRows(centers.rowCount) + affectedRows(integrations.rowCount);
+}
+async function cleanupCmc(client, details) {
+    const marker = String(details.marker ?? '');
+    const integrationHome = String(details.integrationHome ?? '');
+    const cdr = await client.query(`DELETE FROM public.cdrcalls WHERE comment = $1`, [marker]);
+    const codes = await client.query(`DELETE FROM public.cmc_codes WHERE notes = $1`, [marker]);
+    const clients = await client.query(`DELETE FROM public.clients WHERE description = $1`, [marker]);
+    const integrations = await client.query(`DELETE FROM public.cdr_integrations WHERE home = $1`, [integrationHome]);
+    return affectedRows(cdr.rowCount) + affectedRows(codes.rowCount) + affectedRows(clients.rowCount) + affectedRows(integrations.rowCount);
+}
+async function cleanupCost(client, details) {
+    const marker = String(details.marker ?? '');
+    const runId = String(details.runId ?? '');
+    const integrationHome = String(details.integrationHome ?? '');
+    const cdr = await client.query(`DELETE FROM public.cdrcalls WHERE comment = $1`, [marker]);
+    const rules = await client.query(`DELETE FROM public.costing_rules WHERE notes = $1`, [marker]);
+    const multipliers = await client.query(`DELETE FROM public.rate_time_multipliers WHERE name LIKE $1`, [`%${runId}%`]);
+    const rateTables = await client.query(`DELETE FROM public.rate_tables WHERE description = $1`, [marker]);
+    const integrations = await client.query(`DELETE FROM public.cdr_integrations WHERE home = $1`, [integrationHome]);
+    return affectedRows(cdr.rowCount) + affectedRows(rules.rowCount) + affectedRows(multipliers.rowCount) + affectedRows(rateTables.rowCount) + affectedRows(integrations.rowCount);
+}
+async function cleanupRegistrationSnapshots(client, details) {
+    const batchId = String(details.batchId ?? '');
+    const rows = await client.query('DELETE FROM public.phone_registration_snapshots WHERE batch_id = $1::uuid', [batchId]);
+    let callmanagersDeleted = 0;
+    if (details.createdCallmanager === true) {
+        const callmanagerId = Number(details.callmanagerId ?? 0);
+        if (callmanagerId > 0) {
+            const callmanagerRows = await client.query('DELETE FROM public.callmanagers WHERE id = $1', [callmanagerId]);
+            callmanagersDeleted = affectedRows(callmanagerRows.rowCount);
+        }
+    }
+    return affectedRows(rows.rowCount) + callmanagersDeleted;
+}
+async function cleanupDashboardTemplates(client, details) {
+    const dashboardIds = Array.isArray(details.dashboardIds) ? details.dashboardIds.map(String) : [];
+    const widgetRows = await client.query('DELETE FROM public.dashboard_widgets WHERE dashboard_id = ANY($1::uuid[])', [dashboardIds]);
+    const dashboardRows = await client.query('DELETE FROM public.dashboards WHERE id = ANY($1::uuid[])', [dashboardIds]);
+    return affectedRows(widgetRows.rowCount) + affectedRows(dashboardRows.rowCount);
+}
+async function cleanupBlockRules(client, details) {
+    const ruleIds = parseNumberArray(details.ruleIds);
+    const policyId = Number.parseInt(String(details.policyId ?? ''), 10);
+    const rules = ruleIds.length > 0
+        ? await client.query('DELETE FROM public.rules WHERE id = ANY($1::bigint[])', [ruleIds])
+        : { rowCount: 0 };
+    const policies = Number.isFinite(policyId) && policyId > 0
+        ? await client.query('DELETE FROM public.policies WHERE id = $1', [policyId])
+        : { rowCount: 0 };
+    return affectedRows(rules.rowCount) + affectedRows(policies.rowCount);
+}
+async function cleanupPermitRules(client, details) {
+    return cleanupBlockRules(client, details);
+}
+async function cleanupTdosViolations(client, details) {
+    const violationIds = parseNumberArray(details.violationIds);
+    const policyId = Number.parseInt(String(details.policyId ?? ''), 10);
+    const violations = violationIds.length > 0
+        ? await client.query('DELETE FROM public.tdos_violations WHERE id = ANY($1::bigint[])', [violationIds])
+        : { rowCount: 0 };
+    const policies = Number.isFinite(policyId) && policyId > 0
+        ? await client.query('DELETE FROM public.policies WHERE id = $1', [policyId])
+        : { rowCount: 0 };
+    return affectedRows(violations.rowCount) + affectedRows(policies.rowCount);
+}
+async function cleanupWatchListLifecycle(client, details) {
+    const runId = String(details.runId ?? '');
+    const watchListId = Number.parseInt(String(details.watchListId ?? ''), 10);
+    const triggerId = Number.parseInt(String(details.triggerId ?? ''), 10);
+    const policyId = Number.parseInt(String(details.policyId ?? ''), 10);
+    const watchListNumberIds = parseNumberArray(details.watchListNumberIds);
+    const violationIds = parseStringArray(details.violationIds);
+    const violationEvents = violationIds.length > 0
+        ? await client.query('DELETE FROM public.watch_list_violation_events WHERE violation_id = ANY($1::uuid[])', [violationIds])
+        : { rowCount: 0 };
+    const curriEvents = runId
+        ? await client.query(`
+        DELETE FROM public.curri_events
+        WHERE alert_variables->>'ct_seed_run_id' = $1
+          AND alert_variables->>'family' = 'watch_lists_full_lifecycle'
+      `, [runId])
+        : { rowCount: 0 };
+    const violations = violationIds.length > 0
+        ? await client.query('DELETE FROM public.watch_list_violations WHERE id = ANY($1::uuid[])', [violationIds])
+        : { rowCount: 0 };
+    const triggerPolicies = Number.isFinite(triggerId) && triggerId > 0
+        ? await client.query('DELETE FROM public.watch_list_triggers_policies WHERE watch_list_trigger_id = $1', [triggerId])
+        : { rowCount: 0 };
+    const listPolicies = Number.isFinite(watchListId) && watchListId > 0
+        ? await client.query('DELETE FROM public.watch_lists_policies WHERE watch_list_id = $1', [watchListId])
+        : { rowCount: 0 };
+    const listNumbers = Number.isFinite(watchListId) && watchListId > 0
+        ? await client.query('DELETE FROM public.watch_list_numbers_have_watch_lists WHERE watch_list_id = $1', [watchListId])
+        : { rowCount: 0 };
+    const triggers = Number.isFinite(triggerId) && triggerId > 0
+        ? await client.query('DELETE FROM public.watch_list_triggers WHERE id = $1', [triggerId])
+        : { rowCount: 0 };
+    const numbers = watchListNumberIds.length > 0
+        ? await client.query('DELETE FROM public.watch_list_numbers WHERE id = ANY($1::bigint[])', [watchListNumberIds])
+        : { rowCount: 0 };
+    const watchLists = Number.isFinite(watchListId) && watchListId > 0
+        ? await client.query('DELETE FROM public.watch_lists WHERE id = $1', [watchListId])
+        : { rowCount: 0 };
+    const policies = Number.isFinite(policyId) && policyId > 0
+        ? await client.query('DELETE FROM public.policies WHERE id = $1', [policyId])
+        : { rowCount: 0 };
+    return [
+        violationEvents,
+        curriEvents,
+        violations,
+        triggerPolicies,
+        listPolicies,
+        listNumbers,
+        triggers,
+        numbers,
+        watchLists,
+        policies,
+    ].reduce((sum, result) => sum + affectedRows(result.rowCount), 0);
+}
+async function cleanupGlobalBlockList(client, details) {
+    const mcidIds = parseNumberArray(details.mcidIds);
+    const rows = mcidIds.length > 0
+        ? await client.query('DELETE FROM public.mcids WHERE id = ANY($1::bigint[])', [mcidIds])
+        : { rowCount: 0 };
+    return affectedRows(rows.rowCount);
+}
+export async function cleanupSeedFamily(client, family, details) {
+    switch (family) {
+        case 'curri_events':
+            return cleanupCurri(client, details);
+        case 'cdr_records':
+            return cleanupCdrRecords(client, details);
+        case 'missed_calls':
+            return cleanupMissedCalls(client, details);
+        case 'xcc_calls':
+            return cleanupXcc(client, details);
+        case 'fac_calls':
+            return cleanupFac(client, details);
+        case 'cmc_calls':
+            return cleanupCmc(client, details);
+        case 'cost_allocation':
+            return cleanupCost(client, details);
+        case 'registration_snapshots':
+            return cleanupRegistrationSnapshots(client, details);
+        case 'dashboard_templates':
+            return cleanupDashboardTemplates(client, details);
+        case 'block_rules':
+            return cleanupBlockRules(client, details);
+        case 'permit_rules':
+            return cleanupPermitRules(client, details);
+        case 'tdos_violations':
+            return cleanupTdosViolations(client, details);
+        case 'watch_lists_full_lifecycle':
+            return cleanupWatchListLifecycle(client, details);
+        case 'global_block_list':
+            return cleanupGlobalBlockList(client, details);
+    }
+}
+//# sourceMappingURL=families.js.map