@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/process-required-fields.d.ts

@@ -0,0 +1,142 @@
+import { type DatasetRowInput, type JsonObject } from './dataset-local.js';
+type AnnualSupplyStatus = 'existing' | 'completed' | 'blocked' | 'skipped';
+export type ProcessRequiredFieldIssue = {
+    code: string;
+    message: string;
+    path: string;
+};
+export type ProcessRequiredFieldCompletion = {
+    field_path: string;
+    source: 'existing' | 'evidence' | 'missing_data_sentinel' | 'placeholder_repair' | 'required_structure_repair';
+    value: Array<{
+        '#text': string;
+        '@xml:lang': string;
+    }>;
+    amount: string | null;
+    unit: string | null;
+    reference_exchange_internal_id: string | null;
+    basis: string;
+};
+export type ProcessRequiredFieldsRowReport = {
+    index: number;
+    id: string | null;
+    version: string | null;
+    type: string | null;
+    status: AnnualSupplyStatus;
+    issues: ProcessRequiredFieldIssue[];
+    completions: ProcessRequiredFieldCompletion[];
+};
+export type ProcessRequiredFieldsReport = {
+    generated_at_utc: string;
+    input_path: string;
+    out_path: string;
+    out_dir: string | null;
+    status: 'completed' | 'completed_with_blockers';
+    default_unit: string;
+    counts: {
+        total: number;
+        processes: number;
+        completed: number;
+        existing: number;
+        blocked: number;
+        skipped: number;
+    };
+    files: {
+        output_rows: string;
+        report: string | null;
+        evidence: string | null;
+    };
+    rows: ProcessRequiredFieldsRowReport[];
+};
+export type RunProcessRequiredFieldsCompleteOptions = {
+    inputPath: string;
+    outPath: string;
+    outDir?: string | null;
+    defaultUnit?: string | null;
+    flowInputPath?: string | null;
+    rawInput?: unknown;
+    rawFlowInput?: unknown;
+    now?: Date;
+};
+type CompletionContext = {
+    defaultUnit: string;
+    flowUnitById?: Map<string, string>;
+};
+type AnnualSupplyEvidenceValue = {
+    value: Array<{
+        '#text': string;
+        '@xml:lang': string;
+    }>;
+    amount: string;
+    unit: string;
+    basis: string;
+};
+declare function textValue(value: unknown): string | null;
+declare function valueAtPath(root: unknown, pathExpression: string): unknown;
+declare function isValidAnnualSupplyVolume(value: unknown): boolean;
+declare function hasDeferredAnnualSupplyTrace(root: JsonObject): boolean;
+declare function isValidReview(value: unknown): boolean;
+declare function isValidComplianceDeclaration(value: unknown): boolean;
+export declare function collectProcessRequiredFieldIssues(payload: JsonObject): ProcessRequiredFieldIssue[];
+declare function issuePath(pathSegments: Array<string | number>): string;
+export declare function collectProcessPlaceholderIssues(payload: JsonObject): ProcessRequiredFieldIssue[];
+declare function repairRequiredProcessStructures(root: JsonObject): ProcessRequiredFieldCompletion[];
+declare function selectReferenceExchange(root: JsonObject): JsonObject | null;
+declare function inferSpecificUnitFromFlowPayload(payload: JsonObject): string | null;
+declare function buildFlowUnitIndex(flowRows: DatasetRowInput[], fallbackUnit: string): Map<string, string>;
+declare function inferUnitFromReferenceExchange(exchange: JsonObject, fallbackOrContext: string | CompletionContext): string;
+declare function annualSupplyTextParts(value: string): {
+    amount: string;
+    unit: string;
+} | null;
+declare function annualSupplyValueFromText(value: string): AnnualSupplyEvidenceValue | null;
+declare function normalizeAnnualSupplyEvidenceValue(candidate: unknown, context: CompletionContext): AnnualSupplyEvidenceValue | null;
+declare function isAnnualSupplyEvidencePath(pathExpression: string | null): boolean;
+declare function fieldPathFromEvidenceEntry(entry: JsonObject): string | null;
+declare function findAnnualSupplyEvidenceEntry(container: unknown, context: CompletionContext): AnnualSupplyEvidenceValue | null;
+declare function findAnnualSupplyEvidenceValue(row: JsonObject, payload: JsonObject, context: CompletionContext): AnnualSupplyEvidenceValue | null;
+declare function ensureDataSources(root: JsonObject): JsonObject;
+declare function annualSupplyMissingDataSentinelValue(): Array<{
+    '#text': string;
+    '@xml:lang': string;
+}>;
+declare function cloneRowWithPayload(row: DatasetRowInput): {
+    row: JsonObject;
+    payload: JsonObject;
+};
+declare function completeProcessRow(row: DatasetRowInput, context: CompletionContext): {
+    row: JsonObject;
+    report: ProcessRequiredFieldsRowReport;
+};
+declare function requireOutputPath(value: string): string;
+export declare function runProcessRequiredFieldsComplete(options: RunProcessRequiredFieldsCompleteOptions): Promise<ProcessRequiredFieldsReport>;
+export declare const __testInternals: {
+    ANNUAL_SUPPLY_MISSING_DATA_SENTINEL_TEXT: string;
+    ANNUAL_SUPPLY_ROOT_FIELD: string;
+    annualSupplyMissingDataSentinelValue: typeof annualSupplyMissingDataSentinelValue;
+    annualSupplyTextParts: typeof annualSupplyTextParts;
+    annualSupplyValueFromText: typeof annualSupplyValueFromText;
+    cloneRowWithPayload: typeof cloneRowWithPayload;
+    collectProcessRequiredFieldIssues: typeof collectProcessRequiredFieldIssues;
+    completeProcessRow: typeof completeProcessRow;
+    ensureDataSources: typeof ensureDataSources;
+    fieldPathFromEvidenceEntry: typeof fieldPathFromEvidenceEntry;
+    hasDeferredAnnualSupplyTrace: typeof hasDeferredAnnualSupplyTrace;
+    findAnnualSupplyEvidenceValue: typeof findAnnualSupplyEvidenceValue;
+    findAnnualSupplyEvidenceEntry: typeof findAnnualSupplyEvidenceEntry;
+    buildFlowUnitIndex: typeof buildFlowUnitIndex;
+    inferUnitFromReferenceExchange: typeof inferUnitFromReferenceExchange;
+    inferSpecificUnitFromFlowPayload: typeof inferSpecificUnitFromFlowPayload;
+    issuePath: typeof issuePath;
+    isAnnualSupplyEvidencePath: typeof isAnnualSupplyEvidencePath;
+    isValidComplianceDeclaration: typeof isValidComplianceDeclaration;
+    isValidAnnualSupplyVolume: typeof isValidAnnualSupplyVolume;
+    isValidReview: typeof isValidReview;
+    normalizeAnnualSupplyEvidenceValue: typeof normalizeAnnualSupplyEvidenceValue;
+    repairRequiredProcessStructures: typeof repairRequiredProcessStructures;
+    requireOutputPath: typeof requireOutputPath;
+    selectReferenceExchange: typeof selectReferenceExchange;
+    textValue: typeof textValue;
+    valueAtPath: typeof valueAtPath;
+};
+export {};

package/dist/src/lib/process-resume-build.d.ts

@@ -0,0 +1,77 @@
+type JsonRecord = Record<string, unknown>;
+export type ProcessResumeBuildLayout = {
+    runId: string;
+    runRoot: string;
+    collectionDir: string;
+    cacheDir: string;
+    manifestsDir: string;
+    reportsDir: string;
+    latestRunIdPath: string;
+    statePath: string;
+    handoffSummaryPath: string;
+    runManifestPath: string;
+    invocationIndexPath: string;
+    resumeMetadataPath: string;
+    resumeHistoryPath: string;
+    reportPath: string;
+};
+export type ProcessResumeBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'prepared_local_process_resume_run';
+    run_id: string;
+    run_root: string;
+    request_id: string | null;
+    resumed_from: string;
+    checkpoint: string | null;
+    attempt: number;
+    state_summary: {
+        build_status: string | null;
+        next_stage: string | null;
+        stop_after: string | null;
+        process_count: number;
+        matched_exchange_count: number;
+        process_dataset_count: number;
+        source_dataset_count: number;
+    };
+    files: {
+        state: string;
+        handoff_summary: string;
+        run_manifest: string;
+        invocation_index: string;
+        resume_metadata: string;
+        resume_history: string;
+        report: string;
+    };
+    next_actions: string[];
+};
+export type RunProcessResumeBuildOptions = {
+    runId?: string;
+    runDir?: string | null;
+    now?: Date;
+    cwd?: string;
+};
+declare function buildLayout(runRoot: string, runId: string): ProcessResumeBuildLayout;
+declare function resolveLayout(options: RunProcessResumeBuildOptions): ProcessResumeBuildLayout;
+declare function buildStateSummary(state: JsonRecord): ProcessResumeBuildReport['state_summary'];
+declare function resolveResumedFrom(state: JsonRecord): string;
+declare function nextAttempt(history: JsonRecord[]): number;
+declare function updateStepMarkers(stepMarkers: unknown, completedAt: string): JsonRecord;
+declare function buildUpdatedState(state: JsonRecord, resumeMetadata: JsonRecord, now: Date): JsonRecord;
+declare function buildInvocationIndex(layout: ProcessResumeBuildLayout, invocationIndex: JsonRecord, options: RunProcessResumeBuildOptions, now: Date): JsonRecord;
+declare function buildNextActions(layout: ProcessResumeBuildLayout, summary: ProcessResumeBuildReport['state_summary']): string[];
+declare function buildReport(layout: ProcessResumeBuildLayout, state: JsonRecord, resumeMetadata: JsonRecord, summary: ProcessResumeBuildReport['state_summary'], now: Date): ProcessResumeBuildReport;
+export declare function runProcessResumeBuild(options: RunProcessResumeBuildOptions): Promise<ProcessResumeBuildReport>;
+export declare const __testInternals: {
+    buildLayout: typeof buildLayout;
+    resolveLayout: typeof resolveLayout;
+    buildStateSummary: typeof buildStateSummary;
+    resolveResumedFrom: typeof resolveResumedFrom;
+    nextAttempt: typeof nextAttempt;
+    updateStepMarkers: typeof updateStepMarkers;
+    buildUpdatedState: typeof buildUpdatedState;
+    buildInvocationIndex: typeof buildInvocationIndex;
+    buildNextActions: typeof buildNextActions;
+    buildReport: typeof buildReport;
+};
+export {};

package/dist/src/lib/process-save-draft-run.d.ts

@@ -0,0 +1,72 @@
+import type { FetchLike } from './http.js';
+import { type ProcessPayloadValidationResult } from './process-payload-validation.js';
+import { type ProcessStateAwareWriteResult } from './process-save-draft.js';
+type JsonObject = Record<string, unknown>;
+export type ProcessSaveDraftSource = 'rows_file' | 'bundle' | 'input';
+export type ProcessSaveDraftCandidate = {
+    id: string | null;
+    version: string | null;
+    source: ProcessSaveDraftSource;
+    bundle_path: string | null;
+    payload: JsonObject;
+    validation?: ProcessPayloadValidationResult;
+    error?: {
+        message: string;
+    };
+};
+export type ProcessSaveDraftProcessReport = {
+    id: string | null;
+    version: string | null;
+    source: ProcessSaveDraftSource;
+    bundle_path: string | null;
+    status: 'prepared' | 'executed' | 'failed';
+    validation?: ProcessPayloadValidationResult;
+    execution?: ProcessStateAwareWriteResult;
+    error?: {
+        message: string;
+    };
+};
+export type ProcessSaveDraftReport = {
+    generated_at_utc: string;
+    input_path: string;
+    input_kind: 'rows_file' | 'publish_request';
+    out_dir: string;
+    commit: boolean;
+    mode: 'dry_run' | 'commit';
+    target_user_id: string | null;
+    account_guard: {
+        target_user_id_required: boolean;
+        target_user_id: string | null;
+        commit_account_binding: 'current_cli_auth_session';
+        post_write_verify_required: boolean;
+    };
+    status: 'completed' | 'completed_with_failures';
+    counts: {
+        selected: number;
+        prepared: number;
+        executed: number;
+        failed: number;
+    };
+    files: {
+        normalized_input: string;
+        selected_processes: string;
+        progress_jsonl: string;
+        failures_jsonl: string;
+        summary_json: string;
+    };
+    processes: ProcessSaveDraftProcessReport[];
+};
+export type RunProcessSaveDraftOptions = {
+    inputPath: string;
+    outDir?: string | null;
+    commit?: boolean | null;
+    rawInput?: unknown;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    targetUserId?: string | null;
+    validateProcessPayloadImpl?: (payload: JsonObject) => ProcessPayloadValidationResult;
+};
+export declare function runProcessSaveDraft(options: RunProcessSaveDraftOptions): Promise<ProcessSaveDraftReport>;
+export {};

package/dist/src/lib/process-save-draft.d.ts

@@ -0,0 +1,53 @@
+import { CliError } from './errors.js';
+import type { FetchLike } from './http.js';
+import { type SupabaseJsonOrderedWriteResult } from './supabase-json-ordered-write.js';
+type JsonObject = Record<string, unknown>;
+export type VisibleProcessRow = {
+    id: string;
+    version: string;
+    user_id: string | null;
+    state_code: number | null;
+};
+export type ProcessSaveDraftRpcResult = {
+    ok: true;
+    [key: string]: unknown;
+};
+export type ProcessStateAwareWriteResult = SupabaseJsonOrderedWriteResult | {
+    status: 'success';
+    operation: 'save_draft';
+    write_path: 'cmd_dataset_save_draft';
+    rpc_result: ProcessSaveDraftRpcResult;
+    visible_row: VisibleProcessRow;
+};
+export type SyncStateAwareProcessRecordOptions = {
+    id: string;
+    version: string;
+    payload: JsonObject;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs?: number;
+    audit?: JsonObject;
+    modelId?: string | null;
+    targetUserId?: string | null;
+};
+declare function buildVisibleRowsUrl(restBaseUrl: string, id: string, version: string): string;
+declare function parseVisibleRows(payload: unknown, url: string): VisibleProcessRow[];
+declare function visibleDraftRow(rows: VisibleProcessRow[]): VisibleProcessRow | null;
+declare function visibleDraftRowForTarget(rows: VisibleProcessRow[], targetUserId: string | null): VisibleProcessRow | null;
+declare function buildCurrentUserUrl(restBaseUrl: string): string;
+declare function assertTargetUserMatchesCurrent(options: {
+    targetUserId: string | null;
+    currentUserId: string;
+}): void;
+declare function buildUnsupportedVisibleRowError(id: string, version: string, rows: VisibleProcessRow[]): CliError;
+export declare function syncStateAwareProcessRecord(options: SyncStateAwareProcessRecordOptions): Promise<ProcessStateAwareWriteResult>;
+export declare const __testInternals: {
+    buildVisibleRowsUrl: typeof buildVisibleRowsUrl;
+    buildCurrentUserUrl: typeof buildCurrentUserUrl;
+    parseVisibleRows: typeof parseVisibleRows;
+    visibleDraftRow: typeof visibleDraftRow;
+    visibleDraftRowForTarget: typeof visibleDraftRowForTarget;
+    assertTargetUserMatchesCurrent: typeof assertTargetUserMatchesCurrent;
+    buildUnsupportedVisibleRowError: typeof buildUnsupportedVisibleRowError;
+};
+export {};

package/dist/src/lib/process-scope-statistics.d.ts

@@ -0,0 +1,210 @@
+import type { FetchLike, ResponseLike } from './http.js';
+type JsonRecord = Record<string, unknown>;
+type ProcessScopeStatisticsScope = 'visible' | 'current-user';
+type SnapshotRow = {
+    id: string;
+    version: string;
+    state_code: number | null;
+    user_id: string | null;
+    modified_at: string | null;
+    model_id: string | null;
+    json: JsonRecord;
+};
+type ClassificationEntry = {
+    level: number;
+    text: string;
+};
+type StatisticsMetadata = {
+    userId: string | null;
+    maskedUserEmail: string | null;
+    totalRowsReportedByRemote: number | null;
+};
+type StatisticsOptions = {
+    scope: ProcessScopeStatisticsScope;
+    stateCodes: number[];
+};
+export type RunProcessScopeStatisticsOptions = {
+    outDir: string;
+    scope?: ProcessScopeStatisticsScope;
+    stateCodes?: number[];
+    pageSize?: number | null;
+    reuseSnapshot?: boolean;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    maxRetries?: number;
+    now?: Date;
+};
+export type ProcessScopeStatisticsReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_process_scope_statistics';
+    out_dir: string;
+    scope: ProcessScopeStatisticsScope;
+    state_codes: number[];
+    total_process_rows: number;
+    domain_count_primary: number;
+    domain_count_leaf: number;
+    craft_count: number;
+    unit_process_rows: number;
+    product_count: number;
+    files: {
+        snapshot_manifest: string;
+        snapshot_rows: string;
+        process_scope_summary: string;
+        domain_summary: string;
+        craft_summary: string;
+        product_summary: string;
+        type_of_dataset_summary: string;
+        report: string;
+        report_zh: string;
+    };
+};
+type ProcessScopeStatisticsSummary = {
+    schema_version: 1;
+    generated_at_utc: string;
+    scope: ProcessScopeStatisticsScope;
+    state_codes: number[];
+    user_id: string | null;
+    masked_user_email: string | null;
+    total_process_rows: number;
+    total_rows_reported_by_remote: number | null;
+    rows_by_state_code: Record<string, number>;
+    distinct_visible_owner_user_ids: number;
+    domain_count_primary: number;
+    domain_count_leaf: number;
+    craft_count: number;
+    unit_process_rows: number;
+    unit_process_share: number;
+    product_count: number;
+    products_with_flow_id: number;
+    products_without_flow_id: number;
+    rows_missing_classification: number;
+    rows_missing_craft: number;
+    rows_missing_product: number;
+    rows_missing_reference_exchange: number;
+    metric_definitions: Record<string, string>;
+};
+type ProcessScopeStatisticsArtifacts = {
+    summary: ProcessScopeStatisticsSummary;
+    domainPrimarySummary: Array<{
+        domain: string;
+        count: number;
+        sample_path?: string;
+    }>;
+    domainLeafSummary: Array<{
+        domain: string;
+        count: number;
+        sample_path?: string;
+    }>;
+    craftSummary: Array<{
+        craft_signature: string;
+        label: string;
+        count: number;
+        source_kind: string;
+    }>;
+    productSummary: Array<{
+        product_key: string;
+        label: string;
+        count: number;
+        stable_flow_id: string;
+        stable_flow_version: string;
+        source_kind: string;
+    }>;
+    typeOfDataSetSummary: Array<{
+        type_of_dataset: string;
+        count: number;
+    }>;
+    craftSourceSummary: Array<{
+        source_kind: string;
+        count: number;
+    }>;
+    productSourceSummary: Array<{
+        source_kind: string;
+        count: number;
+    }>;
+};
+declare function toPositiveInteger(value: number | null | undefined, label: string, code: string): number;
+declare function normalizeStateCodes(value: readonly number[] | undefined): number[];
+declare function ensureScope(value: string | undefined): ProcessScopeStatisticsScope;
+declare function parseJsonResponse(response: ResponseLike, label: string): Promise<unknown>;
+declare function fetchJsonWithRetry(options: {
+    url: string;
+    init: RequestInit;
+    label: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+}): Promise<{
+    status: number;
+    headers: Headers;
+    body: unknown;
+}>;
+declare function resolveCurrentUserId(options: {
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    now: Date;
+    maxRetries: number;
+}): Promise<string>;
+declare function fetchProcessRows(options: {
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    maxRetries: number;
+    scope: ProcessScopeStatisticsScope;
+    stateCodes: number[];
+    pageSize: number;
+    userId: string | null;
+}): Promise<{
+    rows: SnapshotRow[];
+    total: number | null;
+}>;
+declare function normalizeSnapshotRow(value: unknown): SnapshotRow | null;
+declare function normalizePayload(value: unknown): JsonRecord | null;
+declare function getLangList(value: unknown): JsonRecord[];
+declare function getLangText(value: unknown, lang: string | null): string;
+declare function getAnyLangText(value: unknown): string;
+declare function extractClassificationEntries(dataSetInformation: JsonRecord): ClassificationEntry[];
+declare function normalizeSignature(text: string): string;
+declare function extractCraftCandidate(dataSetInformation: JsonRecord, technology: JsonRecord): {
+    source_kind: string;
+    label: string;
+    signature: string;
+};
+declare function extractReferenceProduct(processDataSet: JsonRecord, dataSetInformation: JsonRecord): {
+    key: string;
+    stable_flow_id: string;
+    stable_flow_version: string;
+    label: string;
+    source_kind: string;
+    missing_reference_exchange: boolean;
+};
+declare function calculateStatistics(rows: SnapshotRow[], options: StatisticsOptions, metadata: StatisticsMetadata, generatedAtUtc: string): ProcessScopeStatisticsArtifacts;
+declare function escapePipe(value: unknown): string;
+declare function renderMarkdownReport(statistics: ProcessScopeStatisticsArtifacts, reportLang: 'en' | 'zh'): string;
+declare function readSnapshotManifest(filePath: string): JsonRecord | null;
+export declare function runProcessScopeStatistics(options: RunProcessScopeStatisticsOptions): Promise<ProcessScopeStatisticsReport>;
+export declare const __testInternals: {
+    calculateStatistics: typeof calculateStatistics;
+    ensureScope: typeof ensureScope;
+    escapePipe: typeof escapePipe;
+    extractClassificationEntries: typeof extractClassificationEntries;
+    extractCraftCandidate: typeof extractCraftCandidate;
+    extractReferenceProduct: typeof extractReferenceProduct;
+    fetchJsonWithRetry: typeof fetchJsonWithRetry;
+    fetchProcessRows: typeof fetchProcessRows;
+    getAnyLangText: typeof getAnyLangText;
+    getLangList: typeof getLangList;
+    getLangText: typeof getLangText;
+    normalizePayload: typeof normalizePayload;
+    normalizeSignature: typeof normalizeSignature;
+    normalizeSnapshotRow: typeof normalizeSnapshotRow;
+    normalizeStateCodes: typeof normalizeStateCodes;
+    parseJsonResponse: typeof parseJsonResponse;
+    readSnapshotManifest: typeof readSnapshotManifest;
+    resolveCurrentUserId: typeof resolveCurrentUserId;
+    renderMarkdownReport: typeof renderMarkdownReport;
+    toPositiveInteger: typeof toPositiveInteger;
+};
+export {};

package/dist/src/lib/process-verify-rows.d.ts

@@ -0,0 +1,71 @@
+import { type ProcessPayloadValidationResult } from './process-payload-validation.js';
+type JsonObject = Record<string, unknown>;
+type NameFieldKey = 'baseName' | 'treatmentStandardsRoutes' | 'mixAndLocationTypes' | 'functionalUnitFlowProperties';
+export type ProcessVerifyNameFieldSummary = {
+    present: boolean;
+    en: string;
+    zh: string;
+    any: string;
+};
+export type ProcessVerifyRowRecord = {
+    row_index: number;
+    id: string | null;
+    version: string | null;
+    status: 'ok' | 'invalid';
+    validation: ProcessPayloadValidationResult;
+    name_summary: {
+        missing_required_fields: Array<'baseName' | 'treatmentStandardsRoutes' | 'mixAndLocationTypes'>;
+        fields: Record<NameFieldKey, ProcessVerifyNameFieldSummary>;
+    };
+};
+export type ProcessVerifyRowsReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed_process_row_verification' | 'completed_with_invalid_process_rows';
+    rows_file: string;
+    out_dir: string;
+    row_count: number;
+    invalid_count: number;
+    schema_invalid_count: number;
+    missing_required_name_field_count: number;
+    invalid_rows: Array<{
+        id: string | null;
+        version: string | null;
+        row_index: number;
+        missing_required_fields: Array<'baseName' | 'treatmentStandardsRoutes' | 'mixAndLocationTypes'>;
+        schema_issue_count: number;
+    }>;
+    files: {
+        summary_json: string;
+        verification_jsonl: string;
+    };
+};
+export type RunProcessVerifyRowsOptions = {
+    rowsFile: string;
+    outDir: string;
+    now?: Date;
+    validateProcessPayloadImpl?: (payload: JsonObject) => ProcessPayloadValidationResult;
+};
+declare function readRowsFile(filePath: string): unknown[];
+declare function getPayload(row: unknown): JsonObject;
+declare function getIdentity(row: unknown, payload: JsonObject, index: number): {
+    row_index: number;
+    id: string | null;
+    version: string | null;
+};
+declare function getLangList(value: unknown): JsonObject[];
+declare function getLangText(value: unknown, lang: string | null): string;
+declare function summarizeNameFields(payload: JsonObject): {
+    missing_required_fields: Array<'baseName' | 'treatmentStandardsRoutes' | 'mixAndLocationTypes'>;
+    fields: Record<NameFieldKey, ProcessVerifyNameFieldSummary>;
+};
+export declare function runProcessVerifyRows(options: RunProcessVerifyRowsOptions): Promise<ProcessVerifyRowsReport>;
+export declare const __testInternals: {
+    getIdentity: typeof getIdentity;
+    getLangList: typeof getLangList;
+    getLangText: typeof getLangText;
+    getPayload: typeof getPayload;
+    readRowsFile: typeof readRowsFile;
+    summarizeNameFields: typeof summarizeNameFields;
+};
+export {};