@centia-io/sdk 0.2.14 → 0.2.15

package/README.md

@@ -602,6 +602,40 @@ await features.deleteFeature('my_schema', 'my_table', [1, 2, 3])
 
 `srs` on `postFeature`/`patchFeature` declares the SRID of the *incoming* geometry. Reading requires a key — use the SQL or WFS APIs to query whole collections. PUT is not supported.
 
+## Snapshots (GeoParquet exports)
+
+`Snapshots` wraps the snapshot API: asynchronous GeoParquet exports of a table or view to S3, and read access to the published snapshot files. It takes a `CentiaHttpClient` and requires a Bearer token:
+
+```ts
+import { createCentiaClient, Snapshots } from '@centia-io/sdk'
+
+const snapshots = new Snapshots(http)
+
+// Queue an export (202; super-user only). The export runs asynchronously.
+const { id } = await snapshots.postSnapshot({ schema: 'geodanmark', relation: 'bygning', srs: 25832 })
+
+// Poll until it finishes (succeeded/failed/superseded) — or use getSnapshot(id) yourself
+const job = await snapshots.waitForSnapshot(id, { intervalMs: 2000, timeoutMs: 300_000 })
+if (job.status === 'failed') throw new Error(job.error ?? 'export failed')
+
+// List jobs, optionally filtered (super-user only)
+const jobs = await snapshots.getSnapshots({ schema: 'geodanmark', relation: 'bygning' })
+
+// Read API — any user with read access to the relation:
+const published = await snapshots.getRelationSnapshots('geodanmark', 'bygning') // newest first
+const meta = await snapshots.getRelationSnapshot('geodanmark', 'bygning', '2026-09-16')
+
+// The Parquet file itself. dataUrl for DuckDB/GDAL/plain fetch; the data
+// methods return the raw Response (stream or buffer it yourself) and follow
+// the 302 redirect to presigned storage URLs.
+const url = snapshots.getRelationSnapshotDataUrl('geodanmark', 'bygning', '2026-09-16')
+const head = await snapshots.headRelationSnapshotData('geodanmark', 'bygning', '2026-09-16') // Content-Length/ETag
+const part = await snapshots.getRelationSnapshotData('geodanmark', 'bygning', '2026-09-16', { range: [0, 1023] })
+const file = await snapshots.getRelationSnapshotFile('geodanmark', 'bygning', '2026-09-16', 'metadata-<id>.json')
+```
+
+The job API is super-user only (403 `SUPER_USER_ONLY`); creating throws 404 (relation not found), 409 (a snapshot of the relation is already pending or running) or 501 (snapshot storage not configured). The read API needs read access to the relation — sub-users with a deny/limit geofence rule get 403 `GEOFENCE_RULES_APPLY`. A snapshot with several data files answers 409 `MULTI_FILE_SNAPSHOT` on `/data`; list `files` in the metadata and fetch them with `getRelationSnapshotFile`.
+
 ## Error handling
 
 - Network/HTTP errors: thrown as `Error` with the status/body text when available.

package/dist/centia-io-sdk.cjs

@@ -707,6 +707,52 @@ var CentiaHttpClient = class {
 			getHeader: (name) => response.headers.get(name)
 		};
 	}
+	/**
+	* Execute a request and return the raw Response without consuming the body.
+	* For binary endpoints (file downloads): follows redirects (a presigned
+	* storage URL — the fetch spec strips Authorization on cross-origin
+	* redirects), sends no Content-Type, and supports extra request headers
+	* such as Range. Throws CentiaApiError on a status not in expectedStatus.
+	*/
+	async requestRaw(opts) {
+		var _this3 = this;
+		var _opts$accept, _opts$expectedStatus2;
+		const url = _this3.buildUrl(opts.path, opts.query);
+		const headers = { "Accept": (_opts$accept = opts.accept) !== null && _opts$accept !== void 0 ? _opts$accept : "*/*" };
+		if (_this3.auth.getAccessToken) {
+			const token = await _this3.auth.getAccessToken();
+			if (token) headers["Authorization"] = `Bearer ${token}`;
+		}
+		if (_this3.auth.getHeaders) Object.assign(headers, await _this3.auth.getHeaders());
+		if (_this3.userAgent && typeof navigator === "undefined") headers["User-Agent"] = _this3.userAgent;
+		Object.assign(headers, opts.headers);
+		const response = await _this3.fetchFn(url, {
+			method: opts.method,
+			headers,
+			redirect: "follow"
+		});
+		if (!((_opts$expectedStatus2 = opts.expectedStatus) !== null && _opts$expectedStatus2 !== void 0 ? _opts$expectedStatus2 : [200]).includes(response.status)) {
+			var _ref, _parsed$message, _response$headers$get;
+			let bodyText = "";
+			try {
+				bodyText = await response.text();
+			} catch (_unused) {}
+			let parsed = null;
+			if (bodyText) try {
+				parsed = JSON.parse(bodyText);
+			} catch (_unused2) {}
+			throw new CentiaApiError({
+				message: ((_ref = (_parsed$message = parsed === null || parsed === void 0 ? void 0 : parsed.message) !== null && _parsed$message !== void 0 ? _parsed$message : parsed === null || parsed === void 0 ? void 0 : parsed.error) !== null && _ref !== void 0 ? _ref : bodyText) || `Unexpected status ${response.status}`,
+				status: response.status,
+				code: parsed === null || parsed === void 0 ? void 0 : parsed.code,
+				details: parsed,
+				requestId: (_response$headers$get = response.headers.get("x-request-id")) !== null && _response$headers$get !== void 0 ? _response$headers$get : void 0,
+				method: opts.method,
+				url
+			});
+		}
+		return response;
+	}
 	buildUrl(path, query) {
 		const cleanPath = path.replace(/^\/+/, "");
 		let url = `${this.baseUrl}/${cleanPath}`;
@@ -717,19 +763,19 @@ var CentiaHttpClient = class {
 		return url;
 	}
 	async buildHeaders(opts) {
-		var _this3 = this;
-		var _opts$accept;
-		const headers = { "Accept": (_opts$accept = opts.accept) !== null && _opts$accept !== void 0 ? _opts$accept : "application/json" };
-		if (_this3.auth.getAccessToken) {
-			const token = await _this3.auth.getAccessToken();
+		var _this4 = this;
+		var _opts$accept2;
+		const headers = { "Accept": (_opts$accept2 = opts.accept) !== null && _opts$accept2 !== void 0 ? _opts$accept2 : "application/json" };
+		if (_this4.auth.getAccessToken) {
+			const token = await _this4.auth.getAccessToken();
 			if (token) headers["Authorization"] = `Bearer ${token}`;
 		}
-		if (_this3.auth.getHeaders) {
-			const authHeaders = await _this3.auth.getHeaders();
+		if (_this4.auth.getHeaders) {
+			const authHeaders = await _this4.auth.getHeaders();
 			Object.assign(headers, authHeaders);
 		}
-		if (_this3.userAgent && typeof navigator === "undefined") headers["User-Agent"] = _this3.userAgent;
-		const ct = _this3.resolveContentType(opts.contentType);
+		if (_this4.userAgent && typeof navigator === "undefined") headers["User-Agent"] = _this4.userAgent;
+		const ct = _this4.resolveContentType(opts.contentType);
 		if (ct) headers["Content-Type"] = ct;
 		return headers;
 	}
@@ -738,24 +784,24 @@ var CentiaHttpClient = class {
 		return contentType !== null && contentType !== void 0 ? contentType : "application/json";
 	}
 	async handleResponse(response, opts, url) {
-		var _opts$expectedStatus2, _parsed;
-		const expectedStatus = (_opts$expectedStatus2 = opts.expectedStatus) !== null && _opts$expectedStatus2 !== void 0 ? _opts$expectedStatus2 : 200;
+		var _opts$expectedStatus3, _parsed;
+		const expectedStatus = (_opts$expectedStatus3 = opts.expectedStatus) !== null && _opts$expectedStatus3 !== void 0 ? _opts$expectedStatus3 : 200;
 		let bodyText = "";
 		try {
 			bodyText = await response.text();
-		} catch (_unused) {}
+		} catch (_unused3) {}
 		let parsed = null;
 		if (bodyText) try {
 			parsed = JSON.parse(bodyText);
-		} catch (_unused2) {}
+		} catch (_unused4) {}
 		if (response.status !== expectedStatus) {
-			var _ref, _parsed$message, _response$headers$get;
+			var _ref2, _parsed$message2, _response$headers$get2;
 			throw new CentiaApiError({
-				message: ((_ref = (_parsed$message = parsed === null || parsed === void 0 ? void 0 : parsed.message) !== null && _parsed$message !== void 0 ? _parsed$message : parsed === null || parsed === void 0 ? void 0 : parsed.error) !== null && _ref !== void 0 ? _ref : bodyText) || `Unexpected status ${response.status}`,
+				message: ((_ref2 = (_parsed$message2 = parsed === null || parsed === void 0 ? void 0 : parsed.message) !== null && _parsed$message2 !== void 0 ? _parsed$message2 : parsed === null || parsed === void 0 ? void 0 : parsed.error) !== null && _ref2 !== void 0 ? _ref2 : bodyText) || `Unexpected status ${response.status}`,
 				status: response.status,
 				code: parsed === null || parsed === void 0 ? void 0 : parsed.code,
 				details: parsed,
-				requestId: (_response$headers$get = response.headers.get("x-request-id")) !== null && _response$headers$get !== void 0 ? _response$headers$get : void 0,
+				requestId: (_response$headers$get2 = response.headers.get("x-request-id")) !== null && _response$headers$get2 !== void 0 ? _response$headers$get2 : void 0,
 				method: opts.method,
 				url
 			});
@@ -3386,6 +3432,150 @@ var Features = class {
 	}
 };
 
+//#endregion
+//#region src/snapshots/Snapshots.ts
+/**
+* Client for the snapshot API: GeoParquet exports of a relation.
+*
+* The job API (`/api/v4/snapshots`) queues and inspects exports and is
+* super-user only; exports run asynchronously — poll with `getSnapshot` or
+* use `waitForSnapshot`. The read API
+* (`/api/v4/schemas/{schema}/relations/{relation}/snapshots`) serves the
+* published snapshots to any user with read access to the relation, with
+* HEAD + byte-range support so Parquet readers can fetch footers and row
+* groups selectively.
+*
+* ```ts
+* const snapshots = new Snapshots(createCentiaClient({ baseUrl, auth }));
+* const { id } = await snapshots.postSnapshot({ schema: 'geodanmark', relation: 'bygning' });
+* const done = await snapshots.waitForSnapshot(id);
+* ```
+*/
+var Snapshots = class {
+	constructor(client) {
+		this.client = client;
+	}
+	relationPath(schema, relation, rest = "") {
+		return `api/v4/schemas/${encodeURIComponent(schema)}/relations/${encodeURIComponent(relation)}/snapshots${rest}`;
+	}
+	/**
+	* Queue a Parquet snapshot of a table or view. Returns 202 with the job id.
+	* Throws `CentiaApiError`: 403 (super-user only), 404 (relation not found),
+	* 409 (a snapshot of the relation is already pending or running),
+	* 501 (snapshot storage not configured).
+	*/
+	async postSnapshot(body) {
+		return this.client.request({
+			path: "api/v4/snapshots",
+			method: "POST",
+			body,
+			expectedStatus: 202
+		});
+	}
+	/** Get a snapshot job by id. Super-user only. */
+	async getSnapshot(id) {
+		return this.client.request({
+			path: `api/v4/snapshots/${encodeURIComponent(id)}`,
+			method: "GET"
+		});
+	}
+	/** List the newest snapshot jobs (50), optionally filtered by schema/relation. Super-user only. */
+	async getSnapshots(options) {
+		var _this3 = this;
+		const query = {};
+		if ((options === null || options === void 0 ? void 0 : options.schema) !== void 0) query.schema = options.schema;
+		if ((options === null || options === void 0 ? void 0 : options.relation) !== void 0) query.relation = options.relation;
+		return _this3.client.request({
+			path: "api/v4/snapshots",
+			method: "GET",
+			query: Object.keys(query).length > 0 ? query : void 0
+		});
+	}
+	/**
+	* Poll a snapshot job until it reaches a terminal status (succeeded, failed
+	* or superseded) and return it — check `status`/`error` on the result.
+	* Throws an `Error` when `timeoutMs` elapses first.
+	*/
+	async waitForSnapshot(id, options) {
+		var _this4 = this;
+		var _options$intervalMs, _options$timeoutMs;
+		const intervalMs = (_options$intervalMs = options === null || options === void 0 ? void 0 : options.intervalMs) !== null && _options$intervalMs !== void 0 ? _options$intervalMs : 2e3;
+		const timeoutMs = (_options$timeoutMs = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _options$timeoutMs !== void 0 ? _options$timeoutMs : 3e5;
+		const deadline = Date.now() + timeoutMs;
+		for (;;) {
+			const job = await _this4.getSnapshot(id);
+			if (job.status === "succeeded" || job.status === "failed" || job.status === "superseded") return job;
+			if (Date.now() + intervalMs > deadline) throw new Error(`Timed out after ${timeoutMs} ms waiting for snapshot ${id} (status: ${job.status})`);
+			await new Promise((resolve) => setTimeout(resolve, intervalMs));
+		}
+	}
+	/** List the published snapshots of a relation, newest first. */
+	async getRelationSnapshots(schema, relation) {
+		var _this5 = this;
+		return _this5.client.request({
+			path: _this5.relationPath(schema, relation),
+			method: "GET"
+		});
+	}
+	/** Get one published snapshot (metadata) by date (`YYYY-MM-DD`). */
+	async getRelationSnapshot(schema, relation, date) {
+		var _this6 = this;
+		return _this6.client.request({
+			path: _this6.relationPath(schema, relation, `/${encodeURIComponent(date)}`),
+			method: "GET"
+		});
+	}
+	/**
+	* Absolute URL of the snapshot's Parquet file, without fetching it — for
+	* DuckDB/GDAL or a plain fetch. Authorization travels in the request
+	* header, so protected relations need the caller to attach the token.
+	*/
+	getRelationSnapshotDataUrl(schema, relation, date) {
+		return `${this.client.baseUrl}/${this.relationPath(schema, relation, `/${encodeURIComponent(date)}/data`)}`;
+	}
+	/**
+	* Fetch the snapshot's Parquet file and return the raw `Response` (stream
+	* or buffer it yourself). Follows the 302 redirect the server answers in
+	* redirect mode. Pass `range` for a single byte range (206). Throws
+	* `CentiaApiError`: 403, 404, 409 (several files; use
+	* getRelationSnapshotFile), 416, 502.
+	*/
+	async getRelationSnapshotData(schema, relation, date, options) {
+		var _this7 = this;
+		return _this7.rawGet(_this7.relationPath(schema, relation, `/${encodeURIComponent(date)}/data`), "GET", options);
+	}
+	/** HEAD request for the snapshot's Parquet file — Content-Length, Accept-Ranges and ETag without the body. */
+	async headRelationSnapshotData(schema, relation, date) {
+		var _this8 = this;
+		return _this8.rawGet(_this8.relationPath(schema, relation, `/${encodeURIComponent(date)}/data`), "HEAD");
+	}
+	/**
+	* Fetch one file of the snapshot by catalog name (`data-<id>.parquet`,
+	* `metadata-<id>.json`). Same redirect/range semantics as
+	* getRelationSnapshotData.
+	*/
+	async getRelationSnapshotFile(schema, relation, date, file, options) {
+		var _this9 = this;
+		return _this9.rawGet(_this9.relationPath(schema, relation, `/${encodeURIComponent(date)}/files/${encodeURIComponent(file)}`), "GET", options);
+	}
+	/** HEAD request for one file of the snapshot. */
+	async headRelationSnapshotFile(schema, relation, date, file) {
+		var _this10 = this;
+		return _this10.rawGet(_this10.relationPath(schema, relation, `/${encodeURIComponent(date)}/files/${encodeURIComponent(file)}`), "HEAD");
+	}
+	async rawGet(path, method, options) {
+		var _this11 = this;
+		const headers = {};
+		if (options === null || options === void 0 ? void 0 : options.range) headers["Range"] = `bytes=${options.range[0]}-${options.range[1]}`;
+		return _this11.client.requestRaw({
+			path,
+			method,
+			headers: Object.keys(headers).length > 0 ? headers : void 0,
+			expectedStatus: [200, 206]
+		});
+	}
+};
+
 //#endregion
 //#region src/auth/errors.ts
 /**
@@ -3525,6 +3715,7 @@ exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;
 exports.SessionExpiredError = SessionExpiredError;
 exports.SignUp = SignUp;
+exports.Snapshots = Snapshots;
 exports.Sql = Sql;
 exports.SqlNoToken = SqlNoToken;
 exports.Stats = Stats;

package/dist/centia-io-sdk.d.cts

@@ -155,6 +155,21 @@ interface RequestOptions {
   /** Expected HTTP status code. Defaults to 200. Non-match throws CentiaApiError. */
   expectedStatus?: number;
 }
+/** Options for a raw request via CentiaHttpClient.requestRaw(). */
+interface RawRequestOptions {
+  /** URL path relative to baseUrl. Leading slash is stripped. */
+  path: string;
+  /** HTTP method. */
+  method: 'GET' | 'HEAD';
+  /** Query parameters appended to the URL. */
+  query?: Record<string, string>;
+  /** Accept header. Defaults to the wildcard media type. */
+  accept?: string;
+  /** Extra request headers, e.g. Range. */
+  headers?: Record<string, string>;
+  /** Accepted HTTP status codes. Defaults to [200]. Non-match throws CentiaApiError. */
+  expectedStatus?: number[];
+}
 /** Full HTTP response with metadata, returned by CentiaHttpClient.requestFull(). */
 interface FullResponse<T> {
   /** Parsed response body (null for empty responses like 204). */
@@ -187,6 +202,14 @@ declare class CentiaHttpClient {
    * Useful for operations that return Location headers (POST 201, PATCH 303).
    */
   requestFull<T = unknown>(opts: RequestOptions): Promise<FullResponse<T>>;
+  /**
+   * Execute a request and return the raw Response without consuming the body.
+   * For binary endpoints (file downloads): follows redirects (a presigned
+   * storage URL — the fetch spec strips Authorization on cross-origin
+   * redirects), sends no Content-Type, and supports extra request headers
+   * such as Range. Throws CentiaApiError on a status not in expectedStatus.
+   */
+  requestRaw(opts: RawRequestOptions): Promise<Response>;
   private buildUrl;
   private buildHeaders;
   private resolveContentType;
@@ -1967,6 +1990,166 @@ declare class Keyvalue {
   deleteKeyvalue(key: string): Promise<void>;
 }
 //#endregion
+//#region src/snapshots/Snapshots.d.ts
+/** Status of a snapshot job. */
+type SnapshotStatus = 'pending' | 'running' | 'succeeded' | 'failed' | 'superseded';
+/** A request to snapshot a table or view to Parquet on S3. */
+interface SnapshotRequest {
+  /** Schema of the relation. */
+  schema: string;
+  /** Table or view name. */
+  relation: string;
+  /** Optional EPSG code to reproject to. Omit to keep the native SRID. */
+  srs?: number;
+}
+/** 202 response from postSnapshot; poll `_links.self` (or getSnapshot) for status. */
+interface SnapshotAccepted {
+  id: string;
+  status: 'pending';
+  _links: {
+    self: string;
+  };
+}
+/** One column of the relation at snapshot time. */
+interface SnapshotColumn {
+  column_name: string;
+  data_type: string;
+}
+/** Status of a snapshot job. */
+interface SnapshotJob {
+  id: string;
+  schema: string;
+  relation: string;
+  srs: number | null;
+  status: SnapshotStatus;
+  /** UTC date the export ran; the {date} segment of the relation snapshot read API. */
+  snapshot_date: string | null;
+  s3_path: string | null;
+  row_count: number | null;
+  /** md5 fingerprint of relation_schema, for drift detection. */
+  schema_version: string | null;
+  relation_schema: SnapshotColumn[] | null;
+  error: string | null;
+  username: string;
+  created: string;
+  started: string | null;
+  finished: string | null;
+}
+/** One file of a published snapshot. */
+interface RelationSnapshotFile {
+  name: string;
+  size_bytes: number;
+  href: string;
+}
+/** A published snapshot of a relation, as returned by the list endpoint. */
+interface RelationSnapshot {
+  snapshot_date: string;
+  snapshot_id: string;
+  row_count: number;
+  size_bytes: number;
+  schema_version: string;
+  files: RelationSnapshotFile[];
+  published: string;
+}
+/** One published snapshot with full metadata, as returned by the single-date endpoint. */
+interface RelationSnapshotDetails extends RelationSnapshot {
+  srs: number | null;
+  relation_schema: SnapshotColumn[] | null;
+  crs: string | null;
+  _links: {
+    data: string;
+    files: {
+      name: string;
+      href: string;
+    }[];
+  };
+}
+/** Filters for getSnapshots. */
+interface GetSnapshotsOptions {
+  schema?: string;
+  relation?: string;
+}
+/** Polling options for waitForSnapshot. */
+interface WaitForSnapshotOptions {
+  /** Milliseconds between polls. Default 2000. */
+  intervalMs?: number;
+  /** Give up after this many milliseconds. Default 300000 (5 minutes). */
+  timeoutMs?: number;
+}
+/** Options for the snapshot data/file download methods. */
+interface SnapshotDataOptions {
+  /** Inclusive byte range to request, e.g. `[0, 1023]` for the first KiB. */
+  range?: [number, number];
+}
+/**
+ * Client for the snapshot API: GeoParquet exports of a relation.
+ *
+ * The job API (`/api/v4/snapshots`) queues and inspects exports and is
+ * super-user only; exports run asynchronously — poll with `getSnapshot` or
+ * use `waitForSnapshot`. The read API
+ * (`/api/v4/schemas/{schema}/relations/{relation}/snapshots`) serves the
+ * published snapshots to any user with read access to the relation, with
+ * HEAD + byte-range support so Parquet readers can fetch footers and row
+ * groups selectively.
+ *
+ * ```ts
+ * const snapshots = new Snapshots(createCentiaClient({ baseUrl, auth }));
+ * const { id } = await snapshots.postSnapshot({ schema: 'geodanmark', relation: 'bygning' });
+ * const done = await snapshots.waitForSnapshot(id);
+ * ```
+ */
+declare class Snapshots {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  private relationPath;
+  /**
+   * Queue a Parquet snapshot of a table or view. Returns 202 with the job id.
+   * Throws `CentiaApiError`: 403 (super-user only), 404 (relation not found),
+   * 409 (a snapshot of the relation is already pending or running),
+   * 501 (snapshot storage not configured).
+   */
+  postSnapshot(body: SnapshotRequest): Promise<SnapshotAccepted>;
+  /** Get a snapshot job by id. Super-user only. */
+  getSnapshot(id: string): Promise<SnapshotJob>;
+  /** List the newest snapshot jobs (50), optionally filtered by schema/relation. Super-user only. */
+  getSnapshots(options?: GetSnapshotsOptions): Promise<SnapshotJob[]>;
+  /**
+   * Poll a snapshot job until it reaches a terminal status (succeeded, failed
+   * or superseded) and return it — check `status`/`error` on the result.
+   * Throws an `Error` when `timeoutMs` elapses first.
+   */
+  waitForSnapshot(id: string, options?: WaitForSnapshotOptions): Promise<SnapshotJob>;
+  /** List the published snapshots of a relation, newest first. */
+  getRelationSnapshots(schema: string, relation: string): Promise<RelationSnapshot[]>;
+  /** Get one published snapshot (metadata) by date (`YYYY-MM-DD`). */
+  getRelationSnapshot(schema: string, relation: string, date: string): Promise<RelationSnapshotDetails>;
+  /**
+   * Absolute URL of the snapshot's Parquet file, without fetching it — for
+   * DuckDB/GDAL or a plain fetch. Authorization travels in the request
+   * header, so protected relations need the caller to attach the token.
+   */
+  getRelationSnapshotDataUrl(schema: string, relation: string, date: string): string;
+  /**
+   * Fetch the snapshot's Parquet file and return the raw `Response` (stream
+   * or buffer it yourself). Follows the 302 redirect the server answers in
+   * redirect mode. Pass `range` for a single byte range (206). Throws
+   * `CentiaApiError`: 403, 404, 409 (several files; use
+   * getRelationSnapshotFile), 416, 502.
+   */
+  getRelationSnapshotData(schema: string, relation: string, date: string, options?: SnapshotDataOptions): Promise<Response>;
+  /** HEAD request for the snapshot's Parquet file — Content-Length, Accept-Ranges and ETag without the body. */
+  headRelationSnapshotData(schema: string, relation: string, date: string): Promise<Response>;
+  /**
+   * Fetch one file of the snapshot by catalog name (`data-<id>.parquet`,
+   * `metadata-<id>.json`). Same redirect/range semantics as
+   * getRelationSnapshotData.
+   */
+  getRelationSnapshotFile(schema: string, relation: string, date: string, file: string, options?: SnapshotDataOptions): Promise<Response>;
+  /** HEAD request for one file of the snapshot. */
+  headRelationSnapshotFile(schema: string, relation: string, date: string, file: string): Promise<Response>;
+  private rawGet;
+}
+//#endregion
 //#region src/auth/types.d.ts
 interface StoredCredentials {
   token?: string;
@@ -2076,5 +2259,5 @@ declare class SessionExpiredError extends Error {
 */
 
 //#endregion
-export { type AsyncInvocationAccepted, type AuthService, type BatchMessage, type CentiaAdminClient, CentiaApiError, type CentiaApiErrorOptions, type CentiaAuth, type CentiaClientConfig, type CentiaHttpClient, Claims, type ClientInfo, CodeFlow, type CodeFlowOptions, type ColumnDef, type ColumnInfo, type CommitRequest, type CommitResult, type ConstraintInfo, type CreateClientRequest, type CreateClientResponse, type CreateColumnRequest, type CreateConstraintRequest, type CreateFunctionRequest, type CreateIndexRequest, type CreateKeyvalueRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type DeleteMapcacheTilesetOptions, type DryRunResult, type FeatureKey, type FeatureSrsOptions, Features, type FileProcessRequest, type FileProcessResponse, type FileUploadOptions, type FontWeight, type FullResponse, type FunctionEventOp, type FunctionInfo, type FunctionInvocationRecord, type FunctionInvocationResult, type FunctionPackage, type FunctionRuntime, type FunctionStatus, type FunctionTriggers, type GeoJsonFeature, type GeoJsonFeatureCollection, type GeoJsonGeometry, type GeomTransform, type GetLayerOptions, type GetSchemaOptions, Gql, type GqlRequest, type GqlResponse, GuestFlow, type GuestFlowOptions, type IndexInfo, Keyvalue, type KeyvalueEntry, type KeyvalueProjection, type Label, type LabelPosition, type Layer, type LayerCacheType, type LayerClass, type LayerGeotype, type LayerProperties, type LayerTileFormat, type LineCap, type LocationResponse, type MapConfig, Mapcache, type MapcacheParams, type MapcacheTilesetDeleteResult, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, OGC_CRS84, Ogc, type OgcBbox, type OgcCollection, type OgcCollections, type OgcCollectionsOptions, type OgcConformance, type OgcExtent, type OgcFeature, type OgcFeatureCollection, type OgcItemOptions, type OgcItemsOptions, type OgcLandingPage, type OgcLink, type OgcMapOptions, type OgcSpatialOptions, type Options, Ows, type OwsParams, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchFeatureOptions, type PatchFunctionRequest, type PatchKeyvalueRequest, type PatchMetadataRequest, type PatchPrivilegeRequest, type PatchRpcMethodRequest, type PatchRuleRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PrivilegeInfo, type PrivilegeLevel, type RenameSchemaRequest, type RequestOptions, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcMethodInfo, type RpcRequest, type RpcResponse, type RuleAccess, type RuleInfo, type RuleRequest, type RuleService, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, Sql, SqlNoToken, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type StoredCredentials, type Style, type SubscriptionAckMessage, type SubscriptionRequest, type TableBatch, type TableDef, type TableInfo, Tables, type TokenProvider, type TokenStore, type UserInfo, Users, Wfs, type WfsGetParams, type WfsPathOptions, Ws, type WsErrorMessage, type WsMessage, type WsOptions, createApi, createCentiaAdminClient, createCentiaClient, createSqlBuilder, createTokenProvider, isCentiaApiError, ogcEpsgCrs };
+export { type AsyncInvocationAccepted, type AuthService, type BatchMessage, type CentiaAdminClient, CentiaApiError, type CentiaApiErrorOptions, type CentiaAuth, type CentiaClientConfig, type CentiaHttpClient, Claims, type ClientInfo, CodeFlow, type CodeFlowOptions, type ColumnDef, type ColumnInfo, type CommitRequest, type CommitResult, type ConstraintInfo, type CreateClientRequest, type CreateClientResponse, type CreateColumnRequest, type CreateConstraintRequest, type CreateFunctionRequest, type CreateIndexRequest, type CreateKeyvalueRequest, type CreateRpcMethodRequest, type CreateRuleRequest, type CreateSchemaRequest, type CreateSequenceRequest, type CreateTokenProviderOptions, type CreateUserRequest, type DBSchema, type DeleteMapcacheTilesetOptions, type DryRunResult, type FeatureKey, type FeatureSrsOptions, Features, type FileProcessRequest, type FileProcessResponse, type FileUploadOptions, type FontWeight, type FullResponse, type FunctionEventOp, type FunctionInfo, type FunctionInvocationRecord, type FunctionInvocationResult, type FunctionPackage, type FunctionRuntime, type FunctionStatus, type FunctionTriggers, type GeoJsonFeature, type GeoJsonFeatureCollection, type GeoJsonGeometry, type GeomTransform, type GetLayerOptions, type GetSchemaOptions, type GetSnapshotsOptions, Gql, type GqlRequest, type GqlResponse, GuestFlow, type GuestFlowOptions, type IndexInfo, Keyvalue, type KeyvalueEntry, type KeyvalueProjection, type Label, type LabelPosition, type Layer, type LayerCacheType, type LayerClass, type LayerGeotype, type LayerProperties, type LayerTileFormat, type LineCap, type LocationResponse, type MapConfig, Mapcache, type MapcacheParams, type MapcacheTilesetDeleteResult, Meta, type MetadataFieldInfo, type MetadataRelationInfo, NotLoggedInError, OGC_CRS84, Ogc, type OgcBbox, type OgcCollection, type OgcCollections, type OgcCollectionsOptions, type OgcConformance, type OgcExtent, type OgcFeature, type OgcFeatureCollection, type OgcItemOptions, type OgcItemsOptions, type OgcLandingPage, type OgcLink, type OgcMapOptions, type OgcSpatialOptions, type Options, Ows, type OwsParams, type ParamsOfApiMethod, PasswordFlow, type PasswordFlowOptions, type PatchClientRequest, type PatchColumnRequest, type PatchFeatureOptions, type PatchFunctionRequest, type PatchKeyvalueRequest, type PatchMetadataRequest, type PatchPrivilegeRequest, type PatchRpcMethodRequest, type PatchRuleRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PrivilegeInfo, type PrivilegeLevel, type RawRequestOptions, type RelationSnapshot, type RelationSnapshotDetails, type RelationSnapshotFile, type RenameSchemaRequest, type RequestOptions, type RowForTable, type RowOfApiCall, type RowOfApiMethod, type RowOfRequest, type RowOfSelect, type RowsOfApiCall, type RowsOfApiMethod, type RowsOfRequest, type RowsOfSelect, Rpc, type RpcMethodInfo, type RpcRequest, type RpcResponse, type RuleAccess, type RuleInfo, type RuleRequest, type RuleService, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, type SnapshotAccepted, type SnapshotColumn, type SnapshotDataOptions, type SnapshotJob, type SnapshotRequest, type SnapshotStatus, Snapshots, Sql, SqlNoToken, type SqlNoTokenRequest, type SqlRequest, type SqlResponse, Stats, Status, type StoredCredentials, type Style, type SubscriptionAckMessage, type SubscriptionRequest, type TableBatch, type TableDef, type TableInfo, Tables, type TokenProvider, type TokenStore, type UserInfo, Users, type WaitForSnapshotOptions, Wfs, type WfsGetParams, type WfsPathOptions, Ws, type WsErrorMessage, type WsMessage, type WsOptions, createApi, createCentiaAdminClient, createCentiaClient, createSqlBuilder, createTokenProvider, isCentiaApiError, ogcEpsgCrs };
 //# sourceMappingURL=centia-io-sdk.d.cts.map