@vandenberghinc/volt 1.2.6 → 1.2.8

package/frontend/dist/backend/src/database/filters/strict_update_filter.d.ts

@@ -0,0 +1,165 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as mongodb from 'mongodb';
+/**
+ * Helper type for recursive depth limiting
+ */
+type PathsPrev = [never, 0, 1, 2, 3, 4];
+/**
+ * Extract all valid paths from a schema including nested paths
+ * Supports dot notation for nested objects
+ */
+type Paths<T, D extends number = 4> = [D] extends [never] ? never : T extends object ? {
+    [K in keyof T]-?: K extends string | number ? `${K}` | (T[K] extends object ? T[K] extends ReadonlyArray<any> ? never : Paths<T[K], PathsPrev[D]> extends infer P ? P extends string ? `${K}.${P}` : never : never : never) : never;
+}[keyof T] : '';
+/**
+ * Get the value type at a specific path in the schema
+ */
+type PathValue<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer K}.${infer Rest}` ? K extends keyof T ? PathValue<T[K], Rest> : never : never;
+/**
+ * MongoDB bitwise operations — exactly one of 'and' | 'or' | 'xor',
+ * each requiring an integer value per the driver typings.
+ */
+type BitwiseOperators = {
+    and: mongodb.IntegerType;
+} | {
+    or: mongodb.IntegerType;
+} | {
+    xor: mongodb.IntegerType;
+};
+/**
+ * Create an exact object type that doesn't allow extra properties
+ * This is the key to making our types strict
+ */
+type Exact<T, Shape = T> = T extends Shape ? T extends infer O ? {
+    [K in keyof O]: O[K];
+} & {
+    [K in Exclude<keyof T, keyof Shape>]?: never;
+} : never : Shape;
+/**
+ * Strict set/update fields
+ */
+type SetFields<TSchema> = Exact<{
+    [K in Paths<TSchema>]?: PathValue<TSchema, K>;
+}>;
+/**
+ * Strict numeric fields for math operations
+ */
+type NumericFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends (number | bigint | undefined) ? K : never]?: Exclude<PathValue<TSchema, K>, undefined>;
+}>;
+/**
+ * Strict unset fields
+ */
+type UnsetFields<TSchema> = Exact<{
+    [K in Paths<TSchema>]?: '' | true | 1;
+}>;
+/**
+ * Strict rename fields
+ */
+type RenameFields<TSchema> = Exact<{
+    [K in Paths<TSchema>]?: string;
+}>;
+/**
+ * Strict date fields
+ */
+type DateFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends Date | mongodb.Timestamp | undefined ? K : never]?: true | {
+        $type: 'date' | 'timestamp';
+    };
+}>;
+/**
+ * Strict array fields for array operations
+ */
+type ArrayAddFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U | {
+        $each: U[];
+    } : never;
+}>;
+type ArrayPopFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: 1 | -1;
+}>;
+type ArrayPullFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U | mongodb.FilterOperators<U> : never;
+}>;
+type ArrayPushFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U | mongodb.ArrayOperator<PathValue<TSchema, K>> : never;
+}>;
+type ArrayPullAllFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends any[] ? K : never]?: PathValue<TSchema, K> extends (infer U)[] ? U[] : never;
+}>;
+/**
+ * Strict bit fields
+ */
+type BitFields<TSchema> = Exact<{
+    [K in Paths<TSchema> as PathValue<TSchema, K> extends number | undefined ? K : never]?: BitwiseOperators;
+}>;
+/**
+ * Strict version of MongoDB UpdateFilter that only allows updating existing fields
+ * @template TSchema - The document schema type
+ */
+export type StrictUpdateFilter<TSchema> = Exact<{
+    /**
+     * The $set operator replaces the value of a field with the specified value.
+     */
+    $set?: SetFields<TSchema>;
+    /**
+     * The $setOnInsert operator assigns values to fields during an upsert only when inserting a new document.
+     */
+    $setOnInsert?: SetFields<TSchema>;
+    /**
+     * The $unset operator deletes a particular field.
+     */
+    $unset?: UnsetFields<TSchema>;
+    /**
+     * The $inc operator increments a field by a specified value.
+     */
+    $inc?: NumericFields<TSchema>;
+    /**
+     * The $mul operator multiplies the value of a field by a number.
+     */
+    $mul?: NumericFields<TSchema>;
+    /**
+     * The $min operator updates the value of the field to a specified value if the specified value is less than the current value of the field.
+     */
+    $min?: SetFields<TSchema>;
+    /**
+     * The $max operator updates the value of the field to a specified value if the specified value is greater than the current value of the field.
+     */
+    $max?: SetFields<TSchema>;
+    /**
+     * The $currentDate operator sets the value of a field to the current date.
+     */
+    $currentDate?: DateFields<TSchema>;
+    /**
+     * The $rename operator updates the name of a field.
+     */
+    $rename?: RenameFields<TSchema>;
+    /**
+     * The $addToSet operator adds a value to an array unless the value is already present.
+     */
+    $addToSet?: ArrayAddFields<TSchema>;
+    /**
+     * The $pop operator removes the first or last element of an array.
+     */
+    $pop?: ArrayPopFields<TSchema>;
+    /**
+     * The $pull operator removes from an array all instances of a value or values that match a specified condition.
+     */
+    $pull?: ArrayPullFields<TSchema>;
+    /**
+     * The $push operator appends a specified value to an array.
+     */
+    $push?: ArrayPushFields<TSchema>;
+    /**
+     * The $pullAll operator removes all instances of the specified values from an array.
+     */
+    $pullAll?: ArrayPullAllFields<TSchema>;
+    /**
+     * The $bit operator performs a bitwise update of a field.
+     */
+    $bit?: BitFields<TSchema>;
+}>;
+export {};

package/frontend/dist/backend/src/database/filters/strict_update_filter.js

@@ -0,0 +1,5 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+export {};

package/frontend/dist/backend/src/database/flatten.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+/**
+ * Flatten a nested object to a flat `key.subkey` like object, suitable for {@link set} and {@link save} $inc operations.
+ * @param obj The object to flatten.
+ * @param prefix The prefix to use for the keys, used for recursive calls, new keys will be formatted as `{prefix}.key`.
+ * @returns A flat object with keys in the format `key.subkey`.
+ * @example
+ * const nested = { a: { b: 1, c: { d: 2 } }, e: 3 };
+ * const flat = flatten(nested);
+ * // flat = { 'a.b': 1, 'a.c.d': 2, 'e': 3 }
+ *
+ * @nav Database
+ * @docs
+ */
+export declare function flatten<T extends Record<string, any>>(obj: T, prefix?: string): FlattenToDotNotation<T>;
+export declare function flatten<T extends Record<string, any>, const Prefix extends string>(obj: T, prefix: Prefix): FlattenToDotNotation<T, Prefix>;
+/**
+ * Convert union to intersection
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+/**
+ * Check if a type should be flattened (is a plain object, not a primitive or array)
+ */
+type IsPlainObject<T> = T extends string | number | boolean | bigint | symbol | null | undefined | Date | RegExp | Function | any[] ? false : T extends object ? true : false;
+/** Make all properties optional (used when recursing through optional parents) */
+type MakeOptional<T> = {
+    [P in keyof T]?: T[P];
+};
+/** Depth decrementer for 25 levels: Prev25[N] = N - 1, Prev25[0] = never */
+type Prev25 = [
+    never,
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25
+];
+/** Remove undefined from a type (used before object checks) */
+type NonU<T> = Exclude<T, undefined>;
+/**
+ * Create dot notation paths from an object type.
+ * - Handles optional parents by making *all* their dotted children optional.
+ * - Stops recursing at depth 25.
+ */
+export type FlattenToDotNotation<T, Path extends string = "", D extends number = 25> = [
+    D
+] extends [never] ? {} : T extends object ? UnionToIntersection<{
+    [K in keyof T]-?: K extends string | number ? (T[K] extends infer Raw ? (IsPlainObject<NonU<Raw>> extends true ? (undefined extends Raw ? MakeOptional<FlattenToDotNotation<NonU<Raw>, Path extends "" ? `${K}` : `${Path}.${K}`, Prev25[D]>> : FlattenToDotNotation<NonU<Raw>, Path extends "" ? `${K}` : `${Path}.${K}`, Prev25[D]>) : (undefined extends Raw ? {
+        [P in (Path extends "" ? `${K}` : `${Path}.${K}`)]?: NonU<Raw>;
+    } : {
+        [P in (Path extends "" ? `${K}` : `${Path}.${K}`)]: Raw;
+    })) : never) : never;
+}[keyof T]> : T;
+export {};

package/frontend/dist/backend/src/database/flatten.js

@@ -0,0 +1,22 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as vlib from "@vandenberghinc/vlib";
+export function flatten(obj, prefix = "") {
+    if (typeof obj !== "object" || obj == null || Array.isArray(obj)) {
+        vlib.schema.throw_invalid_type("obj", obj, "object", true);
+    }
+    const result = {};
+    for (const key in obj) {
+        if (!Object.hasOwn(obj, key))
+            continue; // ES2022
+        if (vlib.object.is_plain(obj[key])) {
+            Object.assign(result, flatten(obj[key], prefix ? `${prefix}.${key}` : key));
+        }
+        else {
+            result[prefix ? `${prefix}.${key}` : key] = obj[key];
+        }
+    }
+    return result;
+}

package/frontend/dist/backend/src/endpoint.d.ts

@@ -0,0 +1,346 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh. All rights reserved
+ */
+import { View } from './view.js';
+import * as vlib from "@vandenberghinc/vlib";
+import { RateLimitGroup, RateLimitData } from "./rate_limit.js";
+import { Stream, AuthStream } from "./stream.js";
+import { Server } from "./server.js";
+import { Route } from './route.js';
+import { Request } from '../../frontend/src/modules/request.js';
+/**
+ * The endpoint class.
+ * @nav Endpoints
+ * @docs
+ */
+export declare class Endpoint<const M extends Endpoint.Method = "GET", const E extends string | RegExp = string, const S extends vlib.Schema.Entries.Opts = {}> {
+    /** Route attributes */
+    id: string;
+    route: Route;
+    /** Requires authentication */
+    authenticated: boolean;
+    /** Parameter scheme validator */
+    params_validator: undefined | vlib.Schema.Validator<object>;
+    params_schema: undefined | vlib.Schema.Entries.Opts;
+    allow_unknown_params: undefined | boolean;
+    /** The default response headers */
+    headers: [string, string][];
+    /** Option 1) User callback - defined as method so a derived endpoint can do that as well. */
+    callback?(stream: Stream, params: vlib.Schema.Entries.Infer<S>): any;
+    callback?(stream: AuthStream, params: vlib.Schema.Entries.Infer<S>): any;
+    /** Option 2) View based endpoint */
+    view?: View;
+    /** Option 3) Data endpoint, raw */
+    data?: Buffer | string | any[] | Record<any, any>;
+    raw_data?: Buffer | string | any[] | Record<any, any>;
+    /** Option 4 Data endpoint by file path. */
+    file_path?: vlib.Path;
+    /** Content length & type */
+    content_type?: string;
+    /** Booleans */
+    is_static: boolean;
+    is_image_endpoint: boolean;
+    allow_sitemap: boolean;
+    allow_robots: boolean;
+    /** Rate limit groups for internal use. */
+    rate_limit_groups: RateLimitData[];
+    /** Private attributes */
+    private _compress;
+    private _cache;
+    private ip_whitelist?;
+    private _dynamic_initialized;
+    /** A reference to the server. */
+    server?: Server;
+    /**
+     * Clone this endpoint, used to create a modified copy of the current endpoint.
+     * @param override Override specific endpoint options, note that this will be shallow merged.
+     *
+     * @docs
+     */
+    static clone<const M extends Endpoint.Method = "GET", const E extends string | RegExp = string, const S extends vlib.Schema.Entries.Opts = {}>(endpoint: Endpoint<M, E, S>, override?: Partial<Endpoint.Opts<M, E, S>>): Endpoint<M, E, S>;
+    /**
+     * Static function to create a very strict method.
+     * This is a utility type that can be used when defining frontend `Request.Info` types.
+     * With this function we can enforce that the method matches the method defined in the `Request.Info` type,
+     * which can be useful to prevent mistakes when defining endpoints.
+     *
+     * @example
+     * {Create Strict Endpoint}
+     * Create a strict endpoint based on a frontend request info type.
+     * If there are any mismatches between the defined method,
+     * endpoint or result data with the `Request.Info` type,
+     * a TypeScript compile-time error will be thrown.
+     *
+     * ```ts
+     * import { Request } from "@vandenberghinc/volt/frontend";
+     * import * as volt from "@vandenberghinc/volt";
+     *
+     * type MyRequestInfo = Request.Info<
+     *   "POST", // method
+     *   "/api/my-endpoint", // endpoint
+     *   { id: string } // params
+     *   { name: string } // result
+     *   undefined // error
+     * >;
+     *
+     * server.endpoint({
+     *     method: volt.Endpoint.method<MyRequestInfo>("POST"),
+     *     endpoint: volt.Endpoint.endpoint<MyRequestInfo>("/api/my-endpoint"),
+     *     params: { id: "string" },
+     *     callback: async (stream, params) => {
+     *         // Send a success response.
+     *         stream.send<MyRequestInfo["result"]>({
+     *             status: 200,
+     *             data: { name: "John Doe" },
+     *         });
+     *.    },
+     * })
+     * ```
+     */
+    static method<ReqInfo extends Request.Info<Request.Method, any, any, any, any>>(method: ReqInfo["method"]): ReqInfo["method"];
+    /**
+     * Static function to create a very strict endpoint.
+     * This is a utility type that can be used when defining frontend `Request.Info` types.
+     * With this function we can enforce that the endpoint matches the endpoint defined in the `Request.Info` type,
+     * which can be useful to prevent mistakes when defining endpoints.
+     *
+     * @example
+     * {Create Strict Endpoint}
+     * Create a strict endpoint based on a frontend request info type.
+     * If there are any mismatches between the defined method,
+     * endpoint or result data with the `Request.Info` type,
+     * a TypeScript compile-time error will be thrown.
+     *
+     * ```ts
+     * import { Request } from "@vandenberghinc/volt/frontend";
+     * import * as volt from "@vandenberghinc/volt";
+     *
+     * type MyRequestInfo = Request.Info<
+     *   "POST", // method
+     *   "/api/my-endpoint", // endpoint
+     *   { id: string } // params
+     *   { name: string } // result
+     *   undefined // error
+     * >;
+     *
+     * server.endpoint({
+     *     method: volt.Endpoint.method<MyRequestInfo>("POST"),
+     *     endpoint: volt.Endpoint.endpoint<MyRequestInfo>("/api/my-endpoint"),
+     *     params: { id: "string" },
+     *     callback: async (stream, params) => {
+     *         // Send a success response.
+     *         stream.send<MyRequestInfo["result"]>({
+     *             status: 200,
+     *             data: { name: "John Doe" },
+     *         });
+     *.    },
+     * })
+     * ```
+     */
+    static endpoint<ReqInfo extends Request.Info<any, any, any, any, any>>(endpoint: ReqInfo["endpoint"]): ReqInfo["endpoint"];
+    /**
+     * Construct an endpoint.
+     * @docs
+     */
+    constructor({ method, endpoint, authenticated, rate_limit, params, compress, cache, ip_whitelist, sitemap, robots, allow_unknown_params, _is_static, callback, view, data, file_path, content_type, }: Endpoint.Opts<M, E, S>);
+    /**
+     * Serve this endpoint manually from a stream.
+     * This can for instance be used to serve a HTML `/error` endpoint from within a callback.
+     * @docs
+     */
+    serve({ stream, status: status_code, templates, }: {
+        stream: Stream;
+        status?: number;
+        templates?: Record<string, any>;
+    }): Promise<void>;
+    /** Initialize with server. */
+    _initialize(server: Server): this;
+    _dynamic_initialize(): Promise<void>;
+    _set_headers(stream: Stream): void;
+    _serve_options(stream: Stream): Promise<void>;
+}
+export declare namespace Endpoint {
+    /**
+     * The endpoint method.
+     * @docs
+     */
+    type Method = "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "OPTIONS";
+    /**
+     * Options for constructing an endpoint.
+     * For more information on the different options see the nested types:
+     * - {@link Opts.ByData}
+     * - {@link Opts.ByFilePath}
+     * - {@link Opts.ByCallback}
+     * - {@link Opts.ByAuthCallback}
+     * - {@link Opts.ByView}
+     * @docs
+     */
+    type Opts<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> = Opts.ByData<M, E, S> | Opts.ByFilePath<M, E, S> | Opts.ByCallback<M, E, S> | Opts.ByAuthCallback<M, E, S> | Opts.ByView<M, E, S>;
+    /** Nested types for the {@link Opts} type. */
+    namespace Opts {
+        /**
+         * The base options for constructing an endpoint.
+         */
+        interface Base<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> {
+            /**
+             * The endpoint method.
+             * @default "GET"
+             */
+            method?: M extends undefined ? "GET" : M;
+            /** The endpoint sub url. */
+            endpoint: E;
+            /**
+             * The rate limit settings.
+             *
+             * Rate limiting works by creating a rate limit per group of endpoints. Multiple
+             * rate limiting groups can be applied by defining an array with rate limit objects.
+             * A group's interval and limit only need to be defined once on a single endpoint.
+             * When defined again these values will override the initial group settings.
+             *
+             * The rate limit parameter may be defined as three types:
+             * - `string`: Assign the rate limit group without any group parameters. Useful when the group is already defined.
+             * - `RateLimitGroup`: As a rate limit object.
+             * - An array with multiple rate limit objects.
+             *
+             * When left undefined no rate limiting will be applied.
+             */
+            rate_limit?: string | RateLimitGroup | (string | RateLimitGroup)[];
+            /**
+             * The parameter schema for validating request parameters.
+             */
+            params?: S;
+            /**
+             * Allow unknown parameters to be passed to the endpoint that are not
+             * defined in the parameter schema.
+             * @default false
+             */
+            allow_unknown_params?: boolean;
+            /** Compress data sent body. */
+            compress?: boolean;
+            /**
+             * Parameter cache can define the max age of the cached response in seconds or as a boolean `true`.
+             * Anything higher than zero enables caching.
+             *
+             * When server production mode is enabled caching is done automatically unless `cache` is `false`.
+             * When production mode is disabled responses are never cached, even though the parameter is assigned.
+             * The response of an endpoint that uses parameter `callback` is never cached.
+             */
+            cache?: boolean | number;
+            /**
+             * An IP whitelist for the endpoint. When the parameter is defined with an Array,
+             * the whitelist will become active.
+             */
+            ip_whitelist?: string[];
+            /**
+             * A boolean indicating if the endpoint should show up in the sitemap.
+             * By default only when the attribute `view` is defined and the endpoint is unauthenticated,
+             * the endpoint will show up in sitemap.
+             */
+            sitemap?: boolean;
+            /**
+             * A boolean indicating if the endpoint should be crawled by search engines.
+             * By default only endpoints with `view` enabled will be crawled, unless specified otherwise.
+             */
+            robots?: boolean;
+            /** System reserved property indicating whether the endpoint is from static files. */
+            _is_static?: boolean;
+        }
+        /**
+         * Options for constructing an endpoint by data & content type.
+         * @docs
+         */
+        interface ByData<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> extends Base<M, E, S> {
+            /** The data that will be returned as the response body. */
+            data: Buffer | string | any[] | Record<any, any>;
+            /** Not allowed in this variant. */
+            file_path?: never;
+            /** Not allowed in this variant. */
+            view?: never;
+            /** Only allow authenticated requests. */
+            authenticated?: boolean;
+            /** Not allowed in this variant. */
+            callback?: never;
+            /** The content type. */
+            content_type: string;
+        }
+        /**
+         * Options for constructing an endpoint by file path & content type.
+         * @docs
+         */
+        interface ByFilePath<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> extends Base<M, E, S> {
+            /** Not allowed in this variant. */
+            data?: never;
+            /** The file path to load the data from. */
+            file_path: string | vlib.Path;
+            /** Only allow authenticated requests. */
+            authenticated?: boolean;
+            /** Not allowed in this variant. */
+            callback?: never;
+            /** Not allowed in this variant. */
+            view?: never;
+            /** The content type. */
+            content_type?: never;
+        }
+        /**
+         * Options for constructing an endpoint by unauthenticated callback.
+         * @docs
+         */
+        interface ByCallback<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> extends Base<M, E, S> {
+            /** Not allowed in this variant. */
+            data?: never;
+            /** Not allowed in this variant. */
+            file_path?: never;
+            /** Only allow authenticated requests. */
+            authenticated?: false;
+            /** The callback that will be executed when a client requests this endpoint. */
+            callback: ((stream: Stream, params: vlib.Schema.Entries.Infer<S>) => any);
+            /** Not allowed in this variant. */
+            view?: never;
+            /**
+             * The content type.
+             * Not required since a callback could have multiple different content types.
+             */
+            content_type?: string;
+        }
+        /**
+         * Options for constructing an endpoint by authenticated callback.
+         * @docs
+         */
+        interface ByAuthCallback<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> extends Base<M, E, S> {
+            /** Not allowed in this variant. */
+            data?: never;
+            /** Not allowed in this variant. */
+            file_path?: never;
+            /** Only allow authenticated requests. */
+            authenticated: true;
+            /** The callback that will be executed when a client requests this endpoint. */
+            callback: ((stream: AuthStream, params: vlib.Schema.Entries.Infer<S>) => any);
+            /** Not allowed in this variant. */
+            view?: never;
+            /**
+             * The content type.
+             * Not required since a callback could have multiple different content types.
+             */
+            content_type?: string;
+        }
+        /**
+         * Options for constructing an endpoint by authenticated view.
+         * @docs
+         */
+        interface ByView<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> extends Base<M, E, S> {
+            /** Not allowed in this variant. */
+            data?: never;
+            /** Not allowed in this variant. */
+            file_path?: never;
+            /** Only allow authenticated requests. */
+            authenticated?: boolean;
+            /** Not allowed in this variant. */
+            callback?: never;
+            /** The JavaScript view that will be executed on the client side. */
+            view: View | View.Opts;
+            /** The content type. */
+            content_type?: never;
+        }
+    }
+}