@archont561/qgis-sdk 0.3.0 → 0.5.0

package/dist/shared/chunk-3zscfm3y.d.ts

@@ -0,0 +1,342 @@
+import { SerializedValidationIssue2, ActionDescription2, QgisSdkValidationIssue2 } from "./chunk-wtv4vt4q.js";
+import { HostOperationId2, VectorLayerInfo2 } from "./chunk-7tgzmz0m.js";
+import { OperationShape2, QgisSdkHost2, QgisSdkCore2 } from "./chunk-a33y575v.js";
+import { QgisSdkError2 } from "./chunk-pdj2fxjb.js";
+/** 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[];
+/** 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;
+}
+/** 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>;
+}
+/** 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;
+}
+/**
+* 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[]>;
+export { DeclaredSchema2, ValidateOptions2, ContractDirection2, SerializedContractError2, QgisSdkContractError2, validateAgainstSchema2, QgisSdkStoreError2, StoreListener2, Store2, OperationState2, Operation2, OperationStore2, StreamTerminalLike2, StreamHandleLike2, StreamHandlersLike2, Stream2, StreamState2, stableKey2, StreamStore2, FormFieldKind2, FormField2, labelFor2, schemaFields2, FormValues2, FormState2, FormOptions2, FormStore2, formStore2, HostQueryState2, HostQueryLoader2, HostQueryStore2, LayersQueryOptions2, layersQuery2, layerFieldsQuery2 };

package/dist/shared/chunk-7tgzmz0m.d.ts

@@ -0,0 +1,252 @@
+import { QgisSdkError2 } from "./chunk-pdj2fxjb.js";
+declare const HOST_ID2 = "qgis.host";
+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 ["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;
+}
+/** The client this module wraps: anything with a correlated invoke. */
+interface HostClientLike2 {
+	invoke(operation: string, payload?: Readonly<Record<string, unknown>>, options?: HostInvokeOptions2): Promise<unknown>;
+	subscribe(operation: string, payload?: Readonly<Record<string, unknown>>, handlers?: HostStreamHandlers2<{
+		readonly kind: "data" | "progress" | "state";
+		readonly payload: unknown;
+	}>, options?: HostInvokeOptions2): Promise<HostStreamHandle2>;
+}
+/** How a stream ended; `dropped` is only present for a gap. */
+interface HostStreamTerminal2 {
+	readonly kind: "complete" | "error" | "cancelled" | "gap" | "disposed";
+	readonly message?: string;
+	readonly dropped?: number;
+}
+/** What a stream reports: typed events, then exactly one end. */
+interface HostStreamHandlers2<E> {
+	readonly onEvent?: (event: E) => void;
+	readonly onTerminal?: (terminal: HostStreamTerminal2) => void;
+}
+/** A live stream, as the caller holds it. */
+interface HostStreamHandle2 {
+	readonly id: string;
+	readonly closed: boolean;
+	close(): void;
+}
+/** An argument or a response that does not match its declared schema. */
+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;
+}
+interface ExportResult2 {
+	readonly bytes_written: number;
+	readonly name: string;
+}
+interface FetchRequest2 {
+	readonly auth_config?: string;
+	readonly body?: string;
+	readonly headers?: readonly HttpHeader2[];
+	readonly method?: "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+	readonly timeout_seconds?: number;
+	readonly url: string;
+}
+interface FileRef2 {
+	readonly id: string;
+	readonly kind: "file" | "directory";
+	readonly name?: string;
+	readonly operations?: readonly ("read" | "write")[];
+}
+interface HttpHeader2 {
+	readonly name: string;
+	readonly value: string;
+}
+interface IdPage2 {
+	readonly items: readonly string[];
+	readonly next_cursor?: string;
+	readonly truncated: boolean;
+}
+interface LayerPage2 {
+	readonly items: readonly VectorLayerInfo2[];
+	readonly next_cursor?: string;
+	readonly truncated: boolean;
+}
+interface LayerRequest2 {
+	readonly layer_id: string;
+}
+interface NetworkFetchData2 {
+	readonly base64: string | null;
+	readonly headers: readonly HttpHeader2[];
+	readonly reason: string;
+	readonly status_code: number;
+	readonly text: string | null;
+	readonly url: string;
+}
+interface NotificationsInfoRequest2 {
+	readonly message: string;
+}
+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;
+}
+interface StylesApplyRequest2 {
+	readonly layer_id: string;
+	readonly style: string;
+}
+interface VectorLayerInfo2 {
+	readonly crs: string | null;
+	readonly field_names: readonly string[];
+	readonly geometry_type: "point" | "line" | "polygon" | "none";
+	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;
+declare function IdPage2(value: unknown, strict?: boolean): value is IdPage2;
+declare function LayerPage2(value: unknown, strict?: boolean): value is LayerPage2;
+declare function LayerRequest2(value: unknown, strict?: boolean): value is LayerRequest2;
+declare function NetworkFetchData2(value: unknown, strict?: boolean): value is NetworkFetchData2;
+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. */
+type NetworkFetchEvent2 = {
+	readonly kind: "data";
+	readonly payload: NetworkFetchData2;
+};
+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>;
+	};
+	readonly layers: {
+		readonly get: (input: LayerRequest2, options?: HostInvokeOptions2) => Promise<VectorLayerInfo2>;
+		readonly list: (input?: PageRequest2, options?: HostInvokeOptions2) => Promise<LayerPage2>;
+		readonly open_vector: (input: OpenVectorRequest2, options?: HostInvokeOptions2) => Promise<VectorLayerInfo2>;
+	};
+	readonly network: {
+		readonly fetch: (input: FetchRequest2, handlers: HostStreamHandlers2<NetworkFetchEvent2>, options?: HostInvokeOptions2) => Promise<HostStreamHandle2>;
+	};
+	readonly notifications: {
+		readonly info: (input: NotificationsInfoRequest2, options?: HostInvokeOptions2) => Promise<null>;
+	};
+	readonly project: {
+		readonly layer_ids: (input?: PageRequest2, options?: HostInvokeOptions2) => Promise<IdPage2>;
+	};
+	readonly settings: {
+		readonly get: (input: SettingsGetRequest2, options?: HostInvokeOptions2) => Promise<string | null>;
+	};
+	readonly styles: {
+		readonly apply: (input: StylesApplyRequest2, options?: HostInvokeOptions2) => Promise<null>;
+	};
+}
+declare function createHost2(client: HostClientLike2): HostOperations2;
+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 };