@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/dataset-curation-queue.d.ts

@@ -0,0 +1,219 @@
+export type DatasetCurationQueueEntityType = 'support' | 'flow' | 'process';
+export type RunDatasetCurationQueueBuildOptions = {
+    processesPath: string;
+    flowsPath?: string;
+    supportPaths?: string[];
+    externalFlowRefPaths?: string[];
+    outDir: string;
+    excludeProcessIds?: string[];
+    processLimit?: number;
+};
+export type RunDatasetCurationQueueNextOptions = {
+    queueDir: string;
+    entityType?: DatasetCurationQueueEntityType;
+    taskId?: string;
+};
+export type RunDatasetCurationQueueVerifyOptions = {
+    queueDir: string;
+    entityType?: DatasetCurationQueueEntityType;
+    taskId?: string;
+};
+export type DatasetCurationQueueTask = {
+    schema_version: 1;
+    entity_type: DatasetCurationQueueEntityType;
+    task_id: string;
+    entity_id: string;
+    version: string;
+    lock_key: string;
+    depends_on: string[];
+    input_rows_file: string;
+    work_dir: string;
+    checkpoint_file: string;
+    run_plan_file: string;
+    closure_file: string;
+};
+type DatasetCurationQueueBlocker = {
+    schema_version: 1;
+    code: string;
+    severity: 'blocker';
+    entity_type: DatasetCurationQueueEntityType;
+    entity_id: string | null;
+    version: string | null;
+    message: string;
+    details?: unknown;
+};
+export type DatasetCurationQueueBuildReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'ready' | 'blocked';
+    out_dir: string;
+    inputs: {
+        processes: string;
+        flows: string | null;
+        support: string[];
+        external_flow_refs: string[];
+    };
+    counts: {
+        support_rows: number;
+        flow_rows: number;
+        process_rows: number;
+        external_flow_refs: number;
+        tasks: number;
+        blockers: number;
+    };
+    hashes: {
+        inputs: Record<string, string>;
+        task_order: string;
+    };
+    files: {
+        manifest: string;
+        tasks: string;
+        locks: string;
+        blockers: string;
+    };
+    tasks: DatasetCurationQueueTask[];
+    blockers: DatasetCurationQueueBlocker[];
+};
+export type DatasetCurationQueueTaskRuntimeStatus = 'complete' | 'pending' | 'waiting_dependencies' | 'blocked';
+export type DatasetCurationQueueTaskState = {
+    task_id: string;
+    entity_type: DatasetCurationQueueEntityType;
+    entity_id: string;
+    version: string;
+    status: DatasetCurationQueueTaskRuntimeStatus;
+    checkpoint_status: string | null;
+    checkpoint_file: string;
+    depends_on: string[];
+    incomplete_dependencies: string[];
+    reason: string | null;
+};
+export type DatasetCurationQueueNextReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'ready' | 'complete' | 'blocked';
+    queue_dir: string;
+    scope: {
+        entity_type: DatasetCurationQueueEntityType | null;
+        task_id: string | null;
+    };
+    counts: {
+        total: number;
+        complete: number;
+        pending: number;
+        waiting_dependencies: number;
+        blocked: number;
+        runnable: number;
+    };
+    next_task: (DatasetCurationQueueTask & {
+        action: {
+            kind: 'entity_curation_task';
+            input_artifact: string;
+            output_artifacts: string[];
+        };
+    }) | null;
+    task_states: DatasetCurationQueueTaskState[];
+    blockers: DatasetCurationQueueBlocker[];
+};
+export type DatasetCurationQueueVerifyReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'passed' | 'blocked';
+    queue_dir: string;
+    scope: {
+        entity_type: DatasetCurationQueueEntityType | null;
+        task_id: string | null;
+    };
+    counts: {
+        total: number;
+        complete: number;
+        pending: number;
+        waiting_dependencies: number;
+        blocked: number;
+    };
+    task_states: DatasetCurationQueueTaskState[];
+    blockers: DatasetCurationQueueBlocker[];
+};
+type FlowRef = {
+    id: string;
+    version: string | null;
+    path: string;
+};
+type DeferredFlowRef = FlowRef & {
+    actionItemCode: string | null;
+    reason: string | null;
+};
+export declare function runDatasetCurationQueueBuild(options: RunDatasetCurationQueueBuildOptions): Promise<DatasetCurationQueueBuildReport>;
+export declare function runDatasetCurationQueueNext(options: RunDatasetCurationQueueNextOptions): Promise<DatasetCurationQueueNextReport>;
+export declare function runDatasetCurationQueueVerify(options: RunDatasetCurationQueueVerifyOptions): Promise<DatasetCurationQueueVerifyReport>;
+declare function readQueueRuntime(queueDirInput: string): {
+    queueDir: string;
+    tasks: DatasetCurationQueueTask[];
+    blockers: DatasetCurationQueueBlocker[];
+};
+declare function normalizeQueueScope(options: {
+    entityType?: DatasetCurationQueueEntityType;
+    taskId?: string;
+}): {
+    entity_type: DatasetCurationQueueEntityType | null;
+    task_id: string | null;
+};
+declare function buildTaskStates(tasks: DatasetCurationQueueTask[]): DatasetCurationQueueTaskState[];
+declare function taskRuntimeStatus(checkpointStatus: string | null, incompleteDependencies: string[]): DatasetCurationQueueTaskRuntimeStatus;
+declare function readCheckpointStatus(checkpointFile: string): string | null;
+declare function taskMatchesScope(task: Pick<DatasetCurationQueueTask, 'entity_type' | 'task_id'>, scope: {
+    entity_type: DatasetCurationQueueEntityType | null;
+    task_id: string | null;
+}): boolean;
+declare function countTaskStates(taskStates: DatasetCurationQueueTaskState[]): {
+    total: number;
+    complete: number;
+    pending: number;
+    waiting_dependencies: number;
+    blocked: number;
+};
+declare function withQueueAction(task: DatasetCurationQueueTask): DatasetCurationQueueTask & {
+    action: {
+        kind: 'entity_curation_task';
+        input_artifact: string;
+        output_artifacts: string[];
+    };
+};
+declare function readJsonlFile(inputPath: string): unknown[];
+declare function parseQueueTask(value: unknown, inputPath: string, index: number): DatasetCurationQueueTask;
+declare function parseQueueBlocker(value: unknown, inputPath: string, index: number): DatasetCurationQueueBlocker;
+declare function extractDeferredProcessFlowRefs(payload: unknown): DeferredFlowRef[];
+declare function normalizeReferencePath(value: string): string;
+declare function extractProcessFlowRefs(payload: unknown): FlowRef[];
+declare function normalizeProcessLimit(value: number | undefined): number | null;
+declare function requirePath(value: string | undefined, flag: string): string;
+declare function requireExistingPath(value: string | undefined, flag: string): string;
+declare function entityDirPlural(entityType: DatasetCurationQueueEntityType): string;
+declare function entityDirName(id: string, version: string): string;
+declare function taskIdFor(entityType: DatasetCurationQueueEntityType, id: string, version: string): string;
+declare function sanitizePathToken(value: string): string;
+declare function jsonLines(rows: unknown[]): string;
+export declare const __testInternals: {
+    buildTaskStates: typeof buildTaskStates;
+    countTaskStates: typeof countTaskStates;
+    entityDirName: typeof entityDirName;
+    entityDirPlural: typeof entityDirPlural;
+    extractDeferredProcessFlowRefs: typeof extractDeferredProcessFlowRefs;
+    extractProcessFlowRefs: typeof extractProcessFlowRefs;
+    jsonLines: typeof jsonLines;
+    normalizeReferencePath: typeof normalizeReferencePath;
+    normalizeProcessLimit: typeof normalizeProcessLimit;
+    normalizeQueueScope: typeof normalizeQueueScope;
+    parseQueueBlocker: typeof parseQueueBlocker;
+    parseQueueTask: typeof parseQueueTask;
+    readCheckpointStatus: typeof readCheckpointStatus;
+    readJsonlFile: typeof readJsonlFile;
+    readQueueRuntime: typeof readQueueRuntime;
+    requireExistingPath: typeof requireExistingPath;
+    requirePath: typeof requirePath;
+    sanitizePathToken: typeof sanitizePathToken;
+    taskIdFor: typeof taskIdFor;
+    taskMatchesScope: typeof taskMatchesScope;
+    taskRuntimeStatus: typeof taskRuntimeStatus;
+    withQueueAction: typeof withQueueAction;
+};
+export {};

package/dist/src/lib/dataset-evidence-search.d.ts

@@ -0,0 +1,134 @@
+import type { FetchLike } from './http.js';
+export type EvidenceSearchMode = 'plan' | 'run';
+export type EvidenceSearchProfile = 'shallow' | 'balanced' | 'deep';
+export type EvidenceSearchStatus = 'planned' | 'completed_with_evidence' | 'completed_with_partial_evidence' | 'completed_no_sufficient_evidence';
+export type EvidenceSearchBudget = {
+    max_queries: number;
+    max_results_per_query: number;
+    max_provider_calls: number;
+};
+export type EvidenceSearchQuery = {
+    query_id: string;
+    text: string;
+    purpose: string;
+    source_tier: string;
+    priority: number;
+    expected_terms: string[];
+};
+export type EvidenceSearchResult = {
+    query_id: string | null;
+    query: string | null;
+    provider: string;
+    rank: number;
+    title: string;
+    url: string;
+    snippet: string | null;
+    published_at: string | null;
+    source_domain: string | null;
+    source_tier: string;
+    matched_terms: string[];
+    score: number;
+};
+export type EvidenceSearchDeclaration = {
+    schema_version: 1;
+    generated_at_utc: string;
+    question: string;
+    declaration_type: 'no_sufficient_evidence' | 'partial_temporal_evidence';
+    statement: string;
+    search_scope: {
+        query_count: number;
+        provider_count: number;
+        normalized_result_count: number;
+        authoritative_result_count: number;
+        required_complete_year: boolean;
+        requested_year: number | null;
+        temporal_coverage_status: string;
+    };
+    limits: string[];
+};
+export type EvidenceSearchReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    mode: EvidenceSearchMode;
+    status: EvidenceSearchStatus;
+    question: string;
+    field: {
+        dataset_type: string | null;
+        field_path: string | null;
+    };
+    profile: EvidenceSearchProfile;
+    budget: EvidenceSearchBudget;
+    plan: {
+        query_count: number;
+        queries: EvidenceSearchQuery[];
+    };
+    run: {
+        provider_count: number;
+        provider_call_count: number;
+        normalized_result_count: number;
+        authoritative_result_count: number;
+        high_confidence_result_count: number;
+        stop_reason: string;
+    };
+    evidence_quality: {
+        sufficient: boolean;
+        temporal_coverage_status: string;
+        requested_year: number | null;
+        required_complete_year: boolean;
+    };
+    files: {
+        plan: string | null;
+        results: string | null;
+        report: string | null;
+        declaration: string | null;
+    };
+};
+export type RunDatasetEvidenceSearchOptions = {
+    mode: EvidenceSearchMode;
+    query?: string | null;
+    inputPath?: string | null;
+    resultsPath?: string | null;
+    providerUrl?: string | null;
+    providerKey?: string | null;
+    profile?: string | null;
+    outDir?: string | null;
+    maxQueries?: number | null;
+    maxResultsPerQuery?: number | null;
+    timeoutMs?: number | null;
+    rawInput?: unknown;
+    rawResults?: unknown;
+    now?: Date;
+    fetchImpl?: FetchLike;
+};
+type EvidenceSearchRequest = {
+    question: string;
+    field: {
+        dataset_type: string | null;
+        field_path: string | null;
+    };
+    profile: EvidenceSearchProfile;
+    budget: EvidenceSearchBudget;
+    preferred_domains: string[];
+    required_terms: string[];
+    required_complete_year: boolean;
+    requested_year: number | null;
+};
+declare function classifySourceTier(domain: string | null, preferredDomains: string[]): string;
+declare function buildSearchPlan(request: EvidenceSearchRequest): EvidenceSearchQuery[];
+declare function normalizeRequest(options: RunDatasetEvidenceSearchOptions): EvidenceSearchRequest;
+declare function normalizeResults(options: {
+    rawResults: unknown;
+    terms: string[];
+    preferredDomains: string[];
+    maxResultsPerQuery: number;
+}): EvidenceSearchResult[];
+declare function temporalCoverageStatus(request: EvidenceSearchRequest, now: Date): string;
+export declare function runDatasetEvidenceSearch(options: RunDatasetEvidenceSearchOptions): Promise<EvidenceSearchReport>;
+export declare const __testInternals: {
+    buildSearchPlan: typeof buildSearchPlan;
+    classifySourceTier: typeof classifySourceTier;
+    normalizeResults: typeof normalizeResults;
+    normalizeRequest: typeof normalizeRequest;
+    temporalCoverageStatus: typeof temporalCoverageStatus;
+};
+export {};

package/dist/src/lib/dataset-import-lca.d.ts

@@ -0,0 +1,136 @@
+import { spawnSync } from 'node:child_process';
+declare const OPERATION_REPORT_SCHEMA = "tidas.operation-report.v1";
+declare const INVOCATION_CONTEXT_SCHEMA = "tidas.invocation-context.v1";
+declare const IMPORT_REPORT_SCHEMA = "tidas.import-execution-report.v1";
+declare const EXIT_CODES: {
+    readonly success: 0;
+    readonly 'data-issues': 2;
+    readonly usage: 64;
+    readonly unavailable: 69;
+    readonly internal: 70;
+    readonly io: 74;
+    readonly cancelled: 130;
+};
+declare const OPERATION_STATUSES: readonly ['succeeded', 'completed-with-issues', 'failed', 'cancelled'];
+declare const COMPLETENESS_VALUES: readonly ['complete', 'partial', 'not-started'];
+declare const SOURCE_FORMATS: readonly ['ecospold1', 'ecospold2', 'simapro-csv', 'openlca-jsonld', 'openlca-process-xlsx', 'ilcd'];
+type TidasExitClass = keyof typeof EXIT_CODES;
+type TidasOperationStatus = (typeof OPERATION_STATUSES)[number];
+type TidasCompleteness = (typeof COMPLETENESS_VALUES)[number];
+export type DatasetImportLcaTarget = 'tidas' | 'ilcd' | 'both';
+export type DatasetImportLcaSourceFormat = (typeof SOURCE_FORMATS)[number];
+type TidasOperationReport = {
+    schema_version: typeof OPERATION_REPORT_SCHEMA;
+    command: 'version' | 'import';
+    status: TidasOperationStatus;
+    exit_class: TidasExitClass;
+    completeness: TidasCompleteness;
+    invocation: {
+        schema_version: typeof INVOCATION_CONTEXT_SCHEMA;
+        input_policy: 'explicit-path-or-dash';
+        report_destination: 'stdout' | 'file';
+        diagnostic_destination: 'stderr';
+        [key: string]: unknown;
+    };
+    summary: Record<string, unknown>;
+    diagnostics: unknown[];
+    artifacts: unknown[];
+    next_actions: unknown[];
+};
+export type DatasetImportLcaReport = {
+    schema_version: 'tiangong-lca.dataset-import-lca-report.v2';
+    status: TidasOperationStatus;
+    exit_class: TidasExitClass;
+    exit_code: number;
+    generated_at_utc: string;
+    input_path: string;
+    output_dir: string;
+    from_format: DatasetImportLcaSourceFormat | 'auto';
+    target: DatasetImportLcaTarget;
+    tidas: {
+        executable: string;
+        version: string;
+        operation_report_schema: typeof OPERATION_REPORT_SCHEMA;
+        import_report_schema: typeof IMPORT_REPORT_SCHEMA;
+    };
+    command: {
+        args: string[];
+        cwd: string;
+        stderr: string;
+    };
+    operation_report: TidasOperationReport;
+    files: {
+        report: string | null;
+        native_import_report: string;
+        issues: string;
+        tidas_dir: string | null;
+        ilcd_dir: string | null;
+        mapping_csv: string | null;
+        process_bundles_dir: string | null;
+    };
+};
+export type TidasProcessResult = {
+    status: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    error?: Error | undefined;
+};
+export type RunDatasetImportLcaConvertOptions = {
+    inputPath: string;
+    outputDir: string;
+    fromFormat?: string | undefined;
+    target?: string | undefined;
+    reportPath?: string | undefined;
+    writeMapping?: boolean | undefined;
+    processBundles?: boolean | undefined;
+    failOnWarning?: boolean | undefined;
+    maxEntryMib?: number | undefined;
+    memoryBudgetMib?: number | undefined;
+    queueCapacity?: number | undefined;
+    tidasBin?: string | undefined;
+    tidasConfig?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    cwd?: string | undefined;
+    platform?: NodeJS.Platform | undefined;
+    arch?: string | undefined;
+    now?: Date | undefined;
+    spawnImpl?: typeof spawnSync | undefined;
+};
+export declare function runDatasetImportLcaConvert(options: RunDatasetImportLcaConvertOptions): Promise<DatasetImportLcaReport>;
+declare function buildImportArgs(options: {
+    inputPath: string;
+    outputDir: string;
+    fromFormat: DatasetImportLcaSourceFormat | 'auto';
+    target: DatasetImportLcaTarget;
+    reportPath: string | null;
+    configPath: string | null;
+    writeMapping: boolean;
+    processBundles: boolean;
+    failOnWarning: boolean;
+    maxEntryMib: number | undefined;
+    memoryBudgetMib: number | undefined;
+    queueCapacity: number | undefined;
+}): string[];
+declare function readProcessReport(run: TidasProcessResult, reportPath: string | null): string;
+declare function parseOperationReport(text: string, command: 'version' | 'import'): TidasOperationReport;
+declare function readCompatibleVersion(report: TidasOperationReport): string;
+declare function assertImportContract(report: TidasOperationReport): void;
+declare function normalizeSourceFormat(value: string | undefined): DatasetImportLcaSourceFormat | 'auto';
+declare function normalizeTarget(value: string | undefined): DatasetImportLcaTarget;
+declare function resolveTidasBinary(explicitValue: string | undefined, env: NodeJS.ProcessEnv): string;
+declare function assertSupportedPlatform(platform: NodeJS.Platform, arch: string): void;
+declare function requirePositiveInteger(flag: string, value: number | undefined): void;
+export declare const __testInternals: {
+    assertImportContract: typeof assertImportContract;
+    assertSupportedPlatform: typeof assertSupportedPlatform;
+    buildImportArgs: typeof buildImportArgs;
+    normalizeSourceFormat: typeof normalizeSourceFormat;
+    normalizeTarget: typeof normalizeTarget;
+    parseOperationReport: typeof parseOperationReport;
+    readCompatibleVersion: typeof readCompatibleVersion;
+    readProcessReport: typeof readProcessReport;
+    requirePositiveInteger: typeof requirePositiveInteger;
+    resolveTidasBinary: typeof resolveTidasBinary;
+};
+export {};

package/dist/src/lib/dataset-local.d.ts

@@ -0,0 +1,23 @@
+export type JsonObject = Record<string, unknown>;
+export type DatasetKind = 'contact' | 'flow' | 'flowproperty' | 'lifecyclemodel' | 'process' | 'source' | 'unitgroup';
+export type DatasetRowInput = {
+    index: number;
+    row: JsonObject;
+    payload: JsonObject;
+    kind: DatasetKind | null;
+    id: string | null;
+    version: string | null;
+};
+export declare function isRecord(value: unknown): value is JsonObject;
+export declare function cloneJson<T>(value: T): T;
+export declare function trimToken(value: unknown): string | null;
+export declare function firstNonEmpty(...values: unknown[]): string | null;
+export declare function readDatasetRowsInput(inputPath: string, rawInput?: unknown): JsonObject[];
+export declare function datasetRoot(payload: JsonObject, kind: DatasetKind): JsonObject;
+export declare function detectDatasetKind(value: JsonObject): DatasetKind | null;
+export declare function unwrapDatasetPayload(row: JsonObject): JsonObject;
+export declare function datasetIdentity(row: JsonObject, payload: JsonObject, kind: DatasetKind | null): {
+    id: string | null;
+    version: string | null;
+};
+export declare function materializeDatasetRows(inputPath: string, rawInput?: unknown): DatasetRowInput[];

package/dist/src/lib/dataset-maintenance-alias-request.d.ts

@@ -0,0 +1,12 @@
+import { type DatasetMaintenanceAliasBatchPlan, type DatasetMaintenancePlan, type DatasetMaintenancePlanAction, type JsonObject } from './dataset-maintenance-contract.js';
+export declare function loadMaintenanceDesiredPayload(planDir: string, action: DatasetMaintenancePlanAction): JsonObject;
+export declare function orderedAliasBatches(plan: DatasetMaintenancePlan): DatasetMaintenanceAliasBatchPlan[];
+export declare function buildAliasBatchRequest(options: {
+    plan: DatasetMaintenancePlan;
+    batch: DatasetMaintenanceAliasBatchPlan;
+    planDir: string;
+}): JsonObject;
+export declare function buildAliasPlanRequest(options: {
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+}): JsonObject;

package/dist/src/lib/dataset-maintenance-alias-rewrite.d.ts

@@ -0,0 +1,111 @@
+import { type DatasetMaintenanceAliasBatch, type DatasetMaintenanceAliasBatchPlan, type DatasetMaintenanceAliasExchangeRewrite, type DatasetMaintenancePlanAction, type DatasetMaintenanceRemoteRow, type DatasetMaintenanceRowSnapshot, type DatasetMaintenanceScope, type JsonObject } from './dataset-maintenance-contract.js';
+import type { SafeParseSchema } from './tidas-sdk-validation.js';
+export type DatasetMaintenanceAliasSchemas = {
+    flowproperties: SafeParseSchema;
+    flows: SafeParseSchema;
+    processes: SafeParseSchema;
+};
+type DecimalParts = {
+    negative: boolean;
+    coefficient: bigint;
+    scale: number;
+};
+declare function decimalParts(value: string): DecimalParts | null;
+declare function decimalEqual(left: string, right: string): boolean;
+declare function decimalText(parts: DecimalParts): string;
+export declare function multiplyExactDecimal(value: string, factor: string): string | null;
+declare function flowPropertyEntries(payload: JsonObject): JsonObject[] | null;
+declare function flowPropertySingleton(payload: JsonObject): JsonObject | null;
+declare function processExchangeEntries(payload: JsonObject): JsonObject[] | null;
+declare function referenceIdentity(value: unknown): {
+    id: string | null;
+    version: string | null;
+};
+declare function referenceMatches(value: unknown, id: string, version?: string | null): boolean;
+declare function targetSnapshotValid(snapshot: DatasetMaintenanceRowSnapshot | null, table: 'unitgroups' | 'flowproperties', batch: DatasetMaintenanceAliasBatch, userId: string): boolean;
+declare function sourceUnitGroupSnapshotValid(snapshot: DatasetMaintenanceRowSnapshot | null, batch: DatasetMaintenanceAliasBatch, userId: string): boolean;
+declare function sourceReferenceUnit(snapshot: DatasetMaintenanceRowSnapshot | null, batch: DatasetMaintenanceAliasBatch): JsonObject | null;
+declare function targetConversionUnit(options: {
+    source: JsonObject | null;
+    target: DatasetMaintenanceRowSnapshot | null;
+    factor: string;
+}): JsonObject | null;
+declare function targetUnitGroupReferenceFromFlowProperty(snapshot: DatasetMaintenanceRowSnapshot | null, batch: DatasetMaintenanceAliasBatch): JsonObject | null;
+declare function canonicalFlowPropertyReference(rows: DatasetMaintenanceRemoteRow[], batch: DatasetMaintenanceAliasBatch): JsonObject | null;
+declare function replaceAliasFlowProperty(payload: JsonObject, batch: DatasetMaintenanceAliasBatch, targetReference: JsonObject): JsonObject | null;
+declare function replaceFlowReferenceProperty(payload: JsonObject, batch: DatasetMaintenanceAliasBatch, targetReference: JsonObject): JsonObject | null;
+declare function rewriteProcessExchanges(options: {
+    payload: JsonObject;
+    action: DatasetMaintenancePlanAction;
+    batch: DatasetMaintenanceAliasBatch;
+}): {
+    payload: JsonObject;
+    rewrites: DatasetMaintenanceAliasExchangeRewrite[];
+} | null;
+declare function countFlowPropertyRefs(rows: DatasetMaintenanceRemoteRow[], flowpropertyId: string, flowpropertyVersion: string): number;
+declare function countUnitGroupRefs(rows: DatasetMaintenanceRemoteRow[], unitgroupId: string, unitgroupVersion: string): number;
+declare function flowsWithProperty(rows: DatasetMaintenanceRemoteRow[], flowpropertyId: string, flowpropertyVersion: string): Set<string>;
+declare function countExchangeFlowRefs(rows: DatasetMaintenanceRemoteRow[], flowRefs: Set<string>): number;
+declare function exchangeClosureKeys(rows: DatasetMaintenanceRemoteRow[], flowRefs: Set<string>): Set<string>;
+declare function selectorClosureKeys(actions: DatasetMaintenancePlanAction[]): Set<string>;
+declare function projectRows(rows: DatasetMaintenanceRemoteRow[], desiredPayloads: Map<string, JsonObject>, actions: DatasetMaintenancePlanAction[]): DatasetMaintenanceRemoteRow[];
+export declare function buildAliasRewritePlan(options: {
+    scope: DatasetMaintenanceScope;
+    actions: DatasetMaintenancePlanAction[];
+    accountRows: DatasetMaintenanceRemoteRow[];
+    targetSnapshots: Map<string, DatasetMaintenanceAliasBatchPlan['target_snapshots']>;
+    schemas?: DatasetMaintenanceAliasSchemas;
+}): {
+    desired_payloads: Map<string, JsonObject>;
+    batches: DatasetMaintenanceAliasBatchPlan[];
+};
+export declare const __testInternals: {
+    ALIAS_PROFILES: {
+        readonly time: {
+            readonly factor: '0.00011415525114155251';
+            readonly rows: 25;
+            readonly flowproperties: 1;
+            readonly flows: 10;
+            readonly processes: 14;
+            readonly exchanges: 20;
+            readonly target_flow_refs: 106;
+            readonly target_exchange_refs: 441;
+        };
+        readonly length_time: {
+            readonly factor: '1000';
+            readonly rows: 27;
+            readonly flowproperties: 1;
+            readonly flows: 13;
+            readonly processes: 13;
+            readonly exchanges: 39;
+            readonly target_flow_refs: 32;
+            readonly target_exchange_refs: 3216;
+        };
+    };
+    EXPECTED_UNRELATED_EXCHANGES: number;
+    countExchangeFlowRefs: typeof countExchangeFlowRefs;
+    countFlowPropertyRefs: typeof countFlowPropertyRefs;
+    countUnitGroupRefs: typeof countUnitGroupRefs;
+    decimalEqual: typeof decimalEqual;
+    decimalParts: typeof decimalParts;
+    decimalText: typeof decimalText;
+    exchangeClosureKeys: typeof exchangeClosureKeys;
+    flowPropertyEntries: typeof flowPropertyEntries;
+    flowPropertySingleton: typeof flowPropertySingleton;
+    flowsWithProperty: typeof flowsWithProperty;
+    processExchangeEntries: typeof processExchangeEntries;
+    projectRows: typeof projectRows;
+    referenceIdentity: typeof referenceIdentity;
+    referenceMatches: typeof referenceMatches;
+    replaceAliasFlowProperty: typeof replaceAliasFlowProperty;
+    replaceFlowReferenceProperty: typeof replaceFlowReferenceProperty;
+    rewriteProcessExchanges: typeof rewriteProcessExchanges;
+    selectorClosureKeys: typeof selectorClosureKeys;
+    targetUnitGroupReferenceFromFlowProperty: typeof targetUnitGroupReferenceFromFlowProperty;
+    canonicalFlowPropertyReference: typeof canonicalFlowPropertyReference;
+    targetSnapshotValid: typeof targetSnapshotValid;
+    sourceReferenceUnit: typeof sourceReferenceUnit;
+    sourceUnitGroupSnapshotValid: typeof sourceUnitGroupSnapshotValid;
+    targetConversionUnit: typeof targetConversionUnit;
+};
+export {};