rimecms 0.31.5 → 0.32.0

package/dist/.rime-modules.d.ts

@@ -1,23 +0,0 @@
-declare module '$rime/modules/rimecms/core/plugins/sse' {
-  export * from 'rimecms/dist/core/plugins/sse/module.server.js';
-}
-
-declare module '$rime/modules/rimecms/core/plugins/cache' {
-  export * from 'rimecms/dist/core/plugins/cache/module.server.js';
-}
-
-declare module '$rime/modules/rimecms/core/plugins/mailer' {
-  export * from 'rimecms/dist/core/plugins/mailer/module.server.js';
-}
-
-declare module '$rime/modules/rimecms/core/plugins/api-init' {
-  export * from 'rimecms/dist/core/plugins/api-init/module.server.js';
-}
-
-declare module '$rime/modules/rimecms/fields/relation' {
-  export * from 'rimecms/dist/fields/relation/module.server.js';
-}
-
-declare module '$rime/modules/rimecms/fields/link' {
-  export * from 'rimecms/dist/fields/link/module.server.js';
-}

package/dist/.rime-modules.json

@@ -1 +0,0 @@
-{"core/plugins/sse":{"server":"core/plugins/sse/module.server.js"},"core/plugins/cache":{"client":"core/plugins/cache/module.js","server":"core/plugins/cache/module.server.js"},"core/plugins/mailer":{"server":"core/plugins/mailer/module.server.js"},"core/plugins/api-init":{"server":"core/plugins/api-init/module.server.js"},"fields/relation":{"client":"fields/relation/module.js","server":"fields/relation/module.server.js"},"fields/link":{"client":"fields/link/module.js","server":"fields/link/module.server.js"}}

package/dist/adapter-sqlite/generate-schema/relations/definition.server.d.ts

@@ -1,55 +0,0 @@
-/**
- * Generates Drizzle ORM relationship definitions from a relations dictionary
- * Creates both one-to-many and many-to-one relationship definitions by:
- * - Converting each entry into 'hasOne' relations (parent -> child)
- * - Creating 'hasMany' relations for reverse relationships (child -> parent)
- *
- * @example
- * const relationsDic = { pages: ['users', 'medias'] }
- *
- * output:
- * {
- *   relationsDefinitions: `
- *     export const rel_usersHasOnePages = relations(users, ({ one }) => ({
- *       pages: one(pages, {
- *         fields: [users.ownerId],
- *         references: [pages.id],
- *       })
- *     }))
- *
- *     export const rel_pagesHasMany = relations(pages, ({ many }) => ({
- *       users: many(users),
- *     }))`,
- *   relationsNames: ['rel_usersHasOnePages', 'rel_pagesHasMany']
- * }
- */
-export declare function generateRelationshipDefinitions({ relationsDic }: Args): Return;
-type Return = {
-    /**
-     * @example
-     * export const rel_usersHasOnePages = relations(users, ({ one }) => ({
-     *   pages : one(pages, {
-     *     fields: [users.ownerId],
-     *     references: [pages.id],
-     *   }),
-     * }))
-     *
-     * export const rel_pagesHasMany = relations(pages, ({ many }) => ({
-     *   users: many(users),
-     * }))
-     */
-    relationsDefinitions: string;
-    /**
-     * @example
-     * [ 'rel_mediasHasOnePages', 'rel_usersHasOnePages', 'rel_pagesHasMany' ]
-     */
-    relationsNames: string[];
-};
-type Args = {
-    relationsDic: Record<string, string[]>;
-};
-export type RelationFieldsMap = Record<string, {
-    to: string;
-    localized?: boolean;
-}>;
-export {};

package/dist/adapter-sqlite/generate-schema/relations/definition.server.js

@@ -1,52 +0,0 @@
-import { toPascalCase } from '../../../util/string.js';
-import { templateRelationMany, templateRelationOne } from '../templates.server.js';
-const p = toPascalCase;
-/**
- * Generates Drizzle ORM relationship definitions from a relations dictionary
- * Creates both one-to-many and many-to-one relationship definitions by:
- * - Converting each entry into 'hasOne' relations (parent -> child)
- * - Creating 'hasMany' relations for reverse relationships (child -> parent)
- *
- * @example
- * const relationsDic = { pages: ['users', 'medias'] }
- *
- * output:
- * {
- *   relationsDefinitions: `
- *     export const rel_usersHasOnePages = relations(users, ({ one }) => ({
- *       pages: one(pages, {
- *         fields: [users.ownerId],
- *         references: [pages.id],
- *       })
- *     }))
- *
- *     export const rel_pagesHasMany = relations(pages, ({ many }) => ({
- *       users: many(users),
- *     }))`,
- *   relationsNames: ['rel_usersHasOnePages', 'rel_pagesHasMany']
- * }
- */
-export function generateRelationshipDefinitions({ relationsDic }) {
-    if (Object.keys(relationsDic).length === 0)
-        return { relationsDefinitions: '', relationsNames: [] };
-    const relationsNames = [];
-    let toOnes = [];
-    const toManies = [];
-    for (const [table, many] of Object.entries(relationsDic)) {
-        toOnes = [
-            ...toOnes,
-            ...many.map((t) => {
-                const name = `rel_${t}HasOne${p(table)}`;
-                relationsNames.push(name);
-                return templateRelationOne({ name, table: t, parent: table });
-            })
-        ];
-        const name = `rel_${table}HasMany`;
-        relationsNames.push(name);
-        toManies.push(templateRelationMany({ name, table, many }));
-    }
-    return {
-        relationsDefinitions: [...toOnes, ...toManies].join('\n\n'),
-        relationsNames
-    };
-}

package/dist/adapter-sqlite/generate-schema/util.server.d.ts

@@ -1,49 +0,0 @@
-/**
- * Gets all tree table names for a specific collection in the database schema.
- * Tree tables store hierarchical document relationships.
- *
- * @example
- * // Returns ['pagesTreeBaz', 'pagesTreeFoo']
- * getTreeTableNames('pages', dbSchema.tables);
- */
-export declare const getTreeTableNames: (slug: string, tables: Record<string, any>) => string[];
-/**
- * Make a Tree table name given a root table slug and the Tree field name
- *
- * @example
- * // Returns 'pagesTreeBaz'
- * makeTreeTableSlug('pages', 'baz')
- */
-export declare const makeTreeTableSlug: (slug: string, fieldName: string) => string;
-/**
- * Gets all blocks table names for a specific collection in the database schema.
- * Blocks tables store flexible content blocks data.
- *
- * @example
- * // Returns ['pagesBlocks', 'pagesBlocksContent']
- * getBlocksTableNames('pages', dbSchema.tables);
- */
-export declare const getBlocksTableNames: (slug: string, tables: Record<string, any>) => string[];
-/**
- * Make a Block table name given a root table slug and the block.type
- *
- * @example
- * // Returns 'pagesBlocksBaz'
- * makeBlockTableSlug('pages', 'baz')
- */
-export declare const makeBlockTableSlug: (slug: string, blockType: string) => string;
-/**
- * Generate the column and property names for a field given its name and its parent path.
- * Snake case is used for the sqlite column name and Camel case is used for the drizzle column property name.
- *
- * @example
- * // returns { camel : 'groupTitle', snake: 'group__title' }
- * getSchemaColumnNames({ name: 'title', parentPath: 'group' })
- */
-export declare function getSchemaColumnNames(args: {
-    name: string;
-    parentPath?: string;
-}): {
-    camel: string;
-    snake: string;
-};

package/dist/adapter-sqlite/generate-schema/util.server.js

@@ -1,58 +0,0 @@
-import { toCamelCase, toPascalCase, toSnakeCase } from '../../util/string.js';
-/**
- * Gets all tree table names for a specific collection in the database schema.
- * Tree tables store hierarchical document relationships.
- *
- * @example
- * // Returns ['pagesTreeBaz', 'pagesTreeFoo']
- * getTreeTableNames('pages', dbSchema.tables);
- */
-export const getTreeTableNames = (slug, tables) => Object.keys(tables).filter((key) => key.startsWith(`${slug}Tree`) && !key.endsWith('Locales'));
-/**
- * Make a Tree table name given a root table slug and the Tree field name
- *
- * @example
- * // Returns 'pagesTreeBaz'
- * makeTreeTableSlug('pages', 'baz')
- */
-export const makeTreeTableSlug = (slug, fieldName) => `${slug}Tree${toPascalCase(fieldName)}`;
-/**
- * Gets all blocks table names for a specific collection in the database schema.
- * Blocks tables store flexible content blocks data.
- *
- * @example
- * // Returns ['pagesBlocks', 'pagesBlocksContent']
- * getBlocksTableNames('pages', dbSchema.tables);
- */
-export const getBlocksTableNames = (slug, tables) => Object.keys(tables).filter((key) => key.startsWith(`${slug}Blocks`) && !key.endsWith('Locales'));
-/**
- * Make a Block table name given a root table slug and the block.type
- *
- * @example
- * // Returns 'pagesBlocksBaz'
- * makeBlockTableSlug('pages', 'baz')
- */
-export const makeBlockTableSlug = (slug, blockType) => `${slug}Blocks${toPascalCase(blockType)}`;
-/**
- * Generate the column and property names for a field given its name and its parent path.
- * Snake case is used for the sqlite column name and Camel case is used for the drizzle column property name.
- *
- * @example
- * // returns { camel : 'groupTitle', snake: 'group__title' }
- * getSchemaColumnNames({ name: 'title', parentPath: 'group' })
- */
-export function getSchemaColumnNames(args) {
-    const name = args.parentPath ? `${args.parentPath}__${args.name}` : args.name;
-    // Preserve leading underscore if present
-    const hasLeadingUnderscore = name.startsWith('_');
-    const processedName = hasLeadingUnderscore ? name.slice(1) : name;
-    const processParts = (parts, formatter) => {
-        const processed = parts.map((part) => formatter(part)).join('__');
-        return hasLeadingUnderscore ? `_${processed}` : processed;
-    };
-    const parts = processedName.split('__');
-    return {
-        camel: processParts(parts, toCamelCase),
-        snake: processParts(parts, toSnakeCase)
-    };
-}

package/dist/adapter-sqlite/orderBy.server.d.ts

@@ -1,11 +0,0 @@
-import type { PrototypeSlug } from '../core/types/doc.js';
-import type { BuiltArea, BuiltCollection } from '../types.js';
-type Args = {
-    slug: PrototypeSlug;
-    locale?: string;
-    config: BuiltArea | BuiltCollection;
-    by?: string;
-    tables: any;
-};
-export declare const buildOrderByParam: ({ slug, locale, tables, config, by }: Args) => import("drizzle-orm").SQL<unknown>[];
-export {};

package/dist/adapter-sqlite/orderBy.server.js

@@ -1,98 +0,0 @@
-import { logger } from '../core/logger/index.server.js';
-import { withLocalesSuffix, withVersionsSuffix } from '../core/naming.js';
-import { asc, desc, getTableColumns, sql } from 'drizzle-orm';
-import { getTableConfig } from 'drizzle-orm/sqlite-core';
-import { pathToDatabaseColumn } from './util.server.js';
-export const buildOrderByParam = ({ slug, locale, tables, config, by }) => {
-    const hasVersions = !!config.versions;
-    const getOrderFunc = (str) => {
-        if (typeof str !== 'string')
-            return asc;
-        return str.charAt(0) === '-' ? desc : asc;
-    };
-    // Get the root table
-    const rootTable = tables[slug];
-    by = by ? pathToDatabaseColumn(by) : by;
-    // Default case: no sort parameter provided
-    if (!by) {
-        // Default to sorting by updatedAt in descending order
-        return [desc(rootTable.updatedAt)];
-    }
-    // Handle system fields (createdAt/updatedAt)
-    if (by === 'createdAt' || by === 'updatedAt' || by === '-createdAt' || by === '-updatedAt') {
-        // Determine sort direction (asc/desc) based on presence of '-' prefix
-        const orderFunc = getOrderFunc(by);
-        // Remove the '-' prefix if present to get the actual column name
-        const columnStr = by.replace(/^-/, '');
-        return [orderFunc(rootTable[columnStr])];
-    }
-    const orderFunc = getOrderFunc(by);
-    const columnStr = by.replace(/^-/, '');
-    // For non-versioned collections
-    if (!hasVersions) {
-        const rootTableColumns = Object.keys(getTableColumns(rootTable));
-        // Check if the column exists in the root table
-        if (rootTableColumns.includes(columnStr)) {
-            return [orderFunc(rootTable[columnStr])];
-        }
-        // Check if it's a localized field in a non-versioned collection
-        if (locale) {
-            const localeTableName = withLocalesSuffix(slug);
-            if (localeTableName in tables) {
-                const localeTable = tables[localeTableName];
-                const localizedColumns = getTableColumns(localeTable);
-                if (Object.keys(localizedColumns).includes(columnStr)) {
-                    const { name: sqlLocaleTableName } = getTableConfig(localeTable);
-                    const { name: sqlTableName } = getTableConfig(rootTable);
-                    return [
-                        orderFunc(sql.raw(`(SELECT DISTINCT ${sqlLocaleTableName}."${localizedColumns[columnStr].name}" FROM ${sqlLocaleTableName} WHERE ${sqlLocaleTableName}."owner_id" = ${sqlTableName}."id" AND ${sqlLocaleTableName}."locale" = '${locale}')`))
-                    ];
-                }
-            }
-        }
-    }
-    else {
-        const versionTableName = withVersionsSuffix(slug);
-        const versionsTable = tables[versionTableName];
-        const versionsTableColumns = Object.keys(getTableColumns(versionsTable));
-        // Check if the column exists in the versions table and is not a system field
-        if (versionsTableColumns.includes(columnStr) &&
-            columnStr !== 'createdAt' &&
-            columnStr !== 'updatedAt') {
-            const { name: sqlVersionsTableName } = getTableConfig(versionsTable);
-            const { name: sqlRootTableName } = getTableConfig(rootTable);
-            // Use a subquery to get the value from the latest version for ordering
-            return [
-                orderFunc(sql.raw(`(SELECT DISTINCT ${sqlVersionsTableName}."${columnStr}" FROM ${sqlVersionsTableName} WHERE ${sqlVersionsTableName}."owner_id" = ${sqlRootTableName}."id" ORDER BY ${sqlVersionsTableName}."updated_at" DESC LIMIT 1)`))
-            ];
-        }
-        // Check if it's a localized field in a versioned collection
-        if (locale) {
-            const versionsLocaleTableName = withLocalesSuffix(versionTableName);
-            if (versionsLocaleTableName in tables) {
-                const localeTable = tables[versionsLocaleTableName];
-                const localizedColumns = getTableColumns(localeTable);
-                if (Object.keys(localizedColumns).includes(columnStr)) {
-                    const { name: sqlLocaleTableName } = getTableConfig(localeTable);
-                    const { name: sqlVersionsTableName } = getTableConfig(versionsTable);
-                    const { name: sqlRootTableName } = getTableConfig(rootTable);
-                    // Nested subquery: first get the latest version, then get the localized value
-                    return [
-                        orderFunc(sql.raw(`(SELECT ${sqlLocaleTableName}."${localizedColumns[columnStr].name}"
-								  FROM ${sqlLocaleTableName}
-								  WHERE ${sqlLocaleTableName}."owner_id" IN
-								    (SELECT ${sqlVersionsTableName}."id"
-									 FROM ${sqlVersionsTableName}
-									 WHERE ${sqlVersionsTableName}."owner_id" = ${sqlRootTableName}."id"
-									 ORDER BY ${sqlVersionsTableName}."updated_at" DESC LIMIT 1)
-								  AND ${sqlLocaleTableName}."locale" = '${locale}'
-								  LIMIT 1)`))
-                    ];
-                }
-            }
-        }
-    }
-    logger.warn(`"${by}" is not a property of ${slug}`);
-    // Fallback to ordering by createdAt on the root table
-    return [desc(rootTable.createdAt)];
-};

package/dist/adapter-sqlite/url.server.d.ts

@@ -1,14 +0,0 @@
-import type { GetRegisterType } from '../index.js';
-import type { BuiltArea, BuiltCollection } from '../types.js';
-import type { LibSQLDatabase } from 'drizzle-orm/libsql';
-import type { GenericTables } from './types.server.js';
-type Params = {
-    id: string;
-    versionId?: string;
-    config: BuiltArea | BuiltCollection;
-    locale?: string;
-    db: LibSQLDatabase<GetRegisterType<'Schema'>>;
-    tables: GenericTables;
-};
-export declare function updateDocumentUrl(url: string, params: Params): Promise<void>;
-export {};

package/dist/adapter-sqlite/url.server.js

@@ -1,77 +0,0 @@
-import { RimeError } from '../core/errors/index.js';
-import { logger } from '../core/logger/index.server.js';
-import { withLocalesSuffix, withVersionsSuffix } from '../core/naming.js';
-import { and, eq } from 'drizzle-orm';
-const OPERATION = {
-    ROOT: 0,
-    LOCALE: 1,
-    VERSION: 2,
-    VERSION_LOCALE: 3
-};
-export async function updateDocumentUrl(url, params) {
-    //
-    const { config, id, versionId, tables, db } = params;
-    const operationType = defineOperation(params.locale, params.config);
-    let operation;
-    switch (operationType) {
-        case OPERATION.ROOT: {
-            const table = tables[config.slug];
-            operation = db.update(table).set({ url }).where(eq(table.id, id));
-            break;
-        }
-        case OPERATION.LOCALE: {
-            const tableLocale = tables[withLocalesSuffix(config.slug)];
-            operation = db
-                .update(tableLocale)
-                .set({ url })
-                .where(and(
-            //
-            eq(tableLocale.ownerId, id), eq(tableLocale.locale, params.locale)));
-            break;
-        }
-        case OPERATION.VERSION: {
-            const tableVersions = tables[withVersionsSuffix(config.slug)];
-            operation = db
-                .update(tableVersions)
-                .set({ url })
-                .where(and(
-            //
-            eq(tableVersions.ownerId, id), eq(tableVersions.id, versionId)));
-            break;
-        }
-        case OPERATION.VERSION_LOCALE: {
-            const tableVersionsLocales = tables[withLocalesSuffix(withVersionsSuffix(config.slug))];
-            operation = db
-                .update(tableVersionsLocales)
-                .set({ url })
-                .where(and(
-            //
-            eq(tableVersionsLocales.ownerId, versionId), eq(tableVersionsLocales.locale, params.locale)));
-            break;
-        }
-        default:
-            logger.warn(`can't define url update operation for ${config.slug}, ${id}`);
-    }
-    if (operation) {
-        try {
-            operation.run();
-        }
-        catch (err) {
-            throw new RimeError(RimeError.OPERATION_ERROR, `Error storing url for ${config.slug}, ${id}. ${err.message}`);
-        }
-    }
-}
-const defineOperation = (locale, config) => {
-    if (!locale && !config.versions) {
-        return OPERATION.ROOT;
-    }
-    if (locale && !config.versions) {
-        return OPERATION.LOCALE;
-    }
-    if (!locale && !!config.versions) {
-        return OPERATION.VERSION;
-    }
-    if (!!locale && !!config.versions) {
-        return OPERATION.VERSION_LOCALE;
-    }
-};

package/dist/adapter-sqlite/util.server.d.ts

@@ -1,174 +0,0 @@
-import type { BuiltArea, BuiltCollection } from '../core/config/types.js';
-import type { RawDoc } from '../core/types/doc.js';
-import type { OperationQuery, ParsedOperationQuery } from '../core/types/index.js';
-import type { Dic } from '../util/types.js';
-import { Table } from 'drizzle-orm';
-/**
- * Main function to generated primaryKeys
- */
-export declare const generatePK: () => string;
-/**
- * Updates a database table with the provided data and timestamp
- */
-export declare function updateTableRecord(db: any, tables: any, tableName: string, options: {
-    recordId: string;
-    data: any;
-}): Promise<void>;
-/**
- * Inserts a new record into a database table
- * @returns The ID of the inserted record
- */
-export declare function insertTableRecord(db: any, tables: any, tableName: string, data: any): Promise<string>;
-/**
- * Updates or inserts localized data for a record
- */
-export declare function upsertLocalizedData(db: any, tables: any, tableLocalesName: string, options: {
-    ownerId: string;
-    data: any;
-    locale: string;
-}): Promise<void>;
-/**
- * Extract root table properties :
- * - hierarchy props (nested) : _parent and _position
- * - directory props (upload) : _path
- * return an object with the data filtered and the rootData.
- */
-export declare function extractRootData(data: any): {
-    data: any;
-    rootData: {
-        _parent?: string;
-        _position?: number;
-        _path?: string;
-    };
-};
-/**
- * Prepares data for database operations by transforming it according to table schemas
- */
-export declare function prepareSchemaData(data: any, options: {
-    mainTableName: string;
-    localesTableName: string;
-    locale?: string;
-    tables: any;
-    fillNotNull?: boolean;
-}): {
-    mainData: Record<string, any>;
-    localizedData: Record<string, any>;
-    isLocalized: boolean;
-};
-/**
- * Merges a document with its version data to create a complete document representation
- *
- * In versioned collections/areas, data is split between:
- * - Root document table (containing hierarchy fields like _parent, _position, and metadata like createdAt)
- * - Version table (containing the actual content fields)
- *
- * This function combines these two data sources into a single document object:
- * 1. Validates that version data exists or throw 404
- * 2. Handles field selection if specified
- * 3. Preserves root document fields (id, createdAt, updatedAt, _parent, _position)
- * 4. Adds version fields while avoiding duplicates
- * 5. Includes the versionId in the result
- */
-export declare function mergeRawDocumentWithVersion(doc: RawDoc, versionTableName: string, select?: string[]): RawDoc;
-/**
- * Build the query params to get either the latest updated document
- * or the published one if version.draft is enabled and draft is true
- */
-export declare function buildPublishedOrLatestVersionParams(args: {
-    draft?: boolean;
-    config: BuiltArea | BuiltCollection;
-    table: any;
-}): {
-    where: import("drizzle-orm").SQL<unknown>;
-    limit: number;
-    orderBy?: undefined;
-} | {
-    orderBy: import("drizzle-orm").SQL<unknown>[];
-    limit: number;
-    where?: undefined;
-};
-/**
- * Convert and validate on incoming query to a complient query
- * for the buildWhereParam wich require an object with a root prop where.
- *
- * @example
- * // returns
- * { where: queryObject }
- */
-export declare function normalizeQuery(incomingQuery: OperationQuery): ParsedOperationQuery;
-export declare function columnsParams({ table, select }: {
-    table: Dic;
-    select?: string[];
-}): Dic | undefined;
-/**
- * Get the primary key name given a table
- */
-export declare function getPrimaryKey(table: Table): string;
-/**
- * Convert a document path using dot notation to a database schema path using double underscores.
- * This transformation is needed because SQL databases don't support dots in column names.
- *
- * @param path - The document path with dot notation
- * @returns The database column path with double underscore notation
- *
- * @example
- * // Returns 'attributes__hero__title'
- * pathToDatabaseColumn('attributes.hero.title');
- */
-export declare const pathToDatabaseColumn: (path: string) => string;
-/**
- * Convert a database schema path using double underscores to a document path using dot notation.
- * This transforms database column names back to document property paths.
- *
- * @param path - The database column path with double underscore notation
- * @returns The document path with dot notation
- *
- * @example
- * // Returns 'attributes.hero.title'
- * databaseColumnToPath('attributes__hero__title');
- */
-export declare const databaseColumnToPath: (path: string) => string;
-/**
- * Converts an object's keys from database schema format (double underscores) to document format (dot notation).
- *
- * This function takes an object with keys using database column naming (e.g., 'attributes__title')
- * and transforms them to document path format (e.g., 'attributes.title') while preserving the values.
- *
- * @param obj - The object with database column keys
- * @returns A new object with keys converted to document paths
- *
- * @example
- * // Returns { 'attributes.title': 'Home' }
- * transformDatabaseColumnsToPaths({ 'attributes__title': 'Home' });
- */
-export declare const transformDatabaseColumnsToPaths: (obj: Record<string, any>) => Record<string, any>;
-/**
- * Extracts values from a data object and maps them to database column names using schema paths.
- *
- * This function converts document data (which may use nested objects with dot notation paths)
- * into a flat object with keys that match the database schema (using double underscore notation).
- * It only includes fields that exist in the provided columns schema.
- *
- * @param data - The document data object (may be nested)
- * @param columns - The database schema columns definition
- * @param params - Optional parameters for transformation
- * @param params.fillNotNull - If true, adds default values for NOT NULL columns
- * @returns A flat object with database column names and values
- *
- * @example
- * // Returns { 'attributes__title': 'Home' }
- * transformDataToSchema(
- *   { attributes: { title: 'Home' } },
- *   { 'attributes__title': { dataType: 'string', notNull: true } }
- * );
- *
- * // With fillNotNull, provides defaults for missing NOT NULL columns
- * transformDataToSchema(
- *   { attributes: {} },
- *   { 'attributes__title': { dataType: 'string', notNull: true } },
- *   { fillNotNull: true }
- * ); // Returns { 'attributes__title': '' }
- */
-export declare const transformDataToSchema: (data: Record<string, any>, columns: Record<string, any>, params?: {
-    fillNotNull?: boolean;
-}) => Record<string, any>;