@webda/models 0.0.0-stage → 4.0.0-beta.3

package/lib/relations.d.ts

@@ -0,0 +1,705 @@
+import { FilterAttributes, ArrayElement } from "@webda/tsc-esm";
+import { PrimaryKeyType, Storable, PrimaryKey, AttributesArgument, PrimaryKeyAttributes, WEBDA_PRIMARY_KEY, ModelClass } from "./storable.js";
+import type { JSONed, Helpers, PropertyPaths, PropertyPathType, NumericPropertyPaths } from "./types.js";
+import type { Repository } from "./repositories/repository.js";
+import type { QueryParameters, WebdaQLString } from "@webda/ql";
+/** Symbol key holding the parent Storable of a relation. */
+/** Symbol key holding the primary key value of a relation target. */
+export declare const RelationKey: unique symbol;
+/** Symbol key holding the repository used to resolve a relation. */
+export declare const RelationRepository: unique symbol;
+/** Symbol key identifying the role of a relation (Link, Related, Links, CustomLinks). */
+export declare const RelationRole: unique symbol;
+/** Symbol key holding custom data on a ModelRefCustom. */
+export declare const RelationData: unique symbol;
+/** Symbol key holding the model. */
+export declare const RelationModel: unique symbol;
+/** Symbol key holding the type of custom attributes on a ModelLinksArray. */
+export declare const RelationAttributes: unique symbol;
+/**
+ * Assign non symbol properties from source to target
+ * @param target - the destination object
+ * @param source - the source object
+ */
+export declare function assignNonSymbols(target: any, source: any): void;
+/**
+ * A reference to a model
+ */
+export declare class ModelRef<T extends Storable> {
+    [RelationKey]?: PrimaryKeyType<T>;
+    [RelationRepository]?: Repository<ModelClass<T>>;
+    /**
+     * Create a new model reference
+     * @param key - Primary key of the referenced model
+     * @param repository - Repository to resolve the reference against
+     * @param parent - Parent storable that owns this reference
+     */
+    constructor(key: PrimaryKeyType<T>, repository?: Repository<ModelClass<T>>, parent?: Storable);
+    /**
+     * Get the repository and ensure it's initialized
+     * @returns the repository instance
+     */
+    protected getRepository(): Repository<ModelClass<T>>;
+    /**
+     * Get the primary key and ensure it's initialized
+     * @returns the primary key value
+     */
+    protected getKey(): PrimaryKeyType<T>;
+    /**
+     * Get the model
+     * @returns the primary key value
+     */
+    getPrimaryKey(): PrimaryKeyType<T>;
+    /**
+     * Serialize the reference to its primary key value
+     * @returns the primary key value
+     */
+    toJSON(): PrimaryKeyType<T>;
+    /**
+     * Set the attribute of the model
+     * @param attribute - the attribute path to set
+     * @param value - the new attribute value
+     * @returns a promise resolving when complete
+     */
+    setAttribute<A extends PropertyPaths<T>>(attribute: A, value: JSONed<PropertyPathType<T, A>>): Promise<void>;
+    /**
+     * Patch the model
+     * @param data - the partial data to patch
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    patch<K extends keyof T, A extends PropertyPaths<T>>(data: Partial<Omit<T, PrimaryKeyAttributes<T>>>, conditionField?: A, condition?: PropertyPathType<T, A>): Promise<void>;
+    /**
+     * Fully replace the model data (except primary key fields)
+     * @param data - Complete model data excluding primary key
+     * @param conditionField - Optional field for optimistic locking
+     * @param condition - Expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    update<A extends PropertyPaths<T>>(data: Omit<Helpers<T>, PrimaryKeyAttributes<T>>, conditionField?: A, condition?: PropertyPathType<T, A>): Promise<void>;
+    /**
+     * Get the model referenced by the key
+     * @returns the resolved model instance
+     */
+    get(): Promise<T>;
+    /**
+     * Delete the model
+     *
+     * If a condition is specified, it will be used to check if the model can be deleted
+     *
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    delete<A extends PropertyPaths<T>>(conditionField?: A, condition?: PropertyPathType<T, A> | JSONed<PropertyPathType<T, A>>): Promise<void>;
+    /**
+     * Check if the model exists in the repository
+     * @returns true if the model exists
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Increment the attributes of the model
+     * @param info The attributes to increment
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    incrementAttributes(info: (NumericPropertyPaths<T> | {
+        property: NumericPropertyPaths<T>;
+        value?: number;
+    })[] | Record<NumericPropertyPaths<T>, number>, conditionField?: PropertyPaths<T>, condition?: PropertyPathType<T, PropertyPaths<T>>): Promise<void>;
+    /**
+     * Add an item to a collection
+     * @param collection - the collection field name
+     * @param item - the item to add or update
+     * @param index - optional position to insert at
+     * @param itemWriteConditionField - optional field for item write condition
+     * @param itemWriteCondition - expected value for the item write condition
+     * @returns a promise resolving when complete
+     */
+    upsertItemToCollection<K extends Extract<PropertyPaths<T, any[]>, keyof T>, L extends keyof ArrayElement<T[K]>>(collection: K, item: ArrayElement<T[K]> | JSONed<ArrayElement<T[K]>>, index?: number, itemWriteConditionField?: ArrayElement<T[K]> extends object ? L : never, itemWriteCondition?: ArrayElement<T[K]> extends object ? ArrayElement<T[K]>[L] : ArrayElement<T[K]> | null): Promise<void>;
+    /**
+     * Remove an item from a collection
+     * @param collection - the collection field name
+     * @param index - the position to remove from
+     * @param itemWriteConditionField - optional field for item write condition
+     * @param itemWriteCondition - expected value for the item write condition
+     * @returns a promise resolving when complete
+     */
+    deleteItemFromCollection<K extends Extract<PropertyPaths<T, any[]>, keyof T>, L extends keyof ArrayElement<T[K]>>(collection: K, index: number, itemWriteConditionField?: L, itemWriteCondition?: ArrayElement<T[K]>[L]): Promise<void>;
+    /**
+     * Remove an attribute from the model
+     * @param attribute - the attribute to remove
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    removeAttribute<A extends PropertyPaths<T>>(attribute: Exclude<PropertyPaths<T>, PrimaryKeyAttributes<T>>, conditionField?: A, condition?: PropertyPathType<T, A>): Promise<void>;
+    /**
+     * Increment only one attribute of the model
+     * @param property - the numeric property to increment
+     * @param value - the increment amount
+     * @param conditionField - optional field for optimistic locking
+     * @param condition - expected value for the condition field
+     * @returns a promise resolving when complete
+     */
+    incrementAttribute(property: NumericPropertyPaths<T>, value?: number, conditionField?: PropertyPaths<T>, condition?: PropertyPathType<T, PropertyPaths<T>>): Promise<void>;
+}
+/**
+ * Union of all relation property keys on a model (both ModelRelated and ModelLinker fields).
+ */
+export type ModelRelations<T extends object> = FilterAttributes<T, ModelRelated<any, any, any>> | FilterAttributes<T, ModelLinker>;
+/**
+ * Model reference with create and upsert methods
+ */
+export declare class ModelRefWithCreate<T extends Storable> extends ModelRef<T> {
+    /**
+     * Upsert a model reference
+     * @param data - the model data excluding primary key
+     * @returns the upserted model instance
+     */
+    upsert(data: Omit<JSONed<T>, T[typeof WEBDA_PRIMARY_KEY][number]>): Promise<T>;
+    /**
+     * Create a model reference
+     *
+     * It will fail if the model already exists
+     * @param data - the model data excluding primary key
+     * @returns the created model instance
+     */
+    create(data: Omit<AttributesArgument<T>, T[typeof WEBDA_PRIMARY_KEY][number]>): Promise<T>;
+}
+/**
+ * Define a 1:n relation on the current model to another model
+ *
+ * T is the model to link to
+ * _K is the attribute in T to query
+ *
+ * _K is not used but is required to complete the graph
+ * _K define the attribute to use to load the related objects
+ *
+ * In SQL if current model is TableA and T is TableB, _K is the foreign key in TableB
+ *
+ * TODO Deduce attribute from the ModelParent on the other side when "" is used
+ */
+export declare class ModelRelated<T extends Storable, L extends Storable, K extends Extract<FilterAttributes<T, ModelLinker<L>>, string> | "" = ""> {
+    private object;
+    private attribute;
+    private repoSource;
+    /** Create a new ModelRelated
+     * @param targetClass - the target model class
+     * @param object - the source object owning the relation
+     * @param attribute - the attribute name linking the relation
+     */
+    constructor(targetClass: ModelClass<T>, object: L, attribute?: K);
+    /**
+     * Build a WebdaQL query string that filters related objects by this model's primary key.
+     * @param query - optional additional query filter
+     * @returns the constructed query string
+     */
+    getQuery(query?: WebdaQLString<T> | string): WebdaQLString<T>;
+    /**
+     * Query the related objects
+     * @param query - optional additional query filter, optionally with `?` or `:name` placeholders
+     * @param params - values for the placeholders: an array for `?`, an object for `:name`
+     * @returns the query results with optional continuation token
+     */
+    query(query?: WebdaQLString<T>, params?: QueryParameters): Promise<{
+        results: T[];
+        continuationToken?: string;
+    }>;
+    /**
+     * Iterate through linked objects
+     * @param query - the query filter, optionally with `?` or `:name` placeholders
+     * @param params - values for the placeholders: an array for `?`, an object for `:name`
+     * @returns an async iterable of linked objects
+     */
+    iterate(query: WebdaQLString<T>, params?: QueryParameters): AsyncIterable<T>;
+    /**
+     * It is a helper and should not be serialized
+     */
+    toJSON(): void;
+}
+/**
+ * Marker interface for relation properties.
+ *
+ * All relation types (ModelLink, ModelLinksSimpleArray, ModelLinksArray) implement this
+ * so they can be detected and filtered at the type level.
+ *
+ * @typeParam T - The target Storable type
+ * @typeParam K - The relation role identifier
+ */
+export interface ModelLinker<T extends Storable = any, K extends "Link" | "Related" | "Links" | "CustomLinks" = any> {
+    readonly [RelationRole]: K;
+}
+/**
+ * Define a link to n:1 or 1:1 relation on the current model to another model
+ *
+ * T is the model to link to
+ *
+ * This is expected to be the symetric of ModelRelated or ModelLink in a 1:1 relation
+ *
+ * ```
+ * class Album extends Model {
+ *  artist: ModelLink<Artist>;
+ * }
+ * ```
+ */
+export declare class ModelLink<T extends Storable> implements ModelLinker {
+    readonly [RelationRole]: "Link";
+    protected [RelationKey]: PrimaryKeyType<T>;
+    readonly [RelationModel]: ModelClass<T>;
+    /** Create a new ModelLink
+     * @param model - the model class to link to
+     */
+    constructor(
+    /**
+     * The repository of the object to link
+     */
+    model: ModelClass<T>);
+    /**
+     * Resolve the link and fetch the target model from the repository
+     * @returns the linked model instance
+     */
+    get(): Promise<T>;
+    /**
+     * Update the link to point to a different target
+     * @param id - New target: a primary key, model instance, or string UID
+     * @returns this link instance
+     * @WebdaAutoSetter
+     */
+    set(id: PrimaryKeyType<T> | T | string): this;
+    /**
+     * Return the string representation of the linked key
+     * @returns the string representation
+     */
+    toString(): string;
+    /**
+     * Serialize the link to its primary key value
+     * @returns the primary key value
+     */
+    toJSON(): PrimaryKeyType<T>;
+    /**
+     * Get the primary key of the linked model
+     * @returns the primary key value
+     */
+    getPrimaryKey(): PrimaryKeyType<T>;
+}
+/**
+ * Define the parent of the model
+ *
+ * Similar to @ModelLink but implies a Cascade delete
+ */
+export type ModelParent<T extends Storable> = ModelLink<T>;
+/**
+ * Link to a collection of objects
+ *
+ * Uses composition instead of extending Array for better maintainability,
+ * performance, and type safety.
+ *
+ * This allows to do a n:m or 1:n relation between two models
+ *
+ * It does not require to have a symetric relation on the other side
+ * The array contains uuid of the linked objects
+ */
+export declare class ModelLinksSimpleArray<T extends Storable> implements ModelLinker {
+    [RelationRole]: "Links";
+    [RelationAttributes]: object;
+    protected [RelationRepository]: Repository<ModelClass<T>>;
+    private items;
+    /** Create a new ModelLinksSimpleArray
+     * @param model - the model class for linked items
+     * @param content - initial array of primary keys
+     * @param parentObject - optional parent object owning this relation
+     */
+    constructor(model: ModelClass<T>, content?: PrimaryKeyType<T>[], parentObject?: T);
+    /**
+     * Add items to the end of the collection
+     * @param items - items to add
+     * @returns the new collection length
+     */
+    push(...items: (string | PrimaryKeyType<T> | ModelRef<T> | T)[]): number;
+    /**
+     * Add items to the beginning of the collection
+     * @param items - items to prepend
+     * @returns the new collection length
+     */
+    unshift(...items: (string | PrimaryKeyType<T> | ModelRef<T> | T)[]): number;
+    /**
+     * Remove and return the last item
+     * @returns the removed item, or undefined
+     */
+    pop(): ModelRef<T> | undefined;
+    /**
+     * Remove and return the first item
+     * @returns the removed item, or undefined
+     */
+    shift(): ModelRef<T> | undefined;
+    /**
+     * Remove/add items at specified index
+     * @param start - the start index
+     * @param deleteCount - number of items to remove
+     * @param rest - items to insert
+     * @returns the removed items
+     */
+    splice(start: number, deleteCount?: number, ...rest: (string | PrimaryKeyType<T> | ModelRef<T> | T)[]): ModelRef<T>[];
+    /**
+     * Add a model to the collection
+     * @param model - the model to add
+     * @deprecated use push instead
+     */
+    add(model: string | PrimaryKeyType<T> | ModelRef<T> | T): void;
+    /**
+     * Set the collection to a new set of items
+     * @param items - the new items to set
+     * @WebdaAutoSetter
+     */
+    set(items?: (string | PrimaryKeyType<T> | ModelRef<T> | T)[]): void;
+    /**
+     * Remove item by reference or primary key
+     * @param model - the item to remove
+     * @returns true if the item was found and removed
+     */
+    remove(model: string | ModelRef<T> | PrimaryKeyType<T> | T): boolean;
+    /**
+     * Get the number of items
+     * @returns the item count
+     */
+    get length(): number;
+    /**
+     * Get item at index
+     * @param index - the array index
+     * @returns the item, or undefined
+     */
+    at(index: number): ModelRef<T> | undefined;
+    /**
+     * Find item by predicate
+     * @param predicate - the search predicate
+     * @returns the found item, or undefined
+     */
+    find(predicate: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => boolean): ModelRef<T> | undefined;
+    /**
+     * Find index by predicate
+     * @param predicate - the search predicate
+     * @returns the index, or -1
+     */
+    findIndex(predicate: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => boolean): number;
+    /**
+     * Map over items (does NOT mutate)
+     * @param callback - the mapping function
+     * @returns the mapped array
+     */
+    map<U>(callback: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => U): U[];
+    /**
+     * Filter items (does NOT mutate)
+     * @param predicate - the filter predicate
+     * @returns the filtered items
+     */
+    filter(predicate: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => boolean): ModelRef<T>[];
+    /**
+     * Execute callback for each item
+     * @param callback - the function to execute for each item
+     */
+    forEach(callback: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => void): void;
+    /**
+     * Check if any item matches predicate
+     * @param predicate - the test predicate
+     * @returns true if any item matches
+     */
+    some(predicate: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => boolean): boolean;
+    /**
+     * Check if all items match predicate
+     * @param predicate - the test predicate
+     * @returns true if all items match
+     */
+    every(predicate: (item: ModelRef<T>, index: number, array: ModelRef<T>[]) => boolean): boolean;
+    /**
+     * Convert to JSON
+     * @returns array of primary key values
+     */
+    toJSON(): PrimaryKeyType<T>[];
+    /**
+     * Make the collection iterable (for...of loops)
+     * @returns an iterator over the items
+     */
+    [Symbol.iterator](): Iterator<ModelRef<T>>;
+    /**
+     * Support indexed access like an array
+     */
+    [index: number]: ModelRef<T>;
+    /**
+     * Convert any accepted input (string, key, ref, or model) into a ModelRef
+     * @param model - the input to convert
+     * @returns the model reference
+     */
+    protected getModelRef(model: string | PrimaryKeyType<T> | ModelRef<T> | T): ModelRef<T>;
+    /**
+     * Mark the parent model's property for this collection as dirty
+     */
+    protected setDirty(): void;
+}
+/** A ModelRef augmented with custom properties K, exposing them both at runtime and in JSON. */
+type ModelRefCustomProperties<T extends Storable, K extends object> = ModelRef<T> & {
+    [key in keyof K]: K[key];
+} & {
+    toJSON(): JSONed<K> & PrimaryKey<T>;
+};
+/**
+ * ModelRef with custom properties
+ *
+ * This is used to define a link to a collection of objects with additional data
+ *
+ * It does not require to have a symetric relation on the other side
+ * The array contains uuid of the linked objects and additional properties defined as K
+ *
+ * Sample usage:
+ * ```typescript
+ * class MyModel extends AbstractCoreModel {
+ *   _links: ModelLinksArray<OtherModel, { custom: string }>;
+ * }
+ * ```
+ */
+declare class ModelRefCustom<T extends Storable, K> extends ModelRef<T> {
+    protected [RelationData]: K;
+    /** Create a new ModelRefCustom
+     * @param key - the primary key of the referenced object
+     * @param repo - the repository managing the referenced model
+     * @param data - custom data associated with this reference
+     * @param parent - optional parent storable
+     */
+    constructor(key: PrimaryKeyType<T>, repo: Repository<ModelClass<T>>, data: K, parent?: Storable);
+    /**
+     * Override toJSON to include custom properties along with primary key
+     * @returns the relation data
+     */
+    toJSON(): any;
+}
+/**
+ * Link to a collection of objects including some additional data
+ *
+ * Uses composition instead of extending Array for better maintainability,
+ * performance, and type safety. Provides array-like interface through
+ * explicit methods and iterators.
+ *
+ * It does not require to have a symetric relation on the other side
+ * The array contains uuid of the linked objects and additional properties defined as K
+ *
+ * Sample usage:
+ * ```typescript
+ * class MyModel extends AbstractCoreModel {
+ *   _links: ModelLinksArray<OtherModel, { custom: string }>;
+ * }
+ * ```
+ */
+export declare class ModelLinksArray<T extends Storable, K extends object> implements ModelLinker {
+    protected repo: Repository<ModelClass<T>>;
+    [RelationRole]: "CustomLinks";
+    [RelationAttributes]: K;
+    private items;
+    /** Create a new ModelLinksCustomArray
+     * @param repo - the repository for the linked model
+     * @param content - initial array of primary keys with custom data
+     */
+    constructor(repo: Repository<ModelClass<T>>, content?: (PrimaryKey<T> & K)[]);
+    /**
+     * Add a model to the collection
+     * @param model - the model to add
+     * @deprecated use push instead
+     */
+    add(model: JSONed<ModelRefCustomProperties<T, K>>): void;
+    /**
+     * Add items to the end of the collection
+     * @param items - items to add
+     * @returns the new collection length
+     */
+    push(...items: (ModelRefCustomProperties<T, K> | JSONed<ModelRefCustomProperties<T, K>>)[]): number;
+    /**
+     * Remove and return the last item
+     * @returns the removed item, or undefined
+     */
+    pop(): ModelRefCustomProperties<T, K> | undefined;
+    /**
+     * Remove and return the first item
+     * @returns the removed item, or undefined
+     */
+    shift(): ModelRefCustomProperties<T, K> | undefined;
+    /**
+     * Add items to the beginning of the collection
+     * @param items - items to prepend
+     * @returns the new collection length
+     */
+    unshift(...items: (ModelRefCustomProperties<T, K> | JSONed<ModelRefCustomProperties<T, K>>)[]): number;
+    /**
+     * Remove/add items at specified index
+     * @param start - the start index
+     * @param deleteCount - number of items to remove
+     * @param rest - items to insert
+     * @returns the removed items
+     */
+    splice(start: number, deleteCount?: number, ...rest: (ModelRefCustomProperties<T, K> | JSONed<ModelRefCustomProperties<T, K>>)[]): ModelRefCustomProperties<T, K>[];
+    /**
+     * Remove item by reference or primary key
+     * @param model - the item to remove
+     * @returns true if found and removed
+     */
+    remove(model: ModelRefCustomProperties<T, K> | PrimaryKeyType<T> | T): boolean;
+    /**
+     * Get the number of items
+     * @returns the item count
+     */
+    get length(): number;
+    /**
+     * Get item at index
+     * @param index - the array index
+     * @returns the item, or undefined
+     */
+    at(index: number): ModelRefCustomProperties<T, K> | undefined;
+    /**
+     * Find item by predicate
+     * @param predicate - the search predicate
+     * @returns the found item, or undefined
+     */
+    find(predicate: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => boolean): ModelRefCustomProperties<T, K> | undefined;
+    /**
+     * Find index by predicate
+     * @param predicate - the search predicate
+     * @returns the index, or -1
+     */
+    findIndex(predicate: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => boolean): number;
+    /**
+     * Check if item exists in collection
+     * @param search - the item to look for
+     * @param fromIndex - optional start index
+     * @returns true if found
+     */
+    includes(search: ModelRefCustomProperties<T, K>, fromIndex?: number): boolean;
+    /**
+     * Map over items (does NOT mutate)
+     * @param callback - the mapping function
+     * @returns the mapped array
+     */
+    map<U>(callback: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => U): U[];
+    /**
+     * Filter items (does NOT mutate)
+     * @param predicate - the filter predicate
+     * @returns the filtered items
+     */
+    filter(predicate: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => boolean): ModelRefCustomProperties<T, K>[];
+    /**
+     * Execute callback for each item
+     * @param callback - the function to execute for each item
+     */
+    forEach(callback: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => void): void;
+    /**
+     * Check if any item matches predicate
+     * @param predicate - the test predicate
+     * @returns true if any item matches
+     */
+    some(predicate: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => boolean): boolean;
+    /**
+     * Check if all items match predicate
+     * @param predicate - the test predicate
+     * @returns true if all items match
+     */
+    every(predicate: (item: ModelRefCustomProperties<T, K>, index: number, array: ModelRefCustomProperties<T, K>[]) => boolean): boolean;
+    /**
+     * Convert to JSON
+     * @returns array of serialized items
+     */
+    toJSON(): JSONed<ModelRefCustomProperties<T, K>>[];
+    /**
+     * Make the collection iterable (for...of loops)
+     * @returns an iterator over the items
+     */
+    [Symbol.iterator](): Iterator<ModelRefCustomProperties<T, K>>;
+    /**
+     * Support indexed access like an array
+     */
+    [index: number]: ModelRefCustomProperties<T, K>;
+    /**
+     * Convert input into a ModelRefCustom, preserving custom properties
+     * @param model - the input to convert
+     * @returns the model reference with custom properties
+     */
+    protected getModelRef(model: ModelRefCustomProperties<T, K> | JSONed<ModelRefCustomProperties<T, K>>): ModelRefCustomProperties<T, K>;
+    /**
+     * Mark the parent model's property for this collection as dirty
+     */
+    protected setDirty(): void;
+}
+/**
+ * Define a ModelRef with custom properties for map
+ * Exclude the PrimaryKey from the JSON
+ *
+ * @deprecated
+ */
+export declare class ModelRefCustomMap<T extends Storable, K> extends ModelRefCustom<T, K> {
+    /**
+     * Serialize the relation data as a plain object (excluding the primary key).
+     * @returns the relation data
+     */
+    toJSON(): any;
+}
+/** Alias for a many-to-one relation (foreign key link). */
+export type ManyToOne<T extends Storable> = ModelLink<T>;
+/**
+ * Define a 1:n relation on the current model to another model
+ *
+ * This is an helper type that allows to query the related objects with the correct type
+ *
+ * T is the model to link to
+ * K is the attribute in T to query (not used but required to complete the graph)
+ */
+export type OneToMany<T extends Storable, L extends Storable, K extends Extract<FilterAttributes<T, ModelLinker<L>>, string> | ""> = ModelRelated<T, L, K>;
+/** Alias for a one-to-one relation. */
+export type OneToOne<T extends Storable> = ModelLink<T>;
+/**
+ * Alias for a many-to-many relation.
+ * If K (custom properties) is provided, uses ModelLinksArray; otherwise ModelLinksSimpleArray.
+ */
+export type ManyToMany<T extends Storable, K extends object = object> = K extends object ? ModelLinksArray<T, K> : ModelLinksSimpleArray<T>;
+/**
+ * Define the parent of the model
+ * Can only have one parent and implies a Cascade delete
+ *
+ * Alias for @ModelParent
+ * Similar to @ModelLink but implies a Cascade delete
+ */
+export type BelongTo<T extends Storable> = ModelParent<T>;
+/** Alias for ModelLink - defines a relation to another model. */
+export type RelateTo<T extends Storable> = ModelLink<T>;
+/** Alias for ManyToMany - defines ownership of a collection of models. */
+export type Contains<T extends Storable> = ManyToMany<T>;
+/**
+ * Define a junction link between two models in a n:m relation
+ *
+ * This is used to define the junction model in a n:m relation with additional data
+ * It does not require to have a symetric relation on the other side
+ */
+export declare class JunctionLink<T extends Storable, K extends Storable> implements Storable {
+    [WEBDA_PRIMARY_KEY]: readonly ["linkA", "linkB"];
+    linkA: ModelParent<T>;
+    linkB: ModelLink<K>;
+    /**
+     * Return the composite primary key (linkA + linkB)
+     * @returns the composite primary key object
+     */
+    getPrimaryKey(): {
+        linkA: PrimaryKeyType<T>;
+        linkB: PrimaryKeyType<K>;
+    };
+    /** @override */
+    load(params: any): this;
+    /**
+     * Return a string UID combining both link keys
+     * @returns the combined UID string
+     */
+    getUUID(): string;
+    /**
+     * Return the proxied version of this model (identity for JunctionLink)
+     * @returns this instance
+     */
+    toProxy(): this;
+}
+export {};
+//# sourceMappingURL=relations.d.ts.map