@tianshu-ai/tianshu 0.3.0

package/plugins/web-search/node_modules/@vitest/runner/dist/types.d.ts

@@ -0,0 +1,163 @@
+import { DiffOptions } from '@vitest/utils/diff';
+import { F as File, a as Test, S as Suite, L as TaskResultPack, z as TaskEventPack, N as TestAnnotation, U as TestContext, I as ImportDuration, t as SequenceHooks, u as SequenceSetupFiles } from './tasks.d-CkscK4of.js';
+export { A as AfterAllListener, b as AfterEachListener, B as BeforeAllListener, d as BeforeEachListener, g as Custom, j as CustomAPI, D as DoneCallback, E as ExtendedContext, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, H as HookCleanupCallback, q as HookListener, r as InferFixturesTypes, O as OnTestFailedHandler, f as OnTestFinishedHandler, R as RunMode, s as RuntimeContext, k as SuiteAPI, l as SuiteCollector, v as SuiteFactory, h as SuiteHooks, T as Task, w as TaskBase, x as TaskContext, y as TaskCustomOptions, e as TaskHook, G as TaskMeta, J as TaskPopulated, K as TaskResult, M as TaskState, i as TaskUpdateEvent, j as TestAPI, P as TestAnnotationLocation, Q as TestAttachment, V as TestFunction, W as TestOptions, X as Use } from './tasks.d-CkscK4of.js';
+import '@vitest/utils';
+
+/**
+* This is a subset of Vitest config that's required for the runner to work.
+*/
+interface VitestRunnerConfig {
+	root: string;
+	setupFiles: string[];
+	name?: string;
+	passWithNoTests: boolean;
+	testNamePattern?: RegExp;
+	allowOnly?: boolean;
+	sequence: {
+		shuffle?: boolean
+		concurrent?: boolean
+		seed: number
+		hooks: SequenceHooks
+		setupFiles: SequenceSetupFiles
+	};
+	chaiConfig?: {
+		truncateThreshold?: number
+	};
+	maxConcurrency: number;
+	testTimeout: number;
+	hookTimeout: number;
+	retry: number;
+	includeTaskLocation?: boolean;
+	diffOptions?: DiffOptions;
+}
+/**
+* Possible options to run a single file in a test.
+*/
+interface FileSpecification {
+	filepath: string;
+	testLocations: number[] | undefined;
+}
+type VitestRunnerImportSource = "collect" | "setup";
+interface VitestRunnerConstructor {
+	new (config: VitestRunnerConfig): VitestRunner;
+}
+type CancelReason = "keyboard-input" | "test-failure" | (string & Record<string, never>);
+interface VitestRunner {
+	/**
+	* First thing that's getting called before actually collecting and running tests.
+	*/
+	onBeforeCollect?: (paths: string[]) => unknown;
+	/**
+	* Called after the file task was created but not collected yet.
+	*/
+	onCollectStart?: (file: File) => unknown;
+	/**
+	* Called after collecting tests and before "onBeforeRun".
+	*/
+	onCollected?: (files: File[]) => unknown;
+	/**
+	* Called when test runner should cancel next test runs.
+	* Runner should listen for this method and mark tests and suites as skipped in
+	* "onBeforeRunSuite" and "onBeforeRunTask" when called.
+	*/
+	cancel?: (reason: CancelReason) => unknown;
+	/**
+	* Called before running a single test. Doesn't have "result" yet.
+	*/
+	onBeforeRunTask?: (test: Test) => unknown;
+	/**
+	* Called before actually running the test function. Already has "result" with "state" and "startTime".
+	*/
+	onBeforeTryTask?: (test: Test, options: {
+		retry: number
+		repeats: number
+	}) => unknown;
+	/**
+	* When the task has finished running, but before cleanup hooks are called
+	*/
+	onTaskFinished?: (test: Test) => unknown;
+	/**
+	* Called after result and state are set.
+	*/
+	onAfterRunTask?: (test: Test) => unknown;
+	/**
+	* Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
+	*/
+	onAfterTryTask?: (test: Test, options: {
+		retry: number
+		repeats: number
+	}) => unknown;
+	/**
+	* Called before running a single suite. Doesn't have "result" yet.
+	*/
+	onBeforeRunSuite?: (suite: Suite) => unknown;
+	/**
+	* Called after running a single suite. Has state and result.
+	*/
+	onAfterRunSuite?: (suite: Suite) => unknown;
+	/**
+	* If defined, will be called instead of usual Vitest suite partition and handling.
+	* "before" and "after" hooks will not be ignored.
+	*/
+	runSuite?: (suite: Suite) => Promise<void>;
+	/**
+	* If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
+	* "before" and "after" hooks will not be ignored.
+	*/
+	runTask?: (test: Test) => Promise<void>;
+	/**
+	* Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
+	*/
+	onTaskUpdate?: (task: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	/**
+	* Called when annotation is added via the `context.annotate` method.
+	*/
+	onTestAnnotate?: (test: Test, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	/**
+	* Called before running all tests in collected paths.
+	*/
+	onBeforeRunFiles?: (files: File[]) => unknown;
+	/**
+	* Called right after running all tests in collected paths.
+	*/
+	onAfterRunFiles?: (files: File[]) => unknown;
+	/**
+	* Called when new context for a test is defined. Useful if you want to add custom properties to the context.
+	* If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
+	*
+	* @see https://vitest.dev/advanced/runner#your-task-function
+	*/
+	extendTaskContext?: (context: TestContext) => TestContext;
+	/**
+	* Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
+	*/
+	importFile: (filepath: string, source: VitestRunnerImportSource) => unknown;
+	/**
+	* Function that is called when the runner attempts to get the value when `test.extend` is used with `{ injected: true }`
+	*/
+	injectValue?: (key: string) => unknown;
+	/**
+	* Gets the time spent importing each individual non-externalized file that Vitest collected.
+	*/
+	getImportDurations?: () => Record<string, ImportDuration>;
+	/**
+	* Publicly available configuration.
+	*/
+	config: VitestRunnerConfig;
+	/**
+	* The name of the current pool. Can affect how stack trace is inferred on the server side.
+	*/
+	pool?: string;
+	/**
+	* Return the worker context for fixtures specified with `scope: 'worker'`
+	*/
+	getWorkerContext?: () => Record<string, unknown>;
+	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
+	/** @private */
+	_currentTaskStartTime?: number;
+	/** @private */
+	_currentTaskTimeout?: number;
+}
+
+export { File, ImportDuration, SequenceHooks, SequenceSetupFiles, Suite, TaskEventPack, TaskResultPack, Test, TestAnnotation, TestContext };
+export type { CancelReason, FileSpecification, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/plugins/web-search/node_modules/@vitest/runner/dist/types.js

@@ -0,0 +1 @@
+

package/plugins/web-search/node_modules/@vitest/runner/dist/utils.d.ts

@@ -0,0 +1,47 @@
+import { S as Suite, F as File, T as Task, a as Test } from './tasks.d-CkscK4of.js';
+export { C as ChainableFunction, c as createChainable } from './tasks.d-CkscK4of.js';
+import { Arrayable } from '@vitest/utils';
+
+/**
+* If any tasks been marked as `only`, mark all other tasks as `skip`.
+*/
+declare function interpretTaskModes(file: Suite, namePattern?: string | RegExp, testLocations?: number[] | undefined, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
+declare function someTasksAreOnly(suite: Suite): boolean;
+declare function generateHash(str: string): string;
+declare function calculateSuiteHash(parent: Suite): void;
+declare function createFileTask(filepath: string, root: string, projectName: string | undefined, pool?: string): File;
+/**
+* Generate a unique ID for a file based on its path and project name
+* @param file File relative to the root of the project to keep ID the same between different machines
+* @param projectName The name of the test project
+*/
+declare function generateFileHash(file: string, projectName: string | undefined): string;
+
+/**
+* Return a function for running multiple async operations with limited concurrency.
+*/
+declare function limitConcurrency(concurrency?: number): <
+	Args extends unknown[],
+	T
+>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
+
+/**
+* Partition in tasks groups by consecutive concurrent
+*/
+declare function partitionSuiteChildren(suite: Suite): Task[][];
+
+/**
+* @deprecated use `isTestCase` instead
+*/
+declare function isAtomTest(s: Task): s is Test;
+declare function isTestCase(s: Task): s is Test;
+declare function getTests(suite: Arrayable<Task>): Test[];
+declare function getTasks(tasks?: Arrayable<Task>): Task[];
+declare function getSuites(suite: Arrayable<Task>): Suite[];
+declare function hasTests(suite: Arrayable<Suite>): boolean;
+declare function hasFailed(suite: Arrayable<Task>): boolean;
+declare function getNames(task: Task): string[];
+declare function getFullName(task: Task, separator?: string): string;
+declare function getTestName(task: Task, separator?: string): string;
+
+export { calculateSuiteHash, createFileTask, generateFileHash, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, isTestCase, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };

package/plugins/web-search/node_modules/@vitest/runner/dist/utils.js

@@ -0,0 +1,6 @@
+export { v as calculateSuiteHash, r as createChainable, w as createFileTask, x as generateFileHash, y as generateHash, D as getFullName, E as getNames, F as getSuites, G as getTasks, H as getTestName, I as getTests, J as hasFailed, K as hasTests, z as interpretTaskModes, L as isAtomTest, M as isTestCase, B as limitConcurrency, C as partitionSuiteChildren, A as someTasksAreOnly } from './chunk-hooks.js';
+import '@vitest/utils';
+import '@vitest/utils/source-map';
+import '@vitest/utils/error';
+import 'strip-literal';
+import 'pathe';

package/plugins/web-search/node_modules/@vitest/runner/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@vitest/runner",
+  "type": "module",
+  "version": "3.2.6",
+  "description": "Vitest test runner",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/runner#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/runner"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "sideEffects": true,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "default": "./dist/utils.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "*.d.ts",
+    "dist"
+  ],
+  "dependencies": {
+    "pathe": "^2.0.3",
+    "strip-literal": "^3.0.0",
+    "@vitest/utils": "3.2.6"
+  },
+  "scripts": {
+    "build": "rimraf dist && rollup -c",
+    "dev": "rollup -c --watch"
+  }
+}

package/plugins/web-search/node_modules/@vitest/snapshot/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-Present Vitest Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/plugins/web-search/node_modules/@vitest/snapshot/README.md

@@ -0,0 +1,84 @@
+# @vitest/snapshot
+
+Lightweight implementation of Jest's snapshots.
+
+## Usage
+
+```js
+import { SnapshotClient } from '@vitest/snapshot'
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment'
+import { SnapshotManager } from '@vitest/snapshot/manager'
+
+const client = new SnapshotClient({
+  // you need to provide your own equality check implementation if you use it
+  // this function is called when `.toMatchSnapshot({ property: 1 })` is called
+  isEqual: (received, expected) =>
+    equals(received, expected, [iterableEquality, subsetEquality]),
+})
+
+// class that implements snapshot saving and reading
+// by default uses fs module, but you can provide your own implementation depending on the environment
+const environment = new NodeSnapshotEnvironment()
+
+// you need to implement this yourselves,
+// this depends on your runner
+function getCurrentFilepath() {
+  return '/file.spec.js'
+}
+function getCurrentTestName() {
+  return 'test1'
+}
+
+// example for inline snapshots, nothing is required to support regular snapshots,
+// just call `assert` with `isInline: false`
+function wrapper(received) {
+  function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+    client.assert({
+      received,
+      message,
+      isInline: true,
+      inlineSnapshot,
+      filepath: getCurrentFilepath(),
+      name: getCurrentTestName(),
+    })
+  }
+  return {
+    // the name is hard-coded, it should be inside another function, so Vitest can find the actual test file where it was called (parses call stack trace + 2)
+    // you can override this behaviour in SnapshotState's `_inferInlineSnapshotStack` method by providing your own SnapshotState to SnapshotClient constructor
+    toMatchInlineSnapshot: (...args) => __INLINE_SNAPSHOT__(...args),
+  }
+}
+
+const options = {
+  updateSnapshot: 'new',
+  snapshotEnvironment: environment,
+}
+
+await client.startCurrentRun(
+  getCurrentFilepath(),
+  getCurrentTestName(),
+  options
+)
+
+// this will save snapshot to a file which is returned by "snapshotEnvironment.resolvePath"
+client.assert({
+  received: 'some text',
+  isInline: false,
+})
+
+// uses "pretty-format", so it requires quotes
+// also naming is hard-coded when parsing test files
+wrapper('text 1').toMatchInlineSnapshot()
+wrapper('text 2').toMatchInlineSnapshot('"text 2"')
+
+const result = await client.finishCurrentRun() // this saves files and returns SnapshotResult
+
+// you can use manager to manage several clients
+const manager = new SnapshotManager(options)
+manager.add(result)
+
+// do something
+// and then read the summary
+
+console.log(manager.summary)
+```

package/plugins/web-search/node_modules/@vitest/snapshot/dist/environment.d-DHdQ1Csl.d.ts

@@ -0,0 +1,22 @@
+interface ParsedStack {
+	method: string;
+	file: string;
+	line: number;
+	column: number;
+}
+
+interface SnapshotEnvironment {
+	getVersion: () => string;
+	getHeader: () => string;
+	resolvePath: (filepath: string) => Promise<string>;
+	resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
+	saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
+	readSnapshotFile: (filepath: string) => Promise<string | null>;
+	removeSnapshotFile: (filepath: string) => Promise<void>;
+	processStackTrace?: (stack: ParsedStack) => ParsedStack;
+}
+interface SnapshotEnvironmentOptions {
+	snapshotsDirName?: string;
+}
+
+export type { ParsedStack as P, SnapshotEnvironment as S, SnapshotEnvironmentOptions as a };

package/plugins/web-search/node_modules/@vitest/snapshot/dist/environment.d.ts

@@ -0,0 +1,16 @@
+import { S as SnapshotEnvironment, a as SnapshotEnvironmentOptions } from './environment.d-DHdQ1Csl.js';
+
+declare class NodeSnapshotEnvironment implements SnapshotEnvironment {
+	private options;
+	constructor(options?: SnapshotEnvironmentOptions);
+	getVersion(): string;
+	getHeader(): string;
+	resolveRawPath(testPath: string, rawPath: string): Promise<string>;
+	resolvePath(filepath: string): Promise<string>;
+	prepareDirectory(dirPath: string): Promise<void>;
+	saveSnapshotFile(filepath: string, snapshot: string): Promise<void>;
+	readSnapshotFile(filepath: string): Promise<string | null>;
+	removeSnapshotFile(filepath: string): Promise<void>;
+}
+
+export { NodeSnapshotEnvironment, SnapshotEnvironment };

package/plugins/web-search/node_modules/@vitest/snapshot/dist/environment.js

@@ -0,0 +1,40 @@
+import { promises, existsSync } from 'node:fs';
+import { resolve, isAbsolute, dirname, join, basename } from 'pathe';
+
+class NodeSnapshotEnvironment {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	getVersion() {
+		return "1";
+	}
+	getHeader() {
+		return `// Snapshot v${this.getVersion()}`;
+	}
+	async resolveRawPath(testPath, rawPath) {
+		return isAbsolute(rawPath) ? rawPath : resolve(dirname(testPath), rawPath);
+	}
+	async resolvePath(filepath) {
+		return join(join(dirname(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${basename(filepath)}.snap`);
+	}
+	async prepareDirectory(dirPath) {
+		await promises.mkdir(dirPath, { recursive: true });
+	}
+	async saveSnapshotFile(filepath, snapshot) {
+		await promises.mkdir(dirname(filepath), { recursive: true });
+		await promises.writeFile(filepath, snapshot, "utf-8");
+	}
+	async readSnapshotFile(filepath) {
+		if (!existsSync(filepath)) {
+			return null;
+		}
+		return promises.readFile(filepath, "utf-8");
+	}
+	async removeSnapshotFile(filepath) {
+		if (existsSync(filepath)) {
+			await promises.unlink(filepath);
+		}
+	}
+}
+
+export { NodeSnapshotEnvironment };

package/plugins/web-search/node_modules/@vitest/snapshot/dist/index.d.ts

@@ -0,0 +1,137 @@
+import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot.d-lFsMJFUd.js';
+export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-lFsMJFUd.js';
+import { S as SnapshotEnvironment, P as ParsedStack } from './environment.d-DHdQ1Csl.js';
+import { Plugin, Plugins } from '@vitest/pretty-format';
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare class DefaultMap<
+	K,
+	V
+> extends Map<K, V> {
+	private defaultFn;
+	constructor(defaultFn: (key: K) => V, entries?: Iterable<readonly [K, V]>);
+	get(key: K): V;
+}
+declare class CounterMap<K> extends DefaultMap<K, number> {
+	constructor();
+	// compat for jest-image-snapshot https://github.com/vitest-dev/vitest/issues/7322
+	// `valueOf` and `Snapshot.added` setter allows
+	//   snapshotState.added = snapshotState.added + 1
+	// to function as
+	//   snapshotState.added.total_ = snapshotState.added.total() + 1
+	_total: number | undefined;
+	valueOf(): number;
+	increment(key: K): void;
+	total(): number;
+}
+
+interface SnapshotReturnOptions {
+	actual: string;
+	count: number;
+	expected?: string;
+	key: string;
+	pass: boolean;
+}
+interface SaveStatus {
+	deleted: boolean;
+	saved: boolean;
+}
+declare class SnapshotState {
+	testFilePath: string;
+	snapshotPath: string;
+	private _counters;
+	private _dirty;
+	private _updateSnapshot;
+	private _snapshotData;
+	private _initialData;
+	private _inlineSnapshots;
+	private _inlineSnapshotStacks;
+	private _testIdToKeys;
+	private _rawSnapshots;
+	private _uncheckedKeys;
+	private _snapshotFormat;
+	private _environment;
+	private _fileExists;
+	expand: boolean;
+	// getter/setter for jest-image-snapshot compat
+	// https://github.com/vitest-dev/vitest/issues/7322
+	private _added;
+	private _matched;
+	private _unmatched;
+	private _updated;
+	get added(): CounterMap<string>;
+	set added(value: CounterMap<string>);
+	get matched(): CounterMap<string>;
+	set matched(value: CounterMap<string>);
+	get unmatched(): CounterMap<string>;
+	set unmatched(value: CounterMap<string>);
+	get updated(): CounterMap<string>;
+	set updated(value: CounterMap<string>);
+	private constructor();
+	static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
+	get environment(): SnapshotEnvironment;
+	markSnapshotsAsCheckedForTest(testName: string): void;
+	clearTest(testId: string): void;
+	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
+	private _addSnapshot;
+	save(): Promise<SaveStatus>;
+	getUncheckedCount(): number;
+	getUncheckedKeys(): Array<string>;
+	removeUncheckedKeys(): void;
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }: SnapshotMatchOptions): SnapshotReturnOptions;
+	pack(): Promise<SnapshotResult>;
+}
+
+interface AssertOptions {
+	received: unknown;
+	filepath: string;
+	name: string;
+	/**
+	* Not required but needed for `SnapshotClient.clearTest` to implement test-retry behavior.
+	* @default name
+	*/
+	testId?: string;
+	message?: string;
+	isInline?: boolean;
+	properties?: object;
+	inlineSnapshot?: string;
+	error?: Error;
+	errorMessage?: string;
+	rawSnapshot?: RawSnapshotInfo;
+}
+interface SnapshotClientOptions {
+	isEqual?: (received: unknown, expected: unknown) => boolean;
+}
+declare class SnapshotClient {
+	private options;
+	snapshotStateMap: Map<string, SnapshotState>;
+	constructor(options?: SnapshotClientOptions);
+	setup(filepath: string, options: SnapshotStateOptions): Promise<void>;
+	finish(filepath: string): Promise<SnapshotResult>;
+	skipTest(filepath: string, testName: string): void;
+	clearTest(filepath: string, testId: string): void;
+	getSnapshotState(filepath: string): SnapshotState;
+	assert(options: AssertOptions): void;
+	assertRaw(options: AssertOptions): Promise<void>;
+	clear(): void;
+}
+
+declare function stripSnapshotIndentation(inlineSnapshot: string): string;
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare function addSerializer(plugin: Plugin): void;
+declare function getSerializers(): Plugins;
+
+export { SnapshotClient, SnapshotMatchOptions, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };