Erreurs

import { error(alias) function error(status: number, body: App.Error): never (+1 overload)
import error
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.
status 
The HTTP status code. Must be in the range 400-599.
body 
An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
{HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference } from '@sveltejs/kit';
import * as db(alias) module "$lib/server/database"
import db from '$lib/server/database';

/** @type {import('./$types').PageServerLoad} */
export async function loadfunction load(event: ServerLoadEvent<Record<string, any>, Record<string, any>, string | null>): MaybePromise<void | Record<string, any>>
{import('./$types').PageServerLoad}
({ params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 }) {
	const postconst post: {
    title: string;
    content: string;
} | undefined = await db(alias) module "$lib/server/database"
import db.getPostfunction getPost(slug: string): Promise<{
    title: string;
    content: string;
} | undefined>(params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
.slugany);

	if (!postconst post: {
    title: string;
    content: string;
} | undefined) {
		error(alias) error(status: number, body: App.Error): never (+1 overload)
import error
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.
status 
The HTTP status code. Must be in the range 400-599.
body 
An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
{HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference(404, {
			message(property) App.Error.message: string: 'Introuvable'
		});
	}

	return { post(property) post: {
    title: string;
    content: string;
} };
}

import { error(alias) function error(status: number, body: App.Error): never (+1 overload)
import error
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.
status 
The HTTP status code. Must be in the range 400-599.
body 
An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
{HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference } from '@sveltejs/kit';
import * as db(alias) module "$lib/server/database"
import db from '$lib/server/database';
import type { PageServerLoad(alias) type PageServerLoad = (event: ServerLoadEvent<Record<string, any>, Record<string, any>, string | null>) => MaybePromise<void | Record<string, any>>
import PageServerLoad } from './$types';

export const loadconst load: PageServerLoad: PageServerLoad(alias) type PageServerLoad = (event: ServerLoadEvent<Record<string, any>, Record<string, any>, string | null>) => MaybePromise<void | Record<string, any>>
import PageServerLoad = async ({ params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
 }) => {
	const postconst post: {
    title: string;
    content: string;
} | undefined = await db(alias) module "$lib/server/database"
import db.getPostfunction getPost(slug: string): Promise<{
    title: string;
    content: string;
} | undefined>(params(parameter) params: Record<string, any>
The parameters of the current route - e.g. for a route like /blog/[slug], a { slug: string } object.
In the context of a remote function request initiated by the client, this relates to the page the remote function
was called from, not the URL of the endpoint SvelteKit creates for the remote function. Never use this to determine
whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
.slugany);

	if (!postconst post: {
    title: string;
    content: string;
} | undefined) {
		error(alias) error(status: number, body: App.Error): never (+1 overload)
import error
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.
status 
The HTTP status code. Must be in the range 400-599.
body 
An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
{HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference(404, {
			message(property) App.Error.message: string: 'Introuvable'
		});
	}

	return { post(property) post: {
    title: string;
    content: string;
} };
};

<script>
	import { page } from '$app/state';
</script>

<h1>{page.error.message}</h1>

<script lang="ts">
	import { page } from '$app/state';
</script>

<h1>{page.error.message}</h1>

error(alias) error(status: number, body: App.Error): never (+1 overload)
import error
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.
status 
The HTTP status code. Must be in the range 400-599.
body 
An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
{HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference(404, {
	message(property) App.Error.message: string: 'Introuvable',
	code(property) App.Error.code: string: 'NOT_FOUND'
});

error(404, { message: 'Introuvable' });
error(alias) error(status: number, body?: {
    message: string;
} extends App.Error ? App.Error | string | undefined : never): never (+1 overload)
import error
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.
status 
The HTTP status code. Must be in the range 400-599.
body 
An object that conforms to the App.Error type. If a string is passed, it will be used as the message property.
{HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference(404, 'Introuvable');

{ "message": "Internal Error" }

/** @type {import('@sveltejs/kit').Config} */
const configconst config: Config
{import('@sveltejs/kit').Config}
 = {
	kit(property) Config.kit?: KitConfig | undefined
SvelteKit options.
https://svelte.dev/docs/kit/configuration
: {
		experimental(property) KitConfig.experimental?: {
    explicitEnvironmentVariables?: boolean;
    tracing?: {
        server?: boolean;
    };
    instrumentation?: {
        server?: boolean;
    };
    remoteFunctions?: boolean;
    forkPreloads?: boolean;
    handleRenderingErrors?: boolean;
} | undefined
Experimental features. Here be dragons. These are not subject to semantic versioning, so breaking changes or removal can happen in any release.
: {
			handleRenderingErrors(property) handleRenderingErrors?: boolean | undefined
Whether to enable the experimental handling of rendering errors.
When enabled, <svelte:boundary> is used to wrap components at each level
where there's an +error.svelte, rendering the error page if the component fails.
In addition, error boundaries also work on the server and the error object goes through handleError.
false
: true
		}
	}
};

export default configconst config: Config
{import('@sveltejs/kit').Config}
;

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

<h1>{error.message}</h1>

<script lang="ts">
	let { error } = $props();
</script>

<h1>{error.message}</h1>

<svelte:boundary>
	...
	{#snippet failed(error: App.Error)}
		<!-- l'erreur est passée par handelError et est de type App.Error -->
		{error.message}
	{/snippet}
</svelte:boundary>

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="utf-8" />
		<title>%sveltekit.error.message%</title>
	</head>
	<body>
		<h1>Ma page d'erreur personnalisée</h1>
		<p>Statut : %sveltekit.status%</p>
		<p>Message : %sveltekit.error.message%</p>
	</body>
</html>

declare globalnamespace global {
	namespace Appnamespace App
It's possible to tell SvelteKit how to type objects inside your app by declaring the App namespace. By default, a new project will have a file called src/app.d.ts containing the following:
declare global {
	namespace App {
		// interface Error {}
		// interface Locals {}
		// interface PageData {}
		// interface PageState {}
		// interface Platform {}
	}
}

export {};
The export {} line exists because without it, the file would be treated as an ambient module which prevents you from adding import declarations.
If you need to add ambient declare module declarations, do so in a separate file like src/ambient.d.ts.
By populating these interfaces, you will gain type safety when using event.locals, event.platform, and data from load functions.
 {
		interface Errorinterface App.Error
Defines the common shape of expected and unexpected errors. Expected errors are thrown using the error function. Unexpected errors are handled by the handleError hooks which should return this shape.
 {
			code(property) App.Error.code: string: string;
			id(property) App.Error.id: string: string;
		}
	}
}

export {};