@gfdelarue/testkit 0.4.4 → 0.5.0

package/dist/types/node-vitest-contract.d.ts

@@ -0,0 +1,75 @@
+import { expect } from 'vitest';
+
+export interface HttpMethods<Response, Extra extends unknown[]> {
+	get: (path: string, ...extra: Extra) => Response;
+	delete: (path: string, body?: unknown, ...extra: Extra) => Response;
+	post: (path: string, body?: unknown, ...extra: Extra) => Response;
+	put: (path: string, body?: unknown, ...extra: Extra) => Response;
+	patch: (path: string, body?: unknown, ...extra: Extra) => Response;
+}
+export interface ContractScenarioOptions {
+	timeout?: number;
+	timeoutMs?: number;
+}
+export interface ContractHttpRequestOptions extends Record<string, unknown> {
+	contentTypeJson?: boolean;
+	signal?: AbortSignal;
+}
+export interface ContractHttpResponse {
+	body: string;
+	headers: Record<string, string>;
+	json(): unknown;
+	method: string;
+	path: string;
+	status: number;
+	url: string;
+}
+export interface ContractHttpClientOptions {
+	baseUrl?: string;
+	defaultHeaders?: Record<string, string>;
+}
+export interface ContractHttpClient extends HttpMethods<Promise<ContractHttpResponse>, [
+	headers?: Record<string, string>,
+	options?: ContractHttpRequestOptions
+]> {
+	baseUrl: string;
+	request(method: string, path: string, body?: unknown, headers?: Record<string, string>, options?: ContractHttpRequestOptions): Promise<ContractHttpResponse>;
+}
+export interface ContractFixture {
+	buffer(): Buffer;
+	contentType: string;
+	filename: string;
+	json(): unknown;
+	path: string;
+	sha256: string;
+	sizeBytes: number;
+	text(encoding?: BufferEncoding): string;
+}
+export interface ContractRuntimeContext extends Record<string, unknown> {
+	baseUrl?: string | null;
+	engineId?: "node-vitest";
+	readonly env: Readonly<Record<string, string>>;
+	profileId?: "node-vitest-contract";
+	serviceName?: string;
+	task?: {
+		file?: string;
+		id?: number | string;
+		suiteName?: string;
+		testType: "contract";
+	};
+}
+export interface ContractScenarioContext extends ContractRuntimeContext {
+	fixture(name: string): ContractFixture;
+	http(options?: ContractHttpClientOptions): ContractHttpClient;
+}
+export type ContractScenarioRun = (context: ContractScenarioContext) => unknown;
+export declare function contractScenario(name: string, run: ContractScenarioRun): void;
+export declare function contractScenario(name: string, options: ContractScenarioOptions, run: ContractScenarioRun): void;
+export declare function readContractContext(): ContractRuntimeContext;
+export declare function createHttpClient(options?: Readonly<ContractHttpClientOptions>): ContractHttpClient;
+
+export {
+	expect,
+};
+
+export {};

package/dist/types/node-vitest-data.d.ts

@@ -0,0 +1,407 @@
+import { TestContext, expect } from 'vitest';
+
+export type RuntimeMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface RuntimeHeaders {
+	[key: string]: string;
+}
+export interface RuntimeCookie {
+	value: string;
+}
+export interface RuntimeEnv {
+	BASE: string;
+	rawEnv?: Record<string, string | undefined>;
+}
+export interface HttpRequestParams {
+	[key: string]: unknown;
+	headers?: RuntimeHeaders;
+}
+export type HttpProfileEnvironment = Readonly<Record<string, string | undefined>>;
+export interface HttpProfileEnv {
+	[key: string]: unknown;
+	BASE?: string;
+	rawEnv?: HttpProfileEnvironment;
+}
+export type HttpProfileResolvedEnv = HttpProfileEnv & RuntimeEnv;
+export interface HttpProfileHeaderContext {
+	actor?: string | null;
+	env?: HttpProfileEnv;
+}
+export type HttpProfileHeaderBuilder<TSetup = unknown> = (setupData: TSetup | null, context?: HttpProfileHeaderContext & {
+	env: HttpProfileResolvedEnv;
+}) => RuntimeHeaders | undefined;
+/** Response shape the in-process profile setup client resolves to. */
+export interface HttpProfileResponse {
+	body: string;
+	cookies?: Record<string, RuntimeCookie[] | undefined>;
+	headers?: Record<string, string>;
+	status: number;
+}
+export type HttpProfileRequestMethod = "del" | "get" | "patch" | "post" | "put";
+/** HTTP verbs an execution engine hands to a profile's setup step. */
+export type HttpProfileRequestClient<TResult = Promise<HttpProfileResponse>> = {
+	[Method in HttpProfileRequestMethod]: Method extends "get" ? (url: string, params?: HttpRequestParams) => TResult : (url: string, body?: unknown, params?: HttpRequestParams) => TResult;
+};
+export interface HttpProfileSetupContext {
+	env: HttpProfileResolvedEnv;
+	http: HttpProfileRequestClient;
+	json(response: unknown): unknown;
+}
+/**
+ * Explicit, test-owned authentication for a named HTTP profile. The data
+ * profile runs `setup` or `setupAsync` once and passes the
+ * result to `headers` for every request.
+ */
+export interface HttpProfileAuth<TSetup = unknown> {
+	headers?: HttpProfileHeaderBuilder<TSetup>;
+	setup?(context: HttpProfileSetupContext): TSetup;
+	setupAsync?(context: HttpProfileSetupContext): Promise<TSetup>;
+}
+export interface HttpMethods<Response, Extra extends unknown[]> {
+	get: (path: string, ...extra: Extra) => Response;
+	delete: (path: string, body?: unknown, ...extra: Extra) => Response;
+	post: (path: string, body?: unknown, ...extra: Extra) => Response;
+	put: (path: string, body?: unknown, ...extra: Extra) => Response;
+	patch: (path: string, body?: unknown, ...extra: Extra) => Response;
+}
+declare const DATA_ARTIFACT_KIND = "testkit.data-flow";
+declare const DATA_SCHEMA_VERSION = 1;
+export type DataFindingSeverity = "error" | "info" | "waste" | "watch";
+export type DataMetricBudgetOperator = "<" | "<=" | "==" | ">" | ">=" | "exists";
+export type DataSequenceBudgetOperator = "exists" | "sequence==" | "sequenceOnly";
+export interface DataScenarioOptions {
+	description?: string;
+	timeout?: number;
+	timeoutMs?: number;
+}
+export interface DataMetricOptions {
+	description?: string;
+	dimensions?: Record<string, unknown>;
+	kind?: string;
+	unit?: string;
+}
+export interface DataSequenceOptions {
+	description?: string;
+	dimensions?: Record<string, unknown>;
+}
+export interface DataEvidenceDetails extends Record<string, unknown> {
+	status?: string;
+}
+export interface DataBudgetOptions {
+	message?: string;
+}
+export interface DataMetricBudget {
+	atLeast(value: number, options?: DataBudgetOptions): this;
+	atMost(value: number, options?: DataBudgetOptions): this;
+	equals(value: number, options?: DataBudgetOptions): this;
+	greaterThan(value: number, options?: DataBudgetOptions): this;
+	lessThan(value: number, options?: DataBudgetOptions): this;
+	required(options?: DataBudgetOptions): this;
+}
+export interface DataSequenceBudget {
+	equals(values: readonly unknown[], options?: DataBudgetOptions): this;
+	includesOnly(values: readonly unknown[], options?: DataBudgetOptions): this;
+	required(options?: DataBudgetOptions): this;
+}
+export interface DataFixture {
+	buffer(): Buffer;
+	contentType: string;
+	filename: string;
+	json(): unknown;
+	path: string;
+	sha256: string;
+	sizeBytes: number;
+	text(encoding?: BufferEncoding): string;
+}
+export interface DataHttpResponse {
+	body: string;
+	cookies: Record<string, Array<{
+		value: string;
+	}>>;
+	durationMs: number;
+	headers: Record<string, string>;
+	json(): unknown;
+	method: string;
+	path: string;
+	status: number;
+	url: string;
+}
+export interface DataHttpRequestOptions {
+	contentTypeJson?: boolean;
+	signal?: AbortSignal;
+}
+export interface DataActorSession {
+	[key: string]: unknown;
+	actorIndex?: number;
+	email?: string | null;
+	name?: string | null;
+	organizationKey?: string | null;
+	organizationName?: string | null;
+	session?: Record<string, unknown> | null;
+}
+export interface DataSessionBundle {
+	actors: Record<string, DataActorSession | undefined>;
+	primaryActor: string | null;
+}
+export interface DataHttpHeaderContext {
+	actor: DataActorSession | null;
+	actorName: string | null;
+	sessionBundle: DataSessionBundle | null;
+}
+export type DataHttpHeaderBuilder = (context: DataHttpHeaderContext) => Record<string, string>;
+export interface DataHttpClientOptions {
+	baseUrl?: string;
+	defaultActor?: string;
+	defaultHeaders?: Record<string, string>;
+	getHeaders?: DataHttpHeaderBuilder;
+	getRawHeaders?: DataHttpHeaderBuilder;
+	profile?: string;
+	recorder?: DataHttpRecorder;
+	sessionBundle?: DataSessionBundle;
+	trace?: DataHttpRecorder;
+}
+export interface DataHttpRequest {
+	(method: string, path: string, body?: unknown, headers?: Record<string, string>, options?: DataHttpRequestOptions): Promise<DataHttpResponse>;
+}
+export type DataActorRawRequest = DataHttpRequest & HttpMethods<Promise<DataHttpResponse>, [
+	headers?: Record<string, string>,
+	options?: DataHttpRequestOptions
+]>;
+export interface DataRootRawRequest extends DataHttpRequest, Pick<HttpMethods<Promise<DataHttpResponse>, [
+	headers?: Record<string, string>,
+	options?: DataHttpRequestOptions
+]>, "get" | "post"> {
+	as(actorName: string): DataActorRawRequest;
+}
+export interface DataHttpMethods extends HttpMethods<Promise<DataHttpResponse>, [
+	headers?: Record<string, string>,
+	options?: DataHttpRequestOptions
+]> {
+	headers(extraHeaders?: Record<string, string>): Record<string, string>;
+	rawHeaders(extraHeaders?: Record<string, string>): Record<string, string>;
+	request(method: string, path: string, body?: unknown, headers?: Record<string, string>, options?: DataHttpRequestOptions): Promise<DataHttpResponse>;
+}
+export interface DataActorHttpClient extends DataHttpMethods {
+	raw: DataActorRawRequest;
+	rawReq: DataActorRawRequest;
+}
+export interface DataHttpActor {
+	email: string | null;
+	headers: Record<string, string>;
+	index: number;
+	key: string;
+	name: string | null;
+	organizationKey: string | null;
+	organizationName: string | null;
+	rawHeaders: Record<string, string>;
+	rawReq: DataActorRawRequest;
+	req: DataActorHttpClient;
+	session: Record<string, unknown> | null;
+}
+export interface DataHttpActors {
+	get(name: string): DataHttpActor;
+	has(name: string): boolean;
+	list(): DataHttpActor[];
+	names: string[];
+	primary: DataHttpActor | null;
+}
+export interface DataHttpClient extends DataHttpMethods {
+	actor?: DataHttpActor | null;
+	actors?: DataHttpActors;
+	as(actorName: string): DataActorHttpClient;
+	baseUrl: string;
+	env?: HttpProfileEnv;
+	raw: DataRootRawRequest;
+	rawReq: DataRootRawRequest;
+}
+export interface DataHttpRequestRecord {
+	bodyBytes?: number;
+	durationMs?: number;
+	method: string;
+	path: string;
+	requestHeaders?: Record<string, string>;
+	responseBytes?: number;
+	status?: number;
+}
+export interface DataHttpRecorder {
+	recordHttpRequest(entry: DataHttpRequestRecord): unknown;
+}
+export interface DataExternalCallDetails extends DataEvidenceDetails {
+	costMinor?: number;
+	durationMs?: number;
+	requestBytes?: number;
+	responseBytes?: number;
+}
+export interface DataFlow extends DataHttpRecorder {
+	addFinding(severity: string, message: string, details?: Record<string, unknown>): this;
+	actor(name: string, details?: DataEvidenceDetails): this;
+	budget(metricName: string): DataMetricBudget;
+	bytes(name: string, value: number, options?: DataMetricOptions): this;
+	count(name: string, value?: number, options?: DataMetricOptions): this;
+	duration(name: string, value: number, options?: DataMetricOptions): this;
+	event(name: string, details?: Record<string, unknown>): this;
+	expectMetric(metricName: string): DataMetricBudget;
+	expectSequence(sequenceName: string): DataSequenceBudget;
+	externalCall(name: string, details?: DataExternalCallDetails): this;
+	finding(severity: string, message: string, details?: Record<string, unknown>): this;
+	metric(name: string, value: number, options?: DataMetricOptions): this;
+	money(name: string, value: number, options?: DataMetricOptions): this;
+	ratio(name: string, value: number, options?: DataMetricOptions): this;
+	reconcile(name: string, details?: DataEvidenceDetails): this;
+	record(name: string, details?: DataEvidenceDetails & {
+		count?: number;
+	}): this;
+	recordHttpRequest(entry: DataHttpRequestRecord): this;
+	recordCache(name: string, values?: {
+		hits?: number;
+		misses?: number;
+		reads?: number;
+		writes?: number;
+	}): this;
+	recordLlmUsage(name: string, usage?: Record<string, number>): this;
+	recordRpc(name: string, entry?: {
+		method?: string;
+		requestBytes?: number;
+		responseBytes?: number;
+	}): this;
+	sequence(name: string, values: unknown, options?: DataSequenceOptions): this;
+	sequenceBudget(sequenceName: string): DataSequenceBudget;
+	system(name: string, details?: DataEvidenceDetails): this;
+	transition(name: string, details?: DataEvidenceDetails): this;
+}
+export interface DataScenarioContext extends DataFlow, DataRuntimeContext {
+	fixture(name: string): DataFixture;
+	http(options?: DataHttpProfileOptions): Promise<DataHttpClient>;
+}
+export interface DataRuntimeContext extends Record<string, unknown> {
+	baseUrl?: string | null;
+	engineId?: "node-vitest";
+	readonly env: Readonly<Record<string, string>>;
+	profileId?: "node-vitest-data";
+	serviceName?: string;
+	task?: {
+		file?: string;
+		id?: number | string;
+		suiteName?: string;
+		testType: "data";
+	};
+}
+export type DataHttpProfileAuth = HttpProfileAuth<DataSessionBundle>;
+export interface DataHttpProfileOptions extends DataHttpClientOptions {
+	auth?: DataHttpProfileAuth | null;
+	env?: HttpProfileEnv;
+	headers?: HttpProfileHeaderBuilder<DataSessionBundle>;
+	rawHeaders?: HttpProfileHeaderBuilder<DataSessionBundle>;
+}
+export interface DataMetric {
+	aggregation?: string;
+	description: string | null;
+	dimensions: Record<string, unknown>;
+	intervalMs?: number | null;
+	kind: string;
+	name: string;
+	unit: string | null;
+	value: number;
+}
+export interface DataSequence {
+	description: string | null;
+	dimensions: Record<string, unknown>;
+	name: string;
+	values: string[];
+}
+export interface DataEvidence {
+	atMs: number;
+	details: unknown;
+	kind: string;
+	name: string;
+	status: string | null;
+}
+export interface DataEvent {
+	atMs: number;
+	details: unknown;
+	name: string;
+}
+export interface DataFinding {
+	details: unknown;
+	message: string;
+	severity: DataFindingSeverity;
+}
+export interface SerializedDataError {
+	message: string;
+	name: string;
+	stack: string | null;
+}
+export interface DataMetricBudgetInput {
+	expected?: number;
+	message: string | null;
+	metricKey?: string | null;
+	name: string;
+	operator: DataMetricBudgetOperator;
+	target: "metric";
+}
+export interface DataSequenceBudgetInput {
+	expected?: unknown[];
+	message: string | null;
+	name: string;
+	operator: DataSequenceBudgetOperator;
+	target: "sequence";
+}
+export interface DataBudgetResultBase {
+	actual: number | string[] | null;
+	message: string;
+	status: "failed" | "passed";
+}
+export type DataBudgetResult = (Omit<DataMetricBudgetInput, "expected" | "message"> & DataBudgetResultBase & {
+	expected: number | null;
+}) | (Omit<DataSequenceBudgetInput, "expected" | "message"> & DataBudgetResultBase & {
+	expected: unknown[] | null;
+});
+export interface DataScenarioReport {
+	budgetFailures: DataBudgetResult[];
+	budgets: DataBudgetResult[];
+	description: string | null;
+	durationMs: number;
+	error: SerializedDataError | null;
+	events: DataEvent[];
+	evidence: DataEvidence[];
+	findings: DataFinding[];
+	location: {
+		column?: number;
+		line?: number;
+		path: string;
+	};
+	metrics: DataMetric[];
+	name: string;
+	sequences: DataSequence[];
+	status: "failed" | "passed";
+}
+export interface DataFlowReport {
+	file: string | null;
+	generatedAt: string;
+	kind: typeof DATA_ARTIFACT_KIND;
+	scenarios: DataScenarioReport[];
+	schemaVersion: typeof DATA_SCHEMA_VERSION;
+	summary: {
+		budgetFailures: number;
+		failed: number;
+		findingCounts: Record<DataFindingSeverity, number>;
+		passed: number;
+		scenarios: number;
+		status: "failed" | "passed";
+	};
+	summaryText: string;
+	taskId: string | null;
+}
+export declare function createHttpClient(options?: DataHttpClientOptions): DataHttpClient;
+export declare function readDataContext(): DataRuntimeContext;
+export declare function renderDataFlowMarkdown(report: DataFlowReport): string;
+export declare function dataScenario(name: string, run: (context: DataScenarioContext) => unknown): void;
+export declare function dataScenario(name: string, options: DataScenarioOptions, run: (context: DataScenarioContext) => unknown): void;
+export declare function dataFlow(context: TestContext): DataFlow;
+export declare function measureJsonBytes(value: unknown): number;
+export declare function stableHash(value: unknown): string;
+
+export {
+	expect,
+};
+
+export {};

package/dist/types/playwright.d.ts

@@ -0,0 +1,130 @@
+import { APIRequest, APIRequestContext, Page, PlaywrightTestConfig } from '@playwright/test';
+
+export type JsonPrimitive = boolean | null | number | string;
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonObject;
+export interface JsonObject {
+	readonly [key: string]: JsonValue;
+}
+export interface PlaywrightTestContext {
+	readonly baseUrl: null | string;
+	readonly databases: Readonly<Record<string, string>>;
+	readonly endpoints: Readonly<Record<string, string>>;
+	readonly env: Readonly<Record<string, string>>;
+	readonly fixtures: JsonObject;
+	readonly handles: Readonly<Record<string, JsonObject>>;
+	readonly managed: true;
+	readonly setupData?: JsonValue;
+	readonly uiConfig: JsonObject;
+}
+export declare function readPlaywrightContext(): PlaywrightTestContext | null;
+export type DefinedTestkitPlaywrightConfig<TestArgs = object, WorkerArgs = object> = Omit<PlaywrightTestConfig<TestArgs, WorkerArgs>, "expect" | "globalTimeout" | "timeout" | "use" | "webServer"> & {
+	expect: Omit<NonNullable<PlaywrightTestConfig<TestArgs, WorkerArgs>["expect"]>, "timeout"> & {
+		timeout: number;
+	};
+	globalTimeout?: number;
+	timeout: number;
+	use: Omit<NonNullable<PlaywrightTestConfig<TestArgs, WorkerArgs>["use"]>, "actionTimeout" | "baseURL" | "navigationTimeout"> & {
+		actionTimeout: number;
+		baseURL?: string;
+		navigationTimeout: number;
+	};
+	webServer?: PlaywrightTestConfig<TestArgs, WorkerArgs>["webServer"];
+};
+export interface PlaywrightConfigOptions {
+	defaultFileTimeoutSeconds?: number;
+	env?: NodeJS.ProcessEnv;
+}
+export declare function defineTestkitConfig(): DefinedTestkitPlaywrightConfig;
+export declare function defineTestkitConfig<TestArgs = object, WorkerArgs = object>(config: PlaywrightTestConfig<TestArgs, WorkerArgs>, options?: PlaywrightConfigOptions): DefinedTestkitPlaywrightConfig<TestArgs, WorkerArgs>;
+export interface UiSandboxOptions {
+	allowRemote?: boolean;
+	backendBaseUrl?: string;
+	baseUrl?: string;
+	frontendBaseUrl?: string;
+	headers?: Record<string, string>;
+	prefix?: string;
+}
+export interface UiSandboxFixture {
+	backendBaseUrl: string;
+	frontendBaseUrl: string;
+	id: string;
+	page: Page;
+}
+export interface UiSandboxFixtures {
+	testkitSandbox: UiSandboxFixture;
+}
+export interface UiAnimationPage {
+	evaluate(pageFunction: (frameCount: number) => Promise<void>, frameCount: number): Promise<void>;
+}
+export interface UiNetworkIdlePage extends UiAnimationPage {
+	waitForLoadState(state: "domcontentloaded" | "load" | "networkidle", options?: {
+		timeout?: number;
+	}): Promise<void>;
+}
+export interface StableElement {
+	getBoundingClientRect(): {
+		toJSON(): unknown;
+	};
+}
+export interface UiStableLocator {
+	evaluate(pageFunction: (node: StableElement, requiredStableFrames: number) => Promise<void>, requiredStableFrames: number): Promise<void>;
+	waitFor(options: {
+		state: "visible";
+		timeout?: number;
+	}): Promise<void>;
+}
+export interface UiStableElementPage {
+	locator(selector: string): UiStableLocator;
+}
+export interface ImageElement {
+	readonly complete: boolean;
+	addEventListener(type: "error" | "load", listener: () => void, options: {
+		once: true;
+	}): void;
+}
+export interface UiImageLocator {
+	count(): Promise<number>;
+	nth(index: number): {
+		evaluate(pageFunction: (element: ImageElement) => Promise<void> | undefined): Promise<void>;
+	};
+}
+export interface UiImagesPage {
+	locator(selector: string): UiImageLocator;
+}
+export interface UiTargetOptions {
+	allowRemote?: unknown;
+}
+export declare function createUiSandbox(options?: UiSandboxOptions): {
+	expect: import("@playwright/test").Expect<{}>;
+	test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & UiSandboxFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+};
+export declare function createSandboxId(options?: Pick<UiSandboxOptions, "prefix">): string;
+export declare function resolveFrontendBaseUrl(options?: UiSandboxOptions): string;
+export declare function resolveBackendBaseUrl(options?: UiSandboxOptions): string;
+export declare function assertSafeUiTarget(url: unknown, options?: UiTargetOptions): string;
+export declare function assertSafeUiTargets(urls?: readonly unknown[], options?: UiTargetOptions): string[];
+export declare function createAuthedApiClient(playwrightRequest?: APIRequest, options?: UiSandboxOptions): Promise<APIRequestContext>;
+export declare function waitForUiSettled(page: UiNetworkIdlePage, options?: {
+	frames?: number;
+	timeout?: number;
+}): Promise<void>;
+export declare function waitForAnimationFrames(page: UiAnimationPage, frames?: unknown): Promise<void>;
+export declare function waitForNetworkIdle(page: UiNetworkIdlePage, options?: {
+	frames?: number;
+	timeout?: number;
+}): Promise<void>;
+export declare function waitForElementStable(page: UiStableElementPage, selector: string, options?: {
+	frames?: number;
+	timeout?: number;
+}): Promise<void>;
+export declare function waitForImagesLoaded(page: UiImagesPage, containerSelector?: string | null): Promise<void>;
+export * from "@playwright/test";
+
+export {
+	APIRequest,
+	APIRequestContext,
+	Page,
+	PlaywrightTestConfig,
+};
+
+export {};

package/dist/types/tooling-vitest.d.ts

@@ -0,0 +1,13 @@
+export interface VitestConfigOptions {
+	exclude?: readonly string[];
+}
+export type DefinedVitestConfig<TConfig extends Record<string, unknown>> = TConfig & {
+	test: Record<string, unknown> & {
+		exclude: string[];
+	};
+};
+export declare function defineConfig(): DefinedVitestConfig<Record<string, never>>;
+export declare function defineConfig<TConfig extends Record<string, unknown>>(config: TConfig, options?: VitestConfigOptions): DefinedVitestConfig<TConfig>;
+export declare function testkitExcludes(): string[];
+
+export {};