@terrascale/sdk 0.0.2 → 0.0.4

package/types/v1/backups.d.ts

@@ -0,0 +1,128 @@
+/** Backups and explicit point-in-time restore sources for one database. */
+export class V1Backups {
+    /** @param {V1Transport} transport @param {string} database */
+    constructor(transport: V1Transport, database: string);
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1Backup>} */
+    create(options?: V1RequestOptions): Promise<V1Backup>;
+    /** @param {import("./catalog.js").V1DatabaseListRequest} [request] @param {V1RequestOptions} [options] @returns {Promise<V1BackupPage>} */
+    list(request?: import("./catalog.js").V1DatabaseListRequest, options?: V1RequestOptions): Promise<V1BackupPage>;
+    /** @param {string} id @param {{readonly name?: string | null}} [request] @param {V1RequestOptions} [options] @returns {Promise<V1RestoredDatabase>} */
+    restore(id: string, request?: {
+        readonly name?: string | null;
+    }, options?: V1RequestOptions): Promise<V1RestoredDatabase>;
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1BackupPolicy>} */
+    getPolicy(options?: V1RequestOptions): Promise<V1BackupPolicy>;
+    /** @param {V1BackupPolicyRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1BackupPolicy>} */
+    setPolicy(request: V1BackupPolicyRequest, options?: V1RequestOptions): Promise<V1BackupPolicy>;
+    /** @param {{readonly destination?: "platform" | "customer"}} [request] @param {V1RequestOptions} [options] @returns {Promise<V1RestoreWindow>} */
+    window(request?: {
+        readonly destination?: "platform" | "customer";
+    }, options?: V1RequestOptions): Promise<V1RestoreWindow>;
+    /** @param {V1PointInTimeRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1PointInTimePlan>} */
+    plan(request: V1PointInTimeRequest, options?: V1RequestOptions): Promise<V1PointInTimePlan>;
+    /** @param {V1PointInTimeRestoreRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1RestoredDatabase>} */
+    restorePointInTime(request: V1PointInTimeRestoreRequest, options?: V1RequestOptions): Promise<V1RestoredDatabase>;
+    #private;
+}
+/** Write-only destination credentials are sent only to the configured API, never retained in the client. */
+export class V1BackupDestinationClient {
+    /** @param {V1Transport} transport */
+    constructor(transport: V1Transport);
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1BackupDestination>} */
+    get(options?: V1RequestOptions): Promise<V1BackupDestination>;
+    /** @param {V1BackupDestinationRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1BackupDestination>} */
+    set(request: V1BackupDestinationRequest, options?: V1RequestOptions): Promise<V1BackupDestination>;
+    /** @param {V1RequestOptions} [options] @returns {Promise<void>} */
+    delete(options?: V1RequestOptions): Promise<void>;
+    #private;
+}
+export type V1Backup = ReturnType<typeof backup>;
+export type V1BackupPage = ReturnType<typeof backupPage>;
+export type V1BackupPolicy = ReturnType<typeof policy>;
+export type V1RestoreWindow = ReturnType<typeof window>;
+export type V1PointInTimePlan = ReturnType<typeof plan>;
+export type V1RestoredDatabase = ReturnType<typeof restored>;
+export type V1BackupDestination = ReturnType<typeof destination>;
+export type V1BackupPolicyRequest = {
+    readonly fullBackupCron?: string | null;
+    readonly retentionDays?: number | null;
+    readonly disabled?: boolean | null;
+};
+export type V1PointInTimeRequest = {
+    readonly pointInTime: string;
+    readonly destination?: "platform" | "customer" | null;
+};
+export type V1PointInTimeRestoreRequest = V1PointInTimeRequest & {
+    readonly name?: string | null;
+};
+export type V1BackupDestinationRequest = {
+    readonly endpoint: string;
+    readonly region: string;
+    readonly bucket: string;
+    readonly accessKeyId: string;
+    readonly secretKey: string;
+    readonly mode: "both" | "customer";
+};
+import type { V1RequestOptions } from "./terrabase-v1.js";
+import type { V1Transport } from "./transport.js";
+/** @import { V1Transport } from "./transport.js" */
+/** @import { V1RequestOptions } from "./terrabase-v1.js" */
+declare const backup: import("./management-decode.js").Decoder<Readonly<{
+    id: string;
+    databaseId: string;
+    status: string;
+    trigger: string;
+    sizeBytes: number | import("./json.js").ExactDecimal;
+    createdAt: string;
+}>>;
+declare const backupPage: import("./management-decode.js").Decoder<Readonly<{
+    items: readonly Readonly<{
+        id: string;
+        databaseId: string;
+        status: string;
+        trigger: string;
+        sizeBytes: number | import("./json.js").ExactDecimal;
+        createdAt: string;
+    }>[];
+    next: string | null;
+}>>;
+declare const policy: import("./management-decode.js").Decoder<Readonly<{
+    fullBackupCron: string | null;
+    retentionDays: number | import("./json.js").ExactDecimal;
+    disabled: boolean;
+    updatedAt: string | null;
+}>>;
+declare const window: import("./management-decode.js").Decoder<Readonly<{
+    earliest: string;
+    latest: string;
+}>>;
+declare const plan: import("./management-decode.js").Decoder<Readonly<{
+    window: Readonly<{
+        earliest: string;
+        latest: string;
+    }>;
+    pointInTime: string;
+    snapshotAt: string;
+    latestSegmentAt: string | null;
+    segmentCount: number | import("./json.js").ExactDecimal;
+    historyCheck: string;
+}>>;
+declare const restored: import("./management-decode.js").Decoder<Readonly<{
+    id: string;
+    projectId: string;
+    name: string;
+    branchedFrom: string | null;
+    createdAt: string;
+    homeRegion: string | null | undefined;
+    replicaRegions: readonly string[] | null | undefined;
+    placementVersion: number | import("./json.js").ExactDecimal | undefined;
+    replicas: readonly string[];
+}>>;
+declare const destination: import("./management-decode.js").Decoder<Readonly<{
+    endpoint: string;
+    region: string;
+    bucket: string;
+    mode: string;
+    updatedAt: string;
+}>>;
+export {};

package/types/v1/catalog.d.ts

@@ -0,0 +1,92 @@
+/** @param {V1Transport} transport @param {Readonly<Record<string, string>>} params @param {V1RequestOptions} [options] @returns {Promise<V1CollectionSchema>} */
+export function getCollectionSchema(transport: V1Transport, params: Readonly<Record<string, string>>, options?: V1RequestOptions): Promise<V1CollectionSchema>;
+/** @param {V1Transport} transport @param {Readonly<Record<string, string>>} params @param {boolean | JsonInputObject} schema @param {V1RequestOptions} [options] @returns {Promise<V1CollectionSchema>} */
+export function putCollectionSchema(transport: V1Transport, params: Readonly<Record<string, string>>, schema: boolean | JsonInputObject, options?: V1RequestOptions): Promise<V1CollectionSchema>;
+/** @param {V1Transport} transport @param {Readonly<Record<string, string>>} params @param {V1RequestOptions} [options] @returns {Promise<V1CollectionSchema>} */
+export function deleteCollectionSchema(transport: V1Transport, params: Readonly<Record<string, string>>, options?: V1RequestOptions): Promise<V1CollectionSchema>;
+/** Public database catalog operations, bound to the transport's authorized project. */
+export class V1Databases {
+    /** @param {V1Transport} transport */
+    constructor(transport: V1Transport);
+    /** @param {V1DatabaseCreateRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1ManagedDatabase>} */
+    create(request: V1DatabaseCreateRequest, options?: V1RequestOptions): Promise<V1ManagedDatabase>;
+    /** @param {V1DatabaseListRequest} [request] @param {V1RequestOptions} [options] @returns {Promise<V1DatabasePage>} */
+    list(request?: V1DatabaseListRequest, options?: V1RequestOptions): Promise<V1DatabasePage>;
+    /** @param {string} name @param {V1RequestOptions} [options] @returns {Promise<V1ManagedDatabase>} */
+    get(name: string, options?: V1RequestOptions): Promise<V1ManagedDatabase>;
+    /** @param {string} name @param {V1DatabaseUpdateRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1ManagedDatabase>} */
+    update(name: string, request: V1DatabaseUpdateRequest, options?: V1RequestOptions): Promise<V1ManagedDatabase>;
+    /** @param {string} name @param {V1RequestOptions} [options] @returns {Promise<void>} */
+    delete(name: string, options?: V1RequestOptions): Promise<void>;
+    /** @param {string} name @param {V1DatabaseBranchRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1ManagedDatabase>} */
+    branch(name: string, request: V1DatabaseBranchRequest, options?: V1RequestOptions): Promise<V1ManagedDatabase>;
+    #private;
+}
+export type V1ManagedDatabase = {
+    /**
+     * Canonical database ULID.
+     */
+    id: string;
+    /**
+     * Canonical owning-project ULID.
+     */
+    projectId: string;
+    /**
+     * Database name used in data routes.
+     */
+    name: string;
+    /**
+     * Source database ULID, or null.
+     */
+    branchedFrom: string | null;
+    /**
+     * ISO date-time returned by the producer.
+     */
+    createdAt: string;
+    /**
+     * Serving region.
+     */
+    region: string;
+    /**
+     * Management region.
+     */
+    homeRegion: string;
+    /**
+     * Other serving regions; empty when allRegions is true.
+     */
+    replicaRegions: readonly string[];
+    /**
+     * True when a full copy is served in every serving region, including later ones.
+     */
+    allRegions: boolean;
+};
+export type V1DatabaseCreateRequest = {
+    readonly name: string;
+    readonly homeRegion?: string | null | undefined;
+    readonly replicaRegions?: readonly string[] | null | undefined;
+    readonly allRegions?: boolean | undefined;
+};
+export type V1DatabaseUpdateRequest = {
+    readonly replicaRegions?: readonly string[] | undefined;
+    readonly allRegions?: true | undefined;
+    readonly homeRegion?: string | null | undefined;
+};
+export type V1DatabaseBranchRequest = {
+    readonly name: string;
+};
+export type V1DatabaseListRequest = {
+    readonly after?: string | undefined;
+    readonly limit?: number | undefined;
+};
+export type V1DatabasePage = {
+    readonly items: readonly V1ManagedDatabase[];
+    readonly next: string | null;
+};
+export type V1CollectionSchema = {
+    readonly schema: JsonObject | boolean | null;
+    readonly dialect?: string | null | undefined;
+};
+import type { V1Transport } from "./transport.js";
+import type { V1RequestOptions } from "./terrabase-v1.js";
+import type { JsonInputObject } from "./json.js";
+import type { JsonObject } from "./json.js";

package/types/v1/changes.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Reconnects only a normally completed, valid stream, with the latest issued cursor.
+ * Denials, terminal errors, malformed data and lost connections are returned to the caller.
+ * @param {V1Transport} transport
+ * @param {string} database
+ * @param {V1ChangeStreamRequest} [request]
+ * @param {AbortSignal | undefined} [signal]
+ * @returns {AsyncGenerator<V1DatabaseChange | V1DatabaseChangeCursor, void, undefined>}
+ */
+export function streamChanges(transport: V1Transport, database: string, request?: V1ChangeStreamRequest, signal?: AbortSignal | undefined): AsyncGenerator<V1DatabaseChange | V1DatabaseChangeCursor, void, undefined>;
+/**
+ * Cursors are opaque and must be resumed with the identical collection filter.
+ */
+export type V1ChangeStreamRequest = {
+    /**
+     * An issued cursor, or `now`; omitted starts at retention.
+     */
+    cursor?: string | undefined;
+    /**
+     * One to 64 collection names.
+     */
+    collections?: readonly string[] | undefined;
+    /**
+     * Overrides cursor, as the producer's Last-Event-ID header.
+     */
+    lastEventId?: string | undefined;
+};
+/**
+ * At-least-once delivery: callers deduplicate by origin, version, collection and id.
+ * The document is its current serving value, including null, rather than a historical value.
+ * Only the last change of an origin/version carries a resumable cursor.
+ */
+export type V1DatabaseChange = {
+    readonly type: "change";
+    readonly cursor: string | undefined;
+    readonly collection: string;
+    readonly id: string;
+    readonly op: "upsert" | "delete";
+    readonly version: string;
+    readonly origin: string;
+    readonly document: JsonObject | null;
+};
+export type V1DatabaseChangeCursor = {
+    readonly type: "cursor";
+    readonly cursor: string;
+};
+export type WireEvent = {
+    type: string | undefined;
+    id: string | undefined;
+    data: string;
+};
+import type { V1Transport } from "./transport.js";
+import type { JsonObject } from "./json.js";

package/types/v1/database-schema.d.ts

@@ -0,0 +1,82 @@
+/** @typedef {ReturnType<typeof schema>} V1InferredSchema */
+/** @typedef {ReturnType<typeof collections>} V1DatabaseSchema */
+/** @typedef {ReturnType<typeof unique>} V1UniqueSchema */
+/** @typedef {ReturnType<typeof shapes>} V1QueryShapes */
+/** @typedef {"none" | "lowercase" | "trim_lowercase"} V1Normalization */
+/** @typedef {{ readonly fields?: readonly { readonly name: string; readonly unique?: boolean; readonly normalization?: V1Normalization | null }[] | null; readonly indexes?: readonly { readonly name: string; readonly fields: readonly string[]; readonly unique?: boolean; readonly normalization?: V1Normalization | null }[] | null }} V1UniqueSchemaRequest */
+/** Inferred collection fields, declared uniqueness, and observed query statistics. */
+export class V1DatabaseSchemaClient {
+    /** @param {V1Transport} transport @param {string} database */
+    constructor(transport: V1Transport, database: string);
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1DatabaseSchema>} */
+    list(options?: V1RequestOptions): Promise<V1DatabaseSchema>;
+    /** @param {string} collection @param {V1RequestOptions} [options] @returns {Promise<V1InferredSchema>} */
+    infer(collection: string, options?: V1RequestOptions): Promise<V1InferredSchema>;
+    /** @param {string} collection @param {V1UniqueSchemaRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1UniqueSchema>} */
+    declare(collection: string, request: V1UniqueSchemaRequest, options?: V1RequestOptions): Promise<V1UniqueSchema>;
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1QueryShapes>} */
+    queryShapes(options?: V1RequestOptions): Promise<V1QueryShapes>;
+    #private;
+}
+export type V1InferredSchema = ReturnType<typeof schema>;
+export type V1DatabaseSchema = ReturnType<typeof collections>;
+export type V1UniqueSchema = ReturnType<typeof unique>;
+export type V1QueryShapes = ReturnType<typeof shapes>;
+export type V1Normalization = "none" | "lowercase" | "trim_lowercase";
+export type V1UniqueSchemaRequest = {
+    readonly fields?: readonly {
+        readonly name: string;
+        readonly unique?: boolean;
+        readonly normalization?: V1Normalization | null;
+    }[] | null;
+    readonly indexes?: readonly {
+        readonly name: string;
+        readonly fields: readonly string[];
+        readonly unique?: boolean;
+        readonly normalization?: V1Normalization | null;
+    }[] | null;
+};
+import type { V1RequestOptions } from "./terrabase-v1.js";
+import type { V1Transport } from "./transport.js";
+declare const schema: import("./management-decode.js").Decoder<Readonly<{
+    collection: string;
+    documents: number | import("./json.js").ExactDecimal;
+    sampledDocuments: number | import("./json.js").ExactDecimal;
+    fields: readonly Readonly<{
+        path: string;
+        present: number | import("./json.js").ExactDecimal;
+        types: Readonly<Record<string, number | import("./json.js").ExactDecimal>>;
+    }>[];
+    uniqueConstraints: readonly Readonly<{
+        name: string;
+        fields: readonly string[];
+        normalization: string;
+    }>[] | null | undefined;
+}>>;
+declare const collections: import("./management-decode.js").Decoder<Readonly<{
+    items: readonly Readonly<{
+        name: string;
+        documents: number | import("./json.js").ExactDecimal;
+        bytes: number | import("./json.js").ExactDecimal;
+    }>[];
+}>>;
+declare const unique: import("./management-decode.js").Decoder<Readonly<{
+    constraints: readonly Readonly<{
+        name: string;
+        fields: readonly string[];
+        normalization: string;
+    }>[];
+}>>;
+declare const shapes: import("./management-decode.js").Decoder<Readonly<{
+    items: readonly Readonly<{
+        id: string;
+        collection: string;
+        shape: string;
+        queries: number | import("./json.js").ExactDecimal;
+        totalLatencyMs: number | import("./json.js").ExactDecimal;
+        maxLatencyMs: number | import("./json.js").ExactDecimal;
+        rowsScanned: number | import("./json.js").ExactDecimal;
+        lastSeenAt: string;
+    }>[];
+}>>;
+export {};

package/types/v1/decode.d.ts

@@ -4,21 +4,22 @@
  * `document` is the value, or the LWW winner when a causal read answers `"conflict"` with `siblings`.
  * Unknown future states pass through.
  * @typedef {object} V1Document
- * @property {string} id
+ * @property {string} id Caller-supplied key or server-generated ULID.
  * @property {string} version
  * @property {"value" | "conflict" | (string & {})} state
  * @property {JsonObject} document
- * @property {readonly JsonValue[]} [siblings] Every live version, on a causal read with several.
+ * @property {readonly JsonValue[]} [siblings] Live versions and tombstones on a causal conflict.
  */
 /**
  * The result of a document write.
  * @typedef {object} V1WriteResult
- * @property {string} id
+ * @property {string} id Caller-supplied key or server-generated ULID.
  * @property {string} version For a delete, the tombstone's version.
  * @property {string} offset The database commit offset (decimal u64), usable with shape `waitFor`.
  * @property {V1Durability} durability
  * @property {boolean} created True when a PUT or POST answered 201.
  * @property {string | undefined} location The Location header of a POST create.
+ * @property {JsonObject} [document] Stored document returned by PATCH.
  */
 /**
  * @param {string} what
@@ -31,6 +32,8 @@ export function malformed(what: string): never;
  * @returns {JsonObject}
  */
 export function object(value: JsonValue | undefined, what: string): JsonObject;
+/** @param {JsonValue | undefined} value @returns {JsonObject} */
+export function documentObject(value: JsonValue | undefined): JsonObject;
 /**
  * @param {JsonValue | undefined} value
  * @param {string} what
@@ -83,12 +86,15 @@ export type V1Durability = "local_durable" | (string & {});
  * Unknown future states pass through.
  */
 export type V1Document = {
+    /**
+     * Caller-supplied key or server-generated ULID.
+     */
     id: string;
     version: string;
     state: "value" | "conflict" | (string & {});
     document: JsonObject;
     /**
-     * Every live version, on a causal read with several.
+     * Live versions and tombstones on a causal conflict.
      */
     siblings?: readonly JsonValue[];
 };
@@ -96,6 +102,9 @@ export type V1Document = {
  * The result of a document write.
  */
 export type V1WriteResult = {
+    /**
+     * Caller-supplied key or server-generated ULID.
+     */
     id: string;
     /**
      * For a delete, the tombstone's version.
@@ -114,6 +123,10 @@ export type V1WriteResult = {
      * The Location header of a POST create.
      */
     location: string | undefined;
+    /**
+     * Stored document returned by PATCH.
+     */
+    document?: JsonObject;
 };
 import type { JsonValue } from "./json.js";
 import type { JsonObject } from "./json.js";

package/types/v1/errors.d.ts

@@ -21,7 +21,7 @@ export function parseRetryAfter(headers: Headers): number | undefined;
  * @returns {TerraBaseV1Error}
  */
 export function parseV1Error(status: number, headers: Headers, text: string): TerraBaseV1Error;
-/** @import { JsonObject } from "./json.js" */
+/** @import { JsonObject, JsonValue } from "./json.js" */
 /**
  * @typedef {object} TerraBaseV1ErrorInit
  * @property {number} status
@@ -32,6 +32,9 @@ export function parseV1Error(status: number, headers: Headers, text: string): Te
  * @property {number | undefined} [retryAfter]
  * @property {string | undefined} [etag]
  * @property {JsonObject | undefined} [details]
+ * @property {JsonValue | undefined} [body]
+ * @property {string | undefined} [responseText]
+ * @property {Headers | undefined} [headers]
  */
 /**
  * A non-2xx TerraBase v1 response. `code` is the contract's `error.code`, or
@@ -54,6 +57,14 @@ export class TerraBaseV1Error extends Error {
     etag: string | undefined;
     /** @type {JsonObject | undefined} The raw error object, for route-specific metadata. */
     details: JsonObject | undefined;
+    /** @type {JsonValue | undefined} Complete parsed response body, including unknown fields. */
+    body: JsonValue | undefined;
+    /** @type {string} Original response text; empty when absent or unreadable. */
+    responseText: string;
+    /** @type {Headers} Response headers, including authentication challenges and retry metadata. */
+    headers: Headers;
+    /** @type {string | undefined} Diagnostic X-Request-ID, when supplied by the responder. */
+    requestId: string | undefined;
 }
 /** Current document, collection and shape producer codes, plus client not_modified. */
 export const V1ErrorCode: Readonly<{
@@ -103,5 +114,9 @@ export type TerraBaseV1ErrorInit = {
     retryAfter?: number | undefined;
     etag?: string | undefined;
     details?: JsonObject | undefined;
+    body?: JsonValue | undefined;
+    responseText?: string | undefined;
+    headers?: Headers | undefined;
 };
 import type { JsonObject } from "./json.js";
+import type { JsonValue } from "./json.js";

package/types/v1/ids.d.ts

@@ -5,15 +5,12 @@
  */
 export function requireName(kind: "database" | "collection", name: unknown): string;
 /**
- * The producer resolves this opaque catalog project id (normally a UUID), not its display name.
+ * The catalog project ID is a canonical ULID; database and collection routes use names.
  * @param {unknown} project
- * @returns {string}
- */
-export function requireProject(project: unknown): string;
-/**
- * @param {unknown} id
- * @returns {string}
+ * @returns {import("../ids.js").EntityId}
  */
+export function requireProject(project: unknown): import("../ids.js").EntityId;
+/** A caller-supplied key is not a generated entity ID. @param {unknown} id @returns {string} */
 export function requireDocumentId(id: unknown): string;
 /**
  * @param {unknown} version
@@ -33,12 +30,3 @@ export function parseU64(value: unknown): bigint | undefined;
  * @returns {bigint}
  */
 export function requireU64(value: unknown, what: string): bigint;
-/**
- * The deterministic document ID for a natural key in a collection:
- * `uuidv5(uuidv5(NAMESPACE_URL, "terrabase:collection:" + collection), key)`.
- * Uses WebCrypto, so it works in Node.js, browsers and workers.
- * @param {string} collection
- * @param {string} key
- * @returns {Promise<string>}
- */
-export function documentIdFor(collection: string, key: string): Promise<string>;

package/types/v1/imports.d.ts

@@ -0,0 +1,132 @@
+/** @typedef {ReturnType<typeof job>} V1ImportJob */
+/** @typedef {{ readonly missingPrimaryKey?: "reject" | "generate" | null; readonly exclude?: readonly string[] | null }} V1ImportOptions */
+/** @typedef {{ readonly format: "postgres_plain" | "sqlite"; readonly sourceBytes: number; readonly sourceSha256: string; readonly options?: V1ImportOptions | null }} V1CreateImportRequest */
+/** One import job belongs to its destination database; preview confirmation is explicit. */
+export class V1Imports {
+    /** @param {V1Transport} transport @param {string} database */
+    constructor(transport: V1Transport, database: string);
+    /** @param {V1CreateImportRequest} request @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    create(request: V1CreateImportRequest, options?: V1RequestOptions): Promise<V1ImportJob>;
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    get(options?: V1RequestOptions): Promise<V1ImportJob>;
+    /** @param {number | bigint} offset @param {Uint8Array} bytes @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    uploadSource(offset: number | bigint, bytes: Uint8Array, options?: V1RequestOptions): Promise<V1ImportJob>;
+    /** @param {{readonly options?: V1ImportOptions | null}} request @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    update(request: {
+        readonly options?: V1ImportOptions | null;
+    }, options?: V1RequestOptions): Promise<V1ImportJob>;
+    /** @param {{readonly previewId: string}} request @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    start(request: {
+        readonly previewId: string;
+    }, options?: V1RequestOptions): Promise<V1ImportJob>;
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    cancel(options?: V1RequestOptions): Promise<V1ImportJob>;
+    /** @param {V1RequestOptions} [options] @returns {Promise<V1ImportJob>} */
+    resume(options?: V1RequestOptions): Promise<V1ImportJob>;
+    #private;
+}
+export type V1ImportJob = ReturnType<typeof job>;
+export type V1ImportOptions = {
+    readonly missingPrimaryKey?: "reject" | "generate" | null;
+    readonly exclude?: readonly string[] | null;
+};
+export type V1CreateImportRequest = {
+    readonly format: "postgres_plain" | "sqlite";
+    readonly sourceBytes: number;
+    readonly sourceSha256: string;
+    readonly options?: V1ImportOptions | null;
+};
+import type { V1RequestOptions } from "./terrabase-v1.js";
+import type { V1Transport } from "./transport.js";
+declare const job: import("./management-decode.js").Decoder<Readonly<{
+    id: string;
+    project: string;
+    database: string;
+    region: string;
+    state: string;
+    cancelRequested: boolean;
+    options: Readonly<{
+        missingPrimaryKey: string | null;
+        exclude: readonly string[] | null;
+    }>;
+    source: Readonly<{
+        format: string;
+        bytes: number | import("./json.js").ExactDecimal;
+        sha256: string;
+        receivedBytes: number | import("./json.js").ExactDecimal;
+        staged: boolean;
+        retainedUntil: string | null;
+    }>;
+    preview: Readonly<{
+        id: string;
+        tables: readonly Readonly<{
+            source: string;
+            collection: string;
+            excluded: boolean;
+            rows: number | import("./json.js").ExactDecimal;
+            idPolicy: string;
+            primaryKey: readonly string[];
+            columns: readonly Readonly<{
+                name: /*elided*/ any;
+                sourceType: /*elided*/ any;
+                mapping: /*elided*/ any;
+                nullable: /*elided*/ any;
+                excluded: /*elided*/ any;
+            }>[];
+            constraints: readonly Readonly<{
+                kind: /*elided*/ any;
+                name: /*elided*/ any;
+                columns: /*elided*/ any;
+                references: /*elided*/ any;
+                enforced: /*elided*/ any;
+            }>[];
+            issues: readonly Readonly<{
+                severity: /*elided*/ any;
+                code: /*elided*/ any;
+                column: /*elided*/ any;
+                row: /*elided*/ any;
+                message: /*elided*/ any;
+            }>[];
+        }>[];
+        skipped: readonly Readonly<{
+            kind: string;
+            name: string;
+        }>[];
+        skippedTruncated: boolean;
+        blocking: number | import("./json.js").ExactDecimal;
+        warnings: number | import("./json.js").ExactDecimal;
+    }> | null;
+    confirmedPreviewId: string | null;
+    progress: Readonly<{
+        tablesDone: number | import("./json.js").ExactDecimal;
+        tablesTotal: number | import("./json.js").ExactDecimal;
+        rowsWritten: number | import("./json.js").ExactDecimal;
+        rowsTotal: number | import("./json.js").ExactDecimal;
+        currentTable: string | null;
+    }> | null;
+    validation: Readonly<{
+        passed: boolean;
+        tables: readonly Readonly<{
+            source: string;
+            collection: string;
+            sourceRows: number | import("./json.js").ExactDecimal;
+            documents: number | import("./json.js").ExactDecimal;
+            sourceChecksum: string;
+            documentChecksum: string;
+            match: boolean;
+        }>[];
+    }> | null;
+    error: Readonly<{
+        code: string;
+        message: string;
+        retryable: boolean;
+        table: string | null;
+        row: number | import("./json.js").ExactDecimal | null;
+        column: string | null;
+    }> | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+}>>;
+export {};