@terrascale/sdk 0.0.3 → 0.0.4

package/src/v1/usage.js

@@ -0,0 +1,101 @@
+import { requireId } from "../ids.js";
+import { requireName } from "./ids.js";
+import { dictionary, flag, list, nullable, numeric, record, text } from "./management-decode.js";
+import { members } from "./management-validation.js";
+/** @import { V1Transport } from "./transport.js" */
+/** @import { V1RequestOptions } from "./terrabase-v1.js" */
+const period = record({ from: text, to: text, granularity: text, reads: numeric, writes: numeric });
+const series = list(record({ start: text, reads: numeric, writes: numeric }));
+const databaseUsage = record({ databaseId: requireId, storageBytes: numeric, logicalBytes: numeric, collections: numeric,
+  documents: numeric, reads: numeric, writes: numeric, period, series });
+const projectUsage = record({ projectId: requireId, databases: numeric, storageBytes: numeric, logicalBytes: numeric,
+  documents: numeric, reads: numeric, writes: numeric, period, series, items: list(databaseUsage) });
+const bandwidth = record({ bytesSent: numeric, bytesReceived: numeric });
+const directedBandwidth = list(record({ sourceRegion: text, destinationRegion: text, kind: text, bytesSent: numeric, bytesReceived: numeric }));
+const latency = record({ p50Ms: nullable(numeric), p95Ms: nullable(numeric), p99Ms: nullable(numeric) });
+const analytics = record({ projectId: requireId, range: text, from: text, to: text, bucketSeconds: numeric,
+  items: list(record({ databaseId: requireId, databaseName: text, region: text,
+    series: list(record({ start: text, requests: dictionary(numeric), operations: dictionary(numeric), errors: numeric,
+      latency, storageBytes: nullable(numeric), clientBandwidth: bandwidth, replicationBandwidth: bandwidth })) })) });
+const replication = record({ projectId: requireId, range: text, from: text, to: text, bucketSeconds: numeric,
+  items: list(record({ databaseId: requireId, databaseName: text, region: text, status: text, replicatedOps: numeric,
+    lagMs: nullable(numeric), divergence: nullable(flag), convergenceMs: nullable(numeric), lastApplied: nullable(text),
+    bandwidth: directedBandwidth, series: list(record({ start: text, replicatedOps: numeric, bandwidth: directedBandwidth })) })) });
+/** @typedef {ReturnType<typeof databaseUsage>} V1DatabaseUsage */
+/** @typedef {ReturnType<typeof projectUsage>} V1ProjectUsage */
+/** @typedef {ReturnType<typeof analytics>} V1Analytics */
+/** @typedef {ReturnType<typeof replication>} V1Replication */
+/** @typedef {{ readonly granularity?: "hour" | "day"; readonly from?: string; readonly to?: string }} V1UsageRequest */
+/** @typedef {{ readonly range?: "1h" | "24h" | "7d" | "30d"; readonly database?: string; readonly region?: string }} V1AnalyticsRequest */
+/** @param {V1UsageRequest} request */
+function usageQuery(request) {
+  members(request, ["granularity", "from", "to"]);
+  const query = new URLSearchParams();
+  if (request.granularity !== undefined) {
+    if (!["hour", "day"].includes(request.granularity)) throw new TypeError("granularity must be hour or day.");
+    query.set("granularity", request.granularity);
+  }
+  for (const name of /** @type {const} */ (["from", "to"])) {
+    const value = request[name];
+    if (value === undefined) continue;
+    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?(?:Z|[+-]\d{2}:\d{2})$/u.test(value) || !Number.isFinite(Date.parse(value)))
+      throw new TypeError("from and to must be RFC 3339 instants.");
+    query.set(name, value);
+  }
+  return query;
+}
+/** @param {V1AnalyticsRequest} request @param {boolean} project */
+function analyticsQuery(request, project) {
+  members(request, project ? ["range", "database", "region"] : ["range", "region"]);
+  const query = new URLSearchParams();
+  if (request.range !== undefined) {
+    if (!["1h", "24h", "7d", "30d"].includes(request.range)) throw new TypeError("Invalid analytics range.");
+    query.set("range", request.range);
+  }
+  if (request.database !== undefined) query.set("database", requireId(request.database));
+  if (request.region !== undefined) {
+    if (typeof request.region !== "string" || !/^[a-z][a-z0-9-]{0,62}$/u.test(request.region)) throw new TypeError("Invalid region.");
+    query.set("region", request.region);
+  }
+  return query;
+}
+
+/** Project and database usage retain the producer's separate response envelopes. */
+export class V1ProjectUsageClient {
+  /** @type {V1Transport} */
+  #transport;
+  /** @param {V1Transport} transport */
+  constructor(transport) { this.#transport = transport; Object.freeze(this); }
+  /** @param {V1UsageRequest} [request] @param {V1RequestOptions} [options] @returns {Promise<V1ProjectUsage>} */
+  async usage(request = {}, options = {}) {
+    return projectUsage((await this.#transport.call("getProjectUsage", {}, { query: usageQuery(request), signal: options.signal })).value);
+  }
+  /** @param {V1AnalyticsRequest} [request] @param {V1RequestOptions} [options] @returns {Promise<V1Analytics>} */
+  async analytics(request = {}, options = {}) {
+    return analytics((await this.#transport.call("getProjectAnalytics", {}, { query: analyticsQuery(request, true), signal: options.signal })).value);
+  }
+  /** @param {V1AnalyticsRequest} [request] @param {V1RequestOptions} [options] @returns {Promise<V1Replication>} */
+  async replication(request = {}, options = {}) {
+    return replication((await this.#transport.call("getProjectReplication", {}, { query: analyticsQuery(request, true), signal: options.signal })).value);
+  }
+}
+export class V1DatabaseUsageClient {
+  /** @type {V1Transport} */
+  #transport;
+  /** @type {{database: string}} */
+  #params;
+  /** @param {V1Transport} transport @param {string} database */
+  constructor(transport, database) { this.#transport = transport; this.#params = { database: requireName("database", database) }; Object.freeze(this); }
+  /** @param {V1UsageRequest} [request] @param {V1RequestOptions} [options] @returns {Promise<V1DatabaseUsage>} */
+  async usage(request = {}, options = {}) {
+    return databaseUsage((await this.#transport.call("getDatabaseUsage", this.#params, { query: usageQuery(request), signal: options.signal })).value);
+  }
+  /** @param {Omit<V1AnalyticsRequest, "database">} [request] @param {V1RequestOptions} [options] @returns {Promise<V1Analytics>} */
+  async analytics(request = {}, options = {}) {
+    return analytics((await this.#transport.call("getDatabaseAnalytics", this.#params, { query: analyticsQuery(request, false), signal: options.signal })).value);
+  }
+  /** @param {Omit<V1AnalyticsRequest, "database">} [request] @param {V1RequestOptions} [options] @returns {Promise<V1Replication>} */
+  async replication(request = {}, options = {}) {
+    return replication((await this.#transport.call("getDatabaseReplication", this.#params, { query: analyticsQuery(request, false), signal: options.signal })).value);
+  }
+}

package/types/http.d.ts

@@ -1,12 +1,7 @@
 /** Private transport for the named hosted identity and OIDC operations. */
 export class TsAuthHttp {
-    /**
-     * @param {TsAuthRuntimeConfig} config
-     * @param {{ readonly authReverseProxy?: boolean }} [options]
-     */
-    constructor(config: TsAuthRuntimeConfig, options?: {
-        readonly authReverseProxy?: boolean;
-    });
+    /** @param {TsAuthRuntimeConfig} config */
+    constructor(config: TsAuthRuntimeConfig);
     /**
      * @readonly
      * @type {ResolvedTsAuthRuntimeConfig}
@@ -39,7 +34,6 @@ export type TsAuthRequest<TBody> = {
     readonly formBody?: URLSearchParams | string | undefined;
     readonly userinfoAccessToken?: string | undefined;
     readonly resourceIntrospectionBasic?: string | undefined;
-    readonly issuer?: string | undefined;
     readonly signal?: AbortSignal | undefined;
 };
 import type { ResolvedTsAuthRuntimeConfig } from "./config.js";

package/types/index.d.ts

@@ -1,6 +1,15 @@
 export { v1Filter } from "./v1/filter.js";
+export { V1ShapeSubscription } from "./v1/shape-subscription.js";
 export { ExactDecimal } from "./v1/json.js";
 export { staticBaseUrlResolver } from "./v1/transport.js";
+export { V1Databases } from "./v1/catalog.js";
+export { V1SavedQueries } from "./v1/saved-queries.js";
+export { V1DatabaseSchemaClient } from "./v1/database-schema.js";
+export { V1Indexes } from "./v1/indexes.js";
+export { V1Imports } from "./v1/imports.js";
+export type V1ShapeSubscribeOptions = import("./v1/shape-subscription.js").V1ShapeSubscribeOptions;
+export type V1ShapeDocument = import("./v1/shape-subscription.js").V1ShapeDocument;
+export type V1SealedShapePosition = import("./v1/shape-reader.js").V1SealedShapePosition;
 export type EntityId = import("./ids.js").EntityId;
 export type TerraBaseV1ClientConfig = import("./v1/transport.js").TerraBaseV1ClientConfig;
 export type V1RequestOptions = import("./v1/terrabase-v1.js").V1RequestOptions;
@@ -31,6 +40,9 @@ export type V1JsonInputObject = import("./v1/json.js").JsonInputObject;
 export type V1ShapeRequest = import("./v1/shapes.js").V1ShapeRequest;
 export type V1ShapeChange = import("./v1/shapes.js").V1ShapeChange;
 export type V1ShapeOp = import("./v1/shapes.js").V1ShapeOp;
+export type V1SavedQuery = import("./v1/saved-queries.js").V1SavedQuery;
+export type V1SavedQueryRequest = import("./v1/saved-queries.js").V1SavedQueryRequest;
+export type V1SavedQueryPage = import("./v1/saved-queries.js").V1SavedQueryPage;
 export type TerraBaseClientConfig = import("./v1/transport.js").TerraBaseV1ClientConfig;
 export type V1EndpointContext = import("./v1/transport.js").V1EndpointContext;
 export type V1EndpointResolver = import("./v1/transport.js").V1EndpointResolver;
@@ -38,7 +50,63 @@ export type V1CollectionInfo = import("./v1/terrabase-v1.js").V1CollectionInfo;
 export type V1CollectionPage = import("./v1/terrabase-v1.js").V1CollectionPage;
 export type V1CollectionListOptions = import("./v1/terrabase-v1.js").V1CollectionListOptions;
 export type V1ShapePage = import("./v1/shapes.js").V1ShapePage;
+export type V1SqlRow = import("./v1/sql.js").V1SqlRow;
+export type V1SqlResult = import("./v1/sql.js").V1SqlResult;
+export type V1SqlIndexSuggestion = import("./v1/sql.js").V1SqlIndexSuggestion;
+export type V1SqlCheck = import("./v1/sql.js").V1SqlCheck;
+export type V1ChangeStreamRequest = import("./v1/changes.js").V1ChangeStreamRequest;
+export type V1DatabaseChange = import("./v1/changes.js").V1DatabaseChange;
+export type V1DatabaseChangeCursor = import("./v1/changes.js").V1DatabaseChangeCursor;
+export type V1ManagedDatabase = import("./v1/catalog.js").V1ManagedDatabase;
+export type V1DatabaseCreateRequest = import("./v1/catalog.js").V1DatabaseCreateRequest;
+export type V1DatabaseUpdateRequest = import("./v1/catalog.js").V1DatabaseUpdateRequest;
+export type V1DatabaseBranchRequest = import("./v1/catalog.js").V1DatabaseBranchRequest;
+export type V1DatabaseListRequest = import("./v1/catalog.js").V1DatabaseListRequest;
+export type V1DatabasePage = import("./v1/catalog.js").V1DatabasePage;
+export type V1CollectionSchema = import("./v1/catalog.js").V1CollectionSchema;
+export type V1InferredSchema = import("./v1/database-schema.js").V1InferredSchema;
+export type V1DatabaseSchema = import("./v1/database-schema.js").V1DatabaseSchema;
+export type V1UniqueSchema = import("./v1/database-schema.js").V1UniqueSchema;
+export type V1UniqueSchemaRequest = import("./v1/database-schema.js").V1UniqueSchemaRequest;
+export type V1QueryShapes = import("./v1/database-schema.js").V1QueryShapes;
+export type V1Index = import("./v1/indexes.js").V1Index;
+export type V1IndexList = import("./v1/indexes.js").V1IndexList;
+export type V1AutoIndexPolicy = import("./v1/indexes.js").V1AutoIndexPolicy;
+export type V1IndexRecommendations = import("./v1/indexes.js").V1IndexRecommendations;
+export type V1AppliedIndexRecommendation = import("./v1/indexes.js").V1AppliedIndexRecommendation;
+export type V1CreateIndexRequest = import("./v1/indexes.js").V1CreateIndexRequest;
+export type V1DatabaseUsage = import("./v1/usage.js").V1DatabaseUsage;
+export type V1ProjectUsage = import("./v1/usage.js").V1ProjectUsage;
+export type V1Analytics = import("./v1/usage.js").V1Analytics;
+export type V1Replication = import("./v1/usage.js").V1Replication;
+export type V1UsageRequest = import("./v1/usage.js").V1UsageRequest;
+export type V1AnalyticsRequest = import("./v1/usage.js").V1AnalyticsRequest;
+export type V1Backup = import("./v1/backups.js").V1Backup;
+export type V1BackupPage = import("./v1/backups.js").V1BackupPage;
+export type V1BackupPolicy = import("./v1/backups.js").V1BackupPolicy;
+export type V1RestoreWindow = import("./v1/backups.js").V1RestoreWindow;
+export type V1PointInTimePlan = import("./v1/backups.js").V1PointInTimePlan;
+export type V1RestoredDatabase = import("./v1/backups.js").V1RestoredDatabase;
+export type V1BackupDestination = import("./v1/backups.js").V1BackupDestination;
+export type V1BackupPolicyRequest = import("./v1/backups.js").V1BackupPolicyRequest;
+export type V1PointInTimeRequest = import("./v1/backups.js").V1PointInTimeRequest;
+export type V1PointInTimeRestoreRequest = import("./v1/backups.js").V1PointInTimeRestoreRequest;
+export type V1BackupDestinationRequest = import("./v1/backups.js").V1BackupDestinationRequest;
+export type V1ImportJob = import("./v1/imports.js").V1ImportJob;
+export type V1ImportOptions = import("./v1/imports.js").V1ImportOptions;
+export type V1CreateImportRequest = import("./v1/imports.js").V1CreateImportRequest;
+export type TerraBaseSystemClientConfig = import("./v1/system.js").TerraBaseSystemClientConfig;
+export type V1ProbeStatus = import("./v1/system.js").V1ProbeStatus;
+export type V1ReplicationHealth = import("./v1/system.js").V1ReplicationHealth;
+export type V1PlatformDatabases = import("./v1/system.js").V1PlatformDatabases;
+export type V1ShapeManifest = import("./v1/shape-manifest.js").V1ShapeManifest;
+export type V1ShapeManifestRequest = import("./v1/shape-manifest.js").V1ShapeManifestRequest;
+export type V1ShapeKeyRequest = import("./v1/shape-reader.js").V1ShapeKeyRequest;
+export type V1ShapeKey = import("./v1/shape-reader.js").V1ShapeKey;
 export { createTerraBaseV1Client as createTerraBaseClient, TerraBaseV1Client as TerraBaseClient, createTerraBaseV1Client, TerraBaseV1Client, V1Database, V1Collection, V1Collections, V1Transaction } from "./v1/terrabase-v1.js";
 export { terraScaleReleaseBlockers, TerraScaleCapabilityUnavailableError } from "./management-contracts.js";
 export { TerraBaseV1Error, V1PreconditionFailedError, V1InvalidKeyError, V1ForbiddenScopeError, V1NotFoundError, V1ErrorCode, isTerraBaseV1Error } from "./v1/errors.js";
 export { generateId, isValidId, requireId } from "./ids.js";
+export { V1ProjectUsageClient, V1DatabaseUsageClient } from "./v1/usage.js";
+export { V1Backups, V1BackupDestinationClient } from "./v1/backups.js";
+export { createTerraBaseSystemClient, V1Health, V1Platform } from "./v1/system.js";

package/types/local/environment.d.ts

@@ -3,7 +3,7 @@
  * @returns {void}
  */
 export function assertLocalSqliteEnvironment(environment?: Readonly<Record<string, string | undefined>>): void;
-export const localSqlitePresenceIndicators: readonly ["CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "GITLAB_CI", "FORGEJO_ACTIONS", "GITEA_ACTIONS", "TF_BUILD", "BUILDKITE", "CIRCLECI", "JENKINS_URL", "TEAMCITY_VERSION", "VERCEL", "NETLIFY", "CF_PAGES", "RENDER", "FLY_APP_NAME", "K_SERVICE", "CLOUD_RUN_JOB", "KUBERNETES_SERVICE_HOST", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV", "ECS_CONTAINER_METADATA_URI", "ECS_CONTAINER_METADATA_URI_V4", "WEBSITE_INSTANCE_ID", "WEBSITE_SITE_NAME", "FUNCTIONS_WORKER_RUNTIME", "DYNO", "HEROKU_APP_NAME", "RAILWAY_ENVIRONMENT", "RAILWAY_SERVICE_ID", "NOMAD_ALLOC_ID", "TERRASCALE_DEPLOYMENT", "TERRASCALE_QUALIFICATION"];
+export const localSqlitePresenceIndicators: readonly ["CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "GITLAB_CI", "FORGEJO_ACTIONS", "GITEA_ACTIONS", "TF_BUILD", "BUILDKITE", "CIRCLECI", "JENKINS_URL", "TEAMCITY_VERSION", "VERCEL", "NETLIFY", "CF_PAGES", "RENDER", "K_SERVICE", "CLOUD_RUN_JOB", "KUBERNETES_SERVICE_HOST", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV", "ECS_CONTAINER_METADATA_URI", "ECS_CONTAINER_METADATA_URI_V4", "WEBSITE_INSTANCE_ID", "WEBSITE_SITE_NAME", "FUNCTIONS_WORKER_RUNTIME", "DYNO", "HEROKU_APP_NAME", "RAILWAY_ENVIRONMENT", "RAILWAY_SERVICE_ID", "NOMAD_ALLOC_ID", "TERRASCALE_DEPLOYMENT", "TERRASCALE_QUALIFICATION"];
 /**
  * Explicit opt-in for a hosted development environment.
  *

package/types/ts-auth.d.ts

@@ -38,7 +38,6 @@ export function verifyTsAuthWebhookWithTolerance(signingSecret: string, timestam
  * @typedef {Omit<TsAuthRuntimeConfig, "apiBaseUrl"> & {
  *   readonly apiBaseUrl: string; // The ts-auth deployment's public origin; there is no default.
  *   readonly instanceSlug: string; // The instance the `sk_` key belongs to; it prefixes every route.
- *   readonly useReverseProxy?: boolean; // Route public auth calls through the reverse proxy instead of regional discovery.
  * }} TsAuthClientConfig
  */
 /**
@@ -1335,7 +1334,6 @@ export type TsAuthRuntimeConfig = import("./config.js").TsAuthRuntimeConfig;
 export type TsAuthClientConfig = Omit<TsAuthRuntimeConfig, "apiBaseUrl"> & {
     readonly apiBaseUrl: string;
     readonly instanceSlug: string;
-    readonly useReverseProxy?: boolean;
 };
 export type TsAuthRequestOptions = {
     readonly signal?: AbortSignal | undefined;

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 {};