@liip/liipgpt 3.0.3 → 3.0.4

package/config/index.d.ts

@@ -1607,1056 +1607,353 @@ export type Route = {
 	query: string;
 };
 export type ConversationState = "idle" | "searching" | "answering";
-type Primitive$1 = null | undefined | string | number | boolean | symbol | bigint;
-/**
-Extract all optional keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the optional keys only.
-
-@example
-```
-import type {OptionalKeysOf, Except} from 'type-fest';
-
-interface User {
+declare const errorTranslationSchema: z.ZodObject<{
+	blocked: z.ZodString;
+	maintenance: z.ZodString;
+	"rate-limit": z.ZodString;
+	"server-error": z.ZodString;
+	"too-short": z.ZodString;
+	"too-long": z.ZodString;
+	"quota-reached": z.ZodString;
+	aborted: z.ZodString;
+	"sse-error": z.ZodString;
+	"client-error": z.ZodString;
+	"unexpected-call": z.ZodString;
+	"incomplete-error": z.ZodString;
+	"feedback-failed": z.ZodString;
+	"speech-not-supported": z.ZodString;
+	"speech-transcription-failed": z.ZodString;
+	"speech-no-text-detected": z.ZodString;
+	"speech-microphone-access-denied": z.ZodString;
+	"pii-detected": z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	"pii-detected": string;
+	blocked: string;
+	maintenance: string;
+	"rate-limit": string;
+	"server-error": string;
+	"too-short": string;
+	"too-long": string;
+	"quota-reached": string;
+	aborted: string;
+	"unexpected-call": string;
+	"sse-error": string;
+	"client-error": string;
+	"incomplete-error": string;
+	"feedback-failed": string;
+	"speech-not-supported": string;
+	"speech-transcription-failed": string;
+	"speech-no-text-detected": string;
+	"speech-microphone-access-denied": string;
+}, {
+	"pii-detected": string;
+	blocked: string;
+	maintenance: string;
+	"rate-limit": string;
+	"server-error": string;
+	"too-short": string;
+	"too-long": string;
+	"quota-reached": string;
+	aborted: string;
+	"unexpected-call": string;
+	"sse-error": string;
+	"client-error": string;
+	"incomplete-error": string;
+	"feedback-failed": string;
+	"speech-not-supported": string;
+	"speech-transcription-failed": string;
+	"speech-no-text-detected": string;
+	"speech-microphone-access-denied": string;
+}>;
+declare const chatSelectorTranslationSchema: z.ZodObject<{
+	name: z.ZodString;
+	namePlural: z.ZodOptional<z.ZodString>;
+	intro: z.ZodOptional<z.ZodString>;
+	placeholder: z.ZodString;
+	values: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+	values: Record<string, string>;
 	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const REMOVE_FIELD = Symbol('remove field symbol');
-type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
-	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
-};
-
-const update1: UpdateOperation<User> = {
-	name: 'Alice'
-};
-
-const update2: UpdateOperation<User> = {
-	name: 'Bob',
-	luckyNumber: REMOVE_FIELD
-};
-```
-
-@category Utilities
-*/
-export type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
- ? (keyof {
-	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never;
-}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
- : never; // Should never happen
-/**
-Extract all required keys from the given type.
-
-This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
-
-@example
-```
-import type {RequiredKeysOf} from 'type-fest';
-
-declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
-
-interface User {
+	placeholder: string;
+	namePlural?: string | undefined;
+	intro?: string | undefined;
+}, {
+	values: Record<string, string>;
 	name: string;
-	surname: string;
-
-	luckyNumber?: number;
-}
-
-const validator1 = createValidation<User>('name', value => value.length < 25);
-const validator2 = createValidation<User>('surname', value => value.length < 25);
-```
-
-@category Utilities
-*/
-export type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
- ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never; // Should never happen
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
-type AreStringsEqual<A extends string, B extends string> =
-	And<
-		IsNever<Exclude<A, B>> extends true ? true : false,
-		IsNever<Exclude<B, A>> extends true ? true : false
-	>;
-
-type EndIfEqual<I extends string, O extends string> =
-	AreStringsEqual<I, O> extends true
-		? never
-		: void;
-
-function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
-	if (input === output) {
-		process.exit(0);
-	}
-}
-
-endIfEqual('abc', 'abc');
-//=> never
-
-endIfEqual('abc', '123');
-//=> void
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNever<T> = [
-	T
-] extends [
-	never
-] ? true : false;
-/**
-An if-else-like type that resolves depending on whether the given type is `never`.
-
-@see {@link IsNever}
-
-@example
-```
-import type {IfNever} from 'type-fest';
-
-type ShouldBeTrue = IfNever<never>;
-//=> true
-
-type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
-type NoInfer$1<T> = T extends infer U ? U : never;
-/**
-Returns a boolean for whether the given type is `any`.
-
-@link https://stackoverflow.com/a/49928360/1490091
-
-Useful in type utilities, such as disallowing `any`s to be passed to a function.
-
-@example
-```
-import type {IsAny} from 'type-fest';
-
-const typedObject = {a: 1, b: 2} as const;
-const anyObject: any = {a: 1, b: 2};
-
-function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
-	return obj[key];
-}
-
-const typedA = get(typedObject, 'a');
-//=> 1
-
-const anyA = get(anyObject, 'a');
-//=> any
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsAny<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-function fn(object: Record<string, unknown>): void {}
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see SimplifyDeep
-@category Object
-*/
-export type Simplify<T> = {
-	[KeyType in keyof T]: T[KeyType];
-} & {};
+	placeholder: string;
+	namePlural?: string | undefined;
+	intro?: string | undefined;
+}>;
+declare const translationSchema: z.ZodObject<{
+	predefinedQuestions: z.ZodString;
+	introductionTitle: z.ZodString;
+	introductionDisclaimer: z.ZodOptional<z.ZodString>;
+	chatInputPlaceholder: z.ZodString;
+	chatInputPlaceholderListening: z.ZodOptional<z.ZodString>;
+	chatInputSubmit: z.ZodString;
+	chatInputStartListening: z.ZodString;
+	chatInputStopListening: z.ZodString;
+	referenceLink: z.ZodString;
+	referencesDisplay: z.ZodString;
+	referencesHide: z.ZodString;
+	referencesTitle: z.ZodString;
+	referencesFurtherTitle: z.ZodString;
+	newChat: z.ZodString;
+	maintenanceModeError: z.ZodString;
+	messageBotLoading: z.ZodString;
+	messageBotError: z.ZodString;
+	messageBotDefaultError: z.ZodString;
+	noResultsFound: z.ZodString;
+	chatFooterText: z.ZodOptional<z.ZodString>;
+	scrollToBottom: z.ZodString;
+	openButtonTitle: z.ZodOptional<z.ZodString>;
+	openButtonDescription: z.ZodOptional<z.ZodString>;
+	openMenu: z.ZodString;
+	openInfo: z.ZodString;
+	aboutThisChat: z.ZodOptional<z.ZodString>;
+	closeMenu: z.ZodString;
+	closeChat: z.ZodString;
+	close: z.ZodString;
+	send: z.ZodString;
+	thankYouForFeedback: z.ZodString;
+	giveFeedback: z.ZodString;
+	sendFeedback: z.ZodString;
+	feedbackFormTitle: z.ZodString;
+	feedbackFormMessage: z.ZodString;
+	feedbackFormMessagePlaceholder: z.ZodString;
+	feedbackFormEmail: z.ZodString;
+	feedbackFormEmailPlaceholder: z.ZodString;
+	answerGood: z.ZodString;
+	answerBad: z.ZodString;
+	classificationSubmit: z.ZodString;
+	classificationThankYou: z.ZodString;
+	classificationTitle: z.ZodString;
+	selectLanguage: z.ZodString;
+	lightMode: z.ZodString;
+	darkMode: z.ZodString;
+	termsTitle: z.ZodOptional<z.ZodString>;
+	termsContent: z.ZodOptional<z.ZodString>;
+	selectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+		name: z.ZodString;
+		namePlural: z.ZodOptional<z.ZodString>;
+		intro: z.ZodOptional<z.ZodString>;
+		placeholder: z.ZodString;
+		values: z.ZodRecord<z.ZodString, z.ZodString>;
+	}, "strip", z.ZodTypeAny, {
+		values: Record<string, string>;
+		name: string;
+		placeholder: string;
+		namePlural?: string | undefined;
+		intro?: string | undefined;
+	}, {
+		values: Record<string, string>;
+		name: string;
+		placeholder: string;
+		namePlural?: string | undefined;
+		intro?: string | undefined;
+	}>>>;
+	hideSettings: z.ZodString;
+	showSettings: z.ZodString;
+	chooseAtLeastOneOption: z.ZodString;
+	selectAll: z.ZodString;
+	selectNone: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	predefinedQuestions: string;
+	introductionTitle: string;
+	chatInputPlaceholder: string;
+	chatInputSubmit: string;
+	chatInputStartListening: string;
+	chatInputStopListening: string;
+	referenceLink: string;
+	referencesDisplay: string;
+	referencesHide: string;
+	referencesTitle: string;
+	referencesFurtherTitle: string;
+	newChat: string;
+	maintenanceModeError: string;
+	messageBotLoading: string;
+	messageBotError: string;
+	messageBotDefaultError: string;
+	noResultsFound: string;
+	scrollToBottom: string;
+	openMenu: string;
+	openInfo: string;
+	closeMenu: string;
+	closeChat: string;
+	close: string;
+	send: string;
+	thankYouForFeedback: string;
+	giveFeedback: string;
+	sendFeedback: string;
+	feedbackFormTitle: string;
+	feedbackFormMessage: string;
+	feedbackFormMessagePlaceholder: string;
+	feedbackFormEmail: string;
+	feedbackFormEmailPlaceholder: string;
+	answerGood: string;
+	answerBad: string;
+	classificationSubmit: string;
+	classificationThankYou: string;
+	classificationTitle: string;
+	selectLanguage: string;
+	lightMode: string;
+	darkMode: string;
+	hideSettings: string;
+	showSettings: string;
+	chooseAtLeastOneOption: string;
+	selectAll: string;
+	selectNone: string;
+	introductionDisclaimer?: string | undefined;
+	chatInputPlaceholderListening?: string | undefined;
+	chatFooterText?: string | undefined;
+	openButtonTitle?: string | undefined;
+	openButtonDescription?: string | undefined;
+	aboutThisChat?: string | undefined;
+	termsTitle?: string | undefined;
+	termsContent?: string | undefined;
+	selectors?: Record<string, {
+		values: Record<string, string>;
+		name: string;
+		placeholder: string;
+		namePlural?: string | undefined;
+		intro?: string | undefined;
+	}> | undefined;
+}, {
+	predefinedQuestions: string;
+	introductionTitle: string;
+	chatInputPlaceholder: string;
+	chatInputSubmit: string;
+	chatInputStartListening: string;
+	chatInputStopListening: string;
+	referenceLink: string;
+	referencesDisplay: string;
+	referencesHide: string;
+	referencesTitle: string;
+	referencesFurtherTitle: string;
+	newChat: string;
+	maintenanceModeError: string;
+	messageBotLoading: string;
+	messageBotError: string;
+	messageBotDefaultError: string;
+	noResultsFound: string;
+	scrollToBottom: string;
+	openMenu: string;
+	openInfo: string;
+	closeMenu: string;
+	closeChat: string;
+	close: string;
+	send: string;
+	thankYouForFeedback: string;
+	giveFeedback: string;
+	sendFeedback: string;
+	feedbackFormTitle: string;
+	feedbackFormMessage: string;
+	feedbackFormMessagePlaceholder: string;
+	feedbackFormEmail: string;
+	feedbackFormEmailPlaceholder: string;
+	answerGood: string;
+	answerBad: string;
+	classificationSubmit: string;
+	classificationThankYou: string;
+	classificationTitle: string;
+	selectLanguage: string;
+	lightMode: string;
+	darkMode: string;
+	hideSettings: string;
+	showSettings: string;
+	chooseAtLeastOneOption: string;
+	selectAll: string;
+	selectNone: string;
+	introductionDisclaimer?: string | undefined;
+	chatInputPlaceholderListening?: string | undefined;
+	chatFooterText?: string | undefined;
+	openButtonTitle?: string | undefined;
+	openButtonDescription?: string | undefined;
+	aboutThisChat?: string | undefined;
+	termsTitle?: string | undefined;
+	termsContent?: string | undefined;
+	selectors?: Record<string, {
+		values: Record<string, string>;
+		name: string;
+		placeholder: string;
+		namePlural?: string | undefined;
+		intro?: string | undefined;
+	}> | undefined;
+}>;
+declare const languagesSchema: z.ZodEnum<[
+	"en",
+	"de",
+	"fr",
+	"it"
+]>;
+export type Language = z.infer<typeof languagesSchema>;
+export type Translation = z.infer<typeof translationSchema>;
+export type ErrorTranslation = z.infer<typeof errorTranslationSchema>;
+export type Translations = Record<Language, Translation>;
+export type SelectorTranslation = z.infer<typeof chatSelectorTranslationSchema>;
+export type TranslationsPartial = Partial<Record<Language, Omit<Partial<Translation>, "selectors"> & {
+	selectors?: Record<string, SelectorTranslation>;
+}>>;
+declare const SnippetReturn: unique symbol;
+// Use an interface instead of a type, makes for better intellisense info because the type is named in more situations.
 /**
-Omit any index signatures from the given object type, leaving only explicitly defined properties.
-
-This is the counterpart of `PickIndexSignature`.
-
-Use-cases:
-- Remove overly permissive signatures from third-party types.
-
-This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
-
-It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
-
-(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
-
-```
-const indexed: Record<string, unknown> = {}; // Allowed
-
-const keyed: Record<'foo', unknown> = {}; // Error
-// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
-```
-
-Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
-
-```
-type Indexed = {} extends Record<string, unknown>
-	? '✅ `{}` is assignable to `Record<string, unknown>`'
-	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
-// => '✅ `{}` is assignable to `Record<string, unknown>`'
-
-type Keyed = {} extends Record<'foo' | 'bar', unknown>
-	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
-	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
-// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
-```
-
-Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
-
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
-};
-```
-
-...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
-
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType
-		// Is `{}` assignable to `Record<KeyType, unknown>`?
-		as {} extends Record<KeyType, unknown>
-			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
-			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
-	]: ObjectType[KeyType];
-};
-```
-
-If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
-
-@example
-```
-import type {OmitIndexSignature} from 'type-fest';
-
-interface Example {
-	// These index signatures will be removed.
-	[x: string]: any
-	[x: number]: any
-	[x: symbol]: any
-	[x: `head-${string}`]: string
-	[x: `${string}-tail`]: string
-	[x: `head-${string}-tail`]: string
-	[x: `${bigint}`]: string
-	[x: `embedded-${number}`]: string
-
-	// These explicitly defined keys will remain.
-	foo: 'bar';
-	qux?: 'baz';
+ * The type of a `#snippet` block. You can use it to (for example) express that your component expects a snippet of a certain type:
+ * ```ts
+ * let { banner }: { banner: Snippet<[{ text: string }]> } = $props();
+ * ```
+ * You can only call a snippet through the `{@render ...}` tag.
+ *
+ * See the [snippet documentation](https://svelte.dev/docs/svelte/snippet) for more info.
+ *
+ * @template Parameters the parameters that the snippet expects (if any) as a tuple.
+ */
+export interface Snippet<Parameters extends unknown[] = [
+]> {
+	(this: void, 
+	// this conditional allows tuples but not arrays. Arrays would indicate a
+	// rest parameter type, which is not supported. If rest parameters are added
+	// in the future, the condition can be removed.
+	...args: number extends Parameters["length"] ? never : Parameters): {
+		"{@render ...} must be called with a Snippet": "import type { Snippet } from 'svelte'";
+	} & typeof SnippetReturn;
 }
-
-type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
-// => { foo: 'bar'; qux?: 'baz' | undefined; }
-```
-
-@see PickIndexSignature
-@category Object
-*/
-export type OmitIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
-};
-/**
-Pick only index signatures from the given object type, leaving out all explicitly defined properties.
-
-This is the counterpart of `OmitIndexSignature`.
-
-@example
-```
-import type {PickIndexSignature} from 'type-fest';
-
-declare const symbolKey: unique symbol;
-
-type Example = {
-	// These index signatures will remain.
-	[x: string]: unknown;
-	[x: number]: unknown;
-	[x: symbol]: unknown;
-	[x: `head-${string}`]: string;
-	[x: `${string}-tail`]: string;
-	[x: `head-${string}-tail`]: string;
-	[x: `${bigint}`]: string;
-	[x: `embedded-${number}`]: string;
-
-	// These explicitly defined keys will be removed.
-	['kebab-case-key']: string;
-	[symbolKey]: string;
-	foo: 'bar';
-	qux?: 'baz';
-};
-
-type ExampleIndexSignature = PickIndexSignature<Example>;
-// {
-// 	[x: string]: unknown;
-// 	[x: number]: unknown;
-// 	[x: symbol]: unknown;
-// 	[x: `head-${string}`]: string;
-// 	[x: `${string}-tail`]: string;
-// 	[x: `head-${string}-tail`]: string;
-// 	[x: `${bigint}`]: string;
-// 	[x: `embedded-${number}`]: string;
-// }
-```
-
-@see OmitIndexSignature
-@category Object
-*/
-export type PickIndexSignature<ObjectType> = {
-	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
-};
-// Merges two objects without worrying about index signatures.
-export type SimpleMerge<Destination, Source> = {
-	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
-} & Source;
 /**
-Merge two types into a new type. Keys of the second type overrides keys of the first type.
-
-@example
-```
-import type {Merge} from 'type-fest';
-
-interface Foo {
-	[x: string]: unknown;
-	[x: number]: unknown;
-	foo: string;
-	bar: symbol;
+ * An [attachment](https://svelte.dev/docs/svelte/@attach) is a function that runs when an element is mounted
+ * to the DOM, and optionally returns a function that is called when the element is later removed.
+ *
+ * It can be attached to an element with an `{@attach ...}` tag, or by spreading an object containing
+ * a property created with [`createAttachmentKey`](https://svelte.dev/docs/svelte/svelte-attachments#createAttachmentKey).
+ */
+export interface Attachment<T extends EventTarget = Element> {
+	(element: T): void | (() => void);
 }
-
-type Bar = {
-	[x: number]: number;
-	[x: symbol]: unknown;
-	bar: Date;
-	baz: boolean;
-};
-
-export type FooBar = Merge<Foo, Bar>;
-// => {
-// 	[x: string]: unknown;
-// 	[x: number]: number;
-// 	[x: symbol]: unknown;
-// 	foo: string;
-// 	bar: Date;
-// 	baz: boolean;
-// }
-```
-
-@category Object
-*/
-export type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
-/**
-An if-else-like type that resolves depending on whether the given type is `any`.
-
-@see {@link IsAny}
-
-@example
-```
-import type {IfAny} from 'type-fest';
-
-type ShouldBeTrue = IfAny<any>;
-//=> true
-
-type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
-//=> 'bar'
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-export type BuiltIns = Primitive$1 | void | Date | RegExp;
-/**
-Matches non-recursive types.
-*/
-export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-/**
-Merges user specified options with default options.
-
-@example
-```
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: true};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//=> {maxRecursionDepth: 10; leavesOnly: true}
-```
-
-@example
-```
-// Complains if default values are not provided for optional options
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
-```
-
-@example
-```
-// Complains if an option's default type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-
-@example
-```
-// Complains if an option's specified type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: 'yes'};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                                                   ~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-*/
-export type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, {
-	[Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key];
-}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
->>;
-/**
-Recursively simplifies a type while including and/or excluding certain types from being simplified.
-
-This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
-
-See {@link ConditionalSimplify} for usages and examples.
-
-@internal
-@experimental
-@category Object
-*/
-export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? {
-	[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
-} : Type;
-/**
-Deeply simplifies an object type.
-
-You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.
-
-Useful to flatten the type output to improve type hints shown in editors.
-
-@example
-```
-import type {SimplifyDeep} from 'type-fest';
-
-type PositionX = {
-	left: number;
-	right: number;
-};
-
-type PositionY = {
-	top: number;
-	bottom: number;
-};
-
-type Properties1 = {
-	height: number;
-	position: PositionY;
-};
-
-type Properties2 = {
-	width: number;
-	position: PositionX;
-};
-
-type Properties = Properties1 & Properties2;
-// In your editor, hovering over `Props` will show the following:
-//
-// type Properties = Properties1 & Properties2;
-
-type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
-// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
+// Note: We also allow `null` as a valid value because Svelte treats this the same as `undefined`
+export type Booleanish = boolean | "true" | "false";
 //
-// SimplifyDeepProperties = {
-// 	height: number;
-// 	width: number;
-// 	position: {
-// 		top: number;
-// 		bottom: number;
-// 		left: number;
-// 		right: number;
-// 	};
-// };
-```
-
-@example
-```
-import type {SimplifyDeep} from 'type-fest';
-
-// A complex type that you don't want or need to simplify
-type ComplexType = {
-	a: string;
-	b: 'b';
-	c: number;
-	...
-};
-
-type PositionX = {
-	left: number;
-	right: number;
-};
-
-type PositionY = {
-	top: number;
-	bottom: number;
-};
-
-// You want to simplify all other types
-type Properties1 = {
-	height: number;
-	position: PositionY;
-	foo: ComplexType;
-};
-
-type Properties2 = {
-	width: number;
-	position: PositionX;
-	foo: ComplexType;
-};
-
-type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
-// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
-// show a flattened object with all the properties except `ComplexType`:
-//
-// SimplifyDeepProperties = {
-// 	height: number;
-// 	width: number;
-// 	position: {
-// 		top: number;
-// 		bottom: number;
-// 		left: number;
-// 		right: number;
-// 	};
-//	foo: ComplexType;
-// };
-```
-
-@see Simplify
-@category Object
-*/
-export type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>, object>;
-/**
-@see {@link PartialDeep}
-*/
-export type PartialDeepOptions = {
-	/**
-	Whether to affect the individual elements of arrays and tuples.
-
-	@default false
-	*/
-	readonly recurseIntoArrays?: boolean;
-	/**
-	Allows `undefined` values in non-tuple arrays.
-
-	- When set to `true`, elements of non-tuple arrays can be `undefined`.
-	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
-
-	@default true
-
-	@example
-	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
-
-	```
-	import type {PartialDeep} from 'type-fest';
-
-	type Settings = {
-		languages: string[];
-	};
-
-	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
-
-	partialSettings.languages = [undefined]; // Error
-	partialSettings.languages = []; // Ok
-	```
-	*/
-	readonly allowUndefinedInNonTupleArrays?: boolean;
-};
-export type DefaultPartialDeepOptions = {
-	recurseIntoArrays: false;
-	allowUndefinedInNonTupleArrays: true;
-};
-/**
-Create a type from another type with all keys and nested keys set to optional.
-
-Use-cases:
-- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
-- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
-
-@example
-```
-import type {PartialDeep} from 'type-fest';
-
-const settings: Settings = {
-	textEditor: {
-		fontSize: 14,
-		fontColor: '#000000',
-		fontWeight: 400
-	},
-	autocomplete: false,
-	autosave: true
-};
-
-const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
-	return {...settings, ...savedSettings};
-}
-
-settings = applySavedSettings({textEditor: {fontWeight: 500}});
-```
-
-By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
-
-```
-import type {PartialDeep} from 'type-fest';
-
-type Settings = {
-	languages: string[];
-}
-
-const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
-	languages: [undefined]
-};
-```
-
-@see {@link PartialDeepOptions}
-
-@category Object
-@category Array
-@category Set
-@category Map
-*/
-export type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
-export type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : IsNever<keyof T> extends true // For functions with no properties
- ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
- ? Options["recurseIntoArrays"] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
- ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
- ? ReadonlyArray<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
- : T // If they don't opt into array testing, just use the original type
- : PartialObjectDeep<T, Options> : unknown;
-/**
-Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
-*/
-export type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
-/**
-Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
-*/
-export type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
-/**
-Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
-*/
-export type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
-/**
-Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
-*/
-export type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
-/**
-Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
-*/
-export type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends (...arguments_: any) => unknown ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({
-	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>;
-});
-declare const errorTranslationSchema: z.ZodObject<{
-	blocked: z.ZodString;
-	maintenance: z.ZodString;
-	"rate-limit": z.ZodString;
-	"server-error": z.ZodString;
-	"too-short": z.ZodString;
-	"too-long": z.ZodString;
-	"quota-reached": z.ZodString;
-	aborted: z.ZodString;
-	"sse-error": z.ZodString;
-	"client-error": z.ZodString;
-	"unexpected-call": z.ZodString;
-	"incomplete-error": z.ZodString;
-	"feedback-failed": z.ZodString;
-	"speech-not-supported": z.ZodString;
-	"speech-transcription-failed": z.ZodString;
-	"speech-no-text-detected": z.ZodString;
-	"speech-microphone-access-denied": z.ZodString;
-	"pii-detected": z.ZodString;
-}, "strip", z.ZodTypeAny, {
-	"pii-detected": string;
-	blocked: string;
-	maintenance: string;
-	"rate-limit": string;
-	"server-error": string;
-	"too-short": string;
-	"too-long": string;
-	"quota-reached": string;
-	aborted: string;
-	"unexpected-call": string;
-	"sse-error": string;
-	"client-error": string;
-	"incomplete-error": string;
-	"feedback-failed": string;
-	"speech-not-supported": string;
-	"speech-transcription-failed": string;
-	"speech-no-text-detected": string;
-	"speech-microphone-access-denied": string;
-}, {
-	"pii-detected": string;
-	blocked: string;
-	maintenance: string;
-	"rate-limit": string;
-	"server-error": string;
-	"too-short": string;
-	"too-long": string;
-	"quota-reached": string;
-	aborted: string;
-	"unexpected-call": string;
-	"sse-error": string;
-	"client-error": string;
-	"incomplete-error": string;
-	"feedback-failed": string;
-	"speech-not-supported": string;
-	"speech-transcription-failed": string;
-	"speech-no-text-detected": string;
-	"speech-microphone-access-denied": string;
-}>;
-declare const translationSchema: z.ZodObject<{
-	predefinedQuestions: z.ZodString;
-	introductionTitle: z.ZodString;
-	introductionDisclaimer: z.ZodOptional<z.ZodString>;
-	chatInputPlaceholder: z.ZodString;
-	chatInputPlaceholderListening: z.ZodOptional<z.ZodString>;
-	chatInputSubmit: z.ZodString;
-	chatInputStartListening: z.ZodString;
-	chatInputStopListening: z.ZodString;
-	referenceLink: z.ZodString;
-	referencesDisplay: z.ZodString;
-	referencesHide: z.ZodString;
-	referencesTitle: z.ZodString;
-	referencesFurtherTitle: z.ZodString;
-	newChat: z.ZodString;
-	maintenanceModeError: z.ZodString;
-	messageBotLoading: z.ZodString;
-	messageBotError: z.ZodString;
-	messageBotDefaultError: z.ZodString;
-	noResultsFound: z.ZodString;
-	chatFooterText: z.ZodOptional<z.ZodString>;
-	scrollToBottom: z.ZodString;
-	openButtonTitle: z.ZodOptional<z.ZodString>;
-	openButtonDescription: z.ZodOptional<z.ZodString>;
-	openMenu: z.ZodString;
-	openInfo: z.ZodString;
-	aboutThisChat: z.ZodOptional<z.ZodString>;
-	closeMenu: z.ZodString;
-	closeChat: z.ZodString;
-	close: z.ZodString;
-	send: z.ZodString;
-	thankYouForFeedback: z.ZodString;
-	giveFeedback: z.ZodString;
-	sendFeedback: z.ZodString;
-	feedbackFormTitle: z.ZodString;
-	feedbackFormMessage: z.ZodString;
-	feedbackFormMessagePlaceholder: z.ZodString;
-	feedbackFormEmail: z.ZodString;
-	feedbackFormEmailPlaceholder: z.ZodString;
-	answerGood: z.ZodString;
-	answerBad: z.ZodString;
-	classificationSubmit: z.ZodString;
-	classificationThankYou: z.ZodString;
-	classificationTitle: z.ZodString;
-	selectLanguage: z.ZodString;
-	lightMode: z.ZodString;
-	darkMode: z.ZodString;
-	termsTitle: z.ZodOptional<z.ZodString>;
-	termsContent: z.ZodOptional<z.ZodString>;
-	selectors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-		name: z.ZodString;
-		namePlural: z.ZodOptional<z.ZodString>;
-		intro: z.ZodOptional<z.ZodString>;
-		placeholder: z.ZodString;
-		values: z.ZodRecord<z.ZodString, z.ZodString>;
-	}, "strip", z.ZodTypeAny, {
-		values: Record<string, string>;
-		name: string;
-		placeholder: string;
-		namePlural?: string | undefined;
-		intro?: string | undefined;
-	}, {
-		values: Record<string, string>;
-		name: string;
-		placeholder: string;
-		namePlural?: string | undefined;
-		intro?: string | undefined;
-	}>>>;
-	hideSettings: z.ZodString;
-	showSettings: z.ZodString;
-	chooseAtLeastOneOption: z.ZodString;
-	selectAll: z.ZodString;
-	selectNone: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-	predefinedQuestions: string;
-	introductionTitle: string;
-	chatInputPlaceholder: string;
-	chatInputSubmit: string;
-	chatInputStartListening: string;
-	chatInputStopListening: string;
-	referenceLink: string;
-	referencesDisplay: string;
-	referencesHide: string;
-	referencesTitle: string;
-	referencesFurtherTitle: string;
-	newChat: string;
-	maintenanceModeError: string;
-	messageBotLoading: string;
-	messageBotError: string;
-	messageBotDefaultError: string;
-	noResultsFound: string;
-	scrollToBottom: string;
-	openMenu: string;
-	openInfo: string;
-	closeMenu: string;
-	closeChat: string;
-	close: string;
-	send: string;
-	thankYouForFeedback: string;
-	giveFeedback: string;
-	sendFeedback: string;
-	feedbackFormTitle: string;
-	feedbackFormMessage: string;
-	feedbackFormMessagePlaceholder: string;
-	feedbackFormEmail: string;
-	feedbackFormEmailPlaceholder: string;
-	answerGood: string;
-	answerBad: string;
-	classificationSubmit: string;
-	classificationThankYou: string;
-	classificationTitle: string;
-	selectLanguage: string;
-	lightMode: string;
-	darkMode: string;
-	hideSettings: string;
-	showSettings: string;
-	chooseAtLeastOneOption: string;
-	selectAll: string;
-	selectNone: string;
-	introductionDisclaimer?: string | undefined;
-	chatInputPlaceholderListening?: string | undefined;
-	chatFooterText?: string | undefined;
-	openButtonTitle?: string | undefined;
-	openButtonDescription?: string | undefined;
-	aboutThisChat?: string | undefined;
-	termsTitle?: string | undefined;
-	termsContent?: string | undefined;
-	selectors?: Record<string, {
-		values: Record<string, string>;
-		name: string;
-		placeholder: string;
-		namePlural?: string | undefined;
-		intro?: string | undefined;
-	}> | undefined;
-}, {
-	predefinedQuestions: string;
-	introductionTitle: string;
-	chatInputPlaceholder: string;
-	chatInputSubmit: string;
-	chatInputStartListening: string;
-	chatInputStopListening: string;
-	referenceLink: string;
-	referencesDisplay: string;
-	referencesHide: string;
-	referencesTitle: string;
-	referencesFurtherTitle: string;
-	newChat: string;
-	maintenanceModeError: string;
-	messageBotLoading: string;
-	messageBotError: string;
-	messageBotDefaultError: string;
-	noResultsFound: string;
-	scrollToBottom: string;
-	openMenu: string;
-	openInfo: string;
-	closeMenu: string;
-	closeChat: string;
-	close: string;
-	send: string;
-	thankYouForFeedback: string;
-	giveFeedback: string;
-	sendFeedback: string;
-	feedbackFormTitle: string;
-	feedbackFormMessage: string;
-	feedbackFormMessagePlaceholder: string;
-	feedbackFormEmail: string;
-	feedbackFormEmailPlaceholder: string;
-	answerGood: string;
-	answerBad: string;
-	classificationSubmit: string;
-	classificationThankYou: string;
-	classificationTitle: string;
-	selectLanguage: string;
-	lightMode: string;
-	darkMode: string;
-	hideSettings: string;
-	showSettings: string;
-	chooseAtLeastOneOption: string;
-	selectAll: string;
-	selectNone: string;
-	introductionDisclaimer?: string | undefined;
-	chatInputPlaceholderListening?: string | undefined;
-	chatFooterText?: string | undefined;
-	openButtonTitle?: string | undefined;
-	openButtonDescription?: string | undefined;
-	aboutThisChat?: string | undefined;
-	termsTitle?: string | undefined;
-	termsContent?: string | undefined;
-	selectors?: Record<string, {
-		values: Record<string, string>;
-		name: string;
-		placeholder: string;
-		namePlural?: string | undefined;
-		intro?: string | undefined;
-	}> | undefined;
-}>;
-declare const languagesSchema: z.ZodEnum<[
-	"en",
-	"de",
-	"fr",
-	"it"
-]>;
-export type Language = z.infer<typeof languagesSchema>;
-export type Translation = z.infer<typeof translationSchema>;
-export type ErrorTranslation = z.infer<typeof errorTranslationSchema>;
-export type Translations = Record<Language, Translation>;
-export type TranslationsPartial = PartialDeep<Translations>;
-declare const SnippetReturn: unique symbol;
-// Use an interface instead of a type, makes for better intellisense info because the type is named in more situations.
-/**
- * The type of a `#snippet` block. You can use it to (for example) express that your component expects a snippet of a certain type:
- * ```ts
- * let { banner }: { banner: Snippet<[{ text: string }]> } = $props();
- * ```
- * You can only call a snippet through the `{@render ...}` tag.
- *
- * See the [snippet documentation](https://svelte.dev/docs/svelte/snippet) for more info.
- *
- * @template Parameters the parameters that the snippet expects (if any) as a tuple.
- */
-export interface Snippet<Parameters extends unknown[] = [
-]> {
-	(this: void, 
-	// this conditional allows tuples but not arrays. Arrays would indicate a
-	// rest parameter type, which is not supported. If rest parameters are added
-	// in the future, the condition can be removed.
-	...args: number extends Parameters["length"] ? never : Parameters): {
-		"{@render ...} must be called with a Snippet": "import type { Snippet } from 'svelte'";
-	} & typeof SnippetReturn;
-}
-/**
- * An [attachment](https://svelte.dev/docs/svelte/@attach) is a function that runs when an element is mounted
- * to the DOM, and optionally returns a function that is called when the element is later removed.
- *
- * It can be attached to an element with an `{@attach ...}` tag, or by spreading an object containing
- * a property created with [`createAttachmentKey`](https://svelte.dev/docs/svelte/svelte-attachments#createAttachmentKey).
- */
-export interface Attachment<T extends EventTarget = Element> {
-	(element: T): void | (() => void);
-}
-// Note: We also allow `null` as a valid value because Svelte treats this the same as `undefined`
-export type Booleanish = boolean | "true" | "false";
-//
-// Event Handler Types
-// ----------------------------------------------------------------------
-export type EventHandler<E extends Event = Event, T extends EventTarget = Element> = (event: E & {
-	currentTarget: EventTarget & T;
-}) => any;
-export type ClipboardEventHandler<T extends EventTarget> = EventHandler<ClipboardEvent, T>;
-export type CompositionEventHandler<T extends EventTarget> = EventHandler<CompositionEvent, T>;
-export type DragEventHandler<T extends EventTarget> = EventHandler<DragEvent, T>;
-export type FocusEventHandler<T extends EventTarget> = EventHandler<FocusEvent, T>;
-export type FormEventHandler<T extends EventTarget> = EventHandler<Event, T>;
-export type ChangeEventHandler<T extends EventTarget> = EventHandler<Event, T>;
-export type KeyboardEventHandler<T extends EventTarget> = EventHandler<KeyboardEvent, T>;
-export type MouseEventHandler<T extends EventTarget> = EventHandler<MouseEvent, T>;
-export type TouchEventHandler<T extends EventTarget> = EventHandler<TouchEvent, T>;
-export type PointerEventHandler<T extends EventTarget> = EventHandler<PointerEvent, T>;
-export type GamepadEventHandler<T extends EventTarget> = EventHandler<GamepadEvent, T>;
-export type UIEventHandler<T extends EventTarget> = EventHandler<UIEvent, T>;
-export type WheelEventHandler<T extends EventTarget> = EventHandler<WheelEvent, T>;
-export type AnimationEventHandler<T extends EventTarget> = EventHandler<AnimationEvent, T>;
-export type TransitionEventHandler<T extends EventTarget> = EventHandler<TransitionEvent, T>;
-export type MessageEventHandler<T extends EventTarget> = EventHandler<MessageEvent, T>;
-export type ToggleEventHandler<T extends EventTarget> = EventHandler<ToggleEvent, T>;
-export type ContentVisibilityAutoStateChangeEventHandler<T extends EventTarget> = EventHandler<ContentVisibilityAutoStateChangeEvent, T>;
-export type FullAutoFill = AutoFill | "bday" | `${OptionalPrefixToken<AutoFillAddressKind>}${"cc-additional-name"}` | "nickname" | "language" | "organization-title" | "photo" | "sex" | "url";
+// Event Handler Types
+// ----------------------------------------------------------------------
+export type EventHandler<E extends Event = Event, T extends EventTarget = Element> = (event: E & {
+	currentTarget: EventTarget & T;
+}) => any;
+export type ClipboardEventHandler<T extends EventTarget> = EventHandler<ClipboardEvent, T>;
+export type CompositionEventHandler<T extends EventTarget> = EventHandler<CompositionEvent, T>;
+export type DragEventHandler<T extends EventTarget> = EventHandler<DragEvent, T>;
+export type FocusEventHandler<T extends EventTarget> = EventHandler<FocusEvent, T>;
+export type FormEventHandler<T extends EventTarget> = EventHandler<Event, T>;
+export type ChangeEventHandler<T extends EventTarget> = EventHandler<Event, T>;
+export type KeyboardEventHandler<T extends EventTarget> = EventHandler<KeyboardEvent, T>;
+export type MouseEventHandler<T extends EventTarget> = EventHandler<MouseEvent, T>;
+export type TouchEventHandler<T extends EventTarget> = EventHandler<TouchEvent, T>;
+export type PointerEventHandler<T extends EventTarget> = EventHandler<PointerEvent, T>;
+export type GamepadEventHandler<T extends EventTarget> = EventHandler<GamepadEvent, T>;
+export type UIEventHandler<T extends EventTarget> = EventHandler<UIEvent, T>;
+export type WheelEventHandler<T extends EventTarget> = EventHandler<WheelEvent, T>;
+export type AnimationEventHandler<T extends EventTarget> = EventHandler<AnimationEvent, T>;
+export type TransitionEventHandler<T extends EventTarget> = EventHandler<TransitionEvent, T>;
+export type MessageEventHandler<T extends EventTarget> = EventHandler<MessageEvent, T>;
+export type ToggleEventHandler<T extends EventTarget> = EventHandler<ToggleEvent, T>;
+export type ContentVisibilityAutoStateChangeEventHandler<T extends EventTarget> = EventHandler<ContentVisibilityAutoStateChangeEvent, T>;
+export type FullAutoFill = AutoFill | "bday" | `${OptionalPrefixToken<AutoFillAddressKind>}${"cc-additional-name"}` | "nickname" | "language" | "organization-title" | "photo" | "sex" | "url";
 //
 // DOM Attributes
 // ----------------------------------------------------------------------
@@ -4320,7 +3617,732 @@ export interface SvelteHTMLElements {
 		[name: string]: any;
 	};
 }
-export type ClassValue = string | import("clsx").ClassArray | import("clsx").ClassDictionary;
+export type ClassValue = string | import("clsx").ClassArray | import("clsx").ClassDictionary;
+type Primitive$1 = null | undefined | string | number | boolean | symbol | bigint;
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+export type OptionalKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+ ? (keyof {
+	[Key in keyof BaseType as BaseType extends Record<Key, BaseType[Key]> ? never : Key]: never;
+}) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf<BaseType>` is always assignable to `keyof BaseType`
+ : never; // Should never happen
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<Entity extends object, Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+```
+
+@category Utilities
+*/
+export type RequiredKeysOf<BaseType extends object> = BaseType extends unknown // For distributing `BaseType`
+ ? Exclude<keyof BaseType, OptionalKeysOf<BaseType>> : never; // Should never happen
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+// https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
+type AreStringsEqual<A extends string, B extends string> =
+	And<
+		IsNever<Exclude<A, B>> extends true ? true : false,
+		IsNever<Exclude<B, A>> extends true ? true : false
+	>;
+
+type EndIfEqual<I extends string, O extends string> =
+	AreStringsEqual<I, O> extends true
+		? never
+		: void;
+
+function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
+	if (input === output) {
+		process.exit(0);
+	}
+}
+
+endIfEqual('abc', 'abc');
+//=> never
+
+endIfEqual('abc', '123');
+//=> void
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsNever<T> = [
+	T
+] extends [
+	never
+] ? true : false;
+/**
+An if-else-like type that resolves depending on whether the given type is `never`.
+
+@see {@link IsNever}
+
+@example
+```
+import type {IfNever} from 'type-fest';
+
+type ShouldBeTrue = IfNever<never>;
+//=> true
+
+type ShouldBeBar = IfNever<'not never', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfNever<T, TypeIfNever = true, TypeIfNotNever = false> = (IsNever<T> extends true ? TypeIfNever : TypeIfNotNever);
+type NoInfer$1<T> = T extends infer U ? U : never;
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(obj: O, key: K) {
+	return obj[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IsAny<T> = 0 extends 1 & NoInfer$1<T> ? true : false;
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+export type Simplify<T> = {
+	[KeyType in keyof T]: T[KeyType];
+} & {};
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+const keyed: Record<'foo', unknown> = {}; // Error
+// => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+// => '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+	: "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+// => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+		// Is `{}` assignable to `Record<KeyType, unknown>`?
+		as {} extends Record<KeyType, unknown>
+			? ... // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+			: ... // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+interface Example {
+	// These index signatures will be removed.
+	[x: string]: any
+	[x: number]: any
+	[x: symbol]: any
+	[x: `head-${string}`]: string
+	[x: `${string}-tail`]: string
+	[x: `head-${string}-tail`]: string
+	[x: `${bigint}`]: string
+	[x: `embedded-${number}`]: string
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+}
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+// => { foo: 'bar'; qux?: 'baz' | undefined; }
+```
+
+@see PickIndexSignature
+@category Object
+*/
+export type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
+};
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see OmitIndexSignature
+@category Object
+*/
+export type PickIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType];
+};
+// Merges two objects without worrying about index signatures.
+export type SimpleMerge<Destination, Source> = {
+	[Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+interface Foo {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+}
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+@category Object
+*/
+export type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+/**
+An if-else-like type that resolves depending on whether the given type is `any`.
+
+@see {@link IsAny}
+
+@example
+```
+import type {IfAny} from 'type-fest';
+
+type ShouldBeTrue = IfAny<any>;
+//=> true
+
+type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
+//=> 'bar'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type IfAny<T, TypeIfAny = true, TypeIfNotAny = false> = (IsAny<T> extends true ? TypeIfAny : TypeIfNotAny);
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+export type BuiltIns = Primitive$1 | void | Date | RegExp;
+/**
+Matches non-recursive types.
+*/
+export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+export type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = IfAny<SpecifiedOptions, Defaults, IfNever<SpecifiedOptions, Defaults, Simplify<Merge<Defaults, {
+	[Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? Extract<SpecifiedOptions[Key], undefined> extends never ? Key : never : Key]: SpecifiedOptions[Key];
+}> & Required<Options>> // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+>>;
+/**
+Recursively simplifies a type while including and/or excluding certain types from being simplified.
+
+This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
+
+See {@link ConditionalSimplify} for usages and examples.
+
+@internal
+@experimental
+@category Object
+*/
+export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? {
+	[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>;
+} : Type;
+/**
+Deeply simplifies an object type.
+
+You can exclude certain types from being simplified by providing them in the second generic `ExcludeType`.
+
+Useful to flatten the type output to improve type hints shown in editors.
+
+@example
+```
+import type {SimplifyDeep} from 'type-fest';
+
+type PositionX = {
+	left: number;
+	right: number;
+};
+
+type PositionY = {
+	top: number;
+	bottom: number;
+};
+
+type Properties1 = {
+	height: number;
+	position: PositionY;
+};
+
+type Properties2 = {
+	width: number;
+	position: PositionX;
+};
+
+type Properties = Properties1 & Properties2;
+// In your editor, hovering over `Props` will show the following:
+//
+// type Properties = Properties1 & Properties2;
+
+type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2>;
+// But if wrapped in SimplifyDeep, hovering over `SimplifyDeepProperties` will show a flattened object with all the properties:
+//
+// SimplifyDeepProperties = {
+// 	height: number;
+// 	width: number;
+// 	position: {
+// 		top: number;
+// 		bottom: number;
+// 		left: number;
+// 		right: number;
+// 	};
+// };
+```
+
+@example
+```
+import type {SimplifyDeep} from 'type-fest';
+
+// A complex type that you don't want or need to simplify
+type ComplexType = {
+	a: string;
+	b: 'b';
+	c: number;
+	...
+};
+
+type PositionX = {
+	left: number;
+	right: number;
+};
+
+type PositionY = {
+	top: number;
+	bottom: number;
+};
+
+// You want to simplify all other types
+type Properties1 = {
+	height: number;
+	position: PositionY;
+	foo: ComplexType;
+};
+
+type Properties2 = {
+	width: number;
+	position: PositionX;
+	foo: ComplexType;
+};
+
+type SimplifyDeepProperties = SimplifyDeep<Properties1 & Properties2, ComplexType>;
+// If wrapped in `SimplifyDeep` and set `ComplexType` to exclude, hovering over `SimplifyDeepProperties` will
+// show a flattened object with all the properties except `ComplexType`:
+//
+// SimplifyDeepProperties = {
+// 	height: number;
+// 	width: number;
+// 	position: {
+// 		top: number;
+// 		bottom: number;
+// 		left: number;
+// 		right: number;
+// 	};
+//	foo: ComplexType;
+// };
+```
+
+@see Simplify
+@category Object
+*/
+export type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>, object>;
+/**
+@see {@link PartialDeep}
+*/
+export type PartialDeepOptions = {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+	readonly recurseIntoArrays?: boolean;
+	/**
+	Allows `undefined` values in non-tuple arrays.
+
+	- When set to `true`, elements of non-tuple arrays can be `undefined`.
+	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
+
+	@default true
+
+	@example
+	You can prevent `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}` as the second type argument:
+
+	```
+	import type {PartialDeep} from 'type-fest';
+
+	type Settings = {
+		languages: string[];
+	};
+
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: false}>;
+
+	partialSettings.languages = [undefined]; // Error
+	partialSettings.languages = []; // Ok
+	```
+	*/
+	readonly allowUndefinedInNonTupleArrays?: boolean;
+};
+export type DefaultPartialDeepOptions = {
+	recurseIntoArrays: false;
+	allowUndefinedInNonTupleArrays: true;
+};
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400
+	},
+	autocomplete: false,
+	autosave: true
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Settings = {
+	languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
+	languages: [undefined]
+};
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+export type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<T, ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>>;
+export type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends BuiltIns | ((new (...arguments_: any[]) => unknown)) ? T : IsNever<keyof T> extends true // For functions with no properties
+ ? T : T extends Map<infer KeyType, infer ValueType> ? PartialMapDeep<KeyType, ValueType, Options> : T extends Set<infer ItemType> ? PartialSetDeep<ItemType, Options> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? PartialReadonlyMapDeep<KeyType, ValueType, Options> : T extends ReadonlySet<infer ItemType> ? PartialReadonlySetDeep<ItemType, Options> : T extends object ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+ ? Options["recurseIntoArrays"] extends true ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+ ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+ ? ReadonlyArray<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : Array<_PartialDeep<Options["allowUndefinedInNonTupleArrays"] extends false ? ItemType : ItemType | undefined, Options>> : PartialObjectDeep<T, Options> // Tuples behave properly
+ : T // If they don't opt into array testing, just use the original type
+ : PartialObjectDeep<T, Options> : unknown;
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<_PartialDeep<KeyType, Options>, _PartialDeep<ValueType, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<_PartialDeep<T, Options>>;
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+export type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = (ObjectType extends (...arguments_: any) => unknown ? (...arguments_: Parameters<ObjectType>) => ReturnType<ObjectType> : {}) & ({
+	[KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>;
+});
 export type RemovePrefix<Prefix extends string, Value> = Value extends `${Prefix}${infer Rest}` ? Rest : Value;
 export type OnlyOnKeys<Keys> = Keys extends `on${string}` ? (Keys extends `on:${string}` ? never : Keys) : never;
 export type HtmlListenersFor<Obj> = {