@tiangong-lca/cli 0.1.1 → 0.1.2

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

@@ -0,0 +1,458 @@
+import type { FetchLike } from './http.js';
+import { buildAliasBatchRequest, buildAliasPlanRequest } from './dataset-maintenance-alias-request.js';
+import { type DatasetMaintenancePlan, type DatasetMaintenanceAliasBatchPlan, type DatasetMaintenancePlanAction, type DatasetMaintenanceProgressEntry, type DatasetMaintenanceRemoteRow, type JsonObject } from './dataset-maintenance-contract.js';
+import { type DatasetMaintenanceDerivativeSubmitProof } from './dataset-maintenance-derivatives.js';
+import { type DatasetMaintenanceRemoteContext } from './dataset-maintenance-remote.js';
+export type DatasetMaintenanceApplyReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'completed' | 'completed_with_failures' | 'completed_with_unknowns' | 'accepted';
+    task_id: string;
+    operation: DatasetMaintenancePlan['operation'];
+    operation_id: string;
+    target_mode: DatasetMaintenancePlan['target_mode'];
+    plan_sha256: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    summary: {
+        actions: number;
+        success: number;
+        failed: number;
+        unknown?: number;
+        pending: number;
+        resumed_successes: number;
+        accepted?: number;
+    };
+    actions: Array<{
+        action_id: string;
+        action: DatasetMaintenancePlanAction['action'];
+        table: DatasetMaintenancePlanAction['table'];
+        id: string;
+        version: string;
+        status: 'success' | 'failed' | 'unknown' | 'pending' | 'accepted';
+        error: string | null;
+    }>;
+    artifacts: {
+        approval_record: string;
+        apply_progress: string;
+        commit_report: string;
+        attempt_report: string;
+        alias_plan_progress?: string;
+        alias_batch_progress?: string;
+        alias_exchange_progress?: string;
+        derivative_submit_progress?: string;
+        derivative_admission_attempt?: string;
+        execution_log?: string;
+        inbound_reference_barrier?: string;
+    };
+    database_audit: {
+        rpc_transaction_log: 'public.command_audit_log';
+        source: 'tiangong-lca dataset maintenance apply';
+        correlation_fields: string[];
+    };
+    alias_plan_proof?: {
+        plan_request_sha256: string;
+        summary_audit_id: string;
+        batch_count: 2;
+        row_count: 52;
+        exchange_count: 59;
+        idempotent_replay: boolean;
+    };
+    derivative_admission?: DatasetMaintenanceDerivativeSubmitProof & {
+        admission: 'accepted';
+    };
+};
+export type RunDatasetMaintenanceApplyOptions = {
+    planPath: string;
+    commit: boolean;
+    approvePlan: string;
+    confirm: string;
+    timeoutMs?: number;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    now?: Date;
+    maxParallel?: number;
+    globalInboundProofPath?: string;
+    approveGlobalInboundProof?: string;
+};
+type ParallelDeleteExecutionStatus = 'PREPARED' | 'DISPATCHED' | 'COMMITTED' | 'UNKNOWN';
+type ParallelDeleteGlobalInboundProofChunk = {
+    index: number;
+    start: number;
+    end_exclusive: number;
+    target_count: number;
+    captured_at_utc: string;
+    inbound_exchanges: 0;
+    old_flow_identities_with_inbound: 0;
+    process_identities_with_inbound: 0;
+    owner_draft_inbound: 0;
+    public_inbound: 0;
+    foreign_private_inbound: 0;
+    other_state_inbound: 0;
+    sql_sha256: string;
+};
+type ParallelDeleteGlobalInboundProof = {
+    schema_version: 'dataset-maintenance-global-inbound-proof.v1';
+    status: 'PASS_GLOBAL_ALL_PROCESS_INBOUND_ZERO';
+    statement_kind: 'SELECT';
+    source: 'supabase_select_only_raw_sql';
+    process_scope: 'all_process_rows_without_rls_restriction';
+    captured_at_utc: string;
+    project_ref: string;
+    actor_user_id: string;
+    plan_sha256: string;
+    operation: 'delete';
+    target_table: 'flows';
+    target_count: number;
+    target_binding_sha256: string;
+    global_process_rows: number;
+    global_exchange_rows: number;
+    inbound_exchanges: 0;
+    old_flow_identities_with_inbound: 0;
+    process_identities_with_inbound: 0;
+    chunks: ParallelDeleteGlobalInboundProofChunk[];
+    p0: 0;
+    p1: 0;
+    proof_path: string;
+    proof_sha256: string;
+};
+type ParallelDeleteExecutionEntry = {
+    schema_version: 1;
+    plan_sha256: string;
+    operation_id: string;
+    action_id: string;
+    attempt_key: string;
+    action: 'delete';
+    table: 'flows';
+    id: string;
+    version: string;
+    desired_sha256: string;
+    before_sha256: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    status: ParallelDeleteExecutionStatus;
+    recorded_at_utc: string;
+    attempt_consumed: boolean;
+    recovered: boolean;
+    audit_context: {
+        plan_sha256: string;
+        operation_id: string;
+        action_id: string;
+        reason_code: string;
+        source: 'tiangong-lca dataset maintenance apply';
+    };
+    audit_id: string | null;
+    readback_sha256: string | null;
+    remote_result_sha256: string | null;
+    error: string | null;
+};
+type ParallelDeleteExecutionState = {
+    entries: ParallelDeleteExecutionEntry[];
+    byAction: Map<string, ParallelDeleteExecutionEntry[]>;
+    dispatched: Set<string>;
+    committed: Set<string>;
+};
+type ProgressState = {
+    entries: DatasetMaintenanceProgressEntry[];
+    successes: Map<string, DatasetMaintenanceProgressEntry>;
+    latestFailures: Map<string, DatasetMaintenanceProgressEntry>;
+};
+type DerivativeSubmitProgressEntry = {
+    schema_version: 1;
+    plan_sha256: string;
+    operation_id: string;
+    action_id: string;
+    target_mode: 'owner_draft';
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    started_at_utc: string;
+    ended_at_utc: string;
+    result: 'accepted';
+    proof: DatasetMaintenanceDerivativeSubmitProof;
+};
+type DerivativeSubmitProgressState = {
+    entries: DerivativeSubmitProgressEntry[];
+    latest: DerivativeSubmitProgressEntry | null;
+};
+type DerivativeAdmissionAttempt = {
+    schema_version: 1;
+    plan_sha256: string;
+    operation_id: string;
+    action_id: string;
+    table: 'processes';
+    id: string;
+    version: string;
+    expected_snapshot_sha256: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    prepared_at_utc: string;
+};
+type AliasBatchProgressEntry = {
+    schema_version: 1;
+    plan_sha256: string;
+    operation_id: string;
+    batch_id: string;
+    target_mode: 'owner_draft';
+    dimension: DatasetMaintenanceAliasBatchPlan['dimension'];
+    factor: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    started_at_utc: string;
+    ended_at_utc: string;
+    batch_request_sha256: string;
+    idempotent_replay: boolean;
+    row_count: number;
+    exchange_count: number;
+    summary_audit_id: string;
+    plan_request_sha256: string;
+    plan_summary_audit_id: string;
+    result: 'success';
+    error: null;
+};
+type AliasPlanBatchProof = {
+    batch_id: string;
+    dimension: DatasetMaintenanceAliasBatchPlan['dimension'];
+    batch_request_sha256: string;
+    summary_audit_id: string;
+};
+type AliasPlanProgressEntry = {
+    schema_version: 1;
+    plan_sha256: string;
+    operation_id: string;
+    target_mode: 'owner_draft';
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    started_at_utc: string;
+    ended_at_utc: string;
+    plan_request_sha256: string | null;
+    idempotent_replay: boolean | null;
+    batch_count: 2;
+    row_count: 52;
+    exchange_count: 59;
+    summary_audit_id: string | null;
+    batches: AliasPlanBatchProof[];
+    result: 'success' | 'failed';
+    error: string | null;
+};
+type AliasPlanProgressState = {
+    entries: AliasPlanProgressEntry[];
+    success: AliasPlanProgressEntry | null;
+    latestFailure: AliasPlanProgressEntry | null;
+};
+type AliasBatchProgressState = {
+    entries: AliasBatchProgressEntry[];
+    successes: Map<string, AliasBatchProgressEntry>;
+};
+type AliasRpcAuditProof = {
+    action_id: string;
+    table: DatasetMaintenancePlanAction['table'];
+    id: string;
+    version: string;
+    audit_id: string;
+};
+type AliasRpcResult = {
+    target_visibility: 'owner_draft';
+    batch_request_sha256: string;
+    idempotent_replay: boolean;
+    exchange_count: number;
+    summary_audit_id: string;
+    audits: Map<string, AliasRpcAuditProof>;
+    raw: JsonObject;
+};
+type AliasPlanRpcResult = {
+    target_visibility: 'owner_draft';
+    plan_request_sha256: string;
+    idempotent_replay: boolean;
+    batch_count: 2;
+    row_count: 52;
+    exchange_count: 59;
+    summary_audit_id: string;
+    batches: Map<DatasetMaintenanceAliasBatchPlan['dimension'], AliasRpcResult>;
+    raw: JsonObject;
+};
+type RetiredAliasExecutionProof = {
+    rpc: AliasPlanRpcResult;
+    after_by_action: Map<string, string>;
+};
+declare function clock(options: RunDatasetMaintenanceApplyOptions): string;
+declare function errorMessage(error: unknown): string;
+declare function parallelDeleteDesiredSha256(action: DatasetMaintenancePlanAction): string;
+declare function normalizeMaintenanceMaxParallel(value: number | undefined): number;
+declare function assertParallelDeletePlan(plan: DatasetMaintenancePlan): void;
+declare function parallelDeleteTargetBindingSha256(plan: DatasetMaintenancePlan): string;
+declare function assertGlobalInboundProofOptionShape(options: {
+    parallelDeleteMode: boolean;
+    proofPath?: string;
+    approveProof?: string;
+}): void;
+declare function validateParallelDeleteGlobalInboundProof(options: {
+    proofPath: string | undefined;
+    approveProof: string | undefined;
+    plan: DatasetMaintenancePlan;
+    context: DatasetMaintenanceRemoteContext;
+    now: Date;
+}): ParallelDeleteGlobalInboundProof | null;
+declare function parseParallelDeleteExecutionLog(plan: DatasetMaintenancePlan, executionLogPath: string): ParallelDeleteExecutionState;
+declare function appendParallelDeleteExecutionEntry(options: {
+    path: string;
+    state: ParallelDeleteExecutionState;
+    plan: DatasetMaintenancePlan;
+    action: DatasetMaintenancePlanAction;
+    context: DatasetMaintenanceRemoteContext;
+    status: ParallelDeleteExecutionStatus;
+    recordedAtUtc: string;
+    recovered?: boolean;
+    auditId?: string | null;
+    readbackSha256?: string | null;
+    remoteResultSha256?: string | null;
+    error?: string | null;
+}): ParallelDeleteExecutionEntry;
+declare function assertNoVisibleProcessInboundReferences(options: {
+    plan: DatasetMaintenancePlan;
+    rows: DatasetMaintenanceRemoteRow[];
+}): {
+    process_rows: number;
+    process_references: number;
+    snapshot_sha256: string;
+};
+declare function loadDesiredPayload(planDir: string, action: DatasetMaintenancePlanAction): JsonObject;
+declare function parseProgress(plan: DatasetMaintenancePlan, progressPath: string): ProgressState;
+declare function parseDerivativeSubmitProgress(plan: DatasetMaintenancePlan, progressPath: string): DerivativeSubmitProgressState;
+declare function validateDerivativeAdmissionAttempt(options: {
+    path: string;
+    plan: DatasetMaintenancePlan;
+    context: DatasetMaintenanceRemoteContext;
+}): DerivativeAdmissionAttempt | null;
+declare function parseAliasBatchProgress(plan: DatasetMaintenancePlan, progressPath: string): AliasBatchProgressState;
+declare function parseAliasPlanProgress(plan: DatasetMaintenancePlan, progressPath: string): AliasPlanProgressState;
+declare function finalProjectedRows(options: {
+    rows: DatasetMaintenanceRemoteRow[];
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+}): DatasetMaintenanceRemoteRow[];
+declare function assertApplyPreconditions(options: {
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+    currentRows: DatasetMaintenanceRemoteRow[];
+    progress: ProgressState;
+    aliasPlanProgress?: AliasPlanProgressState;
+    attemptedDeleteActionIds?: Set<string>;
+}): void;
+declare function validateApprovalRecord(options: {
+    path: string;
+    plan: DatasetMaintenancePlan;
+    context: DatasetMaintenanceRemoteContext;
+}): void;
+declare function assertAliasSupportSnapshots(options: {
+    plan: DatasetMaintenancePlan;
+    context: DatasetMaintenanceRemoteContext;
+}): Promise<void>;
+declare function validateAliasRpcResult(value: JsonObject, batch: DatasetMaintenanceAliasBatchPlan, plan: DatasetMaintenancePlan): AliasRpcResult;
+declare function validateAliasPlanRpcResult(value: JsonObject, plan: DatasetMaintenancePlan): AliasPlanRpcResult;
+declare function aliasExchangeProgressKey(value: {
+    batch_id: string;
+    action_id: string;
+    exchange_index: number;
+    data_set_internal_id: string;
+}): string;
+declare function appendAliasSuccessLogs(options: {
+    plan: DatasetMaintenancePlan;
+    batch: DatasetMaintenanceAliasBatchPlan;
+    execution: RetiredAliasExecutionProof;
+    progress: ProgressState;
+    progressPath: string;
+    exchangeProgressPath: string;
+    context: DatasetMaintenanceRemoteContext;
+    startedAt: string;
+    endedAt: string;
+}): void;
+declare function appendAliasProofProgress(options: {
+    plan: DatasetMaintenancePlan;
+    execution: RetiredAliasExecutionProof;
+    planProgress: AliasPlanProgressState;
+    batchProgress: AliasBatchProgressState;
+    planProgressPath: string;
+    batchProgressPath: string;
+    context: DatasetMaintenanceRemoteContext;
+    startedAt: string;
+    endedAt: string;
+}): AliasPlanProgressEntry;
+declare function executeAction(options: {
+    action: DatasetMaintenancePlanAction;
+    plan: DatasetMaintenancePlan;
+    planDir: string;
+    context: DatasetMaintenanceRemoteContext;
+}): Promise<{
+    afterSha256: string | null;
+    remoteResultSha256: string;
+}>;
+declare function remoteAuditId(value: JsonObject): string | null;
+declare function executeParallelDeletePlan(options: {
+    plan: DatasetMaintenancePlan;
+    context: DatasetMaintenanceRemoteContext;
+    progress: ProgressState;
+    progressPath: string;
+    executionLogPath: string;
+    execution: ParallelDeleteExecutionState;
+    maxParallel: number;
+    now: () => string;
+}): Promise<Map<string, 'success' | 'failed' | 'unknown'>>;
+declare function executeDerivativeAdmission(options: {
+    plan: DatasetMaintenancePlan;
+    context: DatasetMaintenanceRemoteContext;
+    replayPossible: boolean;
+    attemptPath: string;
+    preparedAtUtc: string;
+}): Promise<DatasetMaintenanceDerivativeSubmitProof>;
+declare function nextAttemptPath(planDir: string): string;
+declare function nextParallelDeleteInboundBarrierPath(planDir: string): string;
+export declare function runDatasetMaintenanceApply(options: RunDatasetMaintenanceApplyOptions): Promise<DatasetMaintenanceApplyReport>;
+export declare const __testInternals: {
+    aliasExchangeProgressKey: typeof aliasExchangeProgressKey;
+    appendAliasSuccessLogs: typeof appendAliasSuccessLogs;
+    appendAliasProofProgress: typeof appendAliasProofProgress;
+    appendParallelDeleteExecutionEntry: typeof appendParallelDeleteExecutionEntry;
+    assertNoVisibleProcessInboundReferences: typeof assertNoVisibleProcessInboundReferences;
+    assertApplyPreconditions: typeof assertApplyPreconditions;
+    assertAliasSupportSnapshots: typeof assertAliasSupportSnapshots;
+    assertGlobalInboundProofOptionShape: typeof assertGlobalInboundProofOptionShape;
+    assertParallelDeletePlan: typeof assertParallelDeletePlan;
+    buildAliasBatchRequest: typeof buildAliasBatchRequest;
+    buildAliasPlanRequest: typeof buildAliasPlanRequest;
+    clock: typeof clock;
+    errorMessage: typeof errorMessage;
+    executeDerivativeAdmission: typeof executeDerivativeAdmission;
+    executeAction: typeof executeAction;
+    executeParallelDeletePlan: typeof executeParallelDeletePlan;
+    finalProjectedRows: typeof finalProjectedRows;
+    loadDesiredPayload: typeof loadDesiredPayload;
+    nextAttemptPath: typeof nextAttemptPath;
+    nextParallelDeleteInboundBarrierPath: typeof nextParallelDeleteInboundBarrierPath;
+    normalizeMaintenanceMaxParallel: typeof normalizeMaintenanceMaxParallel;
+    parallelDeleteDesiredSha256: typeof parallelDeleteDesiredSha256;
+    parallelDeleteTargetBindingSha256: typeof parallelDeleteTargetBindingSha256;
+    parseDerivativeSubmitProgress: typeof parseDerivativeSubmitProgress;
+    validateDerivativeAdmissionAttempt: typeof validateDerivativeAdmissionAttempt;
+    parseAliasBatchProgress: typeof parseAliasBatchProgress;
+    parseAliasPlanProgress: typeof parseAliasPlanProgress;
+    parseProgress: typeof parseProgress;
+    parseParallelDeleteExecutionLog: typeof parseParallelDeleteExecutionLog;
+    remoteAuditId: typeof remoteAuditId;
+    validateAliasRpcResult: typeof validateAliasRpcResult;
+    validateAliasPlanRpcResult: typeof validateAliasPlanRpcResult;
+    validateApprovalRecord: typeof validateApprovalRecord;
+    validateParallelDeleteGlobalInboundProof: typeof validateParallelDeleteGlobalInboundProof;
+};
+export {};

package/dist/src/lib/dataset-maintenance-clear-account.d.ts

@@ -0,0 +1,161 @@
+import { type DatasetCommandTransport } from './dataset-command.js';
+import type { FetchLike, ResponseLike } from './http.js';
+import { type DatasetMaintenanceSnapshotCompleteness, type DatasetMaintenanceTableCompleteness } from './dataset-maintenance-pagination.js';
+export type DatasetMaintenanceClearAccountTable = 'lifecyclemodels' | 'processes' | 'flows' | 'sources' | 'contacts';
+export type DatasetMaintenanceClearAccountRow = {
+    table: DatasetMaintenanceClearAccountTable;
+    id: string | null;
+    version: string | null;
+    user_id: string | null;
+    state_code: number | null;
+    modified_at: string | null;
+};
+export type DatasetMaintenanceClearAccountTableReport = {
+    table: DatasetMaintenanceClearAccountTable;
+    status: 'dry_run' | 'skipped_empty' | 'deleted' | 'failed' | 'skipped_after_failure';
+    candidates: number;
+    deleted: number;
+    remaining: number | null;
+    source_urls: string[];
+    delete_url: string | null;
+    error: string | null;
+};
+export type DatasetMaintenanceClearAccountReport = {
+    schema_version: 1;
+    generated_at_utc: string;
+    status: 'planned_account_clear' | 'cleared_account' | 'completed_with_failures';
+    mode: 'dry-run' | 'commit';
+    account: {
+        email: string;
+        user_id: string;
+        session_source: string;
+    };
+    filters: {
+        tables: DatasetMaintenanceClearAccountTable[];
+        state_codes: number[] | null;
+        page_size: number;
+    };
+    snapshot_completeness: DatasetMaintenanceSnapshotCompleteness<DatasetMaintenanceClearAccountTable>;
+    readback_completeness: DatasetMaintenanceSnapshotCompleteness<DatasetMaintenanceClearAccountTable> | null;
+    readback_error: string | null;
+    summary: {
+        total_candidates: number;
+        total_deleted: number;
+        total_remaining: number;
+        total_failures: number;
+        by_table: Record<DatasetMaintenanceClearAccountTable, {
+            candidates: number;
+            deleted: number;
+            remaining: number | null;
+            status: DatasetMaintenanceClearAccountTableReport['status'];
+        }>;
+    };
+    tables: DatasetMaintenanceClearAccountTableReport[];
+    artifacts: {
+        rls_visible_snapshot: string;
+        dry_run_report: string;
+        approval_record: string | null;
+        commit_report: string | null;
+        readback_verify_report: string | null;
+    };
+};
+export type RunDatasetMaintenanceClearAccountOptions = {
+    outDir?: string | null;
+    stateCodes?: number[] | null;
+    pageSize?: number;
+    timeoutMs?: number;
+    commit?: boolean;
+    confirm?: string | null;
+    env: NodeJS.ProcessEnv;
+    fetchImpl: FetchLike;
+    now?: Date;
+};
+declare function normalizeEmail(value: unknown): string;
+declare function caughtErrorMessage(error: unknown): string;
+declare function normalizeStateCode(value: unknown): number | null;
+declare function normalizeStateCodes(values: number[] | null | undefined): number[] | null;
+declare function normalizePageSize(value: number | undefined): number;
+declare function normalizeTimeoutMs(value: number | undefined): number;
+declare function normalizeRow(table: DatasetMaintenanceClearAccountTable, value: unknown): DatasetMaintenanceClearAccountRow | null;
+declare function buildTableFilterUrl(options: {
+    restBaseUrl: string;
+    table: DatasetMaintenanceClearAccountTable;
+    userId: string;
+    stateCodes: number[] | null;
+}): URL;
+declare function fetchJson(options: {
+    url: string;
+    init: RequestInit;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+    label: string;
+}): Promise<{
+    body: unknown;
+    headers: ResponseLike['headers'];
+}>;
+declare function fetchCurrentUser(options: {
+    projectBaseUrl: string;
+    publishableKey: string;
+    accessToken: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+}): Promise<{
+    id: string;
+    email: string | null;
+}>;
+declare function fetchTableRows(options: {
+    restBaseUrl: string;
+    table: DatasetMaintenanceClearAccountTable;
+    userId: string;
+    stateCodes: number[] | null;
+    pageSize: number;
+    publishableKey: string;
+    accessToken: string;
+    fetchImpl: FetchLike;
+    timeoutMs: number;
+}): Promise<{
+    rows: DatasetMaintenanceClearAccountRow[];
+    sourceUrls: string[];
+    completeness: DatasetMaintenanceTableCompleteness;
+}>;
+declare function fetchAccountSnapshot(options: Omit<Parameters<typeof fetchTableRows>[0], 'table'>): Promise<{
+    tables: Array<{
+        table: DatasetMaintenanceClearAccountTable;
+        rows: DatasetMaintenanceClearAccountRow[];
+        sourceUrls: string[];
+        completeness: DatasetMaintenanceTableCompleteness;
+    }>;
+    rows: DatasetMaintenanceClearAccountRow[];
+    completeness: DatasetMaintenanceSnapshotCompleteness<DatasetMaintenanceClearAccountTable>;
+}>;
+declare function deleteTableRows(options: {
+    transport: DatasetCommandTransport;
+    table: DatasetMaintenanceClearAccountTable;
+    rows: DatasetMaintenanceClearAccountRow[];
+}): Promise<{
+    deletedRows: DatasetMaintenanceClearAccountRow[];
+    deleteUrl: string;
+    failures: Array<{
+        row: DatasetMaintenanceClearAccountRow;
+        error: string;
+    }>;
+}>;
+declare function buildSummary(tables: DatasetMaintenanceClearAccountTableReport[], additionalFailures?: number): DatasetMaintenanceClearAccountReport['summary'];
+export declare function runDatasetMaintenanceClearAccount(options: RunDatasetMaintenanceClearAccountOptions): Promise<DatasetMaintenanceClearAccountReport>;
+export declare const __testInternals: {
+    buildSummary: typeof buildSummary;
+    buildTableFilterUrl: typeof buildTableFilterUrl;
+    caughtErrorMessage: typeof caughtErrorMessage;
+    deleteTableRows: typeof deleteTableRows;
+    fetchAccountSnapshot: typeof fetchAccountSnapshot;
+    fetchCurrentUser: typeof fetchCurrentUser;
+    fetchJson: typeof fetchJson;
+    fetchTableRows: typeof fetchTableRows;
+    normalizeEmail: typeof normalizeEmail;
+    normalizePageSize: typeof normalizePageSize;
+    normalizeRow: typeof normalizeRow;
+    normalizeStateCode: typeof normalizeStateCode;
+    normalizeStateCodes: typeof normalizeStateCodes;
+    normalizeTimeoutMs: typeof normalizeTimeoutMs;
+};
+export {};