Remote functions

// @filename: ambient.d.ts
declare module '$lib/server/database' {
	export function function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql(strings: TemplateStringsArraystrings: TemplateStringsArraystrings: TemplateStringsArray, ...values: any[]values: any[]values: any[]): interface Promise<T>
Represents the completion of an asynchronous operationinterface Promise<T>
Represents the completion of an asynchronous operationPromise<any[]>;
}
// @filename: index.js
// cut
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.
@since2.27query } 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.
@since2.27query(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;
});

// @filename: ambient.d.ts
declare module '$lib/server/database' {
	export function function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql(strings: TemplateStringsArraystrings: TemplateStringsArraystrings: TemplateStringsArray, ...values: any[]values: any[]values: any[]): interface Promise<T>
Represents the completion of an asynchronous operationinterface Promise<T>
Represents the completion of an asynchronous operationPromise<any[]>;
}
// @filename: index.js
// cut
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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). 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.@throws{HttpError} This error instructs SvelteKit to initiate HTTP error handling.@throws{Error} 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.
@since2.27query } 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.
@since2.27query(async () => { /* ... */ });

export const const getPost: RemoteQueryFunction<string, any, string>getPost = query<v.StringSchema<undefined>, any>(schema: v.StringSchema<undefined>, fn: (arg: string) => any): RemoteQueryFunction<string, any, string> (+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.
@since2.27query(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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). 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.@throws{HttpError} This error instructs SvelteKit to initiate HTTP error handling.@throws{Error} If the provided status is invalid (not between 400 and 599).error(404, 'Not found');
	return const post: anypost;
});

<button onclick={() => getPosts().refresh()}>
	Check for new posts
</button>

// @filename: ambient.d.ts
declare module '$lib/server/database' {
	export function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>;
}
// @filename: index.js
// cut
import * as v from 'valibot';
import { query } from '$app/server';
import * as db from '$lib/server/database';

export const getWeather = query.batch(v.string(), async (cityIds) => {
	const weather = await db.sql`
		SELECT * FROM weather
		WHERE city_id = ANY(${cityIds})
	`;
	const lookup = new Map(weather.map(w => [w.city_id, w]));

	return (cityId) => lookup.get(cityId);
});

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.
@since2.27function 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.
@since2.27query } from '$app/server';

export const const getTime: RemoteLiveQueryFunction<void, Date>const getTime: RemoteLiveQueryFunction<void, Date>getTime = 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.
@since2.27function 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.
@since2.27query.function query.live<Date>(fn: (arg: void) => RemoteLiveQueryUserFunctionReturnType<Date>): RemoteLiveQueryFunction<void, Date> (+2 overloads)
Creates a live remote query. When called from the browser, the function will be invoked on the server via a streaming fetch call.
See Remote functions for full documentation.function query.live<Date>(fn: (arg: void) => RemoteLiveQueryUserFunctionReturnType<Date>): RemoteLiveQueryFunction<void, Date> (+2 overloads)
Creates a live remote query. When called from the browser, the function will be invoked on the server via a streaming fetch call.
See Remote functions for full documentation.live(async function* () {
	while (true) {
		yield new 
var Date: DateConstructor
new () => Date (+4 overloads)
var Date: DateConstructor
new () => Date (+4 overloads)Date();
		await new 
var Promise: PromiseConstructor
new <any>(executor: (resolve: (value: any) => void, reject: (reason?: any) => void) => void) => Promise<any>
Creates a new Promise.
@paramexecutor A callback used to initialize the promise. This callback is passed two arguments:
a resolve callback used to resolve the promise with a value or the result of another promise,
and a reject callback used to reject the promise with a provided reason or error.
var Promise: PromiseConstructor
new <any>(executor: (resolve: (value: any) => void, reject: (reason?: any) => void) => void) => Promise<any>
Creates a new Promise.
@paramexecutor A callback used to initialize the promise. This callback is passed two arguments:
a resolve callback used to resolve the promise with a value or the result of another promise,
and a reject callback used to reject the promise with a provided reason or error.Promise((f: (value: any) => voidf: (value: any) => voidf) => function setTimeout<[value: any]>(callback: (value: any) => void, delay?: number, value?: any): NodeJS.Timeout (+1 overload)
MDN Referencefunction setTimeout<[value: any]>(callback: (value: any) => void, delay?: number, value?: any): NodeJS.Timeout (+1 overload)
MDN ReferencesetTimeout(f: (value: any) => voidf: (value: any) => voidf, 1000));
	}
});

// @filename: time.remote.ts
import { type RemoteLiveQueryFunction<Input, Output, _Validated = Input> = (arg: undefined extends Input ? Input | void : Input) => RemoteLiveQuery<Output>
The type of a remote query.live function. See Remote functions for full documentation.
The optional Validated generic parameter represents the argument type after the
query's schema has validated and (optionally) transformed it, and matches the type
yielded by requested.RemoteLiveQueryFunction } from '@sveltejs/kit';
export declare const const getTime: RemoteLiveQueryFunction<undefined, Date>getTime: type RemoteLiveQueryFunction<Input, Output, _Validated = Input> = (arg: undefined extends Input ? Input | void : Input) => RemoteLiveQuery<Output>
The type of a remote query.live function. See Remote functions for full documentation.
The optional Validated generic parameter represents the argument type after the
query's schema has validated and (optionally) transformed it, and matches the type
yielded by requested.RemoteLiveQueryFunction<undefined, Date>;
// @filename: index.js
import { getTime } from './time.remote.js';
// cut
async function logTimes() {
	for await (const value of getTime()) {
		console.log(value);
		if (someCondition) break;
Cannot find name 'someCondition'.
	}
}

// @filename: ambient.d.ts
declare module '$lib/server/database' {
	export function function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>function sql(strings: TemplateStringsArray, ...values: any[]): Promise<any[]>sql(strings: TemplateStringsArraystrings: TemplateStringsArraystrings: TemplateStringsArray, ...values: any[]values: any[]values: any[]): interface Promise<T>
Represents the completion of an asynchronous operationinterface Promise<T>
Represents the completion of an asynchronous operationPromise<any[]>;
}

declare module '$lib/server/auth' {
	interface User {
		User.name: stringUser.name: stringname: string;
	}

	/**
	 * Gets a user's info from their cookies, using `getRequestEvent`
	 */
	export function function getUser(): Promise<User | null>
Gets a user's info from their cookies, using getRequestEventfunction getUser(): Promise<User | null>
Gets a user's info from their cookies, using getRequestEventgetUser(): interface Promise<T>
Represents the completion of an asynchronous operationinterface Promise<T>
Represents the completion of an asynchronous operationPromise<User | null>;
}
// @filename: index.js
// cut
import * as import vimport 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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). 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.@throws{HttpError} This error instructs SvelteKit to initiate HTTP error handling.@throws{Error} If the provided status is invalid (not between 400 and 599).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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). 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.@throws{HttpError} This error instructs SvelteKit to initiate HTTP error handling.@throws{Error} 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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.@paramlocation The location to redirect to.@throws{Redirect} This error instructs SvelteKit to redirect to the specified location.@throws{Error} If the provided status is invalid or the location cannot be used as a header value.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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.@paramlocation The location to redirect to.@throws{Redirect} This error instructs SvelteKit to redirect to the specified location.@throws{Error} If the provided status is invalid or the location cannot be used as a header value.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.
@since2.27function 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.
@since2.27query, function form<Output>(fn: () => MaybePromise<Output>): RemoteForm<void, Output> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27function form<Output>(fn: () => MaybePromise<Output>): RemoteForm<void, Output> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27form } from '$app/server';
import * as 
module db
const db: any
module db
const db: anydb from '$lib/server/database';
import * as module "$lib/server/auth"
module auth
const auth: anyauth from '$lib/server/auth';

export const const getPosts: RemoteQueryFunction<void, void>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.
@since2.27query<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.
@since2.27query(async () => { /* ... */ });

export const const getPost: RemoteQueryFunction<string, void, string>const getPost: RemoteQueryFunction<string, void, string>getPost = query<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>): RemoteQueryFunction<string, void, string> (+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.
@since2.27query<v.StringSchema<undefined>, void>(schema: v.StringSchema<undefined>, fn: (arg: string) => MaybePromise<void>): RemoteQueryFunction<string, void, string> (+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.
@since2.27query(import vimport vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), async (slug: stringslug: stringslug) => { /* ... */ });

export const 
const createPost: RemoteForm<{
    title: string;
    content: string;
}, never>
const createPost: RemoteForm<{
    title: string;
    content: string;
}, never>createPost = 
form<v.ObjectSchema<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}, undefined>, never>(validate: v.ObjectSchema<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}, undefined>, fn: (data: {
    ...;
}, issue: {
    ...;
} & ((message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue)) => Promise<...>): RemoteForm<...> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27
form<v.ObjectSchema<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}, undefined>, never>(validate: v.ObjectSchema<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}, undefined>, fn: (data: {
    ...;
}, issue: {
    ...;
} & ((message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue)) => Promise<...>): RemoteForm<...> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27form(
	import vimport vv.
object<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}>(entries: {
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}): v.ObjectSchema<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}, undefined> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
@paramentries The entries schema.@returnsAn object schema.
object<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}>(entries: {
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}): v.ObjectSchema<{
    readonly title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
    readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
}, undefined> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
@paramentries The entries schema.@returnsAn object schema.object({
		title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>title: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>title: import vimport vv.
pipe<v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>>(schema: v.StringSchema<undefined>, item1: v.NonEmptyAction<string, undefined> | v.PipeAction<string, string, v.NonEmptyIssue<string>>): v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]> (+20 overloads)
export pipe
Adds a pipeline to a schema, that can validate and transform its input.
@paramschema The root schema.@paramitem1 The first pipe item.@returnsA schema with a pipeline.
pipe<v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>>(schema: v.StringSchema<undefined>, item1: v.NonEmptyAction<string, undefined> | v.PipeAction<string, string, v.NonEmptyIssue<string>>): v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]> (+20 overloads)
export pipe
Adds a pipeline to a schema, that can validate and transform its input.
@paramschema The root schema.@paramitem1 The first pipe item.@returnsA schema with a pipeline.pipe(import vimport vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), import vimport vv.
nonEmpty<string>(): v.NonEmptyAction<string, undefined> (+1 overload)
export nonEmpty
Creates a non-empty validation action.
@returnsA non-empty action.
nonEmpty<string>(): v.NonEmptyAction<string, undefined> (+1 overload)
export nonEmpty
Creates a non-empty validation action.
@returnsA non-empty action.nonEmpty()),
		content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>content:import vimport vv.
pipe<v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>>(schema: v.StringSchema<undefined>, item1: v.NonEmptyAction<string, undefined> | v.PipeAction<string, string, v.NonEmptyIssue<string>>): v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]> (+20 overloads)
export pipe
Adds a pipeline to a schema, that can validate and transform its input.
@paramschema The root schema.@paramitem1 The first pipe item.@returnsA schema with a pipeline.
pipe<v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>>(schema: v.StringSchema<undefined>, item1: v.NonEmptyAction<string, undefined> | v.PipeAction<string, string, v.NonEmptyIssue<string>>): v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]> (+20 overloads)
export pipe
Adds a pipeline to a schema, that can validate and transform its input.
@paramschema The root schema.@paramitem1 The first pipe item.@returnsA schema with a pipeline.pipe(import vimport vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(), import vimport vv.
nonEmpty<string>(): v.NonEmptyAction<string, undefined> (+1 overload)
export nonEmpty
Creates a non-empty validation action.
@returnsA non-empty action.
nonEmpty<string>(): v.NonEmptyAction<string, undefined> (+1 overload)
export nonEmpty
Creates a non-empty validation action.
@returnsA non-empty action.nonEmpty())
	}),
	async ({ title: stringtitle: stringtitle, content: stringcontent: stringcontent }) => {
		// Check the user is logged in
		const const user: auth.User | nullconst user: anyuser = await module "$lib/server/auth"
module auth
const auth: anyauth.function getUser(): Promise<auth.User | null>
Gets a user's info from their cookies, using getRequestEventgetUser();
		if (!const user: auth.User | nullconst user: anyuser) 
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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). 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.@throws{HttpError} This error instructs SvelteKit to initiate HTTP error handling.@throws{Error} If the provided status is invalid (not between 400 and 599).
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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses). 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.@throws{HttpError} This error instructs SvelteKit to initiate HTTP error handling.@throws{Error} If the provided status is invalid (not between 400 and 599).error(401, 'Unauthorized');

		const const slug: stringconst slug: stringslug = title: stringtitle: stringtitle.String.toLowerCase(): string
Converts all the alphabetic characters in a string to lowercase.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.
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, '-');

		// Insert into the database
		await 
module db
const db: any
module db
const db: anydb.sql`
			INSERT INTO post (slug, title, content)
			VALUES (${const slug: stringconst slug: stringslug}, ${title: stringtitle: stringtitle}, ${content: stringcontent: stringcontent})
		`;

		// Redirect to the newly created page
		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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.@paramlocation The location to redirect to.@throws{Redirect} This error instructs SvelteKit to redirect to the specified location.@throws{Error} If the provided status is invalid or the location cannot be used as a header value.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](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages). Must be in the range 300-308.@paramlocation The location to redirect to.@throws{Redirect} This error instructs SvelteKit to redirect to the specified location.@throws{Error} If the provided status is invalid or the location cannot be used as a header value.redirect(303, `/blog/${const slug: stringconst slug: stringslug}`);
	}
);

<form {...createPost}>
	<label>
		<h2>Title</h2>
		<input {...createPost.fields.title.as('text')} />
	</label>

	<label>
		<h2>Write your post</h2>
		<textarea {...createPost.fields.content.as('text')}></textarea>
	</label>

	<button>Publish!</button>
</form>

import * as import vimport vv from 'valibot';
import { function form<Output>(fn: () => MaybePromise<Output>): RemoteForm<void, Output> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27function form<Output>(fn: () => MaybePromise<Output>): RemoteForm<void, Output> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27form } from '$app/server';
// cut
const 
const datingProfile: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>
const datingProfile: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>datingProfile = import vimport vv.
object<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}>(entries: {
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}): v.ObjectSchema<...> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
@paramentries The entries schema.@returnsAn object schema.
object<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}>(entries: {
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}): v.ObjectSchema<...> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
@paramentries The entries schema.@returnsAn object schema.object({
	name: v.StringSchema<undefined>name: v.StringSchema<undefined>name: import vimport vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string(),
	photo: v.FileSchema<undefined>photo: v.FileSchema<undefined>photo: import vimport vv.
function file(): v.FileSchema<undefined> (+1 overload)
export file
Creates a file schema.
@returnsA file schema.
function file(): v.FileSchema<undefined> (+1 overload)
export file
Creates a file schema.
@returnsA file schema.file(),
	
info: v.ObjectSchema<{
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}, undefined>
info: v.ObjectSchema<{
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}, undefined>info: import vimport vv.
object<{
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}>(entries: {
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}): v.ObjectSchema<{
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}, undefined> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
@paramentries The entries schema.@returnsAn object schema.
object<{
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}>(entries: {
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}): v.ObjectSchema<{
    readonly height: v.NumberSchema<undefined>;
    readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
}, undefined> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
@paramentries The entries schema.@returnsAn object schema.object({
		height: v.NumberSchema<undefined>height: v.NumberSchema<undefined>height: import vimport vv.
function number(): v.NumberSchema<undefined> (+1 overload)
export number
Creates a number schema.
@returnsA number schema.
function number(): v.NumberSchema<undefined> (+1 overload)
export number
Creates a number schema.
@returnsA number schema.number(),
		likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>likesDogs: import vimport vv.
optional<v.BooleanSchema<undefined>, false>(wrapped: v.BooleanSchema<undefined>, default_: false): v.OptionalSchema<v.BooleanSchema<undefined>, false> (+1 overload)
export optional
Creates an optional schema.
@paramwrapped The wrapped schema.@paramdefault_ The default value.@returnsAn optional schema.
optional<v.BooleanSchema<undefined>, false>(wrapped: v.BooleanSchema<undefined>, default_: false): v.OptionalSchema<v.BooleanSchema<undefined>, false> (+1 overload)
export optional
Creates an optional schema.
@paramwrapped The wrapped schema.@paramdefault_ The default value.@returnsAn optional schema.optional(import vimport vv.
function boolean(): v.BooleanSchema<undefined> (+1 overload)
export boolean
Creates a boolean schema.
@returnsA boolean schema.
function boolean(): v.BooleanSchema<undefined> (+1 overload)
export boolean
Creates a boolean schema.
@returnsA boolean schema.boolean(), false)
	}),
	attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>attributes: import vimport vv.
array<v.StringSchema<undefined>>(item: v.StringSchema<undefined>): v.ArraySchema<v.StringSchema<undefined>, undefined> (+1 overload)
export array
Creates an array schema.
@paramitem The item schema.@returnsAn array schema.
array<v.StringSchema<undefined>>(item: v.StringSchema<undefined>): v.ArraySchema<v.StringSchema<undefined>, undefined> (+1 overload)
export array
Creates an array schema.
@paramitem The item schema.@returnsAn array schema.array(import vimport vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returnsA string schema.string())
});

export const 
const createProfile: RemoteForm<{
    name: string;
    photo: File;
    info: {
        height: number;
        likesDogs?: boolean | undefined;
    };
    attributes: string[];
}, void>
const createProfile: RemoteForm<{
    name: string;
    photo: File;
    info: {
        height: number;
        likesDogs?: boolean | undefined;
    };
    attributes: string[];
}, void>createProfile = 
form<v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>, void>(validate: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>, fn: (data: {
    ...;
}, issue: {
    ...;
} & ((message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue)) => MaybePromise<...>): RemoteForm<...> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27
form<v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>, void>(validate: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>, fn: (data: {
    ...;
}, issue: {
    ...;
} & ((message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue)) => MaybePromise<...>): RemoteForm<...> (+2 overloads)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since2.27form(
const datingProfile: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>
const datingProfile: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly photo: v.FileSchema<undefined>;
    readonly info: v.ObjectSchema<{
        readonly height: v.NumberSchema<undefined>;
        readonly likesDogs: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
    }, undefined>;
    readonly attributes: v.ArraySchema<v.StringSchema<undefined>, undefined>;
}, undefined>datingProfile, (
data: {
    name: string;
    photo: File;
    info: {
        height: number;
        likesDogs: boolean;
    };
    attributes: string[];
}
data: {
    name: string;
    photo: File;
    info: {
        height: number;
        likesDogs: boolean;
    };
    attributes: string[];
}data) => { /* ... */ });