@centia-io/sdk 0.2.15 → 0.2.17

package/README.md

@@ -612,7 +612,18 @@ 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 })
+// formats picks the output format(s) — 'parquet' (default) and/or 'flatgeobuf'.
+const { id } = await snapshots.postSnapshot({
+  schema: 'geodanmark', relation: 'bygning', srs: 25832, formats: ['parquet', 'flatgeobuf'],
+})
+
+// Or queue several at once (all-or-nothing; accepted jobs come back in request order).
+// getSnapshot also accepts an array of ids.
+const accepted = await snapshots.postSnapshot([
+  { schema: 'geodanmark', relation: 'bygning' },
+  { schema: 'geodanmark', relation: 'vej' },
+])
+const both = await snapshots.getSnapshot(accepted.map((a) => a.id))
 
 // Poll until it finishes (succeeded/failed/superseded) — or use getSnapshot(id) yourself
 const job = await snapshots.waitForSnapshot(id, { intervalMs: 2000, timeoutMs: 300_000 })
@@ -632,10 +643,55 @@ const url = snapshots.getRelationSnapshotDataUrl('geodanmark', 'bygning', '2026-
 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')
+
+// One specific output format ('parquet' | 'flatgeobuf'). The snapshot's
+// `formats` array says what was produced (status/size/media_type/href).
+const fgbUrl = snapshots.getRelationSnapshotDataFormatUrl('geodanmark', 'bygning', '2026-09-16', 'flatgeobuf')
+const fgb = await snapshots.getRelationSnapshotDataFormat('geodanmark', 'bygning', '2026-09-16', 'flatgeobuf', { range: [0, 1023] })
 ```
 
 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`.
 
+## Scheduler (recurring imports)
+
+`Scheduler` wraps the scheduler API: cron-scheduled data-import jobs and their runs. Super-user only. It takes a `CentiaHttpClient` and requires a Bearer token:
+
+```ts
+import { createCentiaClient, Scheduler } from '@centia-io/sdk'
+
+const scheduler = new Scheduler(http)
+
+// Create one or more jobs (201; arrays are all-or-nothing). The new ids are
+// parsed from the Location header, in request order.
+const { ids } = await scheduler.postSchedulerJob({
+  name: 'import buildings',
+  schema: 'geodanmark',
+  url: 'https://example.com/data.zip',
+  schedule: '0 3 * * *', // 5-field cron
+  epsg: 25832,           // defaults: epsg 4326, type "AUTO", encoding "UTF8",
+})                       // delete_append false, download_schema true, active true, snapshot false
+
+// Read jobs — a single id returns one job, an array returns an array
+const jobs = await scheduler.getSchedulerJobs()
+const job = await scheduler.getSchedulerJob(ids[0])
+const some = await scheduler.getSchedulerJob([5497, 5498])
+
+// Update / delete (delete is all-or-nothing; 409 if a run is in progress)
+await scheduler.patchSchedulerJob(ids[0], { active: false })
+await scheduler.deleteSchedulerJob([5497, 5498])
+
+// Runs. Starting is asynchronous (202) — poll getSchedulerRuns until it finishes.
+await scheduler.postSchedulerRun({ job: ids[0], force: true }) // force ignores delete_append and overwrites
+const runs = await scheduler.getSchedulerRuns({ job: ids[0], status: 'running' })
+const run = await scheduler.getSchedulerRun(runs[0].uuid)
+
+// Stop a running run: SIGINT, escalated to SIGKILL by the server after 30 s.
+// The request itself can take up to ~30 s — do not use a short timeout.
+const { signal } = await scheduler.deleteSchedulerRun(runs[0].uuid)
+```
+
+Errors throw `CentiaApiError` with status/code: 400 `INVALID_CRON_FIELD`/`INPUT_VALIDATION_ERROR`, 404 `JOB_NOT_FOUND`/`RUN_NOT_FOUND`, 409 `JOB_RUNNING`.
+
 ## Error handling
 
 - Network/HTTP errors: thrown as `Error` with the status/body text when available.

package/dist/centia-io-sdk.cjs

@@ -3458,12 +3458,6 @@ var Snapshots = class {
 	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",
@@ -3472,10 +3466,11 @@ var Snapshots = class {
 			expectedStatus: 202
 		});
 	}
-	/** Get a snapshot job by id. Super-user only. */
 	async getSnapshot(id) {
-		return this.client.request({
-			path: `api/v4/snapshots/${encodeURIComponent(id)}`,
+		var _this2 = this;
+		const keys = Array.isArray(id) ? id : [id];
+		return _this2.client.request({
+			path: `api/v4/snapshots/${keys.map((k) => encodeURIComponent(k)).join(",")}`,
 			method: "GET"
 		});
 	}
@@ -3550,24 +3545,46 @@ var Snapshots = class {
 		return _this8.rawGet(_this8.relationPath(schema, relation, `/${encodeURIComponent(date)}/data`), "HEAD");
 	}
 	/**
+	* Absolute URL of one output format of the snapshot, without fetching it —
+	* for DuckDB/GDAL or a plain fetch.
+	*/
+	getRelationSnapshotDataFormatUrl(schema, relation, date, format) {
+		return `${this.client.baseUrl}/${this.relationPath(schema, relation, `/${encodeURIComponent(date)}/data/${encodeURIComponent(format)}`)}`;
+	}
+	/**
+	* Fetch one output format of the snapshot (Content-Type is the format's
+	* media type). Same redirect/range semantics as getRelationSnapshotData.
+	* Throws `CentiaApiError`: 400 (unknown format id), 404 (no snapshot for
+	* that date, or the format was skipped/not requested), 403, 416, 502.
+	*/
+	async getRelationSnapshotDataFormat(schema, relation, date, format, options) {
+		var _this9 = this;
+		return _this9.rawGet(_this9.relationPath(schema, relation, `/${encodeURIComponent(date)}/data/${encodeURIComponent(format)}`), "GET", options);
+	}
+	/** HEAD request for one output format of the snapshot. */
+	async headRelationSnapshotDataFormat(schema, relation, date, format) {
+		var _this10 = this;
+		return _this10.rawGet(_this10.relationPath(schema, relation, `/${encodeURIComponent(date)}/data/${encodeURIComponent(format)}`), "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);
+		var _this11 = this;
+		return _this11.rawGet(_this11.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");
+		var _this12 = this;
+		return _this12.rawGet(_this12.relationPath(schema, relation, `/${encodeURIComponent(date)}/files/${encodeURIComponent(file)}`), "HEAD");
 	}
 	async rawGet(path, method, options) {
-		var _this11 = this;
+		var _this13 = 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({
+		return _this13.client.requestRaw({
 			path,
 			method,
 			headers: Object.keys(headers).length > 0 ? headers : void 0,
@@ -3576,6 +3593,126 @@ var Snapshots = class {
 	}
 };
 
+//#endregion
+//#region src/scheduler/Scheduler.ts
+function idsPath(id) {
+	return (Array.isArray(id) ? id : [id]).map((k) => encodeURIComponent(String(k))).join(",");
+}
+/**
+* Client for the scheduler API (`/api/v4/scheduler`). Super-user only.
+*
+* Jobs describe recurring data imports (cron-scheduled); runs are their
+* executions. Starting a run is asynchronous — poll `getSchedulerRuns`
+* (the `_links.runs` of the 202) until the run finishes.
+*
+* ```ts
+* const scheduler = new Scheduler(createCentiaClient({ baseUrl, auth }));
+* const { ids } = await scheduler.postSchedulerJob({ name, schema, url, schedule: '0 3 * * *' });
+* await scheduler.postSchedulerRun({ job: ids[0] });
+* ```
+*/
+var Scheduler = class {
+	constructor(client) {
+		this.client = client;
+	}
+	/** List all scheduler jobs. */
+	async getSchedulerJobs() {
+		return this.client.request({
+			path: "api/v4/scheduler/jobs",
+			method: "GET"
+		});
+	}
+	async getSchedulerJob(id) {
+		return this.client.request({
+			path: `api/v4/scheduler/jobs/${idsPath(id)}`,
+			method: "GET"
+		});
+	}
+	/**
+	* Create one or more jobs (201; all-or-nothing for arrays). Returns the
+	* Location header and the new ids parsed from it, in request order.
+	*/
+	async postSchedulerJob(body) {
+		var _this3 = this;
+		var _res$getHeader, _location$split$pop;
+		const location = (_res$getHeader = (await _this3.client.requestFull({
+			path: "api/v4/scheduler/jobs",
+			method: "POST",
+			body,
+			expectedStatus: 201
+		})).getHeader("Location")) !== null && _res$getHeader !== void 0 ? _res$getHeader : "";
+		return {
+			location,
+			ids: ((_location$split$pop = location.split("/").pop()) !== null && _location$split$pop !== void 0 ? _location$split$pop : "").split(",").map((s) => Number(s)).filter((n) => Number.isFinite(n))
+		};
+	}
+	/** Partially update a job (303 + Location). */
+	async patchSchedulerJob(id, body) {
+		var _this4 = this;
+		var _res$getHeader2;
+		return { location: (_res$getHeader2 = (await _this4.client.requestFull({
+			path: `api/v4/scheduler/jobs/${idsPath(id)}`,
+			method: "PATCH",
+			body,
+			expectedStatus: 303
+		})).getHeader("Location")) !== null && _res$getHeader2 !== void 0 ? _res$getHeader2 : "" };
+	}
+	/**
+	* Delete one or more jobs (204). Nothing is deleted if any id fails:
+	* throws 404 (unknown id) or 409 (a run is in progress).
+	*/
+	async deleteSchedulerJob(id) {
+		await this.client.request({
+			path: `api/v4/scheduler/jobs/${idsPath(id)}`,
+			method: "DELETE",
+			expectedStatus: 204
+		});
+	}
+	/** List runs (running plus the newest 50 finished), optionally filtered by job and status. */
+	async getSchedulerRuns(options) {
+		var _this6 = this;
+		const query = {};
+		if ((options === null || options === void 0 ? void 0 : options.job) !== void 0) query.job = String(options.job);
+		if ((options === null || options === void 0 ? void 0 : options.status) !== void 0) query.status = options.status;
+		return _this6.client.request({
+			path: "api/v4/scheduler/runs",
+			method: "GET",
+			query: Object.keys(query).length > 0 ? query : void 0
+		});
+	}
+	/** Get one run by uuid. */
+	async getSchedulerRun(uuid) {
+		return this.client.request({
+			path: `api/v4/scheduler/runs/${encodeURIComponent(uuid)}`,
+			method: "GET"
+		});
+	}
+	/**
+	* Start a run of a job (202). Throws 404 (unknown job) or 409 (a run of
+	* the job is already running).
+	*/
+	async postSchedulerRun(body) {
+		return this.client.request({
+			path: "api/v4/scheduler/runs",
+			method: "POST",
+			body,
+			expectedStatus: 202
+		});
+	}
+	/**
+	* Stop a running run: sends SIGINT, which the server escalates to SIGKILL
+	* after 30 s — the request itself can take up to ~30 s, so do not use a
+	* short timeout. Throws 404 (no running run with that uuid) or 409 (the
+	* run is on another host).
+	*/
+	async deleteSchedulerRun(uuid) {
+		return this.client.request({
+			path: `api/v4/scheduler/runs/${encodeURIComponent(uuid)}`,
+			method: "DELETE"
+		});
+	}
+};
+
 //#endregion
 //#region src/auth/errors.ts
 /**
@@ -3713,6 +3850,7 @@ exports.Ogc = Ogc;
 exports.Ows = Ows;
 exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;
+exports.Scheduler = Scheduler;
 exports.SessionExpiredError = SessionExpiredError;
 exports.SignUp = SignUp;
 exports.Snapshots = Snapshots;

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

@@ -1993,7 +1993,29 @@ declare class Keyvalue {
 //#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. */
+/** A snapshot output format id. Known ids: `parquet`, `flatgeobuf` — extensible server-side. */
+type SnapshotFormat = 'parquet' | 'flatgeobuf' | (string & {});
+/**
+ * One output format of a snapshot and what became of it: `requested` before
+ * the worker ran, then `produced` (with file, size and media type) or
+ * `skipped` (with a reason, e.g. a geometry-only format on a relation
+ * without geometry).
+ */
+interface SnapshotFormatResult {
+  format: SnapshotFormat;
+  status: 'requested' | 'produced' | 'skipped';
+  /** Produced only: file name in the snapshot directory. */
+  file?: string;
+  /** Produced only. */
+  size_bytes?: number;
+  /** Produced only. */
+  media_type?: string;
+  /** Skipped only: why this format could not be produced. */
+  reason?: string;
+  /** Produced only, and only in the relation snapshot read API: where to download this format. */
+  href?: string;
+}
+/** A request to snapshot a table or view to S3. */
 interface SnapshotRequest {
   /** Schema of the relation. */
   schema: string;
@@ -2001,6 +2023,14 @@ interface SnapshotRequest {
   relation: string;
   /** Optional EPSG code to reproject to. Omit to keep the native SRID. */
   srs?: number;
+  /**
+   * Output formats to produce, in order. Omit to use the server default
+   * (usually `['parquet']`). Must be non-empty and free of duplicates; a
+   * geometry-only format (FlatGeobuf) is skipped with a reason for a
+   * relation without geometry — unless every requested format needs one,
+   * which is refused up front (400).
+   */
+  formats?: SnapshotFormat[];
 }
 /** 202 response from postSnapshot; poll `_links.self` (or getSnapshot) for status. */
 interface SnapshotAccepted {
@@ -2034,6 +2064,8 @@ interface SnapshotJob {
   created: string;
   started: string | null;
   finished: string | null;
+  /** One entry per requested output format and its outcome. */
+  formats: SnapshotFormatResult[];
 }
 /** One file of a published snapshot. */
 interface RelationSnapshotFile {
@@ -2050,6 +2082,8 @@ interface RelationSnapshot {
   schema_version: string;
   files: RelationSnapshotFile[];
   published: string;
+  /** One entry per requested output format; a produced one carries its `href` under `/data/{format}`. */
+  formats: SnapshotFormatResult[];
 }
 /** One published snapshot with full metadata, as returned by the single-date endpoint. */
 interface RelationSnapshotDetails extends RelationSnapshot {
@@ -2103,14 +2137,20 @@ declare class Snapshots {
   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).
+   * Queue Parquet snapshots of one or more tables or views (an array returns
+   * an array, in request order; all-or-nothing). Returns 202 with the job
+   * id(s). Throws `CentiaApiError`: 400 (duplicates or an empty list),
+   * 403 (super-user only), 404 (relation not found), 409 (a snapshot of a
+   * relation is already pending or running), 501 (storage not configured).
    */
   postSnapshot(body: SnapshotRequest): Promise<SnapshotAccepted>;
-  /** Get a snapshot job by id. Super-user only. */
+  postSnapshot(body: SnapshotRequest[]): Promise<SnapshotAccepted[]>;
+  /**
+   * Get one snapshot job by id, or several (an array returns an array).
+   * Throws a 404 `CentiaApiError` when any id is unknown. Super-user only.
+   */
   getSnapshot(id: string): Promise<SnapshotJob>;
+  getSnapshot(ids: string[]): Promise<SnapshotJob[]>;
   /** List the newest snapshot jobs (50), optionally filtered by schema/relation. Super-user only. */
   getSnapshots(options?: GetSnapshotsOptions): Promise<SnapshotJob[]>;
   /**
@@ -2139,6 +2179,20 @@ declare class Snapshots {
   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>;
+  /**
+   * Absolute URL of one output format of the snapshot, without fetching it —
+   * for DuckDB/GDAL or a plain fetch.
+   */
+  getRelationSnapshotDataFormatUrl(schema: string, relation: string, date: string, format: SnapshotFormat): string;
+  /**
+   * Fetch one output format of the snapshot (Content-Type is the format's
+   * media type). Same redirect/range semantics as getRelationSnapshotData.
+   * Throws `CentiaApiError`: 400 (unknown format id), 404 (no snapshot for
+   * that date, or the format was skipped/not requested), 403, 416, 502.
+   */
+  getRelationSnapshotDataFormat(schema: string, relation: string, date: string, format: SnapshotFormat, options?: SnapshotDataOptions): Promise<Response>;
+  /** HEAD request for one output format of the snapshot. */
+  headRelationSnapshotDataFormat(schema: string, relation: string, date: string, format: SnapshotFormat): Promise<Response>;
   /**
    * Fetch one file of the snapshot by catalog name (`data-<id>.parquet`,
    * `metadata-<id>.json`). Same redirect/range semantics as
@@ -2150,6 +2204,149 @@ declare class Snapshots {
   private rawGet;
 }
 //#endregion
+//#region src/scheduler/Scheduler.d.ts
+/** Status of a scheduler run. */
+type SchedulerRunStatus = 'running' | 'succeeded' | 'failed' | 'skipped' | 'lost';
+/** Body for creating a scheduler job. Server defaults: epsg 4326, type "AUTO", encoding "UTF8", delete_append false, download_schema true, active true, snapshot false. */
+interface SchedulerJobInput {
+  name: string;
+  schema: string;
+  url: string;
+  /** 5-field cron expression, e.g. "0 3 * * *". */
+  schedule: string;
+  epsg?: number;
+  type?: string;
+  encoding?: string;
+  extra?: string | null;
+  delete_append?: boolean;
+  download_schema?: boolean;
+  presql?: string | null;
+  postsql?: string | null;
+  active?: boolean;
+  snapshot?: boolean;
+}
+/** Partial update of a scheduler job. */
+type PatchSchedulerJobRequest = Partial<SchedulerJobInput>;
+/** A scheduler job as returned by the API. */
+interface SchedulerJob {
+  id: number;
+  name: string;
+  schema: string;
+  url: string;
+  /** 5-field cron expression. */
+  schedule: string;
+  epsg: number | null;
+  type: string;
+  encoding: string;
+  extra: string | null;
+  delete_append: boolean;
+  download_schema: boolean;
+  presql: string | null;
+  postsql: string | null;
+  active: boolean;
+  snapshot: boolean;
+  lastcheck: boolean | null;
+  lasttimestamp: string | null;
+  lastrun: string | null;
+  report: Record<string, unknown> | null;
+}
+/** 201 response info from postSchedulerJob: the Location header and the ids parsed from it. */
+interface SchedulerJobsCreated extends LocationResponse {
+  ids: number[];
+}
+/** One run of a scheduler job. */
+interface SchedulerRun {
+  uuid: string;
+  job: number;
+  name: string | null;
+  pid: number;
+  host: string | null;
+  slot: number | null;
+  status: SchedulerRunStatus;
+  stale: boolean;
+  started_at: string;
+  heartbeat: string | null;
+  finished_at: string | null;
+  exit_reason: string | null;
+}
+/** Body for starting a run. */
+interface PostSchedulerRunRequest {
+  job: number;
+  /** Ignore delete_append and overwrite. */
+  force?: boolean;
+}
+/** 202 response from postSchedulerRun. */
+interface SchedulerRunAccepted {
+  job: number;
+  status: 'starting';
+  _links: {
+    runs: string;
+  };
+}
+/** 200 response from deleteSchedulerRun. The server escalates SIGINT to SIGKILL after 30 s. */
+interface SchedulerRunStopped {
+  uuid: string;
+  signal: string;
+}
+/** Filters for getSchedulerRuns. */
+interface GetSchedulerRunsOptions {
+  job?: number;
+  status?: SchedulerRunStatus;
+}
+/**
+ * Client for the scheduler API (`/api/v4/scheduler`). Super-user only.
+ *
+ * Jobs describe recurring data imports (cron-scheduled); runs are their
+ * executions. Starting a run is asynchronous — poll `getSchedulerRuns`
+ * (the `_links.runs` of the 202) until the run finishes.
+ *
+ * ```ts
+ * const scheduler = new Scheduler(createCentiaClient({ baseUrl, auth }));
+ * const { ids } = await scheduler.postSchedulerJob({ name, schema, url, schedule: '0 3 * * *' });
+ * await scheduler.postSchedulerRun({ job: ids[0] });
+ * ```
+ */
+declare class Scheduler {
+  private readonly client;
+  constructor(client: CentiaHttpClient);
+  /** List all scheduler jobs. */
+  getSchedulerJobs(): Promise<SchedulerJob[]>;
+  /**
+   * Get one job by id, or several (an array returns an array). Throws a 404
+   * `CentiaApiError` when any id is unknown.
+   */
+  getSchedulerJob(id: number): Promise<SchedulerJob>;
+  getSchedulerJob(ids: number[]): Promise<SchedulerJob[]>;
+  /**
+   * Create one or more jobs (201; all-or-nothing for arrays). Returns the
+   * Location header and the new ids parsed from it, in request order.
+   */
+  postSchedulerJob(body: SchedulerJobInput | SchedulerJobInput[]): Promise<SchedulerJobsCreated>;
+  /** Partially update a job (303 + Location). */
+  patchSchedulerJob(id: number, body: PatchSchedulerJobRequest): Promise<LocationResponse>;
+  /**
+   * Delete one or more jobs (204). Nothing is deleted if any id fails:
+   * throws 404 (unknown id) or 409 (a run is in progress).
+   */
+  deleteSchedulerJob(id: number | number[]): Promise<void>;
+  /** List runs (running plus the newest 50 finished), optionally filtered by job and status. */
+  getSchedulerRuns(options?: GetSchedulerRunsOptions): Promise<SchedulerRun[]>;
+  /** Get one run by uuid. */
+  getSchedulerRun(uuid: string): Promise<SchedulerRun>;
+  /**
+   * Start a run of a job (202). Throws 404 (unknown job) or 409 (a run of
+   * the job is already running).
+   */
+  postSchedulerRun(body: PostSchedulerRunRequest): Promise<SchedulerRunAccepted>;
+  /**
+   * Stop a running run: sends SIGINT, which the server escalates to SIGKILL
+   * after 30 s — the request itself can take up to ~30 s, so do not use a
+   * short timeout. Throws 404 (no running run with that uuid) or 409 (the
+   * run is on another host).
+   */
+  deleteSchedulerRun(uuid: string): Promise<SchedulerRunStopped>;
+}
+//#endregion
 //#region src/auth/types.d.ts
 interface StoredCredentials {
   token?: string;
@@ -2259,5 +2456,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, 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 };
+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 GetSchedulerRunsOptions, 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 PatchSchedulerJobRequest, type PatchSequenceRequest, type PatchUserRequest, type pgTypes_d_exports as PgTypes, type PickRow, type PostSchedulerRunRequest, 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, Scheduler, type SchedulerJob, type SchedulerJobInput, type SchedulerJobsCreated, type SchedulerRun, type SchedulerRunAccepted, type SchedulerRunStatus, type SchedulerRunStopped, type SchemaInfo, type SequenceInfo, SessionExpiredError, SignUp, type SnapshotAccepted, type SnapshotColumn, type SnapshotDataOptions, type SnapshotFormat, type SnapshotFormatResult, 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