@madewithremy/admin 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -808,7 +808,7 @@ interface CrashesStatsParams {
  * @example
  * const { errors } = await admin.crashes.list({ sort: 'frequent', limit: 10 });
  */
-declare function list$9(ctx: AdminContext, params?: CrashesListParams): Promise<CrashesListResult>;
+declare function list$a(ctx: AdminContext, params?: CrashesListParams): Promise<CrashesListResult>;
 /**
  * Individual crash events for one fingerprint, cursor-paginated.
  *
@@ -829,7 +829,7 @@ declare function occurrences(ctx: AdminContext, fingerprint: string, params?: Cr
  * @example
  * const event = await admin.crashes.get('evt_xyz789');
  */
-declare function get$6(ctx: AdminContext, eventId: string): Promise<CrashesGetResult>;
+declare function get$8(ctx: AdminContext, eventId: string): Promise<CrashesGetResult>;
 /**
  * Bucketed time series of total crash occurrence volume for the app.
  *
@@ -847,7 +847,7 @@ type crashes_CrashesStatsParams = CrashesStatsParams;
 declare const crashes_occurrences: typeof occurrences;
 declare const crashes_stats: typeof stats;
 declare namespace crashes {
-  export { type crashes_CrashesListParams as CrashesListParams, type crashes_CrashesOccurrencesParams as CrashesOccurrencesParams, type crashes_CrashesStatsParams as CrashesStatsParams, get$6 as get, list$9 as list, crashes_occurrences as occurrences, crashes_stats as stats };
+  export { type crashes_CrashesListParams as CrashesListParams, type crashes_CrashesOccurrencesParams as CrashesOccurrencesParams, type crashes_CrashesStatsParams as CrashesStatsParams, get$8 as get, list$a as list, crashes_occurrences as occurrences, crashes_stats as stats };
 }
 
 /**
@@ -942,7 +942,7 @@ interface CronListParams {
  * const { jobs } = await admin.cron.list({ runs: 50 });
  * const blocked = jobs.filter((j) => j.status === 'blocked');
  */
-declare function list$8(ctx: AdminContext, params?: CronListParams): Promise<CronOverviewResult>;
+declare function list$9(ctx: AdminContext, params?: CronListParams): Promise<CronOverviewResult>;
 /**
  * Trigger a job now (does not affect its schedule).
  *
@@ -957,12 +957,11 @@ declare function list$8(ctx: AdminContext, params?: CronListParams): Promise<Cro
  * @example
  * const { requestId } = await admin.cron.run('dailyDigest');
  */
-declare function run(ctx: AdminContext, route: string): Promise<CronRunResult>;
+declare function run$1(ctx: AdminContext, route: string): Promise<CronRunResult>;
 
 type cron_CronListParams = CronListParams;
-declare const cron_run: typeof run;
 declare namespace cron {
-  export { type cron_CronListParams as CronListParams, list$8 as list, cron_run as run };
+  export { type cron_CronListParams as CronListParams, list$9 as list, run$1 as run };
 }
 
 /**
@@ -1060,6 +1059,629 @@ declare namespace data {
   export { type data_LiftFromLiveParams as LiftFromLiveParams, data_liftFromDev as liftFromDev, data_liftFromLive as liftFromLive };
 }
 
+/**
+ * Response types for bulk ingestion jobs.
+ *
+ * Transcribed from youai-api:
+ *   src/http/routes/V2Apps/manage/dataSourceJobs.ts (jobView)
+ *   src/common/DataSources/jobs/types.ts
+ */
+/**
+ * Where a job's documents come from. `store` is every object under a prefix of
+ * one of the app's file stores (what `files put` fills); `manifest` is a JSONL
+ * object the CLI uploaded, one `{ url, filename?, externalId?, metadata? }` per
+ * line, for documents that live behind URLs; `connector` is a sync of the S3
+ * bucket the source is connected to (`datasources sync`); `remap` runs the
+ * live mapper over the source's own raw copies (`datasources remap`); `replay`
+ * runs an earlier job's quarantined objects through the current mapper
+ * (`datasources jobs replay`).
+ */
+type DataSourceJobSource = {
+    type: 'store';
+    store: string;
+    access: 'private' | 'public';
+    prefix: string;
+} | {
+    type: 'manifest';
+    key: string;
+} | {
+    type: 'connector';
+    connectorId: string;
+} | {
+    /** A random draw of another source's documents (`datasources sample`). */
+    type: 'sample';
+    fromDataSourceId: string;
+    size: number;
+    filter: Record<string, unknown> | null;
+    stratify: string | null;
+} | {
+    type: 'remap';
+} | {
+    type: 'replay';
+    fromJobId: string;
+    kind: 'skip' | 'error' | null;
+};
+/**
+ * planning → planned → running ⇄ paused → done | failed | cancelled.
+ * `planned` waits for `approve` (or was started with `approve: true` and a
+ * gate refused; the job's `error` says which).
+ */
+type DataSourceJobState = 'planning' | 'planned' | 'running' | 'paused' | 'done' | 'failed' | 'cancelled';
+/**
+ * What the corpus would cost before any of it is spent. Every number is an
+ * extrapolation from a sample of about a hundred objects; credits are ledger
+ * credits (nano-dollars) at today's catalog rates.
+ */
+interface DataSourceJobPlan {
+    objects: number;
+    bytes: number;
+    sample: {
+        documents: number;
+        failed: number;
+        avgChunks: number;
+        avgTokens: number;
+        avgPages: number;
+        modelExtractionShare: number;
+        secondsPerDocument: number;
+    };
+    /**
+     * Mapped sources only: what the mapper did with the sampled objects. The
+     * skip share is the baseline the run's skip gate pauses against.
+     */
+    mapping: {
+        objects: number;
+        documentsPerObject: number;
+        passthroughShare: number;
+        skipShare: number;
+        errorShare: number;
+        deleteShare: number;
+        secondsPerObject: number;
+    } | null;
+    projected: {
+        documents: number;
+        chunks: number;
+        tokens: number;
+        points: number;
+        artifactBytes: number;
+        credits: {
+            embedding: number;
+            extraction: number;
+            contextual: number;
+            total: number;
+        };
+    };
+    capacity: {
+        placement: 'shared' | 'dedicated';
+        resourceId: string | null;
+        maxPoints: number;
+        heldPoints: number;
+        /** False means approve is refused until the source moves or the resource grows. */
+        fits: boolean;
+    };
+    durationMinutes: number;
+    warnings: string[];
+    computedAt: string;
+}
+interface DataSourceJob {
+    id: string;
+    dataSourceId: string;
+    pipelineId: string;
+    source: DataSourceJobSource;
+    /**
+     * Objects the mapper skipped or failed on. Counted on `jobs status`; on the
+     * list and on unmapped sources' jobs both are zero.
+     */
+    quarantine: {
+        skipped: number;
+        errors: number;
+    };
+    state: DataSourceJobState;
+    autoApprove: boolean;
+    plan: DataSourceJobPlan | null;
+    budgetCredits: number | null;
+    budgetDollars: number | null;
+    maxInflightBatches: number;
+    limitObjects: number | null;
+    enumerationDone: boolean;
+    counts: {
+        objectsSeen: number;
+        bytesSeen: number;
+        objectsDispatched: number;
+        documentsDone: number;
+        documentsSkipped: number;
+        documentsFailed: number;
+        chunks: number;
+        embedTokens: number;
+        extractionPages: number;
+    };
+    /** Model spend so far at catalog rates — an estimate, not the ledger. */
+    estimatedCredits: number;
+    estimatedDollars: number;
+    /** Recent per-document failures, newest first, at most twenty. */
+    samples: {
+        ref: string;
+        message: string;
+        at: string;
+    }[];
+    error: string | null;
+    /**
+     * Why a running job stopped: the owner, the budget, repeated batch
+     * failures, or (mapped sources) a skip share far above the plan's.
+     */
+    pauseReason: 'user' | 'budget' | 'errors' | 'skips' | null;
+    stalled: boolean;
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    lastProgressAt: string | null;
+}
+/** GET /datasources/jobs */
+interface DataSourceJobsListResult {
+    jobs: DataSourceJob[];
+}
+/** GET /datasources/jobs/:id */
+interface DataSourceJobGetResult {
+    job: DataSourceJob;
+    dataSource: {
+        id: string;
+        slug: string;
+    };
+    batches: Record<'pending' | 'queued' | 'running' | 'done' | 'failed' | 'cancelled', number>;
+}
+/** POST /datasources/jobs and the four controls */
+interface DataSourceJobResult {
+    job: DataSourceJob;
+}
+/** POST /datasources/jobs/manifest-token */
+interface DataSourceJobManifestTokenResult {
+    key: string;
+    upload: {
+        key: string;
+        uploadUrl: string;
+        uploadFields: Record<string, string>;
+    };
+}
+
+/**
+ * Response types for S3 connectors on data sources.
+ *
+ * Transcribed from youai-api:
+ *   src/http/routes/V2Apps/manage/dataSourceConnectors.ts (connectorView)
+ *   src/common/Db/v2Apps/V2DataSourceConnectorsDao.ts
+ */
+
+/**
+ * What to do when a key disappears from the bucket. `mirror`: its document is
+ * removed at the end of the next full sync. `keep`: the document stays.
+ */
+type DataSourceConnectorDeletions = 'mirror' | 'keep';
+interface DataSourceConnectorPolicy {
+    deletions: DataSourceConnectorDeletions;
+    /** Ceiling a sync auto-approves under; null = the plan's own 1.5× headroom. */
+    budgetDollarsPerSync: number | null;
+}
+/** App-secret NAMES that hold the keys. Values never leave the platform. */
+interface DataSourceConnectorCredentials {
+    accessKeyIdSecret: string;
+    secretAccessKeySecret: string;
+}
+interface DataSourceConnector {
+    id: string;
+    type: 's3';
+    bucket: string;
+    region: string;
+    /** Key prefix listed under; '' for the whole bucket. */
+    prefix: string;
+    /** S3-compatible endpoint, or null for AWS. */
+    endpoint: string | null;
+    credentials: DataSourceConnectorCredentials;
+    policy: DataSourceConnectorPolicy;
+    lastSyncJobId: string | null;
+    lastSyncedAt: string | null;
+    lastError: string | null;
+    /** Only on GET: how many customer keys the index tracks. */
+    objects?: {
+        live: number;
+        deleted: number;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+/** POST /datasources/connector, POST /datasources/connector/remove */
+interface DataSourceConnectorResult {
+    connector: DataSourceConnector;
+}
+/** GET /datasources/connector?slug= */
+interface DataSourceConnectorGetResult {
+    connector: DataSourceConnector | null;
+}
+/** POST /datasources/sync */
+interface DataSourceSyncResult {
+    job: DataSourceJob;
+}
+
+/**
+ * Response types for warming, sampling and retrieval evals.
+ *
+ * Transcribed from youai-api:
+ *   src/http/routes/V2Apps/manage/dataSourceEvals.ts (setView, runView)
+ *   src/common/DataSources/evals/types.ts
+ */
+
+/** An index reload in flight after an eviction, or its last failure. */
+interface DataSourcesHydration {
+    copied: number;
+    total: number;
+    startedAt: string;
+    error: string | null;
+}
+/** POST /datasources/hydrate */
+interface DataSourcesHydrateResult {
+    /** True when the points were already there and nothing was started. */
+    resident: boolean;
+    hydration: DataSourcesHydration | null;
+}
+/** POST /datasources/sample */
+interface DataSourcesSampleResult {
+    dataSource: {
+        id: string;
+        slug: string;
+        sampleOf: string;
+        pipelineVersion: number;
+    };
+    job: DataSourceJob;
+}
+/** `queued` until a worker claims the generation; hand-written sets start `ready`. */
+type EvalSetState = 'queued' | 'generating' | 'ready' | 'failed';
+type EvalQueryStyle = 'cloze' | 'question';
+interface EvalSet {
+    id: string;
+    dataSourceId: string;
+    name: string;
+    description: string | null;
+    state: EvalSetState;
+    generation: {
+        style: EvalQueryStyle;
+        size: number;
+        modelId: string | null;
+        seed: number;
+        tags: string[];
+    } | null;
+    queryCount: number;
+    /** Model spend generating questions (estimate); zero for cloze. */
+    estimatedCredits: number;
+    estimatedDollars: number;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** What should come back for a query; the content hash is what crosses sources. */
+interface EvalExpectation {
+    contentHash: string;
+    documentId: string;
+    chunkIndex: number | null;
+    filename: string | null;
+}
+interface EvalQuery {
+    id: string;
+    setId: string;
+    query: string;
+    expected: EvalExpectation[];
+    passage: string | null;
+    tags: string[];
+    origin: 'generated' | 'user';
+    createdAt: string;
+}
+/** Partial retrieval config plus mode, merged over the target's own. */
+interface EvalRetrieval {
+    mode?: 'hybrid' | 'semantic' | 'lexical';
+    hybrid?: boolean;
+    rerank?: {
+        enabled?: boolean;
+        modelId?: string | null;
+        candidates?: number;
+    };
+    adaptive?: {
+        enabled?: boolean;
+        gap?: number;
+    };
+    topK?: number;
+}
+type EvalRunState = 'queued' | 'running' | 'done' | 'failed';
+interface EvalAggregates {
+    queries: number;
+    scored: number;
+    unresolvable: number;
+    errors: number;
+    recall: {
+        at1: number;
+        at5: number;
+        at10: number;
+    };
+    chunkRecall: {
+        at5: number;
+        at10: number;
+        queries: number;
+    } | null;
+    mrr: number;
+    ndcg10: number;
+    latency: {
+        p50: number;
+        p95: number;
+        mean: number;
+    };
+    estimatedCredits: number;
+    estimatedCreditsPerQuery: number;
+    rerankedShare: number;
+    /** Which branch found the expected document, over hits in the top 10. */
+    branches: {
+        denseOnly: number;
+        lexicalOnly: number;
+        both: number;
+        unexplained: number;
+    };
+    byTag: Record<string, {
+        queries: number;
+        recallAt5: number;
+        mrr: number;
+    }>;
+    truncatedTo: number | null;
+    computedAt: string;
+}
+interface EvalRun {
+    id: string;
+    setId: string;
+    dataSourceId: string;
+    pipelineVersion: number;
+    label: string | null;
+    retrieval: EvalRetrieval;
+    state: EvalRunState;
+    completed: number;
+    total: number;
+    aggregates: EvalAggregates | null;
+    estimatedCredits: number;
+    estimatedDollars: number;
+    error: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+/** One row of a run's dataset. */
+interface EvalQueryResult {
+    queryId: string;
+    query: string;
+    tags: string[];
+    resolvable: boolean;
+    documentRank: number | null;
+    chunkRank: number | null;
+    matchedVia: 'dense' | 'lexical' | 'both' | null;
+    retrieved: {
+        documentId: string;
+        contentHash: string | null;
+        chunkIndex: number | null;
+        score: number;
+        retrievalRank: number | null;
+        matchedVia: 'dense' | 'lexical' | 'both' | null;
+    }[];
+    reranked: boolean;
+    latencyMs: number;
+    estimatedCredits: number;
+    error: string | null;
+}
+interface EvalSetResult {
+    set: EvalSet;
+}
+interface EvalSetsListResult {
+    sets: EvalSet[];
+}
+interface EvalSetGetResult {
+    set: EvalSet;
+    dataSource: {
+        id: string;
+        slug: string;
+    } | null;
+    queries?: EvalQuery[];
+}
+interface EvalQueriesAddResult {
+    added: number;
+    queryCount: number;
+}
+interface EvalQueriesListResult {
+    queries: EvalQuery[];
+}
+interface EvalRunResult {
+    run: EvalRun;
+    queries?: EvalQueryResult[];
+}
+interface EvalRunsListResult {
+    runs: EvalRun[];
+}
+interface EvalCompareResult {
+    a: EvalRun;
+    b: EvalRun;
+    /** Aggregate deltas, b minus a, for every numeric field. */
+    delta: Record<string, unknown>;
+    /** Per-query movement when both runs share a set; null otherwise. */
+    queries: {
+        wins: {
+            queryId: string;
+            query: string;
+            rankA: number | null;
+            rankB: number | null;
+        }[];
+        losses: {
+            queryId: string;
+            query: string;
+            rankA: number | null;
+            rankB: number | null;
+        }[];
+        unchanged: number;
+    } | null;
+}
+
+/**
+ * Response types for data-source mappers: inspecting raw objects, testing a
+ * mapper, remapping, and a job's quarantine.
+ *
+ * Transcribed from youai-api:
+ *   src/http/routes/V2Apps/manage/dataSourceMappers.ts
+ *   src/common/DataSources/mapping.ts (mapperView, buildInspectReport)
+ */
+
+/** The mapper a source runs: the file it was compiled from and its version. */
+interface DataSourceMapper {
+    path: string;
+    /** The compiled bundle key, or `dev:<sessionId>` for a tunnel run; stamped on the documents it produces. */
+    mapperKey: string;
+    timeoutMs: number;
+}
+/** Which objects an inspect or map test looked at. */
+type DataSourceObjectSelection = {
+    kind: 'store';
+    store: string;
+    access: 'private' | 'public';
+    prefix: string;
+} | {
+    kind: 'connector';
+};
+interface DataSourceInspectReport {
+    objects: number;
+    bytes: number;
+    /** True when the listing stopped at the limit. */
+    truncated: boolean;
+    byExtension: {
+        extension: string;
+        count: number;
+        bytes: number;
+    }[];
+    /** Keys grouped by shape, digit runs and ids collapsed: `2024/#/{uuid}.json`. */
+    clusters: {
+        pattern: string;
+        extension: string;
+        count: number;
+        bytes: number;
+        examples: string[];
+    }[];
+    sizeBuckets: {
+        label: string;
+        count: number;
+    }[];
+    /** Up to ten objects read (first 256 KB each). */
+    samples: {
+        key: string;
+        size: number | null;
+        contentType: string | null;
+        encoding: 'utf-8' | 'binary';
+        empty: boolean;
+        /** Top-level keys when the head parsed as a JSON object. */
+        jsonKeys: string[] | null;
+        /** Line count for text that was not one JSON object (JSONL, CSV, ...). */
+        lines: number | null;
+        textLength: number;
+        head: string;
+    }[];
+    /** Distinct top-level JSON key sets across the samples, most common first. */
+    jsonSignatures: {
+        keys: string[];
+        count: number;
+    }[];
+}
+/** POST /datasources/inspect */
+interface DataSourceInspectResult {
+    selection: DataSourceObjectSelection;
+    report: DataSourceInspectReport;
+}
+/** One mapped document as a map test previews it (markdown truncated). */
+interface DataSourceMapTestDocument {
+    externalId: string;
+    title: string;
+    metadata: Record<string, string | number | boolean> | null;
+    replaces: string[];
+    markdownBytes: number;
+    preview: string;
+}
+type DataSourceMapTestOutcome = {
+    kind: 'documents';
+    documents: DataSourceMapTestDocument[];
+} | {
+    kind: 'passthrough';
+    metadata: Record<string, string | number | boolean> | null;
+} | {
+    kind: 'skip';
+    reason: string;
+} | {
+    kind: 'deletes';
+    externalIds: string[];
+} | {
+    kind: 'error';
+    message: string;
+    stack?: string;
+};
+/** POST /datasources/map-test */
+interface DataSourceMapTestResult {
+    mapper: DataSourceMapper;
+    /** The mapper ran from local source through the dev session. */
+    dev: boolean;
+    objects: number;
+    /** Documents produced across every `documents` outcome. */
+    produced: number;
+    counts: {
+        documents: number;
+        passthrough: number;
+        skip: number;
+        deletes: number;
+        error: number;
+    };
+    results: {
+        key: string;
+        outcome: DataSourceMapTestOutcome;
+        durationMs: number;
+    }[];
+}
+/** POST /datasources/remap, POST /datasources/jobs/:id/replay */
+interface DataSourceRemapResult {
+    job: DataSourceJob;
+    mapper: DataSourceMapper;
+    dataSource: {
+        id: string;
+        slug: string;
+    };
+}
+/** One object a job's mapper did not turn into documents. */
+interface DataSourceQuarantinedObject {
+    id: string;
+    /** The key or URL the object was known by. */
+    ref: string;
+    kind: 'skip' | 'error';
+    reason: string;
+    /** False when the object's raw copy never landed — a replay cannot reach it. */
+    replayable: boolean;
+    at: string;
+}
+/** GET /datasources/jobs/:id/quarantine */
+interface DataSourceQuarantineResult {
+    job: {
+        id: string;
+        state: string;
+    };
+    dataSource: {
+        id: string;
+        slug: string;
+    };
+    counts: {
+        skipped: number;
+        errors: number;
+    };
+    /** Reasons by frequency, most common first. */
+    reasons: {
+        kind: 'skip' | 'error';
+        reason: string;
+        count: number;
+    }[];
+    objects: DataSourceQuarantinedObject[];
+    nextCursor: string | null;
+}
+
 /**
  * Response types for the data-sources management API.
  *
@@ -1071,6 +1693,7 @@ declare namespace data {
  *
  * 204/empty responses surface as `{ ok: true; status: number }` (readBody in api.ts).
  */
+
 /**
  * Chunking settings pinned at pipeline creation.
  * Any change requires a revectorize, not a config update.
@@ -1241,6 +1864,8 @@ interface DataSourcesDocumentsResult {
 type DataSourcesUploadTokenResult = {
     alreadyCurrent: true;
     document: DataSourcesDocument;
+    /** Mapped sources: every document this mapper version produced from the bytes. */
+    documents?: DataSourcesDocument[];
 } | {
     alreadyCurrent: false;
     contentType: string;
@@ -1250,10 +1875,20 @@ type DataSourcesUploadTokenResult = {
         uploadFields: Record<string, string>;
     };
 };
-/** POST /datasources/documents — confirm an uploaded document and queue a build. */
+/**
+ * POST /datasources/documents — confirm an uploaded object and queue its
+ * builds. On a mapped source the object is a raw copy and the mapper decides
+ * what it becomes: `documents` holds everything produced, `document` the first
+ * of them (null only for a `deletes` outcome).
+ */
 interface DataSourcesDocumentConfirmResult {
-    document: DataSourcesDocument;
+    document: DataSourcesDocument | null;
+    documents: DataSourcesDocument[];
+    /** Whether any document was queued for a build. */
     queued: boolean;
+    outcome: 'unmapped' | 'documents' | 'passthrough' | 'deletes';
+    /** Documents removed or superseded as a result. */
+    removed: number;
 }
 /** Build progress counts used in several list and status shapes. */
 interface DataSourcesBuildProgress {
@@ -1273,6 +1908,25 @@ interface DataSourcesPlacement {
     offeringLabel: string | null;
     phase: string;
 }
+/**
+ * A placement move in flight on the active version, or the last one's
+ * failure; null when idle. The points are copied from durable storage onto
+ * the target in the background (no re-embedding); the source flips when
+ * `copied` reaches `total`. While it runs, writes to the source are refused
+ * with `data_source_migrating`; search keeps serving from the old placement.
+ * A sibling of `placement` because a source on the shared pool (placement
+ * null) can be moving too.
+ */
+interface DataSourcesMigration {
+    /** Where it is going; null is the shared pool. */
+    toResourceId: string | null;
+    toName: string | null;
+    copied: number;
+    total: number;
+    startedAt: string;
+    /** Set when the move failed; the source is unfrozen and a new move may start. */
+    error: string | null;
+}
 /** One data source in the GET /datasources listing. */
 interface DataSourcesListEntry {
     id: string;
@@ -1296,6 +1950,18 @@ interface DataSourcesListEntry {
     } | null;
     /** Dedicated placement, or null for the shared pool. */
     placement: DataSourcesPlacement | null;
+    /** A move in flight, or its last failure. */
+    migration: DataSourcesMigration | null;
+    /** The bulk ingestion job in flight on this source, if any. */
+    job: DataSourceJob | null;
+    /** The S3 bucket this source follows, if it is connected to one. */
+    connector: DataSourceConnector | null;
+    /** An index reload in flight after an eviction, or its last failure. */
+    hydration: DataSourcesHydration | null;
+    /** The source this one was sampled from (`datasources sample`), or null. */
+    sampleOf: string | null;
+    /** The mapper the live release declares for this source, or null. */
+    mapper: DataSourceMapper | null;
     createdAt: string;
 }
 /** GET /datasources — all data sources for the app. */
@@ -1380,13 +2046,19 @@ interface DataSourcesConfigResult {
         config: DataSourcesIngestConfig;
     } | null;
 }
-/** POST /datasources/config — response after updating configuration. */
+/**
+ * POST /datasources/config — response after updating configuration.
+ *
+ * `placementChanged` with `migration` set means a populated source started a
+ * background move rather than moving on the spot.
+ */
 interface DataSourcesConfigUpdateResult {
     ingestChanged: boolean;
     placementChanged: boolean;
     ingest: DataSourcesIngestConfig;
     retrieval: Partial<DataSourcesRetrievalConfig>;
     placement: DataSourcesPlacement | null;
+    migration: DataSourcesMigration | null;
 }
 /** POST /datasources — an empty source, on the requested placement. */
 interface DataSourcesCreateResult {
@@ -1403,6 +2075,13 @@ interface DataSourcesCreateResult {
         config: DataSourcesIngestConfig;
     };
     placement: DataSourcesPlacement | null;
+    migration: DataSourcesMigration | null;
+}
+/** POST /datasources/move — the move as started (or applied, for an empty source). */
+interface DataSourcesMoveResult {
+    placement: DataSourcesPlacement | null;
+    /** Null when the source was empty and moved on the spot. */
+    migration: DataSourcesMigration | null;
 }
 /**
  * POST /datasources/revectorize — starts a new candidate pipeline alongside the live one.
@@ -1444,6 +2123,27 @@ interface DataSourcesDocumentDeleteResult {
     ok: true;
     status: number;
 }
+/**
+ * Which documents a bulk removal selects: the row-level half of the search
+ * filter (`metadata`, `filename`, `documentIds`) plus `externalIdPrefix`, the
+ * identity a bulk job or connector recorded (a customer's key prefix, say).
+ * Chunk-level fields and an empty selector are refused.
+ */
+interface DataSourcesDocumentSelector {
+    metadata?: Record<string, string | number | boolean | (string | number | boolean)[] | {
+        gte?: number;
+        lte?: number;
+    }>;
+    filename?: string | string[];
+    documentIds?: string[];
+    externalIdPrefix?: string;
+}
+/** POST /datasources/documents/delete-many — one page of up to 1,000. */
+interface DataSourcesDocumentDeleteManyResult {
+    deleted: number;
+    /** Still matching after this page; call again while > 0. */
+    remaining: number;
+}
 
 /**
  * Data-sources operations: document ingestion, corpus search, pipeline
@@ -1456,7 +2156,7 @@ interface DataSourcesDocumentDeleteResult {
  */
 
 /** @internal Consumed by the CLI skin; waitForIngest documents the default. */
-declare const DEFAULT_WAIT_TIMEOUT_MS$1: number;
+declare const DEFAULT_WAIT_TIMEOUT_MS$3: number;
 /**
  * The per-document summary projection used by waitForIngest, status, and the
  * revectorize watch loop in the skin. Exported so the skin can reuse it for
@@ -1494,7 +2194,15 @@ interface AddDocumentResult {
     filename: string;
     skipped: boolean;
     queued?: boolean;
-    document: DataSourcesDocument;
+    /**
+     * The document, or the first of them on a mapped source. Null only when the
+     * source's mapper answered `deletes` for the file.
+     */
+    document: DataSourcesDocument | null;
+    /** Every document the file became — one on an unmapped source. */
+    documents: DataSourcesDocument[];
+    /** How the source took the file; absent when it was already current. */
+    outcome?: 'unmapped' | 'documents' | 'passthrough' | 'deletes';
 }
 /**
  * Add one document to a data source.
@@ -1553,6 +2261,24 @@ interface WaitForIngestResult {
  * if (result.status === 'error') { ... }
  */
 declare function waitForIngest(ctx: AdminContext, params: WaitForIngestParams): Promise<WaitForIngestResult>;
+interface WaitForCandidateParams {
+    slug: string;
+    /** Defaults to DEFAULT_WAIT_TIMEOUT_MS (15 min). */
+    timeoutMs?: number;
+    /** Receives `rebuilding… X/Y done (Ns)`. */
+    onProgress?: (message: string) => void;
+}
+interface WaitForCandidateResult {
+    status: 'ready' | 'error' | 'timeout';
+    documents: SummarizedDocument[];
+    /** Present only on status === 'timeout'. */
+    error?: string;
+}
+/**
+ * Poll a candidate version (`revectorize`) until every document has built.
+ * `error` means at least one failed; `promote` with `force` accepts that.
+ */
+declare function waitForCandidate(ctx: AdminContext, params: WaitForCandidateParams): Promise<WaitForCandidateResult>;
 interface DocumentsParams {
     /** Data source slug. */
     slug: string;
@@ -1596,7 +2322,7 @@ declare function allDocuments(ctx: AdminContext, params: Omit<DocumentsParams, '
  * @example
  * const { dataSources } = await admin.dataSources.list();
  */
-declare function list$7(ctx: AdminContext): Promise<DataSourcesListResult>;
+declare function list$8(ctx: AdminContext): Promise<DataSourcesListResult>;
 interface SearchParams {
     /** Data source slug. */
     slug: string;
@@ -1661,9 +2387,8 @@ interface ConfigSetParams {
     retrieval?: DataSourcesRetrievalUpdate;
     /**
      * Where the corpus lives: a dedicated resource (see `admin.infra`) or the
-     * shared pool. Accepted only while the source has no built documents —
-     * moving a populated source is refused with
-     * `placement_change_requires_migration`.
+     * shared pool. An empty source moves on the spot; a populated one starts a
+     * background move (see `move`) and the response carries its `migration`.
      */
     placement?: {
         resourceId: string;
@@ -1677,7 +2402,8 @@ interface ConfigSetParams {
  * instead, which builds a new version alongside the live one so search never
  * degrades.
  *
- * @throws AdminApiError `data_source_not_found` (404).
+ * @throws AdminApiError `data_source_not_found` (404),
+ *   `data_source_migrating` (422) while a move is in flight.
  * @example
  * await admin.dataSources.configSet({
  *   slug: 'policies',
@@ -1704,18 +2430,74 @@ interface CreateParams {
  * Create an empty data source, optionally on dedicated capacity.
  *
  * The one-step way to start a corpus on a resource. `add` also creates a
- * source on first use, but on the shared pool, and a source with built
- * documents cannot move, so a corpus meant for dedicated capacity starts here.
- * Calling this for a source that already exists returns it; a placement given
- * then follows `configSet`'s rule and moves it only while it is empty.
+ * source on first use, but on the shared pool. Calling this for a source that
+ * already exists returns it; a placement given then follows `configSet`'s
+ * rule — an empty source moves on the spot, a populated one starts a move.
  *
  * @throws AdminApiError `invalid_data_source` (400), `data_source_limit` (422),
  *   `resource_not_found` (404), `resource_destroyed` (422),
- *   `placement_change_requires_migration` (422).
+ *   `data_source_migrating` (422), `capacity_exceeded` (422).
  * @example
  * await admin.dataSources.create({ slug: 'archive', placement: { resourceId } });
  */
 declare function create$1(ctx: AdminContext, params: CreateParams): Promise<DataSourcesCreateResult>;
+interface MoveParams {
+    /** Data source slug. */
+    slug: string;
+    /** A dedicated resource (see `admin.infra`) or the shared pool. */
+    placement: {
+        resourceId: string;
+    } | 'shared';
+}
+/**
+ * Move a data source between placements: shared → dedicated, dedicated →
+ * shared, or one resource to another.
+ *
+ * A populated source is copied onto the target in the background from its
+ * stored vectors — nothing is re-extracted or re-embedded — and flips when the
+ * copy lands. Search keeps serving from the old placement meanwhile. Adding,
+ * removing or reconfiguring documents is refused with `data_source_migrating`
+ * until it finishes; `waitForMove` blocks on that. Moving to `'shared'` is how
+ * a source leaves a resource that is about to be destroyed.
+ *
+ * @throws AdminApiError `data_source_not_found` (404), `same_placement` (400),
+ *   `data_source_busy` (422) while documents are still building or a
+ *   candidate version exists, `data_source_migrating` (422), `capacity_<phase>`
+ *   (422) when the target resource is not active, `capacity_exceeded` (422)
+ *   when the target is too small, `resource_not_found` (404).
+ * @example
+ * await admin.dataSources.move({ slug: 'archive', placement: { resourceId } });
+ * const result = await admin.dataSources.waitForMove({ slug: 'archive' });
+ */
+declare function move(ctx: AdminContext, params: MoveParams): Promise<DataSourcesMoveResult>;
+interface WaitForMoveParams {
+    slug: string;
+    /** Defaults to DEFAULT_WAIT_TIMEOUT_MS (15 min). */
+    timeoutMs?: number;
+    /** Receives `moving… X/Y documents (Ns)`. */
+    onProgress?: (message: string) => void;
+}
+type WaitForMoveResult = {
+    status: 'done';
+    source: DataSourcesListEntry;
+} | {
+    status: 'failed';
+    source: DataSourcesListEntry;
+    error: string;
+} | {
+    status: 'timeout';
+    source: DataSourcesListEntry;
+    error: string;
+};
+/**
+ * Poll until a source's move has landed, failed, or the timeout elapses.
+ *
+ * Reads the source from `list` each poll; done when no move is in flight. A
+ * failed move returns immediately with the platform's error.
+ *
+ * @throws AdminApiError `data_source_not_found` (404).
+ */
+declare function waitForMove(ctx: AdminContext, params: WaitForMoveParams): Promise<WaitForMoveResult>;
 interface RevectorizeParams {
     /** Data source slug. */
     slug: string;
@@ -1795,6 +2577,29 @@ interface RmParams {
  * await admin.dataSources.rm({ slug: 'policies', documentId });
  */
 declare function rm(ctx: AdminContext, params: RmParams): Promise<DataSourcesDocumentDeleteResult>;
+interface RmWhereParams {
+    /** Data source slug. */
+    slug: string;
+    filter: DataSourcesDocumentSelector;
+}
+/**
+ * Remove one page (up to 1,000) of the documents matching a selector, across
+ * every pipeline version, and report how many still match. Loop while
+ * `remaining > 0`; `rmWhereAll` does that.
+ *
+ * @throws AdminApiError `data_source_not_found` (404), `invalid_filter` (400),
+ *   `data_source_busy` (422) while a job is in flight, `data_source_migrating`
+ *   (422) during a move.
+ * @example
+ * await admin.dataSources.rmWhere({ slug: 'archive', filter: { metadata: { year: 2019 } } });
+ */
+declare function rmWhere(ctx: AdminContext, params: RmWhereParams): Promise<DataSourcesDocumentDeleteManyResult>;
+/** `rmWhere` until nothing matches. Reports each page through `onProgress`. */
+declare function rmWhereAll(ctx: AdminContext, params: RmWhereParams & {
+    onProgress?: (message: string) => void;
+}): Promise<{
+    deleted: number;
+}>;
 /**
  * Delete a whole data source — every version, every document, and every byte.
  *
@@ -1815,13 +2620,19 @@ type dataSources_CreateParams = CreateParams;
 declare const dataSources_DOCUMENTS_IDS_MAX: typeof DOCUMENTS_IDS_MAX;
 type dataSources_DocumentsParams = DocumentsParams;
 type dataSources_DropParams = DropParams;
+type dataSources_MoveParams = MoveParams;
 type dataSources_PromoteParams = PromoteParams;
 type dataSources_RevectorizeParams = RevectorizeParams;
 type dataSources_RmParams = RmParams;
+type dataSources_RmWhereParams = RmWhereParams;
 type dataSources_SearchParams = SearchParams;
 type dataSources_SummarizedDocument = SummarizedDocument;
+type dataSources_WaitForCandidateParams = WaitForCandidateParams;
+type dataSources_WaitForCandidateResult = WaitForCandidateResult;
 type dataSources_WaitForIngestParams = WaitForIngestParams;
 type dataSources_WaitForIngestResult = WaitForIngestResult;
+type dataSources_WaitForMoveParams = WaitForMoveParams;
+type dataSources_WaitForMoveResult = WaitForMoveResult;
 declare const dataSources_addDocument: typeof addDocument;
 declare const dataSources_allDocuments: typeof allDocuments;
 declare const dataSources_configGet: typeof configGet;
@@ -1829,14 +2640,566 @@ declare const dataSources_configSet: typeof configSet;
 declare const dataSources_deleteSource: typeof deleteSource;
 declare const dataSources_documents: typeof documents;
 declare const dataSources_drop: typeof drop;
+declare const dataSources_move: typeof move;
 declare const dataSources_promote: typeof promote;
 declare const dataSources_revectorize: typeof revectorize;
 declare const dataSources_rm: typeof rm;
+declare const dataSources_rmWhere: typeof rmWhere;
+declare const dataSources_rmWhereAll: typeof rmWhereAll;
 declare const dataSources_search: typeof search;
 declare const dataSources_summarize: typeof summarize;
+declare const dataSources_waitForCandidate: typeof waitForCandidate;
 declare const dataSources_waitForIngest: typeof waitForIngest;
+declare const dataSources_waitForMove: typeof waitForMove;
 declare namespace dataSources {
-  export { type dataSources_AddDocumentParams as AddDocumentParams, type dataSources_AddDocumentResult as AddDocumentResult, type dataSources_ConfigSetParams as ConfigSetParams, type dataSources_CreateParams as CreateParams, DEFAULT_WAIT_TIMEOUT_MS$1 as DEFAULT_WAIT_TIMEOUT_MS, dataSources_DOCUMENTS_IDS_MAX as DOCUMENTS_IDS_MAX, type dataSources_DocumentsParams as DocumentsParams, type dataSources_DropParams as DropParams, type dataSources_PromoteParams as PromoteParams, type dataSources_RevectorizeParams as RevectorizeParams, type dataSources_RmParams as RmParams, type dataSources_SearchParams as SearchParams, type dataSources_SummarizedDocument as SummarizedDocument, type dataSources_WaitForIngestParams as WaitForIngestParams, type dataSources_WaitForIngestResult as WaitForIngestResult, dataSources_addDocument as addDocument, dataSources_allDocuments as allDocuments, dataSources_configGet as configGet, dataSources_configSet as configSet, create$1 as create, dataSources_deleteSource as deleteSource, dataSources_documents as documents, dataSources_drop as drop, list$7 as list, dataSources_promote as promote, dataSources_revectorize as revectorize, dataSources_rm as rm, dataSources_search as search, dataSources_summarize as summarize, dataSources_waitForIngest as waitForIngest };
+  export { type dataSources_AddDocumentParams as AddDocumentParams, type dataSources_AddDocumentResult as AddDocumentResult, type dataSources_ConfigSetParams as ConfigSetParams, type dataSources_CreateParams as CreateParams, DEFAULT_WAIT_TIMEOUT_MS$3 as DEFAULT_WAIT_TIMEOUT_MS, dataSources_DOCUMENTS_IDS_MAX as DOCUMENTS_IDS_MAX, type dataSources_DocumentsParams as DocumentsParams, type dataSources_DropParams as DropParams, type dataSources_MoveParams as MoveParams, type dataSources_PromoteParams as PromoteParams, type dataSources_RevectorizeParams as RevectorizeParams, type dataSources_RmParams as RmParams, type dataSources_RmWhereParams as RmWhereParams, type dataSources_SearchParams as SearchParams, type dataSources_SummarizedDocument as SummarizedDocument, type dataSources_WaitForCandidateParams as WaitForCandidateParams, type dataSources_WaitForCandidateResult as WaitForCandidateResult, type dataSources_WaitForIngestParams as WaitForIngestParams, type dataSources_WaitForIngestResult as WaitForIngestResult, type dataSources_WaitForMoveParams as WaitForMoveParams, type dataSources_WaitForMoveResult as WaitForMoveResult, dataSources_addDocument as addDocument, dataSources_allDocuments as allDocuments, dataSources_configGet as configGet, dataSources_configSet as configSet, create$1 as create, dataSources_deleteSource as deleteSource, dataSources_documents as documents, dataSources_drop as drop, list$8 as list, dataSources_move as move, dataSources_promote as promote, dataSources_revectorize as revectorize, dataSources_rm as rm, dataSources_rmWhere as rmWhere, dataSources_rmWhereAll as rmWhereAll, dataSources_search as search, dataSources_summarize as summarize, dataSources_waitForCandidate as waitForCandidate, dataSources_waitForIngest as waitForIngest, dataSources_waitForMove as waitForMove };
+}
+
+/**
+ * Bulk ingestion jobs: load a corpus into a data source from a file-store
+ * prefix or a manifest of URLs, with a plan (cost, size, duration) shown
+ * before anything is spent.
+ *
+ * Ops are pure (ctx, params) → typed result. The CLI skin in
+ * commands/dataSourceJobs.ts owns flags, progress printing and exit codes.
+ */
+
+/** @internal Consumed by the CLI skin. */
+declare const DEFAULT_WAIT_TIMEOUT_MS$2: number;
+interface StartParams {
+    /** Data source slug. Created on first use, like `add`. */
+    slug: string;
+    source: DataSourceJobSource;
+    /** Run as soon as the plan passes the gates, without a separate approve. */
+    approve?: boolean;
+    /** Stop when estimated spend reaches this; default 1.5× the projection. */
+    budgetDollars?: number;
+    /** Batches in flight at once (default 8, max 64). */
+    concurrency?: number;
+    /** Process only the first N objects — a sample of the corpus. */
+    limit?: number;
+}
+/**
+ * Start a job. The platform enumerates the source, reads a sample, and writes
+ * a plan; the job then waits in `planned` for `approve` unless `approve` was
+ * set. Nothing is embedded until it runs.
+ *
+ * @throws AdminApiError `data_source_busy` (422) — a move, a candidate
+ *   version or another job is in flight; `invalid_source` (400).
+ * @example
+ * const { job } = await admin.dataSourceJobs.start({
+ *   slug: 'archive',
+ *   source: { type: 'store', store: 'raw', access: 'private', prefix: '2024/' },
+ * });
+ */
+declare function start(ctx: AdminContext, params: StartParams): Promise<DataSourceJobResult>;
+interface UploadManifestParams {
+    slug: string;
+    /** JSONL: one `{ url, filename?, externalId?, metadata? }` per line. */
+    content: Buffer;
+}
+/**
+ * Upload a manifest for `start` with a `manifest` source. Returns the key to
+ * pass as `source.key`.
+ */
+declare function uploadManifest(ctx: AdminContext, params: UploadManifestParams): Promise<{
+    key: string;
+}>;
+interface ListParams$1 {
+    /** Only this source's jobs; omit for every job on the app. */
+    slug?: string;
+}
+declare function list$7(ctx: AdminContext, params?: ListParams$1): Promise<DataSourceJobsListResult>;
+interface JobIdParams {
+    id: string;
+}
+/** @throws AdminApiError `job_not_found` (404). */
+declare function get$7(ctx: AdminContext, params: JobIdParams): Promise<DataSourceJobGetResult>;
+/**
+ * Approve a planned job: the yes to the plan's spend. Refused when the
+ * projection does not fit the source's placement or the workspace cannot
+ * cover it.
+ *
+ * @throws AdminApiError `job_not_found` (404), `invalid_transition` (422),
+ *   `plan_requires_dedicated` (422), `plan_exceeds_capacity` (422),
+ *   `insufficient_credits` (402).
+ */
+declare function approve(ctx: AdminContext, params: JobIdParams): Promise<DataSourceJobResult>;
+/** Stop dispatching batches; the ones in flight finish. */
+declare function pause(ctx: AdminContext, params: JobIdParams): Promise<DataSourceJobResult>;
+/** Continue from the checkpoint; failed batches with attempts left are retried. */
+declare function resume$1(ctx: AdminContext, params: JobIdParams): Promise<DataSourceJobResult>;
+/** End the job. Documents already indexed stay. */
+declare function cancel(ctx: AdminContext, params: JobIdParams): Promise<DataSourceJobResult>;
+interface WaitParams$1 {
+    id: string;
+    /** Default one hour. */
+    timeoutMs?: number;
+    onProgress?: (message: string) => void;
+}
+type WaitResult = {
+    status: 'done';
+    job: DataSourceJob;
+}
+/** The plan is ready but the job will not run on its own: a gate refused, or it waits for approval. */
+ | {
+    status: 'planned';
+    job: DataSourceJob;
+    error: string;
+} | {
+    status: 'failed';
+    job: DataSourceJob;
+    error: string;
+} | {
+    status: 'timeout';
+    job: DataSourceJob;
+    error: string;
+};
+/**
+ * Poll until the job leaves `planning`: the plan is ready (`done`), or a gate
+ * refused it (`planned` with the job's error), or it could not be planned.
+ */
+declare function waitForPlan(ctx: AdminContext, params: WaitParams$1): Promise<WaitResult>;
+/**
+ * Poll until the job reaches a terminal state, pauses, or settles in `planned`
+ * with nothing about to move it: a gate refused an auto-approved plan, or the
+ * plan waits for an approval nobody asked this wait to give. A pause is
+ * reported as `failed` with the pause reason, since nothing more will happen
+ * without the owner.
+ */
+declare function waitForJob(ctx: AdminContext, params: WaitParams$1): Promise<WaitResult>;
+/** One line of progress in the job's own terms. */
+declare function describeProgress(job: DataSourceJob, start: number): string;
+
+type dataSourceJobs_JobIdParams = JobIdParams;
+type dataSourceJobs_StartParams = StartParams;
+type dataSourceJobs_UploadManifestParams = UploadManifestParams;
+type dataSourceJobs_WaitResult = WaitResult;
+declare const dataSourceJobs_approve: typeof approve;
+declare const dataSourceJobs_cancel: typeof cancel;
+declare const dataSourceJobs_describeProgress: typeof describeProgress;
+declare const dataSourceJobs_pause: typeof pause;
+declare const dataSourceJobs_start: typeof start;
+declare const dataSourceJobs_uploadManifest: typeof uploadManifest;
+declare const dataSourceJobs_waitForJob: typeof waitForJob;
+declare const dataSourceJobs_waitForPlan: typeof waitForPlan;
+declare namespace dataSourceJobs {
+  export { DEFAULT_WAIT_TIMEOUT_MS$2 as DEFAULT_WAIT_TIMEOUT_MS, type dataSourceJobs_JobIdParams as JobIdParams, type ListParams$1 as ListParams, type dataSourceJobs_StartParams as StartParams, type dataSourceJobs_UploadManifestParams as UploadManifestParams, type WaitParams$1 as WaitParams, type dataSourceJobs_WaitResult as WaitResult, dataSourceJobs_approve as approve, dataSourceJobs_cancel as cancel, dataSourceJobs_describeProgress as describeProgress, get$7 as get, list$7 as list, dataSourceJobs_pause as pause, resume$1 as resume, dataSourceJobs_start as start, dataSourceJobs_uploadManifest as uploadManifest, dataSourceJobs_waitForJob as waitForJob, dataSourceJobs_waitForPlan as waitForPlan };
+}
+
+/**
+ * S3 connectors: make a bucket the customer owns the origin of a data source,
+ * and keep the source in sync with it.
+ *
+ * Ops are pure (ctx, params) → typed result. The CLI skin in
+ * commands/dataSourceConnectors.ts owns flags, progress and exit codes.
+ */
+
+interface ConnectParams {
+    /** Data source slug. Created on first use, like `add`. */
+    slug: string;
+    bucket: string;
+    /** AWS region of the bucket, e.g. `us-east-1`. */
+    region: string;
+    /** Key prefix to follow; omit for the whole bucket. */
+    prefix?: string;
+    /** S3-compatible endpoint (https; http for localhost). Omit for AWS. */
+    endpoint?: string;
+    /** NAME of the app secret holding the access key id. */
+    accessKeyIdSecret: string;
+    /** NAME of the app secret holding the secret access key. */
+    secretAccessKeySecret: string;
+    /** Default `mirror`. */
+    deletions?: DataSourceConnectorDeletions;
+    /** Ceiling a sync auto-approves under. */
+    budgetDollarsPerSync?: number;
+}
+/**
+ * Connect a source to a bucket. The two secrets must already exist on the app
+ * (`secrets set`), and the keys must be able to list the prefix — both are
+ * checked before anything is recorded. Calling again with the same bucket,
+ * region, prefix and endpoint updates credentials and policy in place; a
+ * different origin is refused until the source is disconnected.
+ *
+ * @throws AdminApiError `invalid_connector` (400), `connector_secret_missing`
+ *   (422), `connector_probe_failed` (422), `connector_exists` (422).
+ * @example
+ * await admin.dataSourceConnectors.connect({
+ *   slug: 'archive', bucket: 'acme-docs', region: 'us-east-1', prefix: 'contracts/',
+ *   accessKeyIdSecret: 'ARCHIVE_S3_KEY', secretAccessKeySecret: 'ARCHIVE_S3_SECRET',
+ * });
+ */
+declare function connect(ctx: AdminContext, params: ConnectParams): Promise<DataSourceConnectorResult>;
+/** The source's connector with its object counts, or `connector: null`. */
+declare function get$6(ctx: AdminContext, params: {
+    slug: string;
+}): Promise<DataSourceConnectorGetResult>;
+/**
+ * Stop following the bucket. The documents stay; only the connector and its
+ * object index go.
+ *
+ * @throws AdminApiError `connector_not_found` (422), `data_source_busy` (422)
+ *   while a job is in flight.
+ */
+declare function disconnect(ctx: AdminContext, params: {
+    slug: string;
+}): Promise<DataSourceConnectorResult & {
+    removed: true;
+}>;
+interface SyncParams {
+    slug: string;
+    /** Override the connector's per-sync budget for this run, in dollars. */
+    budgetDollars?: number;
+}
+/**
+ * Start a sync: list the bucket, diff by ETag, run a job over what changed.
+ * Auto-approved under the connector's per-sync budget; a plan over it (or over
+ * the placement's capacity) waits in `planned` for `dataSourceJobs.approve`.
+ * Block on the result with `dataSourceJobs.waitForJob`.
+ *
+ * @throws AdminApiError `connector_not_found` (422), `data_source_busy` (422).
+ */
+declare function sync(ctx: AdminContext, params: SyncParams): Promise<DataSourceSyncResult>;
+
+type dataSourceConnectors_ConnectParams = ConnectParams;
+type dataSourceConnectors_SyncParams = SyncParams;
+declare const dataSourceConnectors_connect: typeof connect;
+declare const dataSourceConnectors_disconnect: typeof disconnect;
+declare const dataSourceConnectors_sync: typeof sync;
+declare namespace dataSourceConnectors {
+  export { type dataSourceConnectors_ConnectParams as ConnectParams, type dataSourceConnectors_SyncParams as SyncParams, dataSourceConnectors_connect as connect, dataSourceConnectors_disconnect as disconnect, get$6 as get, dataSourceConnectors_sync as sync };
+}
+
+/**
+ * Warming an index, sampling a source, and retrieval evals: query sets, runs,
+ * comparisons. Ops are pure (ctx, params) → typed result; the CLI skin in
+ * commands/dataSourceEvals.ts owns flags, progress printing and exit codes.
+ */
+
+/** @internal Consumed by the CLI skin. */
+declare const DEFAULT_WAIT_TIMEOUT_MS$1: number;
+/**
+ * Warm a source's index if it is cold. A search on a large cold index answers
+ * `index_warming` until the reload lands; call this before a demo, or after an
+ * eviction you know about. Answers `resident: true` when nothing was needed.
+ */
+declare function hydrate(ctx: AdminContext, params: {
+    slug: string;
+}): Promise<DataSourcesHydrateResult>;
+interface WaitForHydrationParams {
+    slug: string;
+    timeoutMs?: number;
+    onProgress?: (message: string) => void;
+}
+type WaitForHydrationResult = {
+    status: 'done';
+    source: DataSourcesListEntry;
+} | {
+    status: 'failed';
+    source: DataSourcesListEntry;
+    error: string;
+} | {
+    status: 'timeout';
+    source: DataSourcesListEntry;
+    error: string;
+};
+/** Poll the source list until its `hydration` clears, fails, or the timeout elapses. */
+declare function waitForHydration(ctx: AdminContext, params: WaitForHydrationParams): Promise<WaitForHydrationResult>;
+interface SampleParams {
+    /** The source to draw from. */
+    slug: string;
+    /** Documents to draw (at most 2,000). */
+    size: number;
+    /** Slug for the sample; default `<slug>-sample`. */
+    as?: string;
+    /** Scope the draw: metadata equality, or the full document selector. */
+    filter?: Record<string, unknown>;
+    /** Metadata key to stratify on, proportional per value. */
+    stratify?: string;
+    placement?: {
+        resourceId: string;
+    } | 'shared';
+}
+/**
+ * Draw a sample of a source into a new source with the same pinned config.
+ * The copy is a job (auto-approved; extraction is reused by content hash, so
+ * the plan is chunk + embed only). Documents keep their content hashes, which
+ * is what lets an eval set built on the sample score the parent too.
+ *
+ * @throws AdminApiError `invalid_size` (400), `slug_in_use` (422),
+ *   `data_source_limit` (422), `data_source_busy` (422).
+ */
+declare function sample(ctx: AdminContext, params: SampleParams): Promise<DataSourcesSampleResult>;
+interface CreateSetParams {
+    slug: string;
+    /** Lowercase [a-z0-9_-], unique per source. */
+    name: string;
+    description?: string;
+    /** Queries to generate from the corpus; 0 (default) makes an empty set to add to. */
+    size?: number;
+    /** `cloze` (default, free) or `question` (a chat model writes them). */
+    style?: EvalQueryStyle;
+    /** Chat model for `question`; default the source's contextual model or the platform's. */
+    modelId?: string;
+    tags?: string[];
+    /** Makes generation reproducible; default the current time. */
+    seed?: number;
+}
+/**
+ * Create a query set, generating queries from the corpus when `size` is set.
+ * Generation runs in the background; the set is `generating` until it is
+ * `ready` (see `waitForSet`).
+ *
+ * @throws AdminApiError `eval_set_exists` (422), `invalid_name` (400).
+ */
+declare function createSet(ctx: AdminContext, params: CreateSetParams): Promise<EvalSetResult>;
+declare function listSets(ctx: AdminContext, params?: {
+    slug?: string;
+}): Promise<EvalSetsListResult>;
+declare function getSet(ctx: AdminContext, params: {
+    id: string;
+    queries?: boolean;
+}): Promise<EvalSetGetResult>;
+declare function deleteSet(ctx: AdminContext, params: {
+    id: string;
+}): Promise<{
+    deleted: true;
+    set: EvalSet;
+}>;
+interface QueryInput {
+    query: string;
+    /** Which documents should come back; each reference must exist on the set's source. */
+    expect: {
+        documentIds?: string[];
+        filenames?: string[];
+        externalIds?: string[];
+        contentHashes?: string[];
+    };
+    passage?: string;
+    tags?: string[];
+}
+/**
+ * Add hand-written queries (≤ 500 per call). Every reference is resolved
+ * before anything is written; an unknown filename refuses the whole call by
+ * name (`expected_document_not_found`).
+ */
+declare function addQueries(ctx: AdminContext, params: {
+    id: string;
+    queries: QueryInput[];
+}): Promise<EvalQueriesAddResult>;
+declare function listQueries(ctx: AdminContext, params: {
+    id: string;
+}): Promise<EvalQueriesListResult>;
+declare function deleteQuery(ctx: AdminContext, params: {
+    id: string;
+    queryId: string;
+}): Promise<{
+    deleted: string;
+    queryCount: number;
+}>;
+interface RunParams {
+    setId: string;
+    /** Target source; default the set's own. Expectations resolve by content hash. */
+    slug?: string;
+    /** Evaluate the target's candidate version instead of the active one. */
+    candidate?: boolean;
+    label?: string;
+    retrieval?: EvalRetrieval;
+}
+/**
+ * Score a set against a target. Runs in the background; block with
+ * `waitForRun`. Each query is a real search (embedding + rerank spend).
+ *
+ * @throws AdminApiError `eval_set_not_ready` (422), `eval_set_empty` (422),
+ *   `no_candidate_pipeline` (404), `invalid_retrieval` (400).
+ */
+declare function run(ctx: AdminContext, params: RunParams): Promise<EvalRunResult>;
+declare function listRuns(ctx: AdminContext, params?: {
+    setId?: string;
+    slug?: string;
+}): Promise<EvalRunsListResult>;
+declare function getRun$1(ctx: AdminContext, params: {
+    id: string;
+    queries?: boolean;
+    worst?: number;
+}): Promise<EvalRunResult>;
+/** Two runs side by side: aggregate deltas, and per-query wins/losses when they share a set. */
+declare function compare(ctx: AdminContext, params: {
+    a: string;
+    b: string;
+}): Promise<EvalCompareResult>;
+interface WaitParams {
+    id: string;
+    timeoutMs?: number;
+    onProgress?: (message: string) => void;
+}
+type WaitForRunResult = {
+    status: 'done';
+    run: EvalRun;
+} | {
+    status: 'failed';
+    run: EvalRun;
+    error: string;
+} | {
+    status: 'timeout';
+    run: EvalRun;
+    error: string;
+};
+declare function waitForRun(ctx: AdminContext, params: WaitParams): Promise<WaitForRunResult>;
+type WaitForSetResult = {
+    status: 'done';
+    set: EvalSet;
+} | {
+    status: 'failed';
+    set: EvalSet;
+    error: string;
+} | {
+    status: 'timeout';
+    set: EvalSet;
+    error: string;
+};
+/** Poll until generation lands (`ready`) or fails; a set waits `queued` for a worker first. */
+declare function waitForSet(ctx: AdminContext, params: WaitParams): Promise<WaitForSetResult>;
+
+type dataSourceEvals_CreateSetParams = CreateSetParams;
+type dataSourceEvals_QueryInput = QueryInput;
+type dataSourceEvals_RunParams = RunParams;
+type dataSourceEvals_SampleParams = SampleParams;
+type dataSourceEvals_WaitForHydrationParams = WaitForHydrationParams;
+type dataSourceEvals_WaitForHydrationResult = WaitForHydrationResult;
+type dataSourceEvals_WaitForRunResult = WaitForRunResult;
+type dataSourceEvals_WaitForSetResult = WaitForSetResult;
+type dataSourceEvals_WaitParams = WaitParams;
+declare const dataSourceEvals_addQueries: typeof addQueries;
+declare const dataSourceEvals_compare: typeof compare;
+declare const dataSourceEvals_createSet: typeof createSet;
+declare const dataSourceEvals_deleteQuery: typeof deleteQuery;
+declare const dataSourceEvals_deleteSet: typeof deleteSet;
+declare const dataSourceEvals_getSet: typeof getSet;
+declare const dataSourceEvals_hydrate: typeof hydrate;
+declare const dataSourceEvals_listQueries: typeof listQueries;
+declare const dataSourceEvals_listRuns: typeof listRuns;
+declare const dataSourceEvals_listSets: typeof listSets;
+declare const dataSourceEvals_run: typeof run;
+declare const dataSourceEvals_sample: typeof sample;
+declare const dataSourceEvals_waitForHydration: typeof waitForHydration;
+declare const dataSourceEvals_waitForRun: typeof waitForRun;
+declare const dataSourceEvals_waitForSet: typeof waitForSet;
+declare namespace dataSourceEvals {
+  export { type dataSourceEvals_CreateSetParams as CreateSetParams, DEFAULT_WAIT_TIMEOUT_MS$1 as DEFAULT_WAIT_TIMEOUT_MS, type dataSourceEvals_QueryInput as QueryInput, type dataSourceEvals_RunParams as RunParams, type dataSourceEvals_SampleParams as SampleParams, type dataSourceEvals_WaitForHydrationParams as WaitForHydrationParams, type dataSourceEvals_WaitForHydrationResult as WaitForHydrationResult, type dataSourceEvals_WaitForRunResult as WaitForRunResult, type dataSourceEvals_WaitForSetResult as WaitForSetResult, type dataSourceEvals_WaitParams as WaitParams, dataSourceEvals_addQueries as addQueries, dataSourceEvals_compare as compare, dataSourceEvals_createSet as createSet, dataSourceEvals_deleteQuery as deleteQuery, dataSourceEvals_deleteSet as deleteSet, getRun$1 as getRun, dataSourceEvals_getSet as getSet, dataSourceEvals_hydrate as hydrate, dataSourceEvals_listQueries as listQueries, dataSourceEvals_listRuns as listRuns, dataSourceEvals_listSets as listSets, dataSourceEvals_run as run, dataSourceEvals_sample as sample, dataSourceEvals_waitForHydration as waitForHydration, dataSourceEvals_waitForRun as waitForRun, dataSourceEvals_waitForSet as waitForSet };
+}
+
+/**
+ * Data-source mappers: the loop around customer code that turns raw objects
+ * into documents — inspect the objects, test the mapper, remap after a fix,
+ * read and replay what a job quarantined.
+ *
+ * Ops are pure (ctx, params) → typed result. The CLI skin in
+ * commands/dataSourceMappers.ts owns flags, progress and exit codes.
+ */
+
+/** Which objects to look at: a prefix of an app file store, or the connected bucket. */
+type ObjectSelection = {
+    store: string;
+    access?: 'private' | 'public';
+    prefix?: string;
+} | {
+    connector: true;
+};
+interface InspectParams {
+    /** Required for a connector selection; optional for a store. */
+    slug?: string;
+    selection: ObjectSelection;
+    /** Only these keys. */
+    keys?: string[];
+    /** Objects to list (default 5,000, max 50,000). */
+    limit?: number;
+}
+/**
+ * Profile raw objects before writing a mapper: counts and bytes by extension
+ * and by key shape, size buckets, and ten sampled heads with their JSON key
+ * signatures. Read-only.
+ *
+ * @throws AdminApiError `invalid_source` (400), `connector_not_found` (422).
+ */
+declare function inspect(ctx: AdminContext, params: InspectParams): Promise<DataSourceInspectResult>;
+interface MapTestParams {
+    slug: string;
+    selection: ObjectSelection;
+    keys?: string[];
+    /** Objects to map (default 20, max 200). */
+    limit?: number;
+    /** Run the LOCAL mapper through the app's dev session instead of the live bundle. */
+    dev?: boolean;
+}
+/**
+ * Run the source's mapper over real objects and return the outcomes — nothing
+ * is ingested. With `dev` the mapper runs from local source through the
+ * running dev session, which is how a mapper is checked before a deploy.
+ *
+ * @throws AdminApiError `no_mapper` (422), `no_dev_session` (422),
+ *   `invalid_source` (400).
+ */
+declare function mapTest(ctx: AdminContext, params: MapTestParams): Promise<DataSourceMapTestResult>;
+interface RemapParams {
+    slug: string;
+    /** Pause when estimated spend reaches this; default the plan's headroom. */
+    budgetDollars?: number;
+    /** Only the first N raw objects. */
+    limit?: number;
+}
+/**
+ * Run the live mapper over every raw object the source holds a copy of.
+ * Auto-approved: unchanged markdown is skipped by hash, so a remap after a
+ * metadata tweak costs frames and little else. Block on the job with
+ * `dataSourceJobs.waitForJob`.
+ *
+ * @throws AdminApiError `no_mapper` (422), `nothing_to_remap` (422),
+ *   `data_source_busy` (422).
+ */
+declare function remap(ctx: AdminContext, params: RemapParams): Promise<DataSourceRemapResult>;
+interface QuarantineParams {
+    id: string;
+    kind?: 'skip' | 'error';
+    /** Only objects quarantined with exactly this reason. */
+    reason?: string;
+    cursor?: string;
+    /** Page size (default 100, max 1,000). */
+    limit?: number;
+}
+/**
+ * What a job's mapper skipped or failed on: counts, reasons by frequency, and
+ * a page of objects.
+ *
+ * @throws AdminApiError `job_not_found` (404).
+ */
+declare function quarantine(ctx: AdminContext, params: QuarantineParams): Promise<DataSourceQuarantineResult>;
+interface ReplayParams {
+    id: string;
+    kind?: 'skip' | 'error';
+}
+/**
+ * Run a job's quarantined objects through the current mapper, from their raw
+ * copies. Starts a job; block on it with `dataSourceJobs.waitForJob`.
+ *
+ * @throws AdminApiError `nothing_to_replay` (422), `no_mapper` (422),
+ *   `data_source_busy` (422).
+ */
+declare function replay(ctx: AdminContext, params: ReplayParams): Promise<DataSourceRemapResult>;
+
+type dataSourceMappers_InspectParams = InspectParams;
+type dataSourceMappers_MapTestParams = MapTestParams;
+type dataSourceMappers_ObjectSelection = ObjectSelection;
+type dataSourceMappers_QuarantineParams = QuarantineParams;
+type dataSourceMappers_RemapParams = RemapParams;
+type dataSourceMappers_ReplayParams = ReplayParams;
+declare const dataSourceMappers_inspect: typeof inspect;
+declare const dataSourceMappers_mapTest: typeof mapTest;
+declare const dataSourceMappers_quarantine: typeof quarantine;
+declare const dataSourceMappers_remap: typeof remap;
+declare const dataSourceMappers_replay: typeof replay;
+declare namespace dataSourceMappers {
+  export { type dataSourceMappers_InspectParams as InspectParams, type dataSourceMappers_MapTestParams as MapTestParams, type dataSourceMappers_ObjectSelection as ObjectSelection, type dataSourceMappers_QuarantineParams as QuarantineParams, type dataSourceMappers_RemapParams as RemapParams, type dataSourceMappers_ReplayParams as ReplayParams, dataSourceMappers_inspect as inspect, dataSourceMappers_mapTest as mapTest, dataSourceMappers_quarantine as quarantine, dataSourceMappers_remap as remap, dataSourceMappers_replay as replay };
 }
 
 /**
@@ -3076,9 +4439,15 @@ interface InfraResource {
     health: InfraHealth | null;
     /**
      * What the instance is doing right now, while a transition is under way
-     * ("Waiting for capacity", "Snapshotting ds_x (1/2)"); null when nothing is.
+     * ("Waiting for capacity", "Snapshotting collection 1/2"); null when nothing is.
      */
     detail: string | null;
+    /**
+     * The size this resource is being resized to, while a resize is under way;
+     * null otherwise. A resize passes through `hibernated` and back to the phase
+     * it started from.
+     */
+    resizingTo: InfraOffering | null;
     /** When the last verified snapshot was taken; null if never. */
     lastSnapshotAt: string | null;
     activatedAt: string | null;
@@ -3114,7 +4483,7 @@ interface InfraGetResult {
         name: string | null;
     }[];
 }
-/** POST /infra, /infra/:id/{hibernate,resume,destroy,rename} */
+/** POST /infra, /infra/:id/{hibernate,resume,destroy,rename,resize} */
 interface InfraResourceResult {
     resource: InfraResource;
 }
@@ -3191,13 +4560,39 @@ declare function hibernate(ctx: AdminContext, params: ResourceIdParams): Promise
 declare function resume(ctx: AdminContext, params: ResourceIdParams): Promise<InfraResourceResult>;
 /**
  * Delete a resource. Refused while any data source is placed on it — move
- * those to shared capacity (`datasources config --placement shared`) or
- * delete them first. Billing stops when the phase reaches `destroyed`.
+ * those to shared capacity (`admin.dataSources.move({ placement: 'shared' })`,
+ * data intact) or delete them first. Billing stops when the phase reaches
+ * `destroyed`.
  *
  * @throws AdminApiError `resource_not_found` (404),
  *   `resource_has_attachments` (422), `invalid_transition` (422).
  */
 declare function destroy(ctx: AdminContext, params: ResourceIdParams): Promise<InfraResourceResult>;
+interface ResizeParams {
+    id: string;
+    /** Offering id from `list().offerings`, e.g. `retrieval.medium`. */
+    offeringId: string;
+}
+/**
+ * Change a resource's size, keeping its data.
+ *
+ * The platform parks the resource (a fresh snapshot), swaps its spec, and
+ * brings it back up restored from that snapshot, so a resize passes through
+ * `hibernated` and searches on its sources pause for the few minutes it
+ * takes. A resource that is already hibernated swaps in place and stays
+ * parked. Growing is gated on a month of credits at the new rate like a
+ * provision; shrinking is refused below what the resource holds. The response
+ * carries `resizingTo` until the swap has happened; `waitForPhase` with
+ * `until: (r) => r.resizingTo === null` blocks on the whole thing.
+ *
+ * @throws AdminApiError `resource_not_found` (404), `offering_not_found`
+ *   (400), `offering_retired` (422), `same_offering` (400),
+ *   `offering_kind_mismatch` (400), `resize_pending` (422), `resize_too_small`
+ *   (422), `insufficient_credits` (402), `invalid_transition` (422).
+ * @example
+ * await admin.infra.resize({ id, offeringId: 'retrieval.medium' });
+ */
+declare function resize(ctx: AdminContext, params: ResizeParams): Promise<InfraResourceResult>;
 interface RenameParams {
     id: string;
     name: string;
@@ -3208,6 +4603,11 @@ interface WaitForPhaseParams {
     id: string;
     /** The phase(s) that count as done. */
     phases: InfraPhase[];
+    /**
+     * An extra condition on top of the phase — a resize, for one, ends in the
+     * phase it started from and is done only once `resizingTo` has cleared.
+     */
+    until?: (resource: InfraResource) => boolean;
     /** Default 10 minutes. */
     timeoutMs?: number;
     onProgress?: (message: string) => void;
@@ -3238,6 +4638,7 @@ type infra_GetParams = GetParams;
 type infra_ListParams = ListParams;
 type infra_ProvisionParams = ProvisionParams;
 type infra_RenameParams = RenameParams;
+type infra_ResizeParams = ResizeParams;
 type infra_ResourceIdParams = ResourceIdParams;
 type infra_WaitForPhaseParams = WaitForPhaseParams;
 type infra_WaitForPhaseResult = WaitForPhaseResult;
@@ -3245,10 +4646,11 @@ declare const infra_destroy: typeof destroy;
 declare const infra_hibernate: typeof hibernate;
 declare const infra_provision: typeof provision;
 declare const infra_rename: typeof rename;
+declare const infra_resize: typeof resize;
 declare const infra_resume: typeof resume;
 declare const infra_waitForPhase: typeof waitForPhase;
 declare namespace infra {
-  export { infra_DEFAULT_WAIT_TIMEOUT_MS as DEFAULT_WAIT_TIMEOUT_MS, type infra_GetParams as GetParams, type infra_ListParams as ListParams, type infra_ProvisionParams as ProvisionParams, type infra_RenameParams as RenameParams, type infra_ResourceIdParams as ResourceIdParams, type infra_WaitForPhaseParams as WaitForPhaseParams, type infra_WaitForPhaseResult as WaitForPhaseResult, infra_destroy as destroy, get$4 as get, infra_hibernate as hibernate, list$6 as list, infra_provision as provision, infra_rename as rename, infra_resume as resume, infra_waitForPhase as waitForPhase };
+  export { infra_DEFAULT_WAIT_TIMEOUT_MS as DEFAULT_WAIT_TIMEOUT_MS, type infra_GetParams as GetParams, type infra_ListParams as ListParams, type infra_ProvisionParams as ProvisionParams, type infra_RenameParams as RenameParams, type infra_ResizeParams as ResizeParams, type infra_ResourceIdParams as ResourceIdParams, type infra_WaitForPhaseParams as WaitForPhaseParams, type infra_WaitForPhaseResult as WaitForPhaseResult, infra_destroy as destroy, get$4 as get, infra_hibernate as hibernate, list$6 as list, infra_provision as provision, infra_rename as rename, infra_resize as resize, infra_resume as resume, infra_waitForPhase as waitForPhase };
 }
 
 /**
@@ -5701,6 +7103,10 @@ declare function buildClient(ctx: AdminContext): {
     cron: BoundOps<typeof cron>;
     data: BoundOps<typeof data>;
     dataSources: BoundOps<typeof dataSources>;
+    dataSourceJobs: BoundOps<typeof dataSourceJobs>;
+    dataSourceConnectors: BoundOps<typeof dataSourceConnectors>;
+    dataSourceEvals: BoundOps<typeof dataSourceEvals>;
+    dataSourceMappers: BoundOps<typeof dataSourceMappers>;
     db: BoundOps<typeof db>;
     diagnostics: BoundOps<typeof diagnostics>;
     domains: BoundOps<typeof domains>;
@@ -5777,4 +7183,4 @@ declare class AdminTimeoutError extends Error {
 
 declare const admin: AdminClient;
 
-export { AdminApiError, type AdminClient, type AdminClientOptions, type AdminContext, AdminTimeoutError, type AgentThreadDetail, type AgentThreadListItem, type AgentThreadsGetResult, type AgentThreadsListResult, type AgentToolCall, type AgentTranscriptMessage, type AgentTurnError, type AnalyticsAiHostRow, type AnalyticsAiSourcesResult, type AnalyticsAiVendorRow, type AnalyticsBatchResult, type AnalyticsCrawlersOverviewResult, type AnalyticsCrawlersRecentResult, type AnalyticsCrawlersRecentRow, type AnalyticsCrawlersResult, type AnalyticsCrawlersTimeseriesBucket, type AnalyticsCrawlersTimeseriesResult, type AnalyticsLiveResult, type AnalyticsMapPoint, type AnalyticsMapResult, type AnalyticsMetric, type AnalyticsQueryResult, type AnalyticsQueryResultRow, type AnalyticsSourceRow, type AnalyticsSourcesResult, type AppCronJobStatus, type AppCronJobStatusReason, type AppCronRunState, type AppEmailSuppression, type AppSecretRow, type CrashGroup, type CrashOccurrenceRow, type CrashesGetResult, type CrashesListResult, type CrashesOccurrencesResult, type CrashesStatsBucket, type CrashesStatsResult, type CronJobDecorated, type CronOverviewResult, type CronRunResult, type CronRunSummary, type DashboardLiveRelease, type DashboardReleaseMethod, type DashboardResult, type DataLiftFromDevResult, type DataLiftFromLiveResult, type DataSourcesBuildProgress, type DataSourcesChunkingConfig, type DataSourcesChunkingStrategy, type DataSourcesConfigResult, type DataSourcesConfigUpdateResult, type DataSourcesCreateResult, type DataSourcesDeleteResult, type DataSourcesDocument, type DataSourcesDocumentConfirmResult, type DataSourcesDocumentDeleteResult, type DataSourcesDocumentStatus, type DataSourcesDocumentsResult, type DataSourcesDropResult, type DataSourcesIngestConfig, type DataSourcesIngestUpdate, type DataSourcesListEntry, type DataSourcesListResult, type DataSourcesPlacement, type DataSourcesPromoteResult, type DataSourcesRetrievalConfig, type DataSourcesRetrievalUpdate, type DataSourcesRevectorizeResult, type DataSourcesSearchCitation, type DataSourcesSearchResult, type DataSourcesSearchResultItem, type DataSourcesUploadTokenResult, type DatasetFile, type DbQueryResult, type DiagnosticsAuditEnvironment, type DiagnosticsDashboardResult, type DiagnosticsFinding, type DiagnosticsLighthouseScores, type DiagnosticsPayload, type DiagnosticsReleaseResult, type DiagnosticsRuntimeFindings, type DomainsCheckResult, type DomainsCustomAddResult, type DomainsCustomCheckResult, type DomainsCustomHostnameUiStatus, type DomainsCustomHostnameView, type DomainsCustomListResult, type DomainsCustomRemoveResult, type DomainsCustomRetryResult, type DomainsDnsInstructions, type DomainsGetResult, type DomainsSetResult, type EmailBatchLifecycle, type EmailBatchResult, type EmailBatchSummary, type EmailBatchesResult, type EmailDomainBase, type EmailEffectiveSender, type EmailInboxResult, type EmailListResult, type EmailMessageKind, type EmailMessageResult, type EmailMessageStatus, type EmailSenderTier, type EmailSendingStatusResult, type EmailStatsResult, type EmailSummary, type EmailSuppressResult, type EmailSuppressionsResult, type EmailUnsuppressResult, type EventChannelActivity, type EventsChannelsListResult, type EventsPublishResult, type EventsTailFrame, type FilesDeleteResult, type FilesFileMeta, type FilesListEntry, type FilesListResult, type FilesLsResult, type FilesScanBadge, type FilesScanFlagged, type FilesScanStore, type FilesStatResult, type FilesStoreSummaryEntry, type FilesUploadUrlResult, type FilesUrlResult, type FrontendErrorType, type InboundDnsInstructions, type InboundEmailDomainAddResult, type InboundEmailDomainCheckResult, type InboundEmailDomainDeleteResult, type InboundEmailDomainUiStatus, type InboundEmailDomainVerifyResult, type InboundEmailDomainView, type InboundEmailDomainsListResult, type InboxEmailPreview, type IssueAuthorKind, type IssueCommentRow, type IssueEventType, type IssueKind, type IssueRow, type IssueStatus, type IssuesCommentResult, type IssuesCreateResult, type IssuesDeleteResult, type IssuesGetResult, type IssuesListResult, type IssuesUpdateResult, type JewelPairRow, type JewelPairSummaryRow, type JewelVerdict, type JewelsDatasetSummary, type JewelsDryrunResult, type JewelsExportResult, type JewelsGradeResult, type JewelsGrading, type JewelsOverviewResult, type JewelsPairResult, type JewelsPairsResult, type JewelsQueueResult, type JewelsResolveResult, type JewelsRunResult, type JewelsRunsResult, type JewelsTimeseriesBucket, type JewelsTimeseriesResult, type JewelsTrainResult, type LiftedDatabase, type MethodsInvokeResult, type OutboundDnsInstructions, type OutboundEmailDomainAddResult, type OutboundEmailDomainCheckResult, type OutboundEmailDomainDeleteResult, type OutboundEmailDomainUiStatus, type OutboundEmailDomainVerifyResult, type OutboundEmailDomainView, type OutboundEmailDomainsListResult, type PlatformSuppression, type PrerenderGetResult, type PrerenderInvalidateResult, type PrerenderPage, type PrerenderPagesResult, type PrerenderViewResult, type ReleaseFailureFields, type ReleaseFragment, type ReleasesByCommitResult, type ReleasesGetResult, type ReleasesListResult, type RequestsGetResult, type RequestsListResult, type RequestsListRow, type RequestsStatsMethodBucket, type RequestsStatsMethodResult, type RequestsStatsSummaryBucket, type RequestsStatsSummaryResult, type SecretsDeleteResult, type SecretsGetResult, type SecretsListResult, type SecretsSetResult, type SettingsResult, type SuppressionSource, type TrainingLogEntry, type TrainingRunRow, type TrainingRunStatus, type UserAuthProvider, type UserListItem, type UserRecord, type UsersCreateApiKeyResult, type UsersListResult, type UsersRevokeApiKeyResult, type UsersSetRoleResult, type V2AppSettings, type V2BuildLogEntry, type V2BuildStats, type V2CommitInfo, type V2EmailMessage, type V2ReleaseStatus, type VoiceAvailableNumber, type VoiceNumbersBuyResult, type VoiceNumbersListResult, type VoiceNumbersReleaseResult, type VoiceNumbersSearchResult, type VoiceNumbersSetNameResult, type VoicePhoneNumberStatus, type VoicePhoneNumberView, type VoiceResolvedPolicy, type VoiceSessionChannel, type VoiceSessionCost, type VoiceSessionCostLine, type VoiceSessionDetail, type VoiceSessionGetResult, type VoiceSessionListItem, type VoiceSessionSip, type VoiceSessionSpeechEntry, type VoiceSessionStatus, type VoiceSessionToolEntry, type VoiceSessionTranscriptEntry, type VoiceSessionsListResult, type VoiceSettingsCeilings, type VoiceSettingsGetResult, type VoiceSettingsOverrides, type VoiceSettingsSetResult, admin, createAdminClient, admin as default };
+export { AdminApiError, type AdminClient, type AdminClientOptions, type AdminContext, AdminTimeoutError, type AgentThreadDetail, type AgentThreadListItem, type AgentThreadsGetResult, type AgentThreadsListResult, type AgentToolCall, type AgentTranscriptMessage, type AgentTurnError, type AnalyticsAiHostRow, type AnalyticsAiSourcesResult, type AnalyticsAiVendorRow, type AnalyticsBatchResult, type AnalyticsCrawlersOverviewResult, type AnalyticsCrawlersRecentResult, type AnalyticsCrawlersRecentRow, type AnalyticsCrawlersResult, type AnalyticsCrawlersTimeseriesBucket, type AnalyticsCrawlersTimeseriesResult, type AnalyticsLiveResult, type AnalyticsMapPoint, type AnalyticsMapResult, type AnalyticsMetric, type AnalyticsQueryResult, type AnalyticsQueryResultRow, type AnalyticsSourceRow, type AnalyticsSourcesResult, type AppCronJobStatus, type AppCronJobStatusReason, type AppCronRunState, type AppEmailSuppression, type AppSecretRow, type CrashGroup, type CrashOccurrenceRow, type CrashesGetResult, type CrashesListResult, type CrashesOccurrencesResult, type CrashesStatsBucket, type CrashesStatsResult, type CronJobDecorated, type CronOverviewResult, type CronRunResult, type CronRunSummary, type DashboardLiveRelease, type DashboardReleaseMethod, type DashboardResult, type DataLiftFromDevResult, type DataLiftFromLiveResult, type DataSourceConnector, type DataSourceConnectorCredentials, type DataSourceConnectorDeletions, type DataSourceConnectorGetResult, type DataSourceConnectorPolicy, type DataSourceConnectorResult, type DataSourceInspectReport, type DataSourceInspectResult, type DataSourceJob, type DataSourceJobGetResult, type DataSourceJobManifestTokenResult, type DataSourceJobPlan, type DataSourceJobResult, type DataSourceJobSource, type DataSourceJobState, type DataSourceJobsListResult, type DataSourceMapTestDocument, type DataSourceMapTestOutcome, type DataSourceMapTestResult, type DataSourceMapper, type DataSourceObjectSelection, type DataSourceQuarantineResult, type DataSourceQuarantinedObject, type DataSourceRemapResult, type DataSourceSyncResult, type DataSourcesBuildProgress, type DataSourcesChunkingConfig, type DataSourcesChunkingStrategy, type DataSourcesConfigResult, type DataSourcesConfigUpdateResult, type DataSourcesCreateResult, type DataSourcesDeleteResult, type DataSourcesDocument, type DataSourcesDocumentConfirmResult, type DataSourcesDocumentDeleteManyResult, type DataSourcesDocumentDeleteResult, type DataSourcesDocumentSelector, type DataSourcesDocumentStatus, type DataSourcesDocumentsResult, type DataSourcesDropResult, type DataSourcesHydrateResult, type DataSourcesHydration, type DataSourcesIngestConfig, type DataSourcesIngestUpdate, type DataSourcesListEntry, type DataSourcesListResult, type DataSourcesMigration, type DataSourcesMoveResult, type DataSourcesPlacement, type DataSourcesPromoteResult, type DataSourcesRetrievalConfig, type DataSourcesRetrievalUpdate, type DataSourcesRevectorizeResult, type DataSourcesSampleResult, type DataSourcesSearchCitation, type DataSourcesSearchResult, type DataSourcesSearchResultItem, type DataSourcesUploadTokenResult, type DatasetFile, type DbQueryResult, type DiagnosticsAuditEnvironment, type DiagnosticsDashboardResult, type DiagnosticsFinding, type DiagnosticsLighthouseScores, type DiagnosticsPayload, type DiagnosticsReleaseResult, type DiagnosticsRuntimeFindings, type DomainsCheckResult, type DomainsCustomAddResult, type DomainsCustomCheckResult, type DomainsCustomHostnameUiStatus, type DomainsCustomHostnameView, type DomainsCustomListResult, type DomainsCustomRemoveResult, type DomainsCustomRetryResult, type DomainsDnsInstructions, type DomainsGetResult, type DomainsSetResult, type EmailBatchLifecycle, type EmailBatchResult, type EmailBatchSummary, type EmailBatchesResult, type EmailDomainBase, type EmailEffectiveSender, type EmailInboxResult, type EmailListResult, type EmailMessageKind, type EmailMessageResult, type EmailMessageStatus, type EmailSenderTier, type EmailSendingStatusResult, type EmailStatsResult, type EmailSummary, type EmailSuppressResult, type EmailSuppressionsResult, type EmailUnsuppressResult, type EvalAggregates, type EvalCompareResult, type EvalExpectation, type EvalQueriesAddResult, type EvalQueriesListResult, type EvalQuery, type EvalQueryResult, type EvalQueryStyle, type EvalRetrieval, type EvalRun, type EvalRunResult, type EvalRunState, type EvalRunsListResult, type EvalSet, type EvalSetGetResult, type EvalSetResult, type EvalSetState, type EvalSetsListResult, type EventChannelActivity, type EventsChannelsListResult, type EventsPublishResult, type EventsTailFrame, type FilesDeleteResult, type FilesFileMeta, type FilesListEntry, type FilesListResult, type FilesLsResult, type FilesScanBadge, type FilesScanFlagged, type FilesScanStore, type FilesStatResult, type FilesStoreSummaryEntry, type FilesUploadUrlResult, type FilesUrlResult, type FrontendErrorType, type InboundDnsInstructions, type InboundEmailDomainAddResult, type InboundEmailDomainCheckResult, type InboundEmailDomainDeleteResult, type InboundEmailDomainUiStatus, type InboundEmailDomainVerifyResult, type InboundEmailDomainView, type InboundEmailDomainsListResult, type InboxEmailPreview, type IssueAuthorKind, type IssueCommentRow, type IssueEventType, type IssueKind, type IssueRow, type IssueStatus, type IssuesCommentResult, type IssuesCreateResult, type IssuesDeleteResult, type IssuesGetResult, type IssuesListResult, type IssuesUpdateResult, type JewelPairRow, type JewelPairSummaryRow, type JewelVerdict, type JewelsDatasetSummary, type JewelsDryrunResult, type JewelsExportResult, type JewelsGradeResult, type JewelsGrading, type JewelsOverviewResult, type JewelsPairResult, type JewelsPairsResult, type JewelsQueueResult, type JewelsResolveResult, type JewelsRunResult, type JewelsRunsResult, type JewelsTimeseriesBucket, type JewelsTimeseriesResult, type JewelsTrainResult, type LiftedDatabase, type MethodsInvokeResult, type OutboundDnsInstructions, type OutboundEmailDomainAddResult, type OutboundEmailDomainCheckResult, type OutboundEmailDomainDeleteResult, type OutboundEmailDomainUiStatus, type OutboundEmailDomainVerifyResult, type OutboundEmailDomainView, type OutboundEmailDomainsListResult, type PlatformSuppression, type PrerenderGetResult, type PrerenderInvalidateResult, type PrerenderPage, type PrerenderPagesResult, type PrerenderViewResult, type ReleaseFailureFields, type ReleaseFragment, type ReleasesByCommitResult, type ReleasesGetResult, type ReleasesListResult, type RequestsGetResult, type RequestsListResult, type RequestsListRow, type RequestsStatsMethodBucket, type RequestsStatsMethodResult, type RequestsStatsSummaryBucket, type RequestsStatsSummaryResult, type SecretsDeleteResult, type SecretsGetResult, type SecretsListResult, type SecretsSetResult, type SettingsResult, type SuppressionSource, type TrainingLogEntry, type TrainingRunRow, type TrainingRunStatus, type UserAuthProvider, type UserListItem, type UserRecord, type UsersCreateApiKeyResult, type UsersListResult, type UsersRevokeApiKeyResult, type UsersSetRoleResult, type V2AppSettings, type V2BuildLogEntry, type V2BuildStats, type V2CommitInfo, type V2EmailMessage, type V2ReleaseStatus, type VoiceAvailableNumber, type VoiceNumbersBuyResult, type VoiceNumbersListResult, type VoiceNumbersReleaseResult, type VoiceNumbersSearchResult, type VoiceNumbersSetNameResult, type VoicePhoneNumberStatus, type VoicePhoneNumberView, type VoiceResolvedPolicy, type VoiceSessionChannel, type VoiceSessionCost, type VoiceSessionCostLine, type VoiceSessionDetail, type VoiceSessionGetResult, type VoiceSessionListItem, type VoiceSessionSip, type VoiceSessionSpeechEntry, type VoiceSessionStatus, type VoiceSessionToolEntry, type VoiceSessionTranscriptEntry, type VoiceSessionsListResult, type VoiceSettingsCeilings, type VoiceSettingsGetResult, type VoiceSettingsOverrides, type VoiceSettingsSetResult, admin, createAdminClient, admin as default };