@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/dataset-maintenance-support-validation.d.ts

@@ -0,0 +1,18 @@
+import type { DatasetMaintenanceSupportTable, JsonObject } from './dataset-maintenance-contract.js';
+import type { SafeParseResult, SafeParseSchema } from './tidas-sdk-validation.js';
+export type DatasetMaintenanceSupportSchemas = Partial<Record<DatasetMaintenanceSupportTable, SafeParseSchema>>;
+export declare function maintenancePayloadIdentity(payload: JsonObject): {
+    id: string | null;
+    version: string | null;
+};
+export declare function inspectMaintenanceSupportPayload(options: {
+    table: DatasetMaintenanceSupportTable;
+    payload: JsonObject;
+    schemas?: DatasetMaintenanceSupportSchemas;
+}): {
+    identity: {
+        id: string | null;
+        version: string | null;
+    };
+    schemaResult: SafeParseResult;
+};

package/dist/src/lib/dataset-maintenance-verify.d.ts

@@ -0,0 +1,102 @@
+import type { FetchLike } from './http.js';
+import { type DatasetMaintenancePlan, type DatasetMaintenancePlanAction, type DatasetMaintenanceRemoteRow, type JsonObject } from './dataset-maintenance-contract.js';
+import { type DatasetMaintenanceDerivativeStatusProof, type DatasetMaintenanceDerivativeSubmitProof } from './dataset-maintenance-derivatives.js';
+import { type DatasetMaintenanceSnapshotCompleteness } from './dataset-maintenance-pagination.js';
+export type DatasetMaintenanceVerifyIssue = {
+    code: string;
+    message: string;
+    action_id?: string;
+    table?: string;
+    id?: string;
+    version?: string;
+    details?: unknown;
+};
+export type DatasetMaintenanceVerifyReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'pending' | 'passed' | 'failed';
+    task_id: string;
+    operation: DatasetMaintenancePlan['operation'];
+    operation_id: string;
+    target_mode: DatasetMaintenancePlan['target_mode'];
+    plan_sha256: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    snapshot_completeness: DatasetMaintenanceSnapshotCompleteness;
+    summary: {
+        actions: number;
+        action_checks_passed: number;
+        protected_rows: number;
+        protected_checks_passed: number;
+        progress_successes: number;
+        atomic_plan_proofs?: number;
+        atomic_batches?: number;
+        atomic_batch_successes?: number;
+        exchange_rewrite_logs?: number;
+        derivative_admissions?: number;
+        derivative_request_status?: string;
+        dangling_deleted_target_references: number;
+        issues: number;
+    };
+    action_checks: Array<{
+        action_id: string;
+        status: 'pending' | 'passed' | 'failed';
+        observed: 'desired_payload' | 'absent' | 'mismatch' | 'derivative_pending' | 'derivative_current';
+    }>;
+    issues: DatasetMaintenanceVerifyIssue[];
+    artifacts: {
+        plan: string;
+        approval_record: string;
+        apply_progress: string;
+        commit_report: string;
+        alias_plan_progress?: string;
+        alias_batch_progress?: string;
+        alias_exchange_progress?: string;
+        derivative_submit_progress?: string;
+        report: string;
+    };
+    derivative_status?: {
+        proof: DatasetMaintenanceDerivativeStatusProof;
+        raw_evidence: JsonObject;
+        note: string;
+    };
+};
+export type RunDatasetMaintenanceVerifyOptions = {
+    planPath: string;
+    outDir?: string;
+    pageSize?: number;
+    timeoutMs?: number;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    now?: Date;
+};
+declare function issue(code: string, message: string, action?: DatasetMaintenancePlanAction, details?: unknown): DatasetMaintenanceVerifyIssue;
+declare function desiredPayload(planDir: string, action: DatasetMaintenancePlanAction): JsonObject | null;
+declare function deletedTargetReferences(options: {
+    rows: DatasetMaintenanceRemoteRow[];
+    deletes: DatasetMaintenancePlanAction[];
+}): Array<{
+    target_action_id: string;
+    source_key: string;
+    path: string;
+}>;
+declare function derivativeSubmitIdentity(proof: DatasetMaintenanceDerivativeSubmitProof): string;
+declare function readDerivativeSubmitProof(options: {
+    plan: DatasetMaintenancePlan;
+    progressPath: string;
+    problems: DatasetMaintenanceVerifyIssue[];
+}): {
+    proof: DatasetMaintenanceDerivativeSubmitProof | null;
+    admissions: number;
+};
+export declare function runDatasetMaintenanceVerify(options: RunDatasetMaintenanceVerifyOptions): Promise<DatasetMaintenanceVerifyReport>;
+export declare const __testInternals: {
+    deletedTargetReferences: typeof deletedTargetReferences;
+    derivativeSubmitIdentity: typeof derivativeSubmitIdentity;
+    desiredPayload: typeof desiredPayload;
+    issue: typeof issue;
+    readDerivativeSubmitProof: typeof readDerivativeSubmitProof;
+};
+export {};

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

@@ -0,0 +1,193 @@
+import { materializeDatasetRows, type JsonObject } from './dataset-local.js';
+type PatchApplyStatus = 'completed' | 'blocked';
+type PatchOperationName = 'add' | 'remove' | 'replace' | 'test';
+export type DatasetPatchEvidence = string | {
+    source?: string | null;
+    quote?: string | null;
+    path?: string | null;
+    package?: string | null;
+    reasoning?: string | null;
+    trace_hash?: string | null;
+    [key: string]: unknown;
+} | unknown[] | null;
+export type DatasetPatchOperation = {
+    op: PatchOperationName | string;
+    path: string;
+    value?: unknown;
+    evidence?: DatasetPatchEvidence;
+    basis?: string | null;
+    resolution?: unknown;
+    closes?: unknown;
+    closes_action_items?: unknown;
+    closesActionItems?: unknown;
+    action_items?: unknown;
+    actionItems?: unknown;
+};
+export type DatasetPatchSet = {
+    row_index?: number | string | null;
+    dataset_id?: string | null;
+    id?: string | null;
+    uuid?: string | null;
+    entity_id?: string | null;
+    version?: string | null;
+    dataset_version?: string | null;
+    authoring_package?: string | null;
+    operations?: DatasetPatchOperation[];
+    patches?: DatasetPatchOperation[];
+};
+export type DatasetPatchApplyBlocker = {
+    code: string;
+    message: string;
+    row_index?: number;
+    dataset_id?: string | null;
+    dataset_version?: string | null;
+    patch_index?: number;
+    operation_index?: number;
+    op?: string;
+    path?: string;
+};
+export type DatasetPatchEvidenceEntry = {
+    row_index: number;
+    dataset_id: string | null;
+    dataset_version: string | null;
+    patch_index: number;
+    operation_index: number;
+    op: PatchOperationName;
+    path: string;
+    basis: string | null;
+    evidence: DatasetPatchEvidence;
+    resolution?: unknown;
+    authoring_package: string | null;
+    authoring_package_sha256?: string | null;
+    closes_action_items?: ActionItemClosure[];
+};
+export type DatasetPatchApplyReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    input_path: string;
+    patch_path: string;
+    out_path: string;
+    status: PatchApplyStatus;
+    row_count: number;
+    patch_count: number;
+    operation_count: number;
+    applied_operation_count: number;
+    evidence_count: number;
+    closed_action_item_count?: number;
+    blockers: DatasetPatchApplyBlocker[];
+    files: {
+        patched_rows: string;
+        patch_evidence: string | null;
+        report: string | null;
+    };
+};
+export type RunDatasetPatchApplyOptions = {
+    inputPath: string;
+    patchPath: string;
+    outPath: string;
+    outDir?: string | null;
+    rawInput?: unknown;
+    rawPatch?: unknown;
+    authoringPackageDir?: string | null;
+    requireAuthoringPackage?: boolean;
+    requireActionItemClosure?: boolean;
+    now?: Date;
+};
+type NormalizedPatchSet = {
+    rowIndex: number | null;
+    datasetId: string | null;
+    datasetVersion: string | null;
+    authoringPackage: string | null;
+    operations: DatasetPatchOperation[];
+};
+type AuthoringPackageContext = {
+    path: string;
+    sha256: string;
+    payload: JsonObject;
+    actionItems: ActionItemClosure[];
+};
+type ActionItemClosure = {
+    code: string;
+    path: string | null;
+};
+type NormalizePatchResult = {
+    patches: NormalizedPatchSet[];
+    blockers: DatasetPatchApplyBlocker[];
+};
+type PatchTarget = {
+    container: JsonObject | unknown[];
+    key: string | number;
+};
+declare function parseRowIndex(value: unknown): number | null;
+declare function caughtErrorMessage(error: unknown): string;
+declare function normalizeClosure(value: unknown): ActionItemClosure | null;
+declare function normalizeClosureList(value: unknown): ActionItemClosure[];
+declare function operationClosures(operation: DatasetPatchOperation): ActionItemClosure[];
+declare function actionItemFromPackage(value: unknown): ActionItemClosure | null;
+declare function closureMatchesActionItem(closure: ActionItemClosure, actionItem: ActionItemClosure): boolean;
+declare function normalizeOperationArray(value: unknown): DatasetPatchOperation[] | null;
+declare function looksLikeOperation(value: unknown): boolean;
+declare function normalizePatchSet(value: unknown): NormalizedPatchSet | null;
+declare function patchPayloadCompletionStatus(rawPatch: unknown): string | null;
+declare function normalizePatchPayload(rawPatch: unknown): NormalizePatchResult;
+declare function parsePointer(pointer: unknown): string[];
+declare function parseArrayIndex(token: string, length: number, allowAppend: boolean): number;
+declare function resolvePatchTarget(root: JsonObject, pointer: string, allowAdd: boolean): PatchTarget;
+declare function targetExists(target: PatchTarget): boolean;
+declare function getTargetValue(target: PatchTarget): unknown;
+declare function setTargetValue(target: PatchTarget, value: unknown, insert: boolean): void;
+declare function removeTargetValue(target: PatchTarget): void;
+declare function evidenceIsPresent(evidence: unknown): boolean;
+declare function operationBasis(operation: DatasetPatchOperation): string | null;
+declare function validateOperationShape(operation: DatasetPatchOperation, patchIndex: number, operationIndex: number, rowIndex: number, datasetId: string | null, datasetVersion: string | null): DatasetPatchApplyBlocker | null;
+declare function applyOperation(root: JsonObject, operation: DatasetPatchOperation): void;
+declare function findTargetRow(patch: NormalizedPatchSet, rows: ReturnType<typeof materializeDatasetRows>, patchIndex: number): {
+    rowIndex: number;
+    blocker: null;
+} | {
+    rowIndex: null;
+    blocker: DatasetPatchApplyBlocker;
+};
+declare function resolveAuthoringPackagePath(authoringPackage: string | null, authoringPackageDir: string | null | undefined): string | null;
+declare function readAuthoringPackageContext(options: {
+    patch: NormalizedPatchSet;
+    rowIndex: number;
+    rowId: string | null | undefined;
+    rowVersion: string | null | undefined;
+    patchIndex: number;
+    authoringPackageDir?: string | null;
+    requireAuthoringPackage?: boolean;
+}): {
+    context: AuthoringPackageContext | null;
+    blockers: DatasetPatchApplyBlocker[];
+};
+export declare function runDatasetPatchApply(options: RunDatasetPatchApplyOptions): Promise<DatasetPatchApplyReport>;
+export declare const __testInternals: {
+    actionItemFromPackage: typeof actionItemFromPackage;
+    applyOperation: typeof applyOperation;
+    closureMatchesActionItem: typeof closureMatchesActionItem;
+    caughtErrorMessage: typeof caughtErrorMessage;
+    evidenceIsPresent: typeof evidenceIsPresent;
+    findTargetRow: typeof findTargetRow;
+    getTargetValue: typeof getTargetValue;
+    looksLikeOperation: typeof looksLikeOperation;
+    normalizeClosure: typeof normalizeClosure;
+    normalizeClosureList: typeof normalizeClosureList;
+    normalizeOperationArray: typeof normalizeOperationArray;
+    normalizePatchPayload: typeof normalizePatchPayload;
+    normalizePatchSet: typeof normalizePatchSet;
+    operationBasis: typeof operationBasis;
+    operationClosures: typeof operationClosures;
+    parseArrayIndex: typeof parseArrayIndex;
+    parsePointer: typeof parsePointer;
+    parseRowIndex: typeof parseRowIndex;
+    patchPayloadCompletionStatus: typeof patchPayloadCompletionStatus;
+    readAuthoringPackageContext: typeof readAuthoringPackageContext;
+    removeTargetValue: typeof removeTargetValue;
+    resolveAuthoringPackagePath: typeof resolveAuthoringPackagePath;
+    resolvePatchTarget: typeof resolvePatchTarget;
+    setTargetValue: typeof setTargetValue;
+    targetExists: typeof targetExists;
+    validateOperationShape: typeof validateOperationShape;
+};
+export {};

package/dist/src/lib/dataset-references-rewrite.d.ts

@@ -0,0 +1,77 @@
+import type { FetchLike } from './http.js';
+import { type DatasetKind } from './dataset-local.js';
+import { runLifecyclemodelSaveDraft, type LifecyclemodelSaveDraftReport } from './lifecyclemodel-save-draft-run.js';
+import { runProcessSaveDraft, type ProcessSaveDraftReport } from './process-save-draft-run.js';
+type ReferenceKind = 'flow';
+type ParsedReference = {
+    kind: ReferenceKind;
+    id: string;
+    version: string | null;
+};
+export type DatasetReferencesRewriteChange = {
+    row_index: number;
+    dataset_type: DatasetKind | null;
+    dataset_id: string | null;
+    dataset_version: string | null;
+    path: string;
+    field: '@refObjectId' | '@version' | '@flowUUID';
+    before: string | null;
+    after: string | null;
+};
+export type DatasetReferencesRewriteReport = {
+    generated_at_utc: string;
+    input_path: string;
+    out_dir: string;
+    mode: 'dry_run' | 'commit';
+    status: 'completed' | 'completed_with_failures';
+    from: ParsedReference;
+    to: ParsedReference;
+    filters: {
+        types: DatasetKind[];
+        scope: string | null;
+    };
+    counts: {
+        input_rows: number;
+        patched_rows: number;
+        changes: number;
+        process_rows: number;
+        lifecyclemodel_rows: number;
+    };
+    files: {
+        patched_rows: string;
+        rewrite_plan: string;
+        summary: string;
+    };
+    changes: DatasetReferencesRewriteChange[];
+    commit_reports: {
+        processes: ProcessSaveDraftReport | null;
+        lifecyclemodels: LifecyclemodelSaveDraftReport | null;
+    };
+};
+export type RunDatasetReferencesRewriteOptions = {
+    inputPath: string;
+    outDir: string;
+    from: string;
+    to: string;
+    types?: string[] | null;
+    scope?: string | null;
+    commit?: boolean | null;
+    rawInput?: unknown;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    now?: Date;
+    runProcessSaveDraftImpl?: typeof runProcessSaveDraft;
+    runLifecyclemodelSaveDraftImpl?: typeof runLifecyclemodelSaveDraft;
+};
+declare function parseReference(value: string, label: string): ParsedReference;
+declare function normalizeTypes(values: string[] | null | undefined): DatasetKind[];
+declare function rewriteProcessReferences(value: unknown, from: ParsedReference, to: ParsedReference, pathPrefix: string, change: (path: string, field: '@refObjectId' | '@version', before: string | null, after: string | null) => void): void;
+declare function rewriteLifecyclemodelReferences(value: unknown, from: ParsedReference, to: ParsedReference, pathPrefix: string, change: (path: string, field: '@flowUUID', before: string | null, after: string | null) => void): void;
+export declare function runDatasetReferencesRewrite(options: RunDatasetReferencesRewriteOptions): Promise<DatasetReferencesRewriteReport>;
+export declare const __testInternals: {
+    normalizeTypes: typeof normalizeTypes;
+    parseReference: typeof parseReference;
+    rewriteLifecyclemodelReferences: typeof rewriteLifecyclemodelReferences;
+    rewriteProcessReferences: typeof rewriteProcessReferences;
+};
+export {};

package/dist/src/lib/dataset-remote-refresh.d.ts

@@ -0,0 +1,64 @@
+import type { FetchLike } from './http.js';
+import { type JsonObject } from './dataset-local.js';
+import { type DatasetRemoteVerificationReport, type RemoteVerificationCheck, type RunDatasetRemoteVerifyOptions } from './dataset-remote-verify.js';
+export type DatasetRemoteRefreshPatch = {
+    row_index: number;
+    role: string;
+    table: string | null;
+    id: string | null;
+    from_version: string | null;
+    to_version: string;
+    path: string;
+    status_before: string;
+};
+export type DatasetRemoteRefreshReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed' | 'completed_with_blockers';
+    root_policy: NonNullable<RunDatasetRemoteVerifyOptions['rootPolicy']>;
+    input_path: string;
+    out_path: string;
+    out_dir: string;
+    counts: {
+        rows: number;
+        pre_refresh_blockers: number;
+        refreshable_references: number;
+        patched_references: number;
+        post_refresh_blockers: number;
+    };
+    remaining_blockers: DatasetRemoteVerificationReport['blockers'];
+    files: {
+        output_rows: string;
+        report: string;
+        patches: string;
+        pre_verification_report: string;
+        post_verification_report: string;
+    };
+};
+export type RunDatasetRemoteRefreshOptions = {
+    inputPath: string;
+    outPath: string;
+    outDir: string;
+    rawInput?: unknown;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    rootPolicy?: RunDatasetRemoteVerifyOptions['rootPolicy'];
+    runDatasetRemoteVerifyImpl?: (options: RunDatasetRemoteVerifyOptions) => Promise<DatasetRemoteVerificationReport>;
+};
+declare function pointerSegments(pointerPath: string): string[];
+declare function valueAtPointer(root: unknown, pointerPath: string): unknown;
+declare function refreshableCheck(check: RemoteVerificationCheck): boolean;
+declare function applyRemoteRefreshPatches(rows: JsonObject[], checks: RemoteVerificationCheck[]): {
+    rows: JsonObject[];
+    patches: DatasetRemoteRefreshPatch[];
+};
+export declare function runDatasetRemoteRefresh(options: RunDatasetRemoteRefreshOptions): Promise<DatasetRemoteRefreshReport>;
+export declare const __testInternals: {
+    applyRemoteRefreshPatches: typeof applyRemoteRefreshPatches;
+    pointerSegments: typeof pointerSegments;
+    refreshableCheck: typeof refreshableCheck;
+    valueAtPointer: typeof valueAtPointer;
+};
+export {};

package/dist/src/lib/dataset-remote-verify.d.ts

@@ -0,0 +1,168 @@
+import type { FetchLike } from './http.js';
+import { type SupabaseDataRuntime } from './supabase-client.js';
+import { type JsonObject } from './dataset-local.js';
+export type RemoteDatasetTable = 'contacts' | 'flowproperties' | 'flows' | 'lciamethods' | 'lifecyclemodels' | 'processes' | 'sources' | 'unitgroups';
+export type RemoteVerificationReferenceRole = 'root' | 'reference';
+export type RemoteVerificationRootPolicy = 'existing' | 'candidate';
+export type RemoteVerificationStatus = 'ok' | 'lookup_failed' | 'missing_dataset' | 'missing_version' | 'unsupported_type' | 'version_missing' | 'version_outdated';
+export type RemoteVerificationIssueCode = RemoteVerificationStatus | 'owner_mismatch' | 'payload_mismatch' | 'remote_payload_missing' | 'state_code_mismatch';
+export type RemoteDatasetReference = {
+    row_index: number;
+    role: RemoteVerificationReferenceRole;
+    table: RemoteDatasetTable | null;
+    type: string | null;
+    id: string | null;
+    version: string | null;
+    path: string;
+    short_description: string | null;
+};
+export type RemoteDatasetLookupRow = {
+    id: string;
+    version: string | null;
+};
+export type RemoteDatasetLookup = {
+    exact: RemoteDatasetLookupRow | null;
+    latest: RemoteDatasetLookupRow | null;
+    exact_source_url: string | null;
+    latest_source_url: string | null;
+};
+export type RemoteDatasetPayloadLookup = {
+    id: string;
+    version: string | null;
+    user_id: string | null;
+    state_code: number | null;
+    modified_at: string | null;
+    payload: JsonObject | null;
+    source_url: string | null;
+};
+export type RemoteDatasetLookupRequest = {
+    table: RemoteDatasetTable;
+    id: string;
+    version: string | null;
+};
+export type RemoteVerificationCheck = {
+    row_index: number;
+    role: RemoteVerificationReferenceRole;
+    table: RemoteDatasetTable | null;
+    type: string | null;
+    id: string | null;
+    version: string | null;
+    path: string;
+    short_description: string | null;
+    status: RemoteVerificationIssueCode;
+    exact_version: string | null;
+    latest_version: string | null;
+    exact_source_url: string | null;
+    latest_source_url: string | null;
+    message: string;
+    remote_user_id?: string | null;
+    remote_state_code?: number | null;
+    remote_modified_at?: string | null;
+    local_payload_sha256?: string | null;
+    remote_payload_sha256?: string | null;
+};
+export type RemoteVerificationBlocker = {
+    code: RemoteVerificationIssueCode;
+    severity: 'error';
+    message: string;
+    row_index: number;
+    role: RemoteVerificationReferenceRole;
+    table: RemoteDatasetTable | null;
+    id: string | null;
+    version: string | null;
+    latest_version: string | null;
+    path: string;
+};
+export type DatasetRemoteVerificationReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'passed_remote_verification' | 'blocked_remote_verification';
+    root_policy: RemoteVerificationRootPolicy;
+    input_path: string;
+    out_dir: string;
+    counts: {
+        rows: number;
+        references: number;
+        checked: number;
+        blockers: number;
+        root_readback_checks?: number;
+        root_payload_mismatches?: number;
+        by_status: Record<string, number>;
+        by_table: Record<RemoteDatasetTable, number>;
+    };
+    blockers: RemoteVerificationBlocker[];
+    files: {
+        report: string;
+        checks: string;
+        blockers: string;
+    };
+};
+export type RunDatasetRemoteVerifyOptions = {
+    inputPath: string;
+    outDir: string;
+    rootPolicy?: RemoteVerificationRootPolicy;
+    compareRootPayload?: boolean;
+    targetUserId?: string | null;
+    stateCode?: number | null;
+    rawInput?: unknown;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    now?: Date;
+    lookupDatasetImpl?: (request: RemoteDatasetLookupRequest) => Promise<RemoteDatasetLookup>;
+    lookupRootPayloadImpl?: (request: RemoteDatasetLookupRequest) => Promise<RemoteDatasetPayloadLookup | null>;
+};
+declare function tableFromType(value: string | null): RemoteDatasetTable | null;
+declare function tableFromPath(pathExpression: string): RemoteDatasetTable | null;
+declare function shortDescription(value: unknown): string | null;
+declare function isFoundryTracePath(pathExpression: string): boolean;
+export declare function collectRemoteReferences(rows: JsonObject[]): RemoteDatasetReference[];
+declare function compareVersions(left: string | null, right: string | null): number;
+declare function buildRemoteUrl(restBaseUrl: string, table: RemoteDatasetTable, id: string, version: string | null): string;
+declare function normalizeRows(value: unknown): RemoteDatasetLookupRow[];
+declare function sha256Json(value: unknown): string;
+declare function buildRemotePayloadUrl(restBaseUrl: string, table: RemoteDatasetTable, id: string, version: string): string;
+declare function normalizePayloadRow(value: unknown): RemoteDatasetPayloadLookup | null;
+export declare function lookupRemoteDataset(options: {
+    runtime: SupabaseDataRuntime;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    request: RemoteDatasetLookupRequest;
+}): Promise<RemoteDatasetLookup>;
+declare function lookupRemoteDatasetPayload(options: {
+    runtime: SupabaseDataRuntime;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    request: RemoteDatasetLookupRequest;
+}): Promise<RemoteDatasetPayloadLookup | null>;
+declare function makeRootReadbackCheck(reference: RemoteDatasetReference, status: RemoteVerificationIssueCode, message: string, remote: RemoteDatasetPayloadLookup | null, hashes?: {
+    local: string | null;
+    remote: string | null;
+}): RemoteVerificationCheck;
+declare function rootReadbackChecks(options: {
+    reference: RemoteDatasetReference;
+    localPayload: JsonObject;
+    remote: RemoteDatasetPayloadLookup | null;
+    compareRootPayload: boolean;
+    targetUserId: string | null;
+    stateCode: number | null;
+}): RemoteVerificationCheck[];
+export declare function runDatasetRemoteVerify(options: RunDatasetRemoteVerifyOptions): Promise<DatasetRemoteVerificationReport>;
+export declare const __testInternals: {
+    buildRemotePayloadUrl: typeof buildRemotePayloadUrl;
+    buildRemoteUrl: typeof buildRemoteUrl;
+    collectRemoteReferences: typeof collectRemoteReferences;
+    compareVersions: typeof compareVersions;
+    isFoundryTracePath: typeof isFoundryTracePath;
+    lookupRemoteDatasetPayload: typeof lookupRemoteDatasetPayload;
+    lookupRemoteDataset: typeof lookupRemoteDataset;
+    makeRootReadbackCheck: typeof makeRootReadbackCheck;
+    normalizePayloadRow: typeof normalizePayloadRow;
+    normalizeRows: typeof normalizeRows;
+    rootReadbackChecks: typeof rootReadbackChecks;
+    sha256Json: typeof sha256Json;
+    shortDescription: typeof shortDescription;
+    tableFromPath: typeof tableFromPath;
+    tableFromType: typeof tableFromType;
+};
+export {};