@archont561/qgis-sdk 0.4.0 → 0.6.0

package/dist/shared/{chunk-khemhx86.d.ts → chunk-7tgzmz0m.d.ts}

@@ -1,9 +1,9 @@
 import { QgisSdkError2 } from "./chunk-pdj2fxjb.js";
 declare const HOST_ID2 = "qgis.host";
-declare const HOST_FINGERPRINT2 = "sha256:f96bdf1046434de3c5eae01efb34c8ad2bcd1cf241a3dc42f6c4b613dc7d7d6f";
+declare const HOST_FINGERPRINT2 = "sha256:16790dc8c4d77ef5b5f22636702e913f3d6fb63275d0ae3e5a4ca6e8001a9abd";
 declare const HOST_SCHEMA_VERSION2 = 1;
 /** Every declared operation id, so a name can be checked, not guessed. */
-declare const HOST_OPERATIONS2: readonly ["files.export", "layers.get", "layers.list", "layers.open_vector", "network.fetch", "notifications.info", "project.layer_ids", "settings.get", "styles.apply"];
+declare const HOST_OPERATIONS2: readonly ["algorithms.describe", "algorithms.list", "algorithms.providers", "algorithms.run", "files.export", "layers.get", "layers.list", "layers.open_vector", "network.fetch", "notifications.info", "project.layer_ids", "settings.get", "styles.apply"];
 type HostOperationId2 = (typeof HOST_OPERATIONS2)[number];
 interface HostInvokeOptions2 {
 	readonly signal?: AbortSignal;
@@ -38,6 +38,39 @@ declare class QgisSdkHostContractError2 extends QgisSdkError2 {
 	readonly operation: string;
 	constructor(operation: string, message: string);
 }
+interface AlgorithmInfo2 {
+	readonly deprecated: boolean;
+	readonly group: string;
+	readonly group_id: string;
+	readonly help: string;
+	readonly id: string;
+	readonly label: string;
+	readonly name: string;
+	readonly outputs: readonly OutputInfo2[];
+	readonly parameters: readonly ParameterInfo2[];
+	readonly provider: string;
+}
+interface AlgorithmListRequest2 {
+	readonly cursor?: string;
+	readonly limit?: number;
+	readonly provider?: string;
+}
+interface AlgorithmPage2 {
+	readonly items: readonly AlgorithmSummary2[];
+	readonly next_cursor?: string;
+	readonly truncated: boolean;
+}
+interface AlgorithmRequest2 {
+	readonly algorithm_id: string;
+}
+interface AlgorithmSummary2 {
+	readonly deprecated: boolean;
+	readonly group: string;
+	readonly id: string;
+	readonly label: string;
+	readonly name: string;
+	readonly provider: string;
+}
 interface ExportRequest2 {
 	readonly content: string;
 	readonly file: FileRef2;
@@ -56,7 +89,7 @@ interface FetchRequest2 {
 }
 interface FileRef2 {
 	readonly id: string;
-	readonly kind: "file";
+	readonly kind: "file" | "directory";
 	readonly name?: string;
 	readonly operations?: readonly ("read" | "write")[];
 }
@@ -91,10 +124,58 @@ interface NotificationsInfoRequest2 {
 interface OpenVectorRequest2 {
 	readonly file: FileRef2;
 }
+interface OutputInfo2 {
+	readonly kind: string;
+	readonly label: string;
+	readonly name: string;
+}
 interface PageRequest2 {
 	readonly cursor?: string;
 	readonly limit?: number;
 }
+interface ParameterInfo2 {
+	readonly advanced: boolean;
+	readonly default_json: string | null;
+	readonly description: string;
+	readonly destination: boolean;
+	readonly extension: string | null;
+	readonly hidden: boolean;
+	readonly kind: string;
+	readonly label: string;
+	readonly maximum: number | null;
+	readonly minimum: number | null;
+	readonly multiple: boolean;
+	readonly name: string;
+	readonly number_type: string | null;
+	readonly optional: boolean;
+	readonly options: readonly string[];
+	readonly required: boolean;
+}
+interface ProviderInfo2 {
+	readonly id: string;
+	readonly label: string;
+	readonly version: string;
+}
+interface ProviderPage2 {
+	readonly items: readonly ProviderInfo2[];
+	readonly next_cursor?: string;
+	readonly truncated: boolean;
+}
+interface RunAlgorithmRequest2 {
+	readonly algorithm_id: string;
+	readonly params: Record<string, unknown>;
+}
+interface RunOutput2 {
+	readonly file?: FileRef2;
+	readonly kind: "vector" | "file" | "value";
+	readonly layer?: VectorLayerInfo2;
+	readonly name: string;
+	readonly value?: string | number | boolean | null;
+}
+interface RunResult2 {
+	readonly algorithm: string;
+	readonly outputs: readonly RunOutput2[];
+}
 interface SettingsGetRequest2 {
 	readonly default?: string | null;
 	readonly key: string;
@@ -110,6 +191,10 @@ interface VectorLayerInfo2 {
 	readonly id: string;
 	readonly name: string;
 }
+declare function AlgorithmInfo2(value: unknown, strict?: boolean): value is AlgorithmInfo2;
+declare function AlgorithmListRequest2(value: unknown, strict?: boolean): value is AlgorithmListRequest2;
+declare function AlgorithmPage2(value: unknown, strict?: boolean): value is AlgorithmPage2;
+declare function AlgorithmRequest2(value: unknown, strict?: boolean): value is AlgorithmRequest2;
 declare function ExportRequest2(value: unknown, strict?: boolean): value is ExportRequest2;
 declare function ExportResult2(value: unknown, strict?: boolean): value is ExportResult2;
 declare function FetchRequest2(value: unknown, strict?: boolean): value is FetchRequest2;
@@ -120,6 +205,9 @@ declare function NetworkFetchData2(value: unknown, strict?: boolean): value is N
 declare function NotificationsInfoRequest2(value: unknown, strict?: boolean): value is NotificationsInfoRequest2;
 declare function OpenVectorRequest2(value: unknown, strict?: boolean): value is OpenVectorRequest2;
 declare function PageRequest2(value: unknown, strict?: boolean): value is PageRequest2;
+declare function ProviderPage2(value: unknown, strict?: boolean): value is ProviderPage2;
+declare function RunAlgorithmRequest2(value: unknown, strict?: boolean): value is RunAlgorithmRequest2;
+declare function RunResult2(value: unknown, strict?: boolean): value is RunResult2;
 declare function SettingsGetRequest2(value: unknown, strict?: boolean): value is SettingsGetRequest2;
 declare function StylesApplyRequest2(value: unknown, strict?: boolean): value is StylesApplyRequest2;
 /** One event of `network.fetch`, narrowed by its kind. */
@@ -130,6 +218,12 @@ type NetworkFetchEvent2 = {
 declare function NetworkFetchEvent2(value: unknown, strict?: boolean): value is NetworkFetchEvent2;
 /** Every operation this surface declares, as callable methods. */
 interface HostOperations2 {
+	readonly algorithms: {
+		readonly describe: (input: AlgorithmRequest2, options?: HostInvokeOptions2) => Promise<AlgorithmInfo2>;
+		readonly list: (input?: AlgorithmListRequest2, options?: HostInvokeOptions2) => Promise<AlgorithmPage2>;
+		readonly providers: (input?: PageRequest2, options?: HostInvokeOptions2) => Promise<ProviderPage2>;
+		readonly run: (input: RunAlgorithmRequest2, options?: HostInvokeOptions2) => Promise<RunResult2>;
+	};
 	readonly files: {
 		readonly export: (input: ExportRequest2, options?: HostInvokeOptions2) => Promise<ExportResult2>;
 	};
@@ -155,4 +249,4 @@ interface HostOperations2 {
 	};
 }
 declare function createHost2(client: HostClientLike2): HostOperations2;
-export { HOST_ID2, HOST_FINGERPRINT2, HOST_SCHEMA_VERSION2, HOST_OPERATIONS2, HostOperationId2, HostInvokeOptions2, HostClientLike2, HostStreamTerminal2, HostStreamHandlers2, HostStreamHandle2, QgisSdkHostContractError2, ExportRequest2, ExportResult2, FetchRequest2, FileRef2, HttpHeader2, IdPage2, LayerPage2, LayerRequest2, NetworkFetchData2, NotificationsInfoRequest2, OpenVectorRequest2, PageRequest2, SettingsGetRequest2, StylesApplyRequest2, VectorLayerInfo2, NetworkFetchEvent2, HostOperations2, createHost2 };
+export { HOST_ID2, HOST_FINGERPRINT2, HOST_SCHEMA_VERSION2, HOST_OPERATIONS2, HostOperationId2, HostInvokeOptions2, HostClientLike2, HostStreamTerminal2, HostStreamHandlers2, HostStreamHandle2, QgisSdkHostContractError2, AlgorithmInfo2, AlgorithmListRequest2, AlgorithmPage2, AlgorithmRequest2, AlgorithmSummary2, ExportRequest2, ExportResult2, FetchRequest2, FileRef2, HttpHeader2, IdPage2, LayerPage2, LayerRequest2, NetworkFetchData2, NotificationsInfoRequest2, OpenVectorRequest2, OutputInfo2, PageRequest2, ParameterInfo2, ProviderInfo2, ProviderPage2, RunAlgorithmRequest2, RunOutput2, RunResult2, SettingsGetRequest2, StylesApplyRequest2, VectorLayerInfo2, NetworkFetchEvent2, HostOperations2, createHost2 };

package/dist/shared/{chunk-wtv4vt4q.d.ts → chunk-8c12nwme.d.ts}

@@ -70,7 +70,7 @@ declare class QgisSdkContractValidationError2 extends QgisSdkError2 {
 	toJSON(): SerializedContractValidationError2;
 }
 /**
-* Parse and validate a version 1 `PluginDescription` emitted by `describe_plugin`.
+* Parse and validate a version 1 `PluginDescription` emitted by `describe(app)`.
 */
 declare function parsePluginDescription2(input: string | Readonly<Record<string, unknown>>): PluginDescription2;
 declare const BRIDGE_PROTOCOL_VERSION2: 1;
@@ -134,75 +134,6 @@ interface BridgeClientOptions2 {
 interface InvokeOptions2 {
 	readonly signal?: AbortSignal;
 }
-/**
-* An envelope or reply does not match the versioned bridge protocol.
-*/
-declare class QgisSdkBridgeProtocolError2 extends QgisSdkError2 {
-	constructor(message: string);
-}
-/**
-* The host did not answer in time. The call may still have run, so this is an
-* unknown outcome: retrying automatically is forbidden, deciding is the caller's.
-*/
-declare class QgisSdkBridgeTimeoutError2 extends QgisSdkError2 {
-	readonly callId: string;
-	constructor(callId: string, timeoutMs: number);
-}
-/**
-* The caller aborted locally. Distinct from the host cancelling the operation,
-* which arrives as a failure reply carrying the `cancelled` code.
-*/
-declare class QgisSdkBridgeAbortedError2 extends QgisSdkError2 {
-	readonly callId: string;
-	constructor(callId: string);
-}
-/**
-* The client was closed, so pending calls can no longer be answered.
-*/
-declare class QgisSdkBridgeClosedError2 extends QgisSdkError2 {
-	constructor();
-}
-/**
-* A subscription's frames were not the sequence the host promised.
-*
-* The client does not try to reassemble: a missed frame is a fact about the
-* subscription, not something to paper over.
-*/
-declare class QgisSdkBridgeSequenceError2 extends QgisSdkError2 {
-	readonly subscriptionId: string;
-	readonly expected: number;
-	readonly received: number;
-	constructor(subscriptionId: string, expected: number, received: number);
-}
-/**
-* The subscription ended with a terminal frame the caller may want to inspect.
-*/
-declare class QgisSdkBridgeStreamEndedError2 extends QgisSdkError2 {
-	readonly subscriptionId: string;
-	readonly terminal: BridgeStreamTerminal2;
-	constructor(subscriptionId: string, terminal: BridgeStreamTerminal2);
-}
-/**
-* The host refused or failed the operation; `failure.code` is the contract.
-*/
-declare class QgisSdkBridgeRemoteError2 extends QgisSdkError2 {
-	readonly failure: BridgeFailure2;
-	readonly callId: string;
-	constructor(callId: string, failure: BridgeFailure2);
-}
-/**
-* Parse one reply, refusing anything the host could not legitimately have sent.
-*/
-declare function parseInvokeReply2(raw: unknown): InvokeReply2;
-/**
-* Parse one stream frame, refusing anything the host could not legitimately
-* have sent.
-*
-* Exactly one of `event` and `terminal` has to be present: a frame that carries
-* both leaves the client guessing which one wins, and a client that guesses is
-* a client that will eventually deliver an event after the end of a stream.
-*/
-declare function parseStreamFrame2(raw: unknown): BridgeStreamFrame2;
 /** Callbacks a subscription reports through. */
 interface SubscriptionHandlers2 {
 	readonly onEvent?: (event: BridgeStreamEvent2) => void;
@@ -277,4 +208,53 @@ declare class BridgeClient2 {
 	/** The last malformed message this client refused, if any. */
 	get protocolError(): Error | null;
 }
-export { MAX_SAFE_INTEGER2, MIN_SAFE_INTEGER2, PLUGIN_DESCRIPTION_SCHEMA_VERSION2, ValidationDirection2, SerializedValidationIssue2, SerializedContractValidationError2, ActionDescription2, StreamEventKind2, StreamDescription2, PluginDescription2, isSafeJsonInteger2, QgisSdkDeclarationError2, QgisSdkValidationIssue2, QgisSdkContractValidationError2, parsePluginDescription2, BRIDGE_PROTOCOL_VERSION2, MAX_CALL_ID_LENGTH2, BridgeFailure2, InvokeReply2, StreamTerminalKind2, BridgeStreamEvent2, BridgeStreamTerminal2, BridgeEventFrame2, BridgeTerminalFrame2, BridgeStreamFrame2, WireTransport2, BridgeClientOptions2, InvokeOptions2, QgisSdkBridgeProtocolError2, QgisSdkBridgeTimeoutError2, QgisSdkBridgeAbortedError2, QgisSdkBridgeClosedError2, QgisSdkBridgeSequenceError2, QgisSdkBridgeStreamEndedError2, QgisSdkBridgeRemoteError2, parseInvokeReply2, parseStreamFrame2, SubscriptionHandlers2, BridgeSubscription2, BridgeClient2 };
+/**
+* An envelope or reply does not match the versioned bridge protocol.
+*/
+declare class QgisSdkBridgeProtocolError2 extends QgisSdkError2 {
+	constructor(message: string);
+}
+/**
+* The host did not answer in time. The call may still have run, so this is an
+* unknown outcome: retrying automatically is forbidden, deciding is the caller's.
+*/
+declare class QgisSdkBridgeTimeoutError2 extends QgisSdkError2 {
+	readonly callId: string;
+	constructor(callId: string, timeoutMs: number);
+}
+/**
+* The caller aborted locally. Distinct from the host cancelling the operation,
+* which arrives as a failure reply carrying the `cancelled` code.
+*/
+declare class QgisSdkBridgeAbortedError2 extends QgisSdkError2 {
+	readonly callId: string;
+	constructor(callId: string);
+}
+/**
+* The client was closed, so pending calls can no longer be answered.
+*/
+declare class QgisSdkBridgeClosedError2 extends QgisSdkError2 {
+	constructor();
+}
+/**
+* The host refused or failed the operation; `failure.code` is the contract.
+*/
+declare class QgisSdkBridgeRemoteError2 extends QgisSdkError2 {
+	readonly failure: BridgeFailure2;
+	readonly callId: string;
+	constructor(callId: string, failure: BridgeFailure2);
+}
+/**
+* Parse one reply, refusing anything the host could not legitimately have sent.
+*/
+declare function parseInvokeReply2(raw: unknown): InvokeReply2;
+/**
+* Parse one stream frame, refusing anything the host could not legitimately
+* have sent.
+*
+* Exactly one of `event` and `terminal` has to be present: a frame that carries
+* both leaves the client guessing which one wins, and a client that guesses is
+* a client that will eventually deliver an event after the end of a stream.
+*/
+declare function parseStreamFrame2(raw: unknown): BridgeStreamFrame2;
+export { MAX_SAFE_INTEGER2, MIN_SAFE_INTEGER2, PLUGIN_DESCRIPTION_SCHEMA_VERSION2, ValidationDirection2, SerializedValidationIssue2, SerializedContractValidationError2, ActionDescription2, StreamEventKind2, StreamDescription2, PluginDescription2, isSafeJsonInteger2, QgisSdkDeclarationError2, QgisSdkValidationIssue2, QgisSdkContractValidationError2, parsePluginDescription2, BRIDGE_PROTOCOL_VERSION2, MAX_CALL_ID_LENGTH2, BridgeFailure2, InvokeReply2, StreamTerminalKind2, BridgeStreamEvent2, BridgeStreamTerminal2, BridgeEventFrame2, BridgeTerminalFrame2, BridgeStreamFrame2, WireTransport2, BridgeClientOptions2, InvokeOptions2, SubscriptionHandlers2, BridgeSubscription2, BridgeClient2, QgisSdkBridgeProtocolError2, QgisSdkBridgeTimeoutError2, QgisSdkBridgeAbortedError2, QgisSdkBridgeClosedError2, QgisSdkBridgeRemoteError2, parseInvokeReply2, parseStreamFrame2 };

package/dist/shared/chunk-b11znjn6.d.ts

@@ -0,0 +1,342 @@
+import { SerializedValidationIssue2, ActionDescription2, QgisSdkValidationIssue2 } from "./chunk-8c12nwme.js";
+import { HostOperationId2, VectorLayerInfo2 } from "./chunk-7tgzmz0m.js";
+import { OperationShape2, QgisSdkHost2, QgisSdkCore2 } from "./chunk-nwz8n14x.js";
+import { QgisSdkError2 } from "./chunk-pdj2fxjb.js";
+/** A store was built or driven outside the shape it needs. */
+declare class QgisSdkStoreError2 extends QgisSdkError2 {
+	constructor(message: string);
+}
+/** What a listener receives: the whole snapshot, never a diff. */
+type StoreListener2<T> = (snapshot: T) => void;
+/**
+* The contract every store honours, and the one `useSyncExternalStore`,
+* Vue's `shallowRef` wiring and Svelte's `$store` all read.
+*/
+interface Store2<T> {
+	/** The current value; the same object until the next change. Bound. */
+	readonly getSnapshot: () => T;
+	/**
+	* Call `listener` now and after every change; the returned function
+	* stops the calls. Bound. Svelte passes a second `invalidate` argument,
+	* which is ignored.
+	*/
+	readonly subscribe: (listener: StoreListener2<T>) => () => void;
+}
+declare abstract class BaseStore<T> implements Store2<T> {
+	private snapshot;
+	private readonly listeners;
+	protected constructor(initial: T);
+	readonly getSnapshot: () => T;
+	readonly subscribe: (listener: StoreListener2<T>) => (() => void);
+	protected publish(next: T): void;
+}
+/** One schema of the declared dialect, as the description carries it. */
+type DeclaredSchema2 = Readonly<Record<string, unknown>>;
+/** Options for {@link validateAgainstSchema}. */
+interface ValidateOptions2 {
+	/** Ignore properties the schema does not name (results and events). */
+	readonly allowUnknown?: boolean;
+	/** Where the value sits, prefixed to every issue's path. */
+	readonly path?: readonly (string | number)[];
+}
+/** Which side of a call a contract issue belongs to. */
+type ContractDirection2 = "request" | "result" | "event";
+/** The JSON form of {@link QgisSdkContractError}. */
+interface SerializedContractError2 {
+	readonly code: string;
+	readonly operation: string;
+	readonly direction: ContractDirection2;
+	readonly issues: SerializedValidationIssue2[];
+}
+/**
+* An argument, a reply or an event does not match the declared contract.
+*
+* The code is the one both languages use for this category, so a page that
+* already matches `contract_validation_failed` needs no second branch.
+*/
+declare class QgisSdkContractError2 extends QgisSdkError2 {
+	readonly operation: string;
+	readonly direction: ContractDirection2;
+	readonly issues: readonly QgisSdkValidationIssue2[];
+	constructor(operation: string, direction: ContractDirection2, issues: readonly QgisSdkValidationIssue2[]);
+	toJSON(): SerializedContractError2;
+}
+/**
+* Return every issue `value` has against `schema`; an empty array is a match.
+*
+* Throws {@link QgisSdkDeclarationError} when `schema` leaves the declared
+* dialect, because that is a fault in the declaration, never in the value.
+*/
+declare function validateAgainstSchema2(value: unknown, schema: DeclaredSchema2, options?: ValidateOptions2): QgisSdkValidationIssue2[];
+/** Where one invocation stands. */
+type OperationState2<R> = {
+	readonly status: "idle";
+} | {
+	readonly status: "pending";
+} | {
+	readonly status: "ok";
+	readonly value: R;
+} | {
+	readonly status: "error";
+	readonly error: Error;
+};
+/** An operation member of a generated map: input, optional signal, promise. */
+type Operation2<
+	I,
+	R
+> = (input: I, options?: {
+	readonly signal?: AbortSignal;
+}) => Promise<R>;
+/**
+* Run one generated operation.
+*
+* `run` resolves with the value, or with `undefined` when the call failed,
+* was aborted or was superseded by a later run - the state carries the error,
+* so the promise never rejects into an event handler. Only the latest run can
+* change the state. `abort` ends the in-flight call locally (the host may
+* still run it); `reset` aborts and returns to `idle`. The methods are bound,
+* so they can be passed around without the store.
+*/
+declare class OperationStore2<
+	I,
+	R
+> extends BaseStore<OperationState2<R>> {
+	private readonly operation;
+	private generation;
+	private controller;
+	constructor(operation: Operation2<I, R>);
+	readonly abort: () => void;
+	readonly reset: () => void;
+	readonly run: (input: I) => Promise<R | undefined>;
+}
+/**
+* The input families a declared request can ask for: the same names the
+* Python `qgis_sdk.ui` catalogue draws, so a form on either side of the
+* bridge renders one declaration the same way.
+*/
+type FormFieldKind2 = "text" | "integer" | "number" | "boolean" | "choice" | "layer" | "crs" | "metres" | "file" | "directory" | "field" | "range" | "colour";
+/** One input of a declared action, as a page should render it. */
+interface FormField2 {
+	readonly name: string;
+	/** `buffer_distance` -> `Buffer distance`. */
+	readonly label: string;
+	readonly kind: FormFieldKind2;
+	readonly required: boolean;
+	readonly nullable: boolean;
+	/** The `enum` of a `choice` field; empty otherwise. */
+	readonly choices: readonly unknown[];
+	/** Bounds, a parent input, picker filters: what the kind needs beyond a name. */
+	readonly details: Readonly<Record<string, unknown>>;
+	/** The property schema the value is validated against. */
+	readonly schema: DeclaredSchema2;
+}
+/** Render a field name as a label. */
+declare function labelFor2(name: string): string;
+/**
+* The fields of a declared request schema, in declaration order: the
+* TypeScript twin of `qgis_sdk.ui.schema_fields`.
+*/
+declare function schemaFields2(schema: DeclaredSchema2, owner?: string): readonly FormField2[];
+/** The values a form holds: one entry per field the user or the schema set. */
+type FormValues2 = Readonly<Record<string, unknown>>;
+/** Where one form stands. */
+interface FormState2<R> {
+	readonly values: FormValues2;
+	/** Every issue the current values have against the request schema. */
+	readonly issues: readonly QgisSdkValidationIssue2[];
+	/** The first issue code per field name, for a label to show. */
+	readonly errors: Readonly<Record<string, string>>;
+	readonly valid: boolean;
+	/** A value changed since construction or the last `reset`. */
+	readonly dirty: boolean;
+	/** `submit` was attempted since construction or the last `reset`. */
+	readonly submitted: boolean;
+	/** The latest submission, as an operation store reports it. */
+	readonly submission: OperationState2<R>;
+}
+/** Options for {@link FormStore}. */
+interface FormOptions2 {
+	/** Values to start from; the declared dialect has no defaults of its own. */
+	readonly initial?: FormValues2;
+}
+type RequestOf<
+	O,
+	K extends keyof O
+> = O[K] extends OperationShape2 ? O[K]["request"] : never;
+type ResultOf<
+	O,
+	K extends keyof O
+> = O[K] extends OperationShape2 ? O[K]["result"] : never;
+/**
+* Bind the request of one declared action to its schema.
+*
+* The fields come from the declaration, so a page renders `form.fields`
+* instead of guessing; `set` coerces what an `<input>` yields (`"3"` for a
+* numeric field, `""` for an unset one) and re-validates; `submit` refuses
+* invalid values without a call and otherwise runs the operation through an
+* {@link OperationStore}, whose state is `submission`.
+*/
+declare class FormStore2<
+	Req extends object,
+	R
+> extends BaseStore<FormState2<R>> {
+	readonly id: string;
+	readonly title: string;
+	readonly fields: readonly FormField2[];
+	private readonly byName;
+	private readonly request;
+	private readonly initial;
+	private readonly operation;
+	private readonly unsubscribe;
+	constructor(qgis: QgisSdkCore2<unknown, unknown>, id: string, options?: FormOptions2);
+	/** The declaration the form was built from, for a page that renders more. */
+	static describe(qgis: QgisSdkCore2<unknown, unknown>, id: string): ActionDescription2 | undefined;
+	private static defaults;
+	private static evaluate;
+	/** Set one field; `undefined` unsets it. */
+	readonly set: (name: string, value: unknown) => void;
+	/** Set several fields at once. */
+	readonly setValues: (changes: FormValues2) => void;
+	/** The declared field, for a renderer working from a name. */
+	field(name: string): FormField2;
+	/** Back to the initial values and an idle submission; aborts a call in flight. */
+	readonly reset: () => void;
+	/** Abort a submission in flight; the values stay. */
+	readonly abort: () => void;
+	/**
+	* Validate, then run the action with the current values. Resolves with the
+	* result, or `undefined` when the values are invalid (no call is made) or
+	* the call failed, was aborted or superseded - `submission` says which.
+	*/
+	readonly submit: () => Promise<R | undefined>;
+	/** Stop following the submission; for an adapter tearing the form down. */
+	dispose(): void;
+}
+/**
+* The form for `qgis.<id>`, typed from the schema: the request names the
+* fields, the result types the submission.
+*/
+declare function formStore2<
+	O,
+	K extends keyof O & string
+>(qgis: QgisSdkCore2<O, unknown>, id: K, options?: FormOptions2): FormStore2<RequestOf<O, K> & object, ResultOf<O, K>>;
+/** Where one host query stands. */
+type HostQueryState2<T> = {
+	readonly status: "idle";
+} | {
+	readonly status: "loading";
+} | {
+	readonly status: "ok";
+	readonly value: T;
+} | {
+	readonly status: "error";
+	readonly error: Error;
+} | {
+	/** The handshake did not grant `operation`; no call was made. */
+	readonly status: "refused";
+	readonly operation: HostOperationId2;
+	readonly message: string;
+};
+/** What a host query runs once the grant is confirmed. */
+type HostQueryLoader2<T> = (host: QgisSdkHost2, options: {
+	readonly signal: AbortSignal;
+}) => Promise<T>;
+/**
+* Read the curated host surface, grant first.
+*
+* `refresh` waits for the handshake, then - when `qgis.host.granted` lacks
+* the operation the query needs - settles on `refused` without a call, so a
+* page can show "ask the plugin author for `layers.read`" instead of a
+* `not_authorized` fault. Otherwise the loader runs with latest-wins
+* semantics like an operation store.
+*/
+declare class HostQueryStore2<T> extends BaseStore<HostQueryState2<T>> {
+	private readonly qgis;
+	readonly operation: HostOperationId2;
+	private readonly loader;
+	private generation;
+	private controller;
+	constructor(qgis: QgisSdkCore2<unknown, unknown>, operation: HostOperationId2, loader: HostQueryLoader2<T>);
+	readonly abort: () => void;
+	readonly reset: () => void;
+	readonly refresh: () => Promise<T | undefined>;
+}
+/** Options for {@link layersQuery}. */
+interface LayersQueryOptions2 {
+	/** Items per page while following `next_cursor`; the host's default otherwise. */
+	readonly pageSize?: number;
+}
+/**
+* Every vector layer of the project, following `layers.list` pages to the
+* end: what a layer picker binds to. Needs the `layers.read` grant.
+*/
+declare function layersQuery2(qgis: QgisSdkCore2<unknown, unknown>, options?: LayersQueryOptions2): HostQueryStore2<readonly VectorLayerInfo2[]>;
+/**
+* The field names of one vector layer, for a `field` input whose `of` names
+* a layer input: `layers.get` under the `layers.read` grant. A layer's CRS is
+* on the same reply; a project CRS query is not on the wire yet.
+*/
+declare function layerFieldsQuery2(qgis: QgisSdkCore2<unknown, unknown>, layerId: string): HostQueryStore2<readonly string[]>;
+/** How a stream ended, as the generated module reports it. */
+interface StreamTerminalLike2 {
+	readonly kind: string;
+	readonly message?: string;
+	readonly dropped?: number;
+}
+/** The handle a generated stream member resolves with. */
+interface StreamHandleLike2 {
+	readonly id: string;
+	readonly closed: boolean;
+	close(): void;
+}
+/** Handlers for a stream, as a generated module types them. */
+interface StreamHandlersLike2<E> {
+	readonly onEvent?: (event: E) => void;
+	readonly onTerminal?: (terminal: StreamTerminalLike2) => void;
+}
+/** A stream member of a generated map. */
+type Stream2<
+	I,
+	E
+> = (input: I, handlers: StreamHandlersLike2<E>, options?: {
+	readonly signal?: AbortSignal;
+}) => Promise<StreamHandleLike2>;
+/** Where one subscription stands. */
+interface StreamState2<E> {
+	/** `idle` with a null input, `failed` when the host refused to open it. */
+	readonly status: "idle" | "opening" | "open" | "ended" | "failed";
+	readonly lastEvent: E | null;
+	readonly terminal: StreamTerminalLike2 | null;
+	readonly error: Error | null;
+}
+/**
+* Return a key that is equal for two inputs with the same content, whatever
+* the order their fields were written in.
+*/
+declare function stableKey2(value: unknown): string;
+/**
+* Hold one generated stream open while its input is non-null.
+*
+* `setInput` follows the *content* of the input: a new object with the same
+* fields changes nothing, a different one closes the old stream and opens a
+* new one, `null` closes it. Handlers are read fresh on every frame, so
+* `setHandlers` with a new closure reopens nothing. `close` is safe before the
+* host has acknowledged the stream: the handle is closed the moment it
+* arrives.
+*/
+declare class StreamStore2<
+	I,
+	E
+> extends BaseStore<StreamState2<E>> {
+	private readonly open;
+	private handlers;
+	private key;
+	private cancel;
+	constructor(open: Stream2<I, E>, handlers?: StreamHandlersLike2<E>);
+	/** Replace the handlers the next frames reach; nothing reopens. */
+	setHandlers(handlers: StreamHandlersLike2<E>): void;
+	readonly setInput: (input: I | null) => void;
+	readonly close: () => void;
+	private start;
+}
+export { QgisSdkStoreError2, StoreListener2, Store2, DeclaredSchema2, ValidateOptions2, ContractDirection2, SerializedContractError2, QgisSdkContractError2, validateAgainstSchema2, OperationState2, Operation2, OperationStore2, FormFieldKind2, FormField2, labelFor2, schemaFields2, FormValues2, FormState2, FormOptions2, FormStore2, formStore2, HostQueryState2, HostQueryLoader2, HostQueryStore2, LayersQueryOptions2, layersQuery2, layerFieldsQuery2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, stableKey2, StreamStore2 };