@rebasepro/common 0.2.1 → 0.2.4

package/dist/util/permissions.d.ts

@@ -1,4 +1,5 @@
 import { AuthController, Entity, EntityCollection, User } from "@rebasepro/types";
+export declare function checkOperation<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, entity: Entity<M> | null, targetOperation: "select" | "insert" | "update" | "delete"): boolean;
 export declare function canReadCollection<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>): boolean;
 export declare function canEditEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
 export declare function canCreateEntity<M extends Record<string, unknown>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/common",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -41,8 +41,8 @@
   "dependencies": {
     "fast-equals": "6.0.0",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/types": "0.2.1",
-    "@rebasepro/utils": "0.2.1"
+    "@rebasepro/utils": "0.2.4",
+    "@rebasepro/types": "0.2.4"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
@@ -92,7 +92,10 @@
     ],
     "testEnvironment": "node",
     "moduleNameMapper": {
-      "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js"
+      "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js",
+      "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
+      "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
+      "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
     }
   },
   "scripts": {

package/src/collections/CollectionRegistry.ts

@@ -172,8 +172,19 @@ export class CollectionRegistry {
         const mergedRelationsRaw = [...extractedRelations];
         for (const manual of manualRelations) {
             const name = manual.relationName;
-            if (!name || !mergedRelationsRaw.find(r => r.relationName === name)) {
+            if (!name) {
                 mergedRelationsRaw.push(manual);
+            } else {
+                const existingIndex = mergedRelationsRaw.findIndex(r => r.relationName === name);
+                if (existingIndex === -1) {
+                    mergedRelationsRaw.push(manual);
+                } else {
+                    // Merge manual into existing, preserving custom fields like 'collection'
+                    mergedRelationsRaw[existingIndex] = {
+                        ...manual,
+                        ...mergedRelationsRaw[existingIndex]
+                    };
+                }
             }
         }
 

package/src/collections/default-collections.ts

@@ -0,0 +1,79 @@
+import { PostgresCollection } from "@rebasepro/types";
+
+/**
+ * Default users collection definition.
+ *
+ * Shared between the admin UI (for navigation/display) and the backend
+ * (for schema generation). Both consumers prepend this to the developer's
+ * collections array and rely on generic slug-based deduplication
+ * (Map keyed by slug, last-write-wins) so that developer-defined
+ * collections with the same slug override this default — no hardcoded
+ * string checks required.
+ */
+export const defaultUsersCollection: PostgresCollection = {
+    name: "Users",
+    singularName: "User",
+    slug: "users",
+    table: "users",
+    schema: "rebase",
+    icon: "Users",
+    group: "Settings",
+    properties: {
+        id: {
+            name: "ID",
+            type: "string",
+            isId: "uuid"
+        },
+        email: {
+            name: "Email",
+            type: "string",
+            validation: { required: true, unique: true }
+        },
+        password_hash: {
+            name: "Password Hash",
+            type: "string",
+            ui: { hideFromCollection: true }
+        },
+        display_name: {
+            name: "Display Name",
+            type: "string"
+        },
+        photo_url: {
+            name: "Photo URL",
+            type: "string"
+        },
+        email_verified: {
+            name: "Email Verified",
+            type: "boolean",
+            defaultValue: false
+        },
+        email_verification_token: {
+            name: "Email Verification Token",
+            type: "string",
+            ui: { hideFromCollection: true }
+        },
+        email_verification_sent_at: {
+            name: "Email Verification Sent At",
+            type: "date",
+            ui: { hideFromCollection: true }
+        },
+        metadata: {
+            name: "Metadata",
+            type: "map",
+            defaultValue: {},
+            ui: { hideFromCollection: true }
+        },
+        created_at: {
+            name: "Created At",
+            type: "date",
+            autoValue: "on_create",
+            ui: { readOnly: true, hideFromCollection: true }
+        },
+        updated_at: {
+            name: "Updated At",
+            type: "date",
+            autoValue: "on_update",
+            ui: { readOnly: true, hideFromCollection: true }
+        }
+    }
+};

package/src/collections/index.ts

@@ -1 +1,2 @@
 export * from "./CollectionRegistry";
+export * from "./default-collections";

package/src/data/buildRebaseData.ts

@@ -11,6 +11,7 @@ import {
     WhereFieldValue
 } from "@rebasepro/types";
 import { toSnakeCase } from "@rebasepro/utils";
+import { QueryBuilder } from "./query_builder";
 
 /**
  * Convert where-clause filter object to the internal DataDriver FilterValues format.
@@ -129,14 +130,11 @@ function parseOrderBy(orderBy?: string): [string, "asc" | "desc"] | undefined {
     return [field, direction];
 }
 
-/**
- * Create a CollectionAccessor that delegates to a DataDriver for a given collection slug.
- */
 function createDriverAccessor<M extends Record<string, unknown> = Record<string, unknown>>(
     driver: DataDriver,
     slug: string
 ): CollectionAccessor<M> {
-    return {
+    const accessor: CollectionAccessor<M> = {
         async find(params?: FindParams): Promise<FindResponse<M>> {
             const orderParsed = parseOrderBy(params?.orderBy);
             const entities = await driver.fetchCollection<M>({
@@ -237,8 +235,30 @@ values: {} as Record<string, unknown> }
                     onUpdate: (entity) => onUpdate(entity ?? undefined),
                     onError
                 });
-            } : undefined
+            } : undefined,
+
+        // Fluent Query Builder
+        where(column: keyof M & string, operator: WhereFilterOp, value: unknown) {
+            return new QueryBuilder<M>(accessor).where(column, operator, value);
+        },
+        orderBy(column: keyof M & string, ascending?: "asc" | "desc") {
+            return new QueryBuilder<M>(accessor).orderBy(column, ascending);
+        },
+        limit(count: number) {
+            return new QueryBuilder<M>(accessor).limit(count);
+        },
+        offset(count: number) {
+            return new QueryBuilder<M>(accessor).offset(count);
+        },
+        search(searchString: string) {
+            return new QueryBuilder<M>(accessor).search(searchString);
+        },
+        include(...relations: string[]) {
+            return new QueryBuilder<M>(accessor).include(...relations);
+        }
     };
+
+    return accessor;
 }
 
 /**

package/src/data/query_builder.ts

@@ -0,0 +1,117 @@
+import { FindParams, Entity, FindResponse, CollectionAccessor, QueryBuilderInterface, FilterOperator } from "@rebasepro/types";
+
+/**
+ * Maps standard operators to Rebase backend's string-based operators
+ */
+function mapOperator(op: FilterOperator): string {
+    switch (op) {
+        case "==": return "eq";
+        case "!=": return "neq";
+        case ">": return "gt";
+        case ">=": return "gte";
+        case "<": return "lt";
+        case "<=": return "lte";
+        case "array-contains": return "cs";
+        case "array-contains-any": return "csa";
+        case "not-in": return "nin";
+        default: return op;
+    }
+}
+
+export class QueryBuilder<M extends Record<string, unknown> = Record<string, unknown>> implements QueryBuilderInterface<M> {
+    private params: FindParams = { where: {} };
+
+    constructor(private collection: CollectionAccessor<M>) {}
+
+    /**
+     * Add a filter condition to your query.
+     * @example
+     * client.collection('users').where('age', '>=', 18).find()
+     */
+    where(column: keyof M & string, operator: FilterOperator, value: unknown): this {
+        if (!this.params.where) {
+            this.params.where = {};
+        }
+
+        const mappedOp = mapOperator(operator);
+        let formattedValue = value;
+
+        // Handle arrays for in, nin, cs, csa
+        if (Array.isArray(value) && ["in", "nin", "cs", "csa"].includes(mappedOp)) {
+            formattedValue = `(${value.join(",")})`;
+        } else if (value === null) {
+            formattedValue = "null";
+        }
+
+        this.params.where[column] = mappedOp === "eq" ? String(formattedValue) : `${mappedOp}.${formattedValue}`;
+        return this;
+    }
+
+    /**
+     * Order the results by a specific column.
+     * @example
+     * client.collection('users').orderBy('createdAt', 'desc').find()
+     */
+    orderBy(column: keyof M & string, ascending: "asc" | "desc" = "asc"): this {
+        this.params.orderBy = `${column}:${ascending}`;
+        return this;
+    }
+
+    /**
+     * Limit the number of results returned.
+     */
+    limit(count: number): this {
+        this.params.limit = count;
+        return this;
+    }
+
+    /**
+     * Skip the first N results.
+     */
+    offset(count: number): this {
+        this.params.offset = count;
+        return this;
+    }
+
+    /**
+     * Set a free-text search string if supported by the backend.
+     */
+    search(searchString: string): this {
+        this.params.searchString = searchString;
+        return this;
+    }
+
+    /**
+     * Include related entities in the response.
+     * Relations will be populated with full entity data instead of just IDs.
+     *
+     * @param relations - Relation names to include, or "*" for all.
+     * @example
+     * // Include specific relations
+     * client.data.posts.include("tags", "author").find()
+     *
+     * // Include all relations
+     * client.data.posts.include("*").find()
+     */
+    include(...relations: string[]): this {
+        this.params.include = relations;
+        return this;
+    }
+
+    /**
+     * Execute the find query and return the results.
+     */
+    async find(): Promise<FindResponse<M>> {
+        return this.collection.find(this.params) as Promise<FindResponse<M>>;
+    }
+
+    /**
+     * Listen to realtime updates matching this query.
+     */
+    listen(onUpdate: (data: FindResponse<M>) => void, onError?: (error: Error) => void): () => void {
+        if (!this.collection.listen) {
+            throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
+        }
+        return this.collection.listen(this.params, onUpdate, onError);
+    }
+}

package/src/index.ts

@@ -1,3 +1,5 @@
 export * from "./util";
 export * from "./collections";
 export * from "./data/buildRebaseData";
+export * from "./data/query_builder";
+

package/src/util/permissions.ts

@@ -135,7 +135,7 @@ function evaluateRule<USER extends User, M extends Record<string, unknown>>(rule
     return true;
 }
 
-function checkOperation<M extends Record<string, unknown>, USER extends User>(
+export function checkOperation<M extends Record<string, unknown>, USER extends User>(
     collection: EntityCollection<M>,
     authController: AuthController<USER>,
     entity: Entity<M> | null,

package/src/util/relations.ts

@@ -33,6 +33,8 @@ export function sanitizeRelation(
         } else {
             targetCollection = evaluated;
         }
+    } else if (rawTarget && typeof rawTarget === "object") {
+        targetCollection = rawTarget as EntityCollection;
     }
 
     if (!targetCollection) {
@@ -215,11 +217,15 @@ export function resolveCollectionRelations(
     //    Each relation is stored once under its canonical relationName key.
     if (relCollection.relations) {
         relCollection.relations.forEach((relation: Relation) => {
-            const normalizedRelation = sanitizeRelation(relation, collection);
-            const relationKey = normalizedRelation.relationName;
-            if (relationKey) {
-                relations[relationKey] = normalizedRelation;
-                registeredRelationNames.add(relationKey);
+            try {
+                const normalizedRelation = sanitizeRelation(relation, collection);
+                const relationKey = normalizedRelation.relationName;
+                if (relationKey) {
+                    relations[relationKey] = normalizedRelation;
+                    registeredRelationNames.add(relationKey);
+                }
+            } catch (e) {
+                // Ignore incomplete or invalid relations (e.g. missing target during registry setup)
             }
         });
     }
@@ -274,7 +280,8 @@ export function resolvePropertyRelation({
 
     const relProp = property as RelationProperty;
 
-    // 1. If the property has inline config (target set), build a Relation from it
+    // If the property has inline config (target set), build a Relation from it.
+    // We only support the flat format where properties are directly on the RelationProperty.
     if (relProp.target) {
         return {
             relationName: relProp.relationName || propertyKey,
@@ -292,15 +299,8 @@ export function resolvePropertyRelation({
         } as Relation;
     }
 
-    // 2. Fall back to lookup from collection.relations[] (backward compat)
-    const relation = (((sourceCollection as CollectionWithRelations).relations) ?? []).find((rel: Relation) => rel.relationName === relProp.relationName)
-    if (!relation) {
-        console.warn(`Unrecognized relation format for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
-        return undefined;
-    }
-
-    return relation as Relation;
-
+    console.warn(`Unrecognized or missing relation target for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
+    return undefined;
 }
 
 export function getTableName(collection: EntityCollection): string {

package/src/util/resolutions.ts

@@ -21,6 +21,7 @@ import { enumToObjectEntries } from "./enums";
 import { DEFAULT_ONE_OF_TYPE } from "./common";
 import { isDefaultFieldConfigId } from "@rebasepro/utils";
 import { getIn, mergeDeep } from "@rebasepro/utils";
+import { resolveCollectionRelations } from "./relations";
 
 /**
  * Resolve property builders, enums and arrays.
@@ -350,8 +351,10 @@ export function getSubcollections<M extends Record<string, unknown> = Record<str
         return (collection as CollectionWithSubcollections).subcollections!() ?? [];
     }
 
-    if (getDataSourceCapabilities(collection.driver).supportsRelations && ((collection as CollectionWithRelations).relations)) {
-        const manyRelations = ((collection as CollectionWithRelations).relations)!.filter((r: Relation) => r.cardinality === "many");
+    if (getDataSourceCapabilities(collection.driver).supportsRelations) {
+        const resolvedRelations = resolveCollectionRelations(collection);
+        const manyRelations = Object.values(resolvedRelations).filter((r: Relation) => r.cardinality === "many");
+        
         return manyRelations.map((r: Relation) => {
             const target = r.target();
             if (!target) return undefined;

package/src/collections/CollectionRegistry.d.ts

@@ -1,56 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-export declare class CollectionRegistry {
-    private collectionsByTableName;
-    private collectionsBySlug;
-    private rootCollections;
-    private cachedCollectionsList;
-    private rawCollectionsByTableName;
-    private rawCollectionsBySlug;
-    private rawRootCollections;
-    private cachedRawCollectionsList;
-    private lastRawInputSnapshot;
-    constructor(collections?: EntityCollection[]);
-    reset(): void;
-    /**
-     * Registers a collection and its subcollections recursively.
-     * Returns true if the collections have changed, false otherwise.
-     *
-     * Idempotent: compares the raw input (before normalization) against a stored
-     * snapshot. Only re-normalizes and re-registers when the raw input actually changed.
-     * @param collections
-     */
-    registerMultiple(collections: EntityCollection[]): boolean;
-    register(collection: EntityCollection, rawCollection?: EntityCollection): void;
-    private _registerRecursively;
-    normalizeCollection(collection: EntityCollection): EntityCollection;
-    /**
-     * Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
-     * This allows developers to define relations directly on properties without a separate
-     * `relations[]` entry on the collection.
-     */
-    private extractRelationsFromProperties;
-    private normalizeProperties;
-    private normalizeProperty;
-    get(path: string): EntityCollection | undefined;
-    /**
-     * Gets the pristine, un-normalized collection exactly as it was provided.
-     * Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
-     */
-    getRaw(path: string): EntityCollection | undefined;
-    /**
-     * Get collection by resolving multi-segment paths through relations
-     * e.g., "authors/70/posts" resolves to the posts collection
-     */
-    getCollectionByPath(collectionPath: string): EntityCollection | undefined;
-    getCollections(): EntityCollection[];
-    getRawCollections(): EntityCollection[];
-    /**
-     * Resolves a multi-segment path like "products/123/locales" and returns
-     * information about the collections and entity IDs along the path
-     */
-    resolvePathToCollections(path: string): {
-        collections: EntityCollection[];
-        entityIds: (string | number)[];
-        finalCollection: EntityCollection;
-    };
-}

package/src/collections/index.d.ts

@@ -1 +0,0 @@
-export * from "./CollectionRegistry";

package/src/data/buildRebaseData.d.ts

@@ -1,14 +0,0 @@
-import { DataDriver, RebaseData } from "@rebasepro/types";
-/**
- * Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
- *
- * This is the key bridge: any property access like `data.products` returns
- * a `CollectionAccessor` backed by the underlying DataDriver, without
- * needing per-collection code generation.
- *
- * @example
- * const data = buildRebaseData(driver);
- * await data.products.create({ name: "Camera", price: 299 });
- * const { data: items } = await data.products.find({ where: { status: "eq.published" } });
- */
-export declare function buildRebaseData(driver: DataDriver): RebaseData;

package/src/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./util";
-export * from "./collections";
-export * from "./data/buildRebaseData";

package/src/util/builders.d.ts

@@ -1,57 +0,0 @@
-import { AdditionalFieldDelegate, ArrayProperty, BooleanProperty, DateProperty, EntityCallbacks, EntityCollection, EnumValueConfig, EnumValues, GeopointProperty, MapProperty, NumberProperty, Properties, Property, ReferenceProperty, StringProperty, User } from "@rebasepro/types";
-/**
- * Identity function we use to defeat the type system of Typescript and build
- * collection views with all its properties
- * @param collection
- * @group Builder
- */
-export declare function buildCollection<M extends Record<string, unknown> = Record<string, unknown>, USER extends User = User>(collection: EntityCollection<M, USER>): EntityCollection<M, USER>;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the property keys.
- * @param property
- * @group Builder
- */
-export declare function buildProperty<T, P extends Property = Property>(property: P): P extends StringProperty ? StringProperty : P extends NumberProperty ? NumberProperty : P extends BooleanProperty ? BooleanProperty : P extends DateProperty ? DateProperty : P extends GeopointProperty ? GeopointProperty : P extends ReferenceProperty ? ReferenceProperty : P extends ArrayProperty ? ArrayProperty : P extends MapProperty ? MapProperty : never;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param properties
- * @group Builder
- */
-export declare function buildProperties<M extends Record<string, unknown>>(properties: Properties): Properties;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param propertiesOrBuilder
- * @group Builder
- */
-export declare function buildPropertiesOrBuilder<M extends Record<string, unknown>>(propertiesOrBuilder: Properties): Properties;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param enumValues
- * @group Builder
- */
-export declare function buildEnum(enumValues: EnumValues): EnumValues;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param enumValueConfig
- * @group Builder
- */
-export declare function buildEnumValueConfig(enumValueConfig: EnumValueConfig): EnumValueConfig;
-/**
- * Identity function we use to defeat the type system of Typescript and preserve
- * the properties keys.
- * @param callbacks
- * @group Builder
- */
-export declare function buildEntityCallbacks<M extends Record<string, unknown> = Record<string, unknown>>(callbacks: EntityCallbacks<M>): EntityCallbacks<M>;
-/**
- * Identity function we use to defeat the type system of Typescript and build
- * additional field delegates views with all its properties
- * @param additionalFieldDelegate
- * @group Builder
- */
-export declare function buildAdditionalFieldDelegate<M extends Record<string, unknown>, USER extends User = User>(additionalFieldDelegate: AdditionalFieldDelegate<M, USER>): AdditionalFieldDelegate<M, USER>;

package/src/util/callbacks.d.ts

@@ -1,6 +0,0 @@
-import { EntityCallbacks, Properties } from "@rebasepro/types";
-/**
- * Helper function to extract field-level PropertyCallbacks from a properties schema
- * and wrap them into an EntityCallbacks object recursively.
- */
-export declare const buildPropertyCallbacks: (properties: Properties) => EntityCallbacks | undefined;

package/src/util/collections.d.ts

@@ -1,11 +0,0 @@
-import { DefaultSelectedViewBuilder, DefaultSelectedViewParams, EntityCollection, Properties } from "@rebasepro/types";
-export declare function sortProperties<M extends Record<string, unknown>>(properties: Properties, propertiesOrder?: string[]): Properties;
-export declare function resolveDefaultSelectedView(defaultSelectedView: string | DefaultSelectedViewBuilder | undefined, params: DefaultSelectedViewParams): string | undefined;
-export declare function getLocalChangesBackup(collection: EntityCollection): "manual_apply" | "auto_apply";
-/**
- * Returns the primary keys for an entity collection by inspecting the properties
- * and finding any properties with `isId`.
- * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
- * @param collection
- */
-export declare function getPrimaryKeys<M extends Record<string, unknown>>(collection: EntityCollection<M>): Extract<keyof M, string>[];

package/src/util/common.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_ONE_OF_TYPE = "type";
-export declare const DEFAULT_ONE_OF_VALUE = "value";

package/src/util/conditions.d.ts

@@ -1,26 +0,0 @@
-import { AuthController, ConditionContext, JsonLogicRule, Property } from "@rebasepro/types";
-/**
- * Register custom JSON Logic operations for Rebase.
- * Call this once at app initialization.
- */
-export declare function registerConditionOperations(): void;
-/**
- * Evaluate a JSON Logic rule against the given context.
- */
-export declare function evaluateCondition(rule: JsonLogicRule, context: ConditionContext): unknown;
-/**
- * Build a ConditionContext from the current property resolution context.
- */
-export declare function buildConditionContext(params: {
-    propertyKey?: string;
-    values?: Record<string, unknown>;
-    previousValues?: Record<string, unknown>;
-    path: string;
-    entityId?: string;
-    index?: number;
-    authController: AuthController;
-}): ConditionContext;
-/**
- * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
- */
-export declare function applyPropertyConditions(property: Property, context: ConditionContext): Property;

package/src/util/entities.d.ts

@@ -1,58 +0,0 @@
-import { DataType, Entity, EntityReference, EntityRelation, EntityStatus, EntityValues, Properties, Property } from "@rebasepro/types";
-export declare function isReadOnly(property: Property): boolean;
-export declare function isHidden(property: Property): boolean;
-export declare function isPropertyBuilder(property?: Property): boolean;
-export declare function getDefaultValuesFor<M extends Record<string, unknown>>(properties: Properties): Partial<EntityValues<M>>;
-export declare function getDefaultValueFor(property?: Property): unknown;
-export declare function getDefaultValueFortype(type: DataType): unknown;
-/**
- * Update the automatic values in an entity before save
- * @group Driver
- */
-export declare function updateDateAutoValues<M extends Record<string, unknown>>({ inputValues, properties, status, timestampNowValue }: {
-    inputValues: Partial<EntityValues<M>>;
-    properties: Properties;
-    status: EntityStatus;
-    timestampNowValue: unknown;
-}): EntityValues<M>;
-/**
- * Add missing required fields, expected in the collection, to the values of an entity
- * @param values
- * @param properties
- * @group Driver
- */
-export declare function sanitizeData<M extends Record<string, unknown>>(values: EntityValues<M>, properties: Properties): Record<string, unknown>;
-export declare function getReferenceFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityReference;
-export declare function getRelationFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityRelation;
-/**
- * Normalize a value into a proper EntityRelation instance.
- * Handles EntityRelation class instances, and plain objects
- * with `__type === "relation"` or an `isEntityRelation()` method.
- *
- * Returns null if the value cannot be coerced.
- */
-export declare function normalizeToEntityRelation(value: unknown): EntityRelation | null;
-export declare function traverseValuesProperties<M extends Record<string, unknown>>(inputValues: Partial<EntityValues<M>>, properties: Properties, operation: (value: unknown, property: Property) => unknown): EntityValues<M> | undefined;
-export declare function traverseValueProperty(inputValue: unknown, property: Property, operation: (value: unknown, property: Property) => unknown): unknown;
-/**
- * Relation reference types used throughout the server layer.
- * These replace the 50+ manual `{ id, path, __type: "relation" }` constructions.
- */
-export interface RelationRef {
-    readonly id: string | number;
-    readonly path: string;
-    readonly __type: "relation";
-}
-export interface RelationRefWithData extends RelationRef {
-    readonly data: Entity;
-}
-/**
- * Create a lightweight relation stub for CMS views.
- * Replaces inline `{ id, path, __type: "relation" }` object literals.
- */
-export declare function createRelationRef(id: string | number, path: string): RelationRef;
-/**
- * Create a hydrated relation reference that includes the full entity data.
- * Used when entity data has been pre-fetched (e.g., via batch loading or JOINs).
- */
-export declare function createRelationRefWithData(id: string | number, path: string, data: Entity): RelationRefWithData;