Fonctions distantes

export default {
	
kit: {
    experimental: {
        remoteFunctions: boolean;
    };
}kit: {
		
experimental: {
    remoteFunctions: boolean;
}experimental: {
			remoteFunctions: booleanremoteFunctions: true
		}
	}
};

import { function query<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query } from '$app/server';
import * as module "$lib/server/database"db from '$lib/server/database';

export const const getPosts: RemoteQueryFunction<void, any[]>getPosts = query<any[]>(fn: () => MaybePromise<any[]>): RemoteQueryFunction<void, any[]> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(async () => {
	const const posts: any[]posts = await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		SELECT title, slug
		FROM post
		ORDER BY published_at
		DESC
	`;

	return const posts: any[]posts;
});

<script>
	import { getPosts } from './data.remote';
</script>

<h1>Articles récents</h1>

<ul>
	{#each await getPosts() as { title, slug }}
		<li><a href="/blog/{slug}">{title}</a></li>
	{/each}
</ul>

<script lang="ts">
	import { getPosts } from './data.remote';
</script>

<h1>Articles récents</h1>

<ul>
	{#each await getPosts() as { title, slug }}
		<li><a href="/blog/{slug}">{title}</a></li>
	{/each}
</ul>

<script>
	import { getPosts } from './data.remote';

	const query = getPosts();
</script>

{#if query.error}
	<p>oups !</p>
{:else if query.loading}
	<p>chargement...</p>
{:else}
	<ul>
		{#each query.current as { title, slug }}
			<li><a href="/blog/{slug}">{title}</a></li>
		{/each}
	</ul>
{/if}

<script lang="ts">
	import { getPosts } from './data.remote';

	const query = getPosts();
</script>

{#if query.error}
	<p>oups !</p>
{:else if query.loading}
	<p>chargement...</p>
{:else}
	<ul>
		{#each query.current as { title, slug }}
			<li><a href="/blog/{slug}">{title}</a></li>
		{/each}
	</ul>
{/if}

<script>
	import { getPost } from '../data.remote';

	let { params } = $props();

	const post = $derived(await getPost(params.slug));
</script>

<h1>{post.title}</h1>
<div>{@html post.content}</div>

<script lang="ts">
	import { getPost } from '../data.remote';

	let { params } = $props();

	const post = $derived(await getPost(params.slug));
</script>

<h1>{post.title}</h1>
<div>{@html post.content}</div>

import * as import vv from 'valibot';
import { function error(status: number, body: App.Error): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error } from '@sveltejs/kit';
import { function query<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query } from '$app/server';
import * as module "$lib/server/database"db from '$lib/server/database';

export const const getPosts: RemoteQueryFunction<void, void>getPosts = query<void>(fn: () => MaybePromise<void>): RemoteQueryFunction<void, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(async () => { /* ... */ });

export const const getPost: RemoteQueryFunction<string, any>getPost = query<v.StringSchema<undefined>, any>(schema: v.StringSchema<undefined>, fn: (arg: string) => any): RemoteQueryFunction<string, any> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (slug: stringslug) => {
	const [const post: anypost] = await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		SELECT * FROM post
		WHERE slug = ${slug: stringslug}
	`;

	if (!const post: anypost) 
function error(status: number, body?: {
    message: string;
} extends App.Error ? App.Error | string | undefined : never): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error(404, 'Not found');
	return const post: anypost;
});

<button onclick={() => getPosts().refresh()}>
	Vérifier s'il y a des nouveaux articles
</button>

import * as import vv from 'valibot';
import { function error(status: number, body: App.Error): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error, function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL): never
Redirect a request. When called during request handling, SvelteKit will return a redirect response.
Make sure you’re not catching the thrown redirect, which would prevent SvelteKit from handling it.
Most common status codes:

303 See Other: redirect as a GET request (often used after a form POST request)
307 Temporary Redirect: redirect will keep the request method
308 Permanent Redirect: redirect will keep the request method, SEO will be transferred to the new page

See all redirect status codes
@paramstatus The HTTP status code. Must be in the range 300-308.
@paramlocation The location to redirect to.
@throwsRedirect This error instructs SvelteKit to redirect to the specified location.
@throwsError If the provided status is invalid.redirect } from '@sveltejs/kit';
import { function query<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query, function form<T>(fn: (data: FormData) => MaybePromise<T>): RemoteForm<T>
Creates a form object that can be spread onto a &#x3C;form> element.
See Remote functions for full documentation.
form } from '$app/server';
import * as module "$lib/server/database"db from '$lib/server/database';
import * as module "$lib/server/auth"auth from '$lib/server/auth';

export const const getPosts: RemoteQueryFunction<void, void>getPosts = query<void>(fn: () => MaybePromise<void>): RemoteQueryFunction<void, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(async () => { /* ... */ });

export const const getPost: RemoteQueryFunction<string, void>getPost = query<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>): RemoteQueryFunction<string, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (slug: stringslug) => { /* ... */ });

export const const createPost: RemoteForm<never>createPost = form<never>(fn: (data: FormData) => Promise<never>): RemoteForm<never>
Creates a form object that can be spread onto a &#x3C;form> element.
See Remote functions for full documentation.
form(async (data: FormDatadata) => {
	// Vérifie si l'utilisateur est connecté
	const const user: auth.User | nulluser = await module "$lib/server/auth"auth.function getUser(): Promise<auth.User | null>
Récupère les informations de l’utilisateur à partir des cookies, en utilisant getRequestEvent
getUser();
	if (!const user: auth.User | nulluser) 
function error(status: number, body?: {
    message: string;
} extends App.Error ? App.Error | string | undefined : never): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error(401, 'Unauthorized');

	const const title: FormDataEntryValue | nulltitle = data: FormDatadata.FormData.get(name: string): FormDataEntryValue | null
MDN Reference
get('title');
	const const content: FormDataEntryValue | nullcontent = data: FormDatadata.FormData.get(name: string): FormDataEntryValue | null
MDN Reference
get('content');

	// Vérifie si les données sont valides
	if (typeof const title: FormDataEntryValue | nulltitle !== 'string' || typeof const content: FormDataEntryValue | nullcontent !== 'string') {
		
function error(status: number, body?: {
    message: string;
} extends App.Error ? App.Error | string | undefined : never): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error(400, 'Title and content are required');
	}

	const const slug: stringslug = const title: stringtitle.String.toLowerCase(): string
Converts all the alphabetic characters in a string to lowercase.
toLowerCase().
String.replace(searchValue: {
    [Symbol.replace](string: string, replaceValue: string): string;
}, replaceValue: string): string (+3 overloads)
Passes a string and 
{@linkcode 
replaceValue
}
 to the [Symbol.replace] method on 
{@linkcode 
searchValue
}
. This method is expected to implement its own replacement algorithm.
@paramsearchValue An object that supports searching for and replacing matches within a string.
@paramreplaceValue The replacement text.replace(/ /g, '-');

	// Insère en base de données
	await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		INSERT INTO post (slug, title, content)
		VALUES (${const slug: stringslug}, ${const title: stringtitle}, ${const content: stringcontent})
	`;

	// Redirige vers la page nouvellement créée
	function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL): never
Redirect a request. When called during request handling, SvelteKit will return a redirect response.
Make sure you’re not catching the thrown redirect, which would prevent SvelteKit from handling it.
Most common status codes:

303 See Other: redirect as a GET request (often used after a form POST request)
307 Temporary Redirect: redirect will keep the request method
308 Permanent Redirect: redirect will keep the request method, SEO will be transferred to the new page

See all redirect status codes
@paramstatus The HTTP status code. Must be in the range 300-308.
@paramlocation The location to redirect to.
@throwsRedirect This error instructs SvelteKit to redirect to the specified location.
@throwsError If the provided status is invalid.redirect(303, `/blog/${const slug: stringslug}`);
});

<script>
	import { createPost } from '../data.remote';
</script>

<h1>Créer un nouvel article</h1>

<form {...createPost}>
	<label>
		<h2>Titre</h2>
		<input name="title" />
	</label>

	<label>
		<h2>Écrivez votre article</h2>
		<textarea name="content"></textarea>
	</label>

	<button>Publier !</button>
</form>

<script lang="ts">
	import { createPost } from '../data.remote';
</script>

<h1>Créer un nouvel article</h1>

<form {...createPost}>
	<label>
		<h2>Titre</h2>
		<input name="title" />
	</label>

	<label>
		<h2>Écrivez votre article</h2>
		<textarea name="content"></textarea>
	</label>

	<button>Publier !</button>
</form>

export const const getPosts: RemoteQueryFunction<void, void>getPosts = query<void>(fn: () => MaybePromise<void>): RemoteQueryFunction<void, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(async () => { /* ... */ });

export const const getPost: RemoteQueryFunction<string, void>getPost = query<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>): RemoteQueryFunction<string, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (slug: stringslug) => { /* ... */ });

export const const createPost: RemoteForm<never>createPost = form<never>(fn: (data: FormData) => Promise<never>): RemoteForm<never>
Creates a form object that can be spread onto a &#x3C;form> element.
See Remote functions for full documentation.
form(async (data: FormDatadata) => {
	// la logique du formulaire se place ici...

	// Met à jour `getPosts()` sur le serveur, et
	// renvoie les données au client avec le résultat
	// de `createPost`
	await const getPosts: (arg: void) => RemoteQuery<void>getPosts().function refresh(): Promise<void>
On the client, this function will re-fetch the query from the server.
On the server, this can be called in the context of a command or form and the refreshed data will accompany the action response back to the client.
This prevents SvelteKit needing to refresh all queries on the page in a second server round-trip.
refresh();

	// Redirige vers la page nouvellement créée
	function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL): never
Redirect a request. When called during request handling, SvelteKit will return a redirect response.
Make sure you’re not catching the thrown redirect, which would prevent SvelteKit from handling it.
Most common status codes:

303 See Other: redirect as a GET request (often used after a form POST request)
307 Temporary Redirect: redirect will keep the request method
308 Permanent Redirect: redirect will keep the request method, SEO will be transferred to the new page

See all redirect status codes
@paramstatus The HTTP status code. Must be in the range 300-308.
@paramlocation The location to redirect to.
@throwsRedirect This error instructs SvelteKit to redirect to the specified location.
@throwsError If the provided status is invalid.redirect(303, `/blog/${const slug: ""slug}`);
});

export const 
const createPost: RemoteForm<{
    success: boolean;
}>createPost = 
form<{
    success: boolean;
}>(fn: (data: FormData) => MaybePromise<{
    success: boolean;
}>): RemoteForm<{
    success: boolean;
}>
Creates a form object that can be spread onto a &#x3C;form> element.
See Remote functions for full documentation.
form(async (data: FormDatadata) => {
	// ...

	return { success: booleansuccess: true };
});

<script>
	import { createPost } from '../data.remote';
</script>

<h1>Créer un nouvel article</h1>

<form {...createPost}><!-- ... --></form>

{#if createPost.result?.success}
	<p>Publié avec succès !</p>
{/if}

<script lang="ts">
	import { createPost } from '../data.remote';
</script>

<h1>Créer un nouvel article</h1>

<form {...createPost}><!-- ... --></form>

{#if createPost.result?.success}
	<p>Publié avec succès !</p>
{/if}

<script>
	import { createPost } from '../data.remote';
	import { showToast } from '$lib/toast';
</script>

<h1>Créer un nouvel article</h1>

<form {...createPost.enhance(async ({ form, data, submit }) => {
	try {
		await submit();
		form.reset();

		showToast('Publié avec succès !');
	} catch (error) {
		showToast('Oh non ! Quelque chose s\'est mal passé !');
	}
})}>
	<input name="title" />
	<textarea name="content"></textarea>
	<button>publier</button>
</form>

<script lang="ts">
	import { createPost } from '../data.remote';
	import { showToast } from '$lib/toast';
</script>

<h1>Créer un nouvel article</h1>

<form {...createPost.enhance(async ({ form, data, submit }) => {
	try {
		await submit();
		form.reset();

		showToast('Publié avec succès !');
	} catch (error) {
		showToast('Oh non ! Quelque chose s\'est mal passé !');
	}
})}>
	<input name="title" />
	<textarea name="content"></textarea>
	<button>publier</button>
</form>

await 
function submit(): Promise<any> & {
    updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<any>;
}submit().function updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<any>updates(function getPosts(): RemoteQuery<Post[]>getPosts());

await 
function submit(): Promise<any> & {
    updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<any>;
}submit().function updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<any>updates(
	function getPosts(): RemoteQuery<Post[]>getPosts().function withOverride(update: (current: Post[]) => Post[]): RemoteQueryOverride
Temporarily override the value of a query. This is used with the updates method of a command or enhanced form submission to provide optimistic updates.
&#x3C;script>
  import { getTodos, addTodo } from './todos.remote.js';
  const todos = getTodos();
&#x3C;/script>

&#x3C;form {...addTodo.enhance(async ({ data, submit }) => {
  await submit().updates(
	todos.withOverride((todos) => [...todos, { text: data.get('text') }])
  );
}}>
  &#x3C;input type="text" name="text" />
  &#x3C;button type="submit">Add Todo&#x3C;/button>
&#x3C;/form>withOverride((posts: Post[]posts) => [const newPost: PostnewPost, ...posts: Post[]posts])
);

<script>
	import { login, register } from '$lib/auth';
</script>

<form {...login}>
	<label>
		Votre nom d'utilisateur
		<input name="username" />
	</label>

	<label>
		Votre mot de passe
		<input name="password" type="password" />
	</label>

	<button>se connecter</button>
	<button {...register.buttonProps}>s'inscrire</button>
</form>

<script lang="ts">
	import { login, register } from '$lib/auth';
</script>

<form {...login}>
	<label>
		Votre nom d'utilisateur
		<input name="username" />
	</label>

	<label>
		Votre mot de passe
		<input name="password" type="password" />
	</label>

	<button>se connecter</button>
	<button {...register.buttonProps}>s'inscrire</button>
</form>

import * as import vv from 'valibot';
import { function query<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query, function command<Output>(fn: () => Output): RemoteCommand<void, Output> (+2 overloads)
Creates a remote command. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
command } from '$app/server';
import * as module "$lib/server/database"db from '$lib/server/database';

export const const getLikes: RemoteQueryFunction<string, any>getLikes = query<v.StringSchema<undefined>, any>(schema: v.StringSchema<undefined>, fn: (arg: string) => any): RemoteQueryFunction<string, any> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (id: stringid) => {
	const [const row: anyrow] = await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		SELECT likes
		FROM item
		WHERE id = ${id: stringid}
	`;

	return const row: anyrow.likes;
});

export const const addLike: RemoteCommand<string, Promise<void>>addLike = command<v.StringSchema<undefined>, Promise<void>>(validate: v.StringSchema<undefined>, fn: (arg: string) => Promise<void>): RemoteCommand<string, Promise<void>> (+2 overloads)
Creates a remote command. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
command(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (id: stringid) => {
	await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		UPDATE item
		SET likes = likes + 1
		WHERE id = ${id: stringid}
	`;
});

<script>
	import { getLikes, addLike } from './likes.remote';
	import { showToast } from '$lib/toast';

	let { item } = $props();
</script>

<button
	onclick={async () => {
		try {
			await addLike(item.id);
		} catch (error) {
			showToast('Quelque chose s\'est mal passé !');
		}
	}}
>
	ajouter un like
</button>

<p>likes : {await getLikes(item.id)}</p>

<script lang="ts">
	import { getLikes, addLike } from './likes.remote';
	import { showToast } from '$lib/toast';

	let { item } = $props();
</script>

<button
	onclick={async () => {
		try {
			await addLike(item.id);
		} catch (error) {
			showToast('Quelque chose s\'est mal passé !');
		}
	}}
>
	ajouter un like
</button>

<p>likes : {await getLikes(item.id)}</p>

export const const getLikes: RemoteQueryFunction<string, void>getLikes = query<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>): RemoteQueryFunction<string, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (id: stringid) => { /* ... */ });

export const const addLike: RemoteCommand<string, Promise<void>>addLike = command<v.StringSchema<undefined>, Promise<void>>(validate: v.StringSchema<undefined>, fn: (arg: string) => Promise<void>): RemoteCommand<string, Promise<void>> (+2 overloads)
Creates a remote command. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
command(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (id: stringid) => {
	await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		UPDATE item
		SET likes = likes + 1
		WHERE id = ${id: stringid}
	`;

	const getLikes: (arg: string) => RemoteQuery<void>getLikes(id: stringid).function refresh(): Promise<void>
On the client, this function will re-fetch the query from the server.
On the server, this can be called in the context of a command or form and the refreshed data will accompany the action response back to the client.
This prevents SvelteKit needing to refresh all queries on the page in a second server round-trip.
refresh();
});

try {
	await 
const addLike: (arg: string) => Promise<void> & {
    updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<...>;
}addLike(const item: Itemitem.Item.id: stringid).function updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<void>updates(const getLikes: (arg: string) => RemoteQuery<number>getLikes(const item: Itemitem.Item.id: stringid));
} catch (var error: unknownerror) {
	function showToast(message: string): voidshowToast('Quelque chose s\'est mal passé !');
}

try {
	await 
const addLike: (arg: string) => Promise<void> & {
    updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<...>;
}addLike(const item: Itemitem.Item.id: stringid).function updates(...queries: Array<RemoteQuery<any> | RemoteQueryOverride>): Promise<void>updates(
		const getLikes: (arg: string) => RemoteQuery<number>getLikes(const item: Itemitem.Item.id: stringid).function withOverride(update: (current: number) => number): RemoteQueryOverride
Temporarily override the value of a query. This is used with the updates method of a command or enhanced form submission to provide optimistic updates.
&#x3C;script>
  import { getTodos, addTodo } from './todos.remote.js';
  const todos = getTodos();
&#x3C;/script>

&#x3C;form {...addTodo.enhance(async ({ data, submit }) => {
  await submit().updates(
	todos.withOverride((todos) => [...todos, { text: data.get('text') }])
  );
}}>
  &#x3C;input type="text" name="text" />
  &#x3C;button type="submit">Add Todo&#x3C;/button>
&#x3C;/form>withOverride((n: numbern) => n: numbern + 1)
	);
} catch (var error: unknownerror) {
	function showToast(message: string): voidshowToast('Quelque chose s\'est mal passé !');
}

import { 
function prerender<Output>(fn: () => MaybePromise<Output>, options?: {
    inputs?: RemotePrerenderInputsGenerator<void>;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<void, Output> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender } from '$app/server';
import * as module "$lib/server/database"db from '$lib/server/database';

export const const getPosts: RemotePrerenderFunction<void, any[]>getPosts = 
prerender<any[]>(fn: () => MaybePromise<any[]>, options?: {
    inputs?: RemotePrerenderInputsGenerator<void>;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(async () => {
	const const posts: any[]posts = await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		SELECT title, slug
		FROM post
		ORDER BY published_at
		DESC
	`;

	return const posts: any[]posts;
});

import * as import vv from 'valibot';
import { function error(status: number, body: App.Error): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error } from '@sveltejs/kit';
import { 
function prerender<Output>(fn: () => MaybePromise<Output>, options?: {
    inputs?: RemotePrerenderInputsGenerator<void>;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<void, Output> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender } from '$app/server';
import * as module "$lib/server/database"db from '$lib/server/database';

export const const getPosts: RemotePrerenderFunction<void, void>getPosts = 
prerender<void>(fn: () => MaybePromise<void>, options?: {
    inputs?: RemotePrerenderInputsGenerator<void>;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(async () => { /* ... */ });

export const const getPost: RemotePrerenderFunction<string, any>getPost = 
prerender<v.StringSchema<undefined>, any>(schema: v.StringSchema<undefined>, fn: (arg: string) => any, options?: {
    inputs?: RemotePrerenderInputsGenerator<string> | undefined;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (slug: stringslug) => {
	const [const post: anypost] = await module "$lib/server/database"db.function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql`
		SELECT * FROM post
		WHERE slug = ${slug: stringslug}
	`;

	if (!const post: anypost) 
function error(status: number, body?: {
    message: string;
} extends App.Error ? App.Error | string | undefined : never): never (+1 overload)
Throws an error with a HTTP status code and an optional message.
When called during request handling, this will cause SvelteKit to
return an error response without invoking handleError.
Make sure you’re not catching the thrown error, which would prevent SvelteKit from handling it.
@paramstatus The HTTP status code. Must be in the range 400-599.
@parambody An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
@throwsHttpError This error instructs SvelteKit to initiate HTTP error handling.
@throwsError If the provided status is invalid (not between 400 and 599).error(404, 'Not found');
	return const post: anypost;
});

export const const getPost: RemotePrerenderFunction<string, void>getPost = 
prerender<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>, options?: {
    inputs?: RemotePrerenderInputsGenerator<string> | undefined;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(
	import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(),
	async (slug: stringslug) => { /* ... */ },
	{
		inputs?: RemotePrerenderInputsGenerator<string> | undefinedinputs: () => [
			'premier-article',
			'deuxième-article',
			'troisième-article'
		]
	}
);

export const const getPost: RemotePrerenderFunction<string, void>getPost = 
prerender<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>, options?: {
    inputs?: RemotePrerenderInputsGenerator<string> | undefined;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(
	import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(),
	async (slug: stringslug) => { /* ... */ },
	{
		inputs?: RemotePrerenderInputsGenerator<string> | undefinedinputs: () => [
			'premier-article',
			'deuxième-article',
			'troisième-article'
		]
	}
);

export const const getPost: RemotePrerenderFunction<string, void>getPost = 
prerender<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>, options?: {
    inputs?: RemotePrerenderInputsGenerator<string> | undefined;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(
	import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(),
	async (slug: stringslug) => { /* ... */ },
	{
		dynamic?: boolean | undefineddynamic: true,
		inputs?: RemotePrerenderInputsGenerator<string> | undefinedinputs: () => [
			'premier-article',
			'deuxième-article',
			'troisième-article'
		]
	}
);

export const const getPost: RemotePrerenderFunction<string, void>getPost = 
prerender<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>, options?: {
    inputs?: RemotePrerenderInputsGenerator<string> | undefined;
    dynamic?: boolean;
} | undefined): RemotePrerenderFunction<...> (+2 overloads)
Creates a remote prerender function. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
prerender(
	import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(),
	async (slug: stringslug) => { /* ... */ },
	{
		dynamic?: boolean | undefineddynamic: true,
		inputs?: RemotePrerenderInputsGenerator<string> | undefinedinputs: () => [
			'premier-article',
			'deuxième-article',
			'troisième-article'
		]
	}
);

/** @type {import('@sveltejs/kit').HandleValidationError} */
export function 
function handleValidationError({ event, issues }: {
    event: any;
    issues: any;
}): {
    message: string;
}
@type{import('@sveltejs/kit').HandleValidationError}handleValidationError({ event: anyevent, issues: anyissues }) {
	return {
		message: stringmessage: 'Nice try, hacker!'
	};
}

import type { 
type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> = (input: {
    issues: Issue[];
    event: RequestEvent;
}) => MaybePromise<App.Error>
The handleValidationError hook runs when the argument to a remote function fails validation.
It will be called with the validation issues and the event, and must return an object shape that matches App.Error.
HandleValidationError } from '@sveltejs/kit';

export const const handleValidationError: HandleValidationErrorhandleValidationError: 
type HandleValidationError<Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue> = (input: {
    issues: Issue[];
    event: RequestEvent;
}) => MaybePromise<App.Error>
The handleValidationError hook runs when the argument to a remote function fails validation.
It will be called with the validation issues and the event, and must return an object shape that matches App.Error.
HandleValidationError = ({ event: RequestEvent<AppLayoutParams<"/">, any>event, issues: StandardSchemaV1.Issue[]issues }) => {
	return {
		App.Error.message: stringmessage: 'Nice try, hacker!'
	};
};

import { function query<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query } from '$app/server';

export const 
const getStuff: RemoteQueryFunction<{
    id: string;
}, void>getStuff = 
query<{
    id: string;
}, void>(validate: "unchecked", fn: (arg: {
    id: string;
}) => MaybePromise<void>): RemoteQueryFunction<{
    id: string;
}, void> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query('unchecked', async ({ id: stringid }: { id: stringid: string }) => {
	// la forme peut ne pas être ce que pense TypeScript
	// puisque des personnes mal intentionnées pourraient
	// appeler cette fonction avec d'autres arguments
});

import { function getRequestEvent(): RequestEvent<findUser<"/">, any>
Returns the current RequestEvent. Can be used inside server hooks, server load functions, actions, and endpoints (and functions called by them).
In environments without AsyncLocalStorage, this must be called synchronously (i.e. not after an await).
@since2.20.0getRequestEvent, function query<Output>(fn: () => MaybePromise<Output>): RemoteQueryFunction<void, Output> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query } from '$app/server';
import { import findUserfindUser } from '$lib/server/database';

export const 
const getProfile: RemoteQueryFunction<void, {
    name: any;
    avatar: any;
}>getProfile = 
query<{
    name: any;
    avatar: any;
}>(fn: () => MaybePromise<{
    name: any;
    avatar: any;
}>): RemoteQueryFunction<void, {
    name: any;
    avatar: any;
}> (+2 overloads)
Creates a remote query. When called from the browser, the function will be invoked on the server via a fetch call.
See Remote functions for full documentation.
query(async () => {
	const const user: anyuser = await function getUser(): anygetUser();

	return {
		name: anyname: const user: anyuser.name,
		avatar: anyavatar: const user: anyuser.avatar
	};
});

// cette fonction pourrait être appelée depuis plusieurs endroits
function function getUser(): anygetUser() {
	const { const cookies: Cookies
Get or set cookies related to the current request
cookies, const locals: App.Locals
Contains custom data that was added to the request within the server handle hook.
locals } = function getRequestEvent(): RequestEvent<findUser<"/">, any>
Returns the current RequestEvent. Can be used inside server hooks, server load functions, actions, and endpoints (and functions called by them).
In environments without AsyncLocalStorage, this must be called synchronously (i.e. not after an await).
@since2.20.0getRequestEvent();

	const locals: App.Locals
Contains custom data that was added to the request within the server handle hook.
locals.userPromise ??= import findUserfindUser(const cookies: Cookies
Get or set cookies related to the current request
cookies.Cookies.get: (name: string, opts?: CookieParseOptions) => string | undefined
Gets a cookie that was previously set with cookies.set, or from the request headers.
@paramname the name of the cookie
@paramopts the options, passed directly to cookie.parse. See documentation hereget('session_id'));
	return await const locals: App.Locals
Contains custom data that was added to the request within the server handle hook.
locals.userPromise;
}