@tmlmobilidade/export-data 20260304.1819.11 → 20260421.1523.13

package/dist/tasks/executive-summary-setup/on-board-sales.js

@@ -0,0 +1,58 @@
+import { Dates } from '@tmlmobilidade/dates';
+import { simplifiedApexOnBoardSales } from '@tmlmobilidade/interfaces';
+/* Main function */
+export async function calculateOnBoardSales({ context, message }) {
+    message('Calculating on-board sales...');
+    const collection = await simplifiedApexOnBoardSales.getCollection();
+    // Convert received dates (yyyymmdd) to UTC range
+    const start = context.dates.start;
+    const end = context.dates.end;
+    const startDate = Dates.fromOperationalDate(start, 'Europe/Lisbon').unix_timestamp;
+    const endDate = Dates.fromOperationalDate(end, 'Europe/Lisbon').unix_timestamp;
+    // MongoDB pipeline based on your query
+    const pipeline = [
+        {
+            $match: {
+                agency_id: { $exists: true },
+                created_at: { $gte: startDate, $lte: endDate },
+                is_passenger: true,
+            },
+        },
+        {
+            $group: {
+                _id: '$agency_id',
+                totalRevenueCents: { $sum: '$price' },
+            },
+        },
+        {
+            $project: {
+                _id: 0,
+                agencyId: '$_id',
+                totalRevenue: {
+                    $divide: ['$totalRevenueCents', 100], // convert to euros
+                },
+            },
+        },
+        {
+            $sort: { agencyId: 1 },
+        },
+    ];
+    const cursor = collection.aggregate(pipeline);
+    const results = [];
+    // console.log('Pipeline results:', JSON.stringify(pipeline, null, 2));
+    for await (const doc of cursor) {
+        // Since the original query has no date, use startDate as reference
+        const date = new Date(startDate);
+        const day = date.getUTCDate().toString().padStart(2, '0');
+        const month = (date.getUTCMonth() + 1).toString().padStart(2, '0');
+        const year = date.getUTCFullYear();
+        const formattedDate = `${day}/${month}/${year}`;
+        results.push({
+            'agencyId': doc.agencyId,
+            'date': formattedDate,
+            'onboard-sales-pr': parseFloat(doc.totalRevenue.toFixed(2)),
+        });
+    }
+    message(`Processed ${results.length} on-board sales records`);
+    return results;
+}

package/dist/tasks/executive-summary-setup/passenger-impact.js

@@ -0,0 +1,46 @@
+import { yyyymmddToDashed } from '../../utils/dates-helper.js';
+import { metrics } from '@tmlmobilidade/interfaces';
+/**
+ * Calculates the estimated affected passengers by agency and day
+ * from the "demand_affected_by_failed_circulations_by_day" metric.
+ */
+export async function calculateAffectedPassengers({ context, message }) {
+    message('Calculating passengers affected by failed circulations...');
+    const metricsCollection = await metrics.getCollection();
+    // Fetch only the relevant metric documents
+    message('Fetching affected passengers metrics...');
+    const docs = await metricsCollection
+        .find({
+        metric: 'demand_affected_by_failed_circulations_by_day',
+    })
+        .toArray();
+    message(`Found ${docs.length} documents to process`);
+    const results = new Map(); // key = `${date}-${agencyId}`
+    const startDate = yyyymmddToDashed(context.dates.start);
+    const endDate = yyyymmddToDashed(context.dates.end);
+    // Process each metric document
+    for (const doc of docs) {
+        const agencyId = doc.properties.agency_id;
+        for (const [date, dayData] of Object.entries(doc.data)) {
+            // Skip dates outside the context range
+            if (date < startDate.replace(/-/g, '') || date > endDate.replace(/-/g, ''))
+                continue;
+            const dashedDate = yyyymmddToDashed(date);
+            const key = `${dashedDate}-${agencyId}`;
+            // Initialize entry if it doesn't exist
+            if (!results.has(key)) {
+                results.set(key, {
+                    agencyId,
+                    date: dashedDate,
+                    estimatedpax_affected_by_failures: 0,
+                });
+            }
+            // Add estimated affected passengers
+            const entry = results.get(key);
+            entry.estimatedpax_affected_by_failures += dayData.estimated_affected_passengers;
+        }
+    }
+    message(`Processed ${results.size} affected passenger records`);
+    // Return results as an array
+    return Array.from(results.values());
+}

package/dist/tasks/executive-summary-setup/passengers-transported.js

@@ -0,0 +1,56 @@
+import { yyyymmddToDashed } from '../../utils/dates-helper.js';
+import { metrics } from '@tmlmobilidade/interfaces';
+/* * */
+export async function calculateDemandFromMetrics({ context, message }) {
+    message('A calcular procura a partir das métricas...');
+    const metricsCollection = await metrics.getCollection();
+    //
+    // Fetch only relevant metrics
+    message('A ir buscar métricas de procura...');
+    const docs = await metricsCollection.find({
+        metric: { $in: ['demand_by_product_by_agency_by_day', 'demand_by_category_by_agency_by_day'] },
+    }).toArray();
+    message(`Encontradas ${docs.length} métricas para processar`);
+    const results = new Map(); // key = `${date}-${agencyId}`
+    const startDate = yyyymmddToDashed(context.dates.start);
+    const endDate = yyyymmddToDashed(context.dates.end);
+    //
+    // Process each metric document
+    for (const doc of docs) {
+        const agencyId = doc.properties.agency_id;
+        const isProductMetric = doc.metric === 'demand_by_product_by_agency_by_day';
+        for (const [date, dayData] of Object.entries(doc.data)) {
+            if (date < startDate || date > endDate)
+                continue;
+            const key = `${date}-${agencyId}`;
+            if (!results.has(key)) {
+                results.set(key, {
+                    agencyId,
+                    byCategory: {},
+                    byProduct: {},
+                    date,
+                    totalpassengers: 0,
+                });
+            }
+            const entry = results.get(key);
+            const qty = dayData.qty;
+            if (isProductMetric) {
+                const productId = doc.properties.product_id;
+                entry.byProduct[productId] = (entry.byProduct[productId] || 0) + qty;
+            }
+            else {
+                const category = doc.properties.category;
+                entry.byCategory[category] = (entry.byCategory[category] || 0) + qty;
+            }
+        }
+    }
+    //
+    // Calculate totalpassengers from byProduct
+    message('A calcular totais de passageiros...');
+    for (const entry of results.values()) {
+        entry.totalpassengers = Object.values(entry.byProduct).reduce((sum, v) => sum + v, 0);
+    }
+    message(`Processados ${results.size} registos de procura`);
+    return Array.from(results.values());
+    //
+}

package/dist/tasks/executive-summary-setup/paxperkm.js

@@ -0,0 +1,73 @@
+import { Dates } from '@tmlmobilidade/dates';
+import { rides } from '@tmlmobilidade/interfaces';
+export async function calculatePassengersPerKm({ context }) {
+    console.log('Calculating passengers per km for executed trips...');
+    const ridesCollection = await rides.getCollection();
+    const startDateStr = Dates.fromOperationalDate(context.dates.start, 'Europe/Lisbon').unix_timestamp;
+    const endDateStr = Dates.fromOperationalDate(context.dates.end, 'Europe/Lisbon').unix_timestamp;
+    console.log(`Date range: ${startDateStr} to ${endDateStr}`);
+    const pipeline = [
+        {
+            $match: {
+                agency_id: { $exists: true },
+                start_time_scheduled: { $gte: startDateStr, $lte: endDateStr },
+            },
+        },
+        {
+            $project: {
+                agencyId: '$agency_id',
+                extensionScheduled: '$extension_scheduled',
+                isValid: {
+                    $or: [
+                        { $eq: ['$analysis.SIMPLE_ONE_APEX_VALIDATION.grade', 'pass'] },
+                        { $eq: ['$analysis.SIMPLE_THREE_VEHICLE_EVENTS.grade', 'pass'] },
+                    ],
+                },
+                passengersObserved: '$passengers_observed',
+            },
+        },
+        {
+            $group: {
+                _id: { agencyId: '$agencyId' },
+                totalKm: { $sum: { $cond: ['$isValid', '$extensionScheduled', 0] } },
+                totalPassengers: { $sum: { $cond: ['$isValid', '$passengersObserved', 0] } },
+            },
+        },
+        {
+            $project: {
+                _id: 0,
+                agencyId: '$_id.agencyId',
+                passengersPerKm: {
+                    $cond: [
+                        { $eq: ['$totalKm', 0] },
+                        0,
+                        {
+                            $round: [
+                                { $divide: ['$totalPassengers', { $divide: ['$totalKm', 1000] }] },
+                                2,
+                            ],
+                        },
+                    ],
+                },
+                totalKm: 1,
+                totalPassengers: 1,
+            },
+        },
+    ];
+    const aggCursor = ridesCollection.aggregate(pipeline);
+    const results = [];
+    for await (const doc of aggCursor) {
+        // // Total Passengers, Km, passengersPerKm DEBUG
+        // console.log(
+        // 	`[DEBUG] Agency: ${doc.agencyId} | Total Passengers: ${doc.totalPassengers} | Total Km: ${doc.totalKm} | passengersPerKm: ${doc.passengersPerKm}`,
+        // );
+        results.push({
+            agencyId: doc.agencyId,
+            passengersPerKm: doc.passengersPerKm,
+            totalKm: doc.totalKm,
+            totalPassengers: doc.totalPassengers,
+        });
+    }
+    console.log(`Processed ${results.length} agencies for the interval.`);
+    return results;
+}

package/dist/tasks/executive-summary-setup/trips.js

@@ -0,0 +1,132 @@
+import { Dates } from '@tmlmobilidade/dates';
+import { rides } from '@tmlmobilidade/interfaces';
+/* * */
+/**
+ * Calculates the number of planned trips per agency and date
+ */
+export async function calculatePlannedTrips({ context, message }) {
+    message('Calculating planned trips...');
+    const ridesCollection = await rides.getCollection();
+    const startDateStr = Dates.fromOperationalDate(context.dates.start, 'Europe/Lisbon').unix_timestamp;
+    const endDateStr = Dates.fromOperationalDate(context.dates.end, 'Europe/Lisbon').unix_timestamp;
+    message(`Date range: ${startDateStr} to ${endDateStr}`);
+    const pipeline = [
+        {
+            $match: {
+                agency_id: { $exists: true },
+                start_time_scheduled: { $gte: startDateStr, $lte: endDateStr },
+            },
+        },
+        {
+            $group: {
+                _id: { agencyId: '$agency_id', date: '$operational_date' },
+                plannedTrips: { $sum: 1 },
+            },
+        },
+        {
+            $project: {
+                _id: 0,
+                agencyId: '$_id.agencyId',
+                date: '$_id.date',
+                plannedTrips: 1,
+            },
+        },
+    ];
+    const aggCursor = ridesCollection.aggregate(pipeline);
+    const results = [];
+    for await (const doc of aggCursor) {
+        const formattedDate = Dates.fromOperationalDate(doc.date, 'Europe/Lisbon').toFormat('dd/MM/yyyy');
+        results.push({
+            agencyId: doc.agencyId,
+            date: formattedDate,
+            plannedTrips: doc.plannedTrips,
+        });
+    }
+    message(`Processed ${results.length} planned trips metrics`);
+    return results;
+}
+/* * */
+/**
+ * Calculates the number of completed trips per agency and date
+ */
+export async function calculateCompletedTrips({ context, message }) {
+    message('Calculating completed trips...');
+    const ridesCollection = await rides.getCollection();
+    const startDateStr = Dates.fromOperationalDate(context.dates.start, 'Europe/Lisbon').toFormat('yyyyMMdd');
+    const endDateStr = Dates.fromOperationalDate(context.dates.end, 'Europe/Lisbon').toFormat('yyyyMMdd');
+    message(`Date range: ${startDateStr} to ${endDateStr}`);
+    const pipeline = [
+        {
+            $match: {
+                agency_id: { $exists: true },
+                operational_date: { $gte: startDateStr, $lte: endDateStr },
+            },
+        },
+        {
+            $group: {
+                _id: { agencyId: '$agency_id', date: '$operational_date' },
+                completedTrips: {
+                    $sum: {
+                        $cond: [
+                            {
+                                $or: [
+                                    { $eq: ['$analysis.SIMPLE_ONE_APEX_VALIDATION.grade', 'pass'] },
+                                    { $eq: ['$analysis.SIMPLE_THREE_VEHICLE_EVENTS.grade', 'pass'] },
+                                ],
+                            },
+                            1,
+                            0,
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            $project: {
+                _id: 0,
+                agencyId: '$_id.agencyId',
+                completedTrips: 1,
+                date: '$_id.date',
+            },
+        },
+    ];
+    const aggCursor = ridesCollection.aggregate(pipeline);
+    const results = [];
+    for await (const doc of aggCursor) {
+        const formattedDate = Dates.fromOperationalDate(doc.date, 'Europe/Lisbon').toFormat('dd/MM/yyyy');
+        results.push({
+            agencyId: doc.agencyId,
+            completedTrips: doc.completedTrips,
+            date: formattedDate,
+        });
+    }
+    message(`Processed ${results.length} completed trips metrics`);
+    return results;
+}
+/* * */
+/**
+ * Calculates the percentage of completed trips based on planned trips
+ */
+export function calculateCompletedTripsPercentage(plannedTrips, completedTrips) {
+    const percentageResults = [];
+    // Create a lookup map for planned trips
+    const plannedMap = new Map();
+    for (const p of plannedTrips) {
+        plannedMap.set(`${p.date}-${p.agencyId}`, p.plannedTrips);
+    }
+    // Calculate % for each completed trip entry
+    for (const c of completedTrips) {
+        const key = `${c.date}-${c.agencyId}`;
+        const planned = plannedMap.get(key) || 0;
+        let percentage = 0;
+        if (planned > 0) {
+            percentage = (c.completedTrips / planned) * 100;
+        }
+        percentageResults.push({
+            agencyId: c.agencyId,
+            date: c.date,
+            percentage: parseFloat(percentage.toFixed(1)), // round to 1 decimal
+        });
+    }
+    return percentageResults;
+}

package/dist/tasks/executive-summary-setup/tripstatus.js

@@ -0,0 +1,114 @@
+import { Dates } from '@tmlmobilidade/dates';
+import { rides } from '@tmlmobilidade/interfaces';
+import { Logger } from '@tmlmobilidade/logger';
+import { Timer } from '@tmlmobilidade/timer';
+/* Helper Function */
+async function processDailyRides(stream, results, agencies, agency43Trips) {
+    for (const rideData of stream) {
+        const agency = rideData.agency_id;
+        if (!agencies.includes(agency))
+            continue;
+        if (rideData.system_status !== 'complete')
+            continue;
+        const analysis = rideData.analysis;
+        if (!analysis)
+            continue;
+        const expectedStart = analysis.EXPECTED_START_TIME?.value;
+        if (expectedStart === undefined || expectedStart === null)
+            continue;
+        if (expectedStart <= -1) {
+            results.agencies[agency].early_rides++;
+            results.total.early_rides++;
+        }
+        if (expectedStart >= 5) {
+            results.agencies[agency].five_min_delays++;
+            results.total.five_min_delays++;
+            const passengers = rideData.passengers_observed ?? 0;
+            results.agencies[agency]['pax-affected-by-delay']
+                = (results.agencies[agency]['pax-affected-by-delay'] ?? 0) + passengers;
+            results.total['pax-affected-by-delay']
+                = (results.total['pax-affected-by-delay'] ?? 0) + passengers;
+            if (agency === '43') {
+                agency43Trips.push(rideData.trip_id);
+            }
+        }
+        if (expectedStart > -1 && expectedStart < 5) {
+            results.agencies[agency].ontime_rides++;
+            results.total.ontime_rides++;
+        }
+    }
+}
+/* Percentages */
+function calculatePercentages(metrics) {
+    const total = metrics.early_rides + metrics.five_min_delays + metrics.ontime_rides;
+    if (total === 0)
+        return { early_rides_pct: 0, five_min_delays_pct: 0, ontime_rides_pct: 0 };
+    return {
+        early_rides_pct: parseFloat(((metrics.early_rides / total) * 100).toFixed(1)),
+        five_min_delays_pct: parseFloat(((metrics.five_min_delays / total) * 100).toFixed(1)),
+        ontime_rides_pct: parseFloat(((metrics.ontime_rides / total) * 100).toFixed(1)),
+    };
+}
+/* Main Function */
+export const calculateDailyServiceCompliance = async (context) => {
+    const agencies = ['41', '42', '43', '44'];
+    const ridesCollection = await rides.getCollection();
+    const agency43Trips = [];
+    const processingTimer = new Timer();
+    let countProcessed = 0;
+    const resultsByDay = {};
+    const startDate = Dates.fromOperationalDate(context.dates.start, 'Europe/Lisbon').unix_timestamp;
+    const endDate = Dates.fromOperationalDate(context.dates.end, 'Europe/Lisbon').unix_timestamp;
+    const ridesQuery = {
+        start_time_scheduled: {
+            $gte: startDate,
+            $lte: endDate,
+        },
+    };
+    const allRidesStream = ridesCollection.find(ridesQuery).batchSize(100_000).stream();
+    for await (const ride of allRidesStream) {
+        const rideData = ride;
+        const dayOperationalStr = Dates.fromOperationalDate(rideData.operational_date, 'Europe/Lisbon').toFormat('yyyyMMdd');
+        if (!resultsByDay[dayOperationalStr]) {
+            resultsByDay[dayOperationalStr] = {
+                agencies: {},
+                total: { 'early_rides': 0, 'five_min_delays': 0, 'ontime_rides': 0, 'pax-affected-by-delay': 0 },
+            };
+            agencies.forEach((op) => {
+                resultsByDay[dayOperationalStr].agencies[op] = {
+                    'early_rides': 0,
+                    'five_min_delays': 0,
+                    'ontime_rides': 0,
+                    'pax-affected-by-delay': 0,
+                };
+            });
+        }
+        await processDailyRides([rideData], resultsByDay[dayOperationalStr], agencies, agency43Trips);
+        countProcessed++;
+        if (countProcessed % 100 === 0) {
+            // Logger.info(`Processed ${countProcessed} rides so far...`);
+        }
+    }
+    Logger.info(`Ride processing completed in ${processingTimer.get()} ms`);
+    /* Format results and calculate percentages */
+    const formattedResults = {};
+    for (const day in resultsByDay) {
+        const displayDate = Dates.fromOperationalDate(day, 'Europe/Lisbon').toFormat('dd/MM/yyyy');
+        const dayMetrics = resultsByDay[day];
+        const agenciesWithPct = {};
+        for (const agencyId of Object.keys(dayMetrics.agencies)) {
+            const percentages = calculatePercentages(dayMetrics.agencies[agencyId]);
+            agenciesWithPct[agencyId] = { ...dayMetrics.agencies[agencyId], ...percentages };
+        }
+        const totalPercentages = calculatePercentages(dayMetrics.total);
+        const totalWithPct = { ...dayMetrics.total, ...totalPercentages };
+        formattedResults[displayDate] = {
+            agencies: agenciesWithPct,
+            total: totalWithPct,
+        };
+    }
+    /* LOG: Export agency 43 trips */
+    // fs.writeFileSync('agency_43_trips.json', JSON.stringify(agency43Trips, null, 2));
+    // Logger.info(`Exported ${agency43Trips.length} trip_id for agency 43 to agency_43_trips.json`);
+    return formattedResults;
+};

package/dist/types.js

@@ -1,6 +1,7 @@
 /* * */
 /* * */
 export const exportTypeLabels = {
+    'executive-summary': '6.0. Sumário Executivo',
     'hashed-shapes-geojson': '4.0. HashedShapes para GeoJSON',
     'rides-raw': '2.0. Rides em bruto (SLAs)',
     'sams-raw': '5.0. SAMs em bruto (Sequencialidade)',

package/dist/utils/dates-helper.js

@@ -0,0 +1,3 @@
+export function yyyymmddToDashed(date) {
+    return `${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6, 8)}`;
+}

package/dist/utils/parse-id-list.js

@@ -0,0 +1,37 @@
+/* * */
+// Parses "id1,id2,start-end" into a flat list of IDs; expands ranges (e.g. 1001-1003)
+export function parseIdListWithRanges(input, digits) {
+    const re = new RegExp(`^(\\d{${digits}})-(\\d{${digits}})$`);
+    const parts = input.replace(/,$/, '').split(',').map(id => id.trim());
+    const result = [];
+    for (const part of parts) {
+        const m = part.match(re);
+        if (m) {
+            const lo = Number(m[1]);
+            const hi = Number(m[2]);
+            for (let n = lo; n <= hi; n++)
+                result.push(String(n).padStart(digits, '0'));
+        }
+        else {
+            result.push(part);
+        }
+    }
+    return result;
+}
+// Returns an error message if the value is invalid, otherwise undefined
+export function validateIdListWithRanges(value, digits) {
+    const re = new RegExp(`^(\\d{${digits}})-(\\d{${digits}})$`);
+    const singleRe = new RegExp(`^\\d{${digits}}$`);
+    const parts = value.replace(/,$/, '').split(',').map(id => id.trim());
+    for (const part of parts) {
+        const m = part.match(re);
+        if (m) {
+            if (Number(m[1]) > Number(m[2]))
+                return `Intervalo inválido: ${part}`;
+        }
+        else if (!singleRe.test(part)) {
+            return `ID ou intervalo inválido: ${part}`;
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@tmlmobilidade/export-data",
 	"description": "CLI tool to export data from GO.",
-	"version": "20260304.1819.11",
+	"version": "20260421.1523.13",
 	"author": {
 		"email": "iso@tmlmobilidade.pt",
 		"name": "TML-ISO"
@@ -36,9 +36,10 @@
 		"lint:fix": "eslint . --fix"
 	},
 	"dependencies": {
-		"@clack/prompts": "1.0.1",
+		"@clack/prompts": "1.2.0",
 		"@tmlmobilidade/consts": "*",
 		"@tmlmobilidade/dates": "*",
+		"@tmlmobilidade/go-performance-pckg-dates": "*",
 		"@tmlmobilidade/interfaces": "*",
 		"@tmlmobilidade/strings": "*",
 		"@tmlmobilidade/timer": "*",
@@ -47,7 +48,7 @@
 	"devDependencies": {
 		"@tmlmobilidade/tsconfig": "*",
 		"@tmlmobilidade/types": "*",
-		"@types/node": "25.3.0",
+		"@types/node": "25.6.0",
 		"resolve-tspaths": "0.8.23",
 		"typescript": "5.9.3"
 	}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/prompts/access-key.d.ts

@@ -1 +0,0 @@
-export declare function promptAccessKey(): Promise<void>;

package/dist/prompts/export-types.d.ts

@@ -1,2 +0,0 @@
-import { type ExportType } from '../types.js';
-export declare function promptExportTypes(): Promise<ExportType[]>;

package/dist/prompts/filter-agency-ids.d.ts

@@ -1 +0,0 @@
-export declare function promptFilterByAgencyIds(): Promise<string[]>;

package/dist/prompts/filter-dates.d.ts

@@ -1,5 +0,0 @@
-import { type OperationalDate } from '@tmlmobilidade/types';
-export declare function promptFilterByDates(): Promise<{
-    end: OperationalDate;
-    start: OperationalDate;
-}>;

package/dist/prompts/filter-line-ids.d.ts

@@ -1 +0,0 @@
-export declare function promptFilterByLineIds(): Promise<string[]>;

package/dist/prompts/filter-pattern-ids.d.ts

@@ -1 +0,0 @@
-export declare function promptFilterByPatternIds(): Promise<string[]>;

package/dist/prompts/filter-stop-ids.d.ts

@@ -1 +0,0 @@
-export declare function promptFilterByStopIds(): Promise<string[]>;

package/dist/prompts/filter-types.d.ts

@@ -1 +0,0 @@
-export declare function promptFilterTypes(): Promise<string[]>;

package/dist/prompts/filter-vehicle-ids.d.ts

@@ -1 +0,0 @@
-export declare function promptFilterByVehicleIds(): Promise<number[]>;

package/dist/prompts/hashedshape-ids.d.ts

@@ -1 +0,0 @@
-export declare function promptHashedShapeIds(): Promise<string[]>;

package/dist/prompts/validation-group-fields.d.ts

@@ -1,2 +0,0 @@
-import { type ValidationGroupField } from '../tasks/apex-validations/validations-aggregated.js';
-export declare function promptValidationGroupFields(): Promise<ValidationGroupField[]>;

package/dist/tasks/apex-validations/validations-aggregated.d.ts

@@ -1,18 +0,0 @@
-import { type TaskProps } from '../../types.js';
-/**
- * Available fields for grouping validations.
- * 'date' is always included by default.
- */
-export declare const validationGroupFields: readonly ["line_id", "pattern_id", "product_id", "trip_id", "stop_id", "agency_id", "vehicle_id"];
-export type ValidationGroupField = typeof validationGroupFields[number];
-export declare const validationGroupFieldLabels: Record<ValidationGroupField, string>;
-interface ValidationAggregatedTaskProps extends TaskProps {
-    groupFields: ValidationGroupField[];
-}
-/**
- * Export Validations aggregated by user-selected fields.
- * Always groups by date, plus any additional fields selected by the user.
- * The 'validations' count is always included.
- */
-export declare function exportValidationsAggregated({ context, groupFields, message }: ValidationAggregatedTaskProps): Promise<void>;
-export {};

package/dist/tasks/apex-validations/validations-raw.d.ts

@@ -1,2 +0,0 @@
-import { type TaskProps } from '../../types.js';
-export declare function exportValidationsRaw({ context, message }: TaskProps): Promise<void>;

package/dist/tasks/hashed-shapes/hashed-shapes-geojson.d.ts

@@ -1,4 +0,0 @@
-import { type TaskProps } from '../../types.js';
-export declare function exportHashedShapesGeoJSON({ context, hashedShapeIds, message }: TaskProps & {
-    hashedShapeIds: string[];
-}): Promise<void>;

package/dist/tasks/rides/rides-raw.d.ts

@@ -1,2 +0,0 @@
-import { type TaskProps } from '../../types.js';
-export declare function exportRidesRaw({ context, message }: TaskProps): Promise<void>;

package/dist/tasks/sams/sams-raw.d.ts

@@ -1,2 +0,0 @@
-import { type TaskProps } from '../../types.js';
-export declare function exportSamsRaw({ context, message }: TaskProps): Promise<void>;