@imqueue/pg-sequelize 4.2.0

package/src/index.d.ts

@@ -0,0 +1,162 @@
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * Copyright (c) 2019, imqueue.com <support@imqueue.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+import { type ILogger } from '@imqueue/rpc';
+import { type SequelizeOptions } from 'sequelize-typescript';
+import { Sequelize } from './BaseModel.js';
+export * from './Graph.js';
+export * from './BaseModel.js';
+export * from './helpers/index.js';
+export * from './decorators/index.js';
+export * from './types/index.js';
+/**
+ * Everything {@link database} needs on its first call.
+ *
+ * @remarks
+ * Only the first `database()` call reads this, so treat it as start-up config rather
+ * than something to vary per call. Note also that `database()` WRITES to the object
+ * it is given — it fills in `connectionString` from the environment and replaces
+ * `sequelize.logging` — so a config exported as a module constant and passed at every
+ * call site does not stay as written.
+ */
+export interface IMQORMOptions {
+    /**
+     * Where SQL statements are logged.
+     *
+     * @remarks
+     * Falls back to the `@imqueue/rpc` service default, then to `console`, so it can
+     * be left out. `@imqueue/async-logger` is the usual choice.
+     */
+    logger: ILogger;
+    /**
+     * Postgres connection string.
+     *
+     * @remarks
+     * Optional only because {@link DB_CONN_STR} can supply it. With neither,
+     * `database()` throws.
+     */
+    connectionString?: string;
+    /**
+     * Options passed through to the Sequelize constructor.
+     *
+     * @remarks
+     * `logging` is the one property `database()` overwrites — see {@link database}
+     * for what each value means.
+     */
+    sequelize: SequelizeOptions;
+    /**
+     * Directory holding the COMPILED model files.
+     *
+     * @remarks
+     * Walked recursively for `.js` files, so point it at build output rather than at
+     * `.ts` sources. Each file must export a symbol named exactly after the file —
+     * `Lead.js` must export `Lead` — because that is how the loader picks the model
+     * out of the module. A mismatch hands Sequelize `undefined` instead of a model.
+     */
+    modelsPath: string;
+}
+/**
+ * `DB_CONN_STR` from the environment, read once when this module loads.
+ *
+ * @remarks
+ * The fallback {@link database} uses when {@link IMQORMOptions.connectionString} is
+ * absent. Because it is captured at import time, changing `process.env` later has no
+ * effect on it.
+ */
+export declare const DB_CONN_STR: string | undefined;
+/**
+ * Whether logged SQL is reformatted across multiple lines. Off by default.
+ *
+ * @remarks
+ * Set `SQL_PRETTIFY` to a positive number to enable. Read once at import, so it is a
+ * deployment setting rather than something to toggle at runtime. Affects logging
+ * only — never the SQL that is executed.
+ */
+export declare const SQL_PRETTIFY: boolean;
+/**
+ * Whether logged SQL carries ANSI colour. Off by default.
+ *
+ * @remarks
+ * Set `SQL_COLORIZE` to a positive number to enable. Worth leaving off wherever logs
+ * are collected rather than read in a terminal, since the escape sequences end up in
+ * the stored line. Independent of {@link SQL_PRETTIFY}.
+ */
+export declare const SQL_COLORIZE: boolean;
+/**
+ * Reformats a SQL string for logging, when {@link SQL_PRETTIFY} is on.
+ *
+ * @remarks
+ * A pass-through when prettifying is off, so it is always safe to call. Otherwise
+ * `sql-formatter` does the work and a handful of substitutions tidy up what it does
+ * to Postgres-specific syntax — casts, `&&`, and bind-parameter markers, which the
+ * formatter would otherwise break across lines.
+ *
+ * For logs only. It is not a parser and the result is not guaranteed to be
+ * executable.
+ *
+ * @param sql - Statement as sequelize reports it.
+ * @returns The reformatted statement, or `sql` unchanged when prettifying is off.
+ */
+export declare function formatSql(sql: string): string;
+/**
+ * A sequelize `logging` callback: the SQL, and the timing when benchmarking is on.
+ */
+export type SqlLoggingFunction = (sql: string, time?: number) => void;
+/**
+ * Connects to the database, loads the models, and returns the Sequelize instance.
+ *
+ * @remarks
+ * A process-wide singleton. The first call does all the work; every call after it
+ * returns the cached instance and DOES NOT LOOK AT ITS ARGUMENT — so passing a
+ * different config later is silently ignored rather than reconnecting. That is why
+ * services can import `database` anywhere and call `database(dbConfig)` freely, and
+ * also why there is no way to swap the connection once it is up.
+ *
+ * The first call resolves its configuration in this order:
+ *
+ * - `connectionString`, or {@link DB_CONN_STR} from the environment. Neither throws.
+ * - `logger`, or the `@imqueue/rpc` service default, or `console`.
+ * - `sequelize.logging`: left alone if explicitly falsy, so `false` disables logging;
+ *   otherwise replaced with this package's formatter, honouring {@link SQL_PRETTIFY}
+ *   and {@link SQL_COLORIZE}. A function you supply is wrapped rather than discarded,
+ *   and receives the formatted SQL.
+ *
+ * Models are then discovered by walking `modelsPath` for compiled `.js` files and
+ * taking the export whose name matches the filename — see
+ * {@link IMQORMOptions.modelsPath}, since a mismatch there fails in a way the error
+ * does not explain. The require is synchronous and CommonJS-scoped, which is what
+ * makes the models loadable from an ESM package.
+ *
+ * @param options - Required on the first call, ignored on every later one.
+ * @returns The single Sequelize instance for this process, with models registered.
+ * @throws TypeError when the first call has no options, or when no connection string
+ *   can be resolved from either the options or the environment.
+ * @example
+ * ```typescript
+ * // config.ts — built once at start-up
+ * export const dbConfig: IMQORMOptions = {
+ *     logger,
+ *     connectionString: process.env.DB_CONN_STR || '',
+ *     sequelize: toSequelizeConfig(process.env.DB_CONN_STR, process.env.DB_DIALECT),
+ *     modelsPath: './src/orm/models',
+ * };
+ *
+ * // anywhere in the service — the first call wins, the rest are free
+ * const orm = database(dbConfig);
+ * ```
+ */
+export declare function database(options?: IMQORMOptions): Sequelize;

package/src/index.js

@@ -0,0 +1,223 @@
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * Copyright (c) 2019, imqueue.com <support@imqueue.com>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+import { DEFAULT_IMQ_SERVICE_OPTIONS } from '@imqueue/rpc';
+import { createRequire } from 'node:module';
+import { styleText } from 'node:util';
+import { readdirSync, statSync } from 'node:fs';
+import { resolve, sep } from 'node:path';
+import {} from 'sequelize-typescript';
+import { Sequelize } from './BaseModel.js';
+import { isDefined, isOk } from './helpers/js.js';
+/* models exports! */
+export * from './Graph.js';
+export * from './BaseModel.js';
+export * from './helpers/index.js';
+export * from './decorators/index.js';
+export * from './types/index.js';
+const JS_EXT_RX = /\.js$/;
+/**
+ * Every file under a directory, recursively.
+ *
+ * @param dir - Directory to walk.
+ * @returns Absolute paths of every file found, directories excluded.
+ */
+function walk(dir) {
+    let results = [];
+    for (let file of readdirSync(dir)) {
+        file = resolve(dir, file);
+        const stat = statSync(file);
+        if (stat && stat.isDirectory()) {
+            results = results.concat(walk(file));
+        }
+        else {
+            results.push(file);
+        }
+    }
+    return results;
+}
+/**
+ * `DB_CONN_STR` from the environment, read once when this module loads.
+ *
+ * @remarks
+ * The fallback {@link database} uses when {@link IMQORMOptions.connectionString} is
+ * absent. Because it is captured at import time, changing `process.env` later has no
+ * effect on it.
+ */
+export const DB_CONN_STR = process.env.DB_CONN_STR;
+/**
+ * Whether logged SQL is reformatted across multiple lines. Off by default.
+ *
+ * @remarks
+ * Set `SQL_PRETTIFY` to a positive number to enable. Read once at import, so it is a
+ * deployment setting rather than something to toggle at runtime. Affects logging
+ * only — never the SQL that is executed.
+ */
+export const SQL_PRETTIFY = +(process.env.SQL_PRETTIFY || 0) > 0;
+/**
+ * Whether logged SQL carries ANSI colour. Off by default.
+ *
+ * @remarks
+ * Set `SQL_COLORIZE` to a positive number to enable. Worth leaving off wherever logs
+ * are collected rather than read in a terminal, since the escape sequences end up in
+ * the stored line. Independent of {@link SQL_PRETTIFY}.
+ */
+export const SQL_COLORIZE = +(process.env.SQL_COLORIZE || 0) > 0;
+import { format as sqlFormat } from 'sql-formatter';
+const RX_SQL_NUM_LAYOUT = /\s+(['"]?\d+['"]?,?)\r?\n/g;
+const RX_SQL_NUM_END = /(\d+['"]?)\s+(\))/g;
+const RX_BRK_DBL_AND = /&\s+&/g;
+const RX_BRK_CAST = /\s+(\[|::)(\s+)?/g;
+const RX_BRK_POCKETS = /(\$)\s+(\d)/g;
+const RX_SQL_PREFIX = /Execut(ed|ing) \(default\):/;
+/**
+ * Reformats a SQL string for logging, when {@link SQL_PRETTIFY} is on.
+ *
+ * @remarks
+ * A pass-through when prettifying is off, so it is always safe to call. Otherwise
+ * `sql-formatter` does the work and a handful of substitutions tidy up what it does
+ * to Postgres-specific syntax — casts, `&&`, and bind-parameter markers, which the
+ * formatter would otherwise break across lines.
+ *
+ * For logs only. It is not a parser and the result is not guaranteed to be
+ * executable.
+ *
+ * @param sql - Statement as sequelize reports it.
+ * @returns The reformatted statement, or `sql` unchanged when prettifying is off.
+ */
+export function formatSql(sql) {
+    return SQL_PRETTIFY
+        ? sqlFormat(sql)
+            .replace(RX_SQL_NUM_LAYOUT, '$1 ')
+            .replace(RX_SQL_NUM_END, '$1$2')
+            .replace(RX_BRK_DBL_AND, '&&')
+            .replace(RX_BRK_CAST, '$1')
+            .replace(RX_BRK_POCKETS, '$1$2')
+        : sql;
+}
+/**
+ * Builds the sequelize `logging` callback, honouring `SQL_PRETTIFY` and
+ * `SQL_COLORIZE`.
+ *
+ * @remarks
+ * Accepts either an `ILogger` or a plain callback, and that distinction is
+ * load-bearing rather than convenience: a caller who sets
+ * `sequelize.logging` to their own function used to have it swapped for this one
+ * with the function itself in the logger slot, so the first query to be logged threw
+ * `TypeError: logger.log is not a function`. Both shapes now receive the formatted
+ * SQL.
+ *
+ * @param sink - Where to write: a logger, or a callback in sequelize's own shape.
+ * @returns The callback to hand to sequelize as `options.logging`.
+ */
+const logging = (sink) => (sql, time) => {
+    const message = SQL_COLORIZE
+        ? `${styleText(['bold', 'yellow'], 'SQL Query:')} ${styleText('cyan', formatSql(sql.replace(RX_SQL_PREFIX, '')))}`
+        : `SQL Query: ${formatSql(sql.replace(RX_SQL_PREFIX, ''))}`;
+    if (typeof sink === 'function') {
+        sink(message, time);
+        return;
+    }
+    sink.log(message, typeof time === 'number' ? `executed in ${time} ms` : '');
+};
+let orm;
+/**
+ * Connects to the database, loads the models, and returns the Sequelize instance.
+ *
+ * @remarks
+ * A process-wide singleton. The first call does all the work; every call after it
+ * returns the cached instance and DOES NOT LOOK AT ITS ARGUMENT — so passing a
+ * different config later is silently ignored rather than reconnecting. That is why
+ * services can import `database` anywhere and call `database(dbConfig)` freely, and
+ * also why there is no way to swap the connection once it is up.
+ *
+ * The first call resolves its configuration in this order:
+ *
+ * - `connectionString`, or {@link DB_CONN_STR} from the environment. Neither throws.
+ * - `logger`, or the `@imqueue/rpc` service default, or `console`.
+ * - `sequelize.logging`: left alone if explicitly falsy, so `false` disables logging;
+ *   otherwise replaced with this package's formatter, honouring {@link SQL_PRETTIFY}
+ *   and {@link SQL_COLORIZE}. A function you supply is wrapped rather than discarded,
+ *   and receives the formatted SQL.
+ *
+ * Models are then discovered by walking `modelsPath` for compiled `.js` files and
+ * taking the export whose name matches the filename — see
+ * {@link IMQORMOptions.modelsPath}, since a mismatch there fails in a way the error
+ * does not explain. The require is synchronous and CommonJS-scoped, which is what
+ * makes the models loadable from an ESM package.
+ *
+ * @param options - Required on the first call, ignored on every later one.
+ * @returns The single Sequelize instance for this process, with models registered.
+ * @throws TypeError when the first call has no options, or when no connection string
+ *   can be resolved from either the options or the environment.
+ * @example
+ * ```typescript
+ * // config.ts — built once at start-up
+ * export const dbConfig: IMQORMOptions = {
+ *     logger,
+ *     connectionString: process.env.DB_CONN_STR || '',
+ *     sequelize: toSequelizeConfig(process.env.DB_CONN_STR, process.env.DB_DIALECT),
+ *     modelsPath: './src/orm/models',
+ * };
+ *
+ * // anywhere in the service — the first call wins, the rest are free
+ * const orm = database(dbConfig);
+ * ```
+ */
+export function database(options) {
+    if (typeof orm !== 'undefined') {
+        return orm;
+    }
+    else if (typeof options === 'undefined') {
+        throw new TypeError('First call of database() must provide valid options!');
+    }
+    if (!options.connectionString) {
+        if (!DB_CONN_STR) {
+            throw new TypeError('Either environment DB_CONN_STR should be set or ' +
+                'connectionString property given!');
+        }
+        options.connectionString = DB_CONN_STR;
+    }
+    if (!options.connectionString) {
+        throw new TypeError('Database connection string is required!');
+    }
+    if (!options.logger) {
+        options.logger =
+            DEFAULT_IMQ_SERVICE_OPTIONS.logger || console;
+    }
+    // A caller-supplied function is a logging SINK, not a logger object — it has
+    // no `.log`, so casting it to ILogger threw on the first query that got
+    // logged. It is still wrapped rather than used raw, so SQL_PRETTIFY and
+    // SQL_COLORIZE keep working for this path too.
+    options.sequelize.logging =
+        !isDefined(options.sequelize.logging) || isOk(options.sequelize.logging)
+            ? logging(typeof options.sequelize.logging === 'function'
+                ? options.sequelize.logging
+                : options.logger)
+            : options.sequelize.logging;
+    orm = new Sequelize(options.connectionString, options.sequelize);
+    // model files are loaded synchronously with a CommonJS require
+    // scoped to this module: consumer model builds are CJS today, and
+    // require(esm) covers them if they migrate (Node >= 22.12)
+    const requireModel = createRequire(import.meta.url);
+    orm.addModels(walk(resolve(options.modelsPath))
+        .filter(name => JS_EXT_RX.test(name))
+        .map(filename => requireModel(filename)[filename.split(sep).reverse()[0].replace(JS_EXT_RX, '')]));
+    options.logger.log('Database models initialized...');
+    return orm;
+}
+//# sourceMappingURL=index.js.map

package/src/types/DataPage.d.ts

@@ -0,0 +1,52 @@
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+/**
+ * One page of results together with the size of the whole set.
+ *
+ * @remarks
+ * The envelope a paginated service method returns, so a caller that asked for 20
+ * rows can still render "20 of 1,340" without a second round trip. Nothing in this
+ * package produces one — it is a shape for your own service methods to declare and
+ * fill, which is why `data` is whatever you put in it rather than an array.
+ *
+ * @example
+ * ```typescript
+ * @expose()
+ * public async listReservations(
+ *     page?: PaginationInput,
+ * ): Promise<DataPage<Reservation[]>> {
+ *     const { rows, count } = await Reservation.findAndCountAll(
+ *         query.toLimitOptions(page),
+ *     );
+ *
+ *     return { total: count, data: rows };
+ * }
+ * ```
+ */
+export interface DataPage<T> {
+    /** Rows matching the query in total, ignoring the page window. */
+    total: number;
+    /** The page itself. */
+    data: T;
+}

package/src/types/DataPage.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataPage.js.map

package/src/types/FieldsInput.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Which fields to return, nested to match the shape of the relations.
+ *
+ * @remarks
+ * Selection is by KEY PRESENCE, not by value — the single most important thing to
+ * know about this type, and the opposite of what `false` suggests. A key names a
+ * field to return; `false` means return that column and nothing further; a nested
+ * `FieldsInput` on a relation includes the relation and selects within it. So
+ * `{ id: false }` DOES return `id`. Omit a field entirely to leave it out, and pass
+ * no map at all to get everything the model declares.
+ *
+ * A value other than `false` is also read as a filter for that column by
+ * `query.autoQuery`, which is why the declared value type is `false | FieldsInput`:
+ * the two roles are told apart by that `false`.
+ *
+ * The recursion is what makes it worth a type of its own — one map describes a whole
+ * object graph, so a caller asking for a reservation with only its car's id does not
+ * need one argument per level. `query.createEntity` threads the nested map down to
+ * each related model as it goes, and `autoQuery` turns each nested level into a
+ * Sequelize `include`.
+ *
+ * Note that `autoQuery` MUTATES the map it is given: a column named in the `order`
+ * that the map does not mention is added to it as `false`, so ordering cannot break
+ * the selection. Do not share one map across calls and expect it to stay as written.
+ *
+ * It is a class rather than an interface because `@indexed` describes it to
+ * `@imqueue/rpc`, which needs a runtime value to attach the description to.
+ *
+ * @example
+ * ```typescript
+ * // the reservation with its type and id, and its car's id and model
+ * const fields: FieldsInput = {
+ *     id: false,
+ *     type: false,
+ *     car: { id: false, model: false },
+ * };
+ * ```
+ */
+export declare class FieldsInput {
+    [fieldName: string]: false | FieldsInput;
+}

package/src/types/FieldsInput.js

@@ -0,0 +1,75 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/*!
+ * @imqueue/pg-sequelize - Sequelize ORM refines for @imqueue
+ *
+ * I'm Queue Software Project
+ * Copyright (C) 2025  imqueue.com <support@imqueue.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * If you want to use this code in a closed source (commercial) project, you can
+ * purchase a proprietary commercial license. Please contact us at
+ * <support@imqueue.com> to get commercial licensing options.
+ */
+import { indexed } from '@imqueue/rpc';
+/**
+ * Which fields to return, nested to match the shape of the relations.
+ *
+ * @remarks
+ * Selection is by KEY PRESENCE, not by value — the single most important thing to
+ * know about this type, and the opposite of what `false` suggests. A key names a
+ * field to return; `false` means return that column and nothing further; a nested
+ * `FieldsInput` on a relation includes the relation and selects within it. So
+ * `{ id: false }` DOES return `id`. Omit a field entirely to leave it out, and pass
+ * no map at all to get everything the model declares.
+ *
+ * A value other than `false` is also read as a filter for that column by
+ * `query.autoQuery`, which is why the declared value type is `false | FieldsInput`:
+ * the two roles are told apart by that `false`.
+ *
+ * The recursion is what makes it worth a type of its own — one map describes a whole
+ * object graph, so a caller asking for a reservation with only its car's id does not
+ * need one argument per level. `query.createEntity` threads the nested map down to
+ * each related model as it goes, and `autoQuery` turns each nested level into a
+ * Sequelize `include`.
+ *
+ * Note that `autoQuery` MUTATES the map it is given: a column named in the `order`
+ * that the map does not mention is added to it as `false`, so ordering cannot break
+ * the selection. Do not share one map across calls and expect it to stay as written.
+ *
+ * It is a class rather than an interface because `@indexed` describes it to
+ * `@imqueue/rpc`, which needs a runtime value to attach the description to.
+ *
+ * @example
+ * ```typescript
+ * // the reservation with its type and id, and its car's id and model
+ * const fields: FieldsInput = {
+ *     id: false,
+ *     type: false,
+ *     car: { id: false, model: false },
+ * };
+ * ```
+ */
+let FieldsInput = class FieldsInput {
+};
+FieldsInput = __decorate([
+    indexed(() => `[fieldName: string]: false | ${FieldsInput.name}`)
+], FieldsInput);
+export { FieldsInput };
+//# sourceMappingURL=FieldsInput.js.map