signalkin 0.2.0

package/types/signalkin.d.ts

@@ -0,0 +1,401 @@
+import { Signal } from '@angular/core';
+import { SignalStoreFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+import { EntityId, SelectEntityId, EntityMap, EntityChanges } from '@ngrx/signals/entities';
+
+/**
+ * How many entities of one side relate to a single entity of the other side.
+ * A literal `1` means single; any other number (e.g. `2`) or `'many'` means multiple.
+ * Pass a literal so the generated key names and return shapes resolve correctly.
+ */
+type Cardinality = number | 'many';
+type IsSingle<Count extends Cardinality> = Count extends 1 ? true : false;
+/** True when a side relates to MORE THAN ONE of the other (any number >= 2, or `'many'`) — i.e. not `1`. */
+type IsMulti<Count extends Cardinality> = IsSingle<Count> extends true ? false : true;
+/**
+ * True when a side's count is a FIXED number of 2+ (not `1`, not `'many'`). A fixed-size set of that
+ * side's ids acts as a composite key that pins one of the other side, so a lookup keyed by it is single.
+ */
+type IsFixedCount<Count extends Cardinality> = Count extends 'many' ? false : Count extends 1 ? false : true;
+/** A single entity for a 1-side (or `undefined` when the link is missing), an array for a many-side. */
+type Related<Entity, Count extends Cardinality> = IsSingle<Count> extends true ? Entity | undefined : Entity[];
+/** Leading noun of a generated key: the bare name for a 1-side, the (given or default `+s`) plural for a many-side. */
+type Lead<Name extends string, Plural extends string, Count extends Cardinality> = IsSingle<Count> extends true ? Name : Plural;
+/** The id-returning noun for a side: `${Name}Id` for a 1-side, `${Name}Ids` for a many/number-side. */
+type IdLead<Name extends string, Count extends Cardinality> = IsSingle<Count> extends true ? `${Name}Id` : `${Name}Ids`;
+/**
+ * Whether a composite lookup keyed by a SET of one side's ids returns a single entity. It does when the
+ * set is a candidate key — the keyed (input) side has a fixed count of 2+ — OR when only one of the
+ * returned side can ever match (the returned side is a 1-side). Otherwise more than one may match, so
+ * the lookup returns an array.
+ */
+type CompositeSingle<InputCount extends Cardinality, ReturnCount extends Cardinality> = IsFixedCount<InputCount> extends true ? true : IsSingle<ReturnCount>;
+/** A single entity when the composite lookup is single, else an array of all matches. */
+type CompositeResult<Entity, InputCount extends Cardinality, ReturnCount extends Cardinality> = CompositeSingle<InputCount, ReturnCount> extends true ? Entity | undefined : Entity[];
+/** A single id when the composite lookup is single, else an array of all matching ids. */
+type CompositeIdResult<Id extends EntityId, InputCount extends Cardinality, ReturnCount extends Cardinality> = CompositeSingle<InputCount, ReturnCount> extends true ? Id | undefined : Id[];
+/** The leading noun of a composite lookup's name: singular when it returns one, plural when it returns an array. */
+type CompositeLead<Name extends string, Plural extends string, InputCount extends Cardinality, ReturnCount extends Cardinality> = CompositeSingle<InputCount, ReturnCount> extends true ? Name : Plural;
+/** The id-returning noun of a composite lookup's name: `${Name}Id` when single, `${Name}Ids` when an array. */
+type CompositeIdLead<Name extends string, InputCount extends Cardinality, ReturnCount extends Cardinality> = CompositeSingle<InputCount, ReturnCount> extends true ? `${Name}Id` : `${Name}Ids`;
+/**
+ * The state a feature REQUIRES: the named collections' entity maps must already exist. Intersected
+ * into a feature's `Input` so `signalStore` refuses to compile it unless placed AFTER those
+ * `withEntities` calls (ordering enforcement), and so the real entity types can be read back out.
+ */
+type RequiredEntityMaps<Names extends string> = {
+    state: Record<`${Names}EntityMap`, Record<EntityId, unknown>>;
+};
+/** {@link RequiredEntityMaps} for a relationship's two sides. */
+type RequiredEntityStore<FromName extends string, ToName extends string> = RequiredEntityMaps<FromName | ToName>;
+/** The collection names present on a store's state, read off its `${name}EntityMap` keys. */
+type CollectionNames<State> = {
+    [Key in keyof State & string]: Key extends `${infer Name}EntityMap` ? Name : never;
+}[keyof State & string];
+/**
+ * Extracts a collection's entity type from the inferred input store, by collection name — e.g.
+ * `EntityOf<Store, 'book'>` reads `Store['state']['bookEntityMap']` and yields `Book`.
+ * Reads the RAW state map (`Record<EntityId, Entity>`), which is what lets a caller pass only the name.
+ */
+type EntityOf<Store, Name extends string> = Store extends {
+    state: infer State;
+} ? State extends Record<`${Name}EntityMap`, Record<EntityId, infer Entity>> ? Entity : never : never;
+/** A test an entity either passes or fails — used to pick which entities a bulk update/remove touches. */
+type EntityPredicate<Entity> = (entity: Entity) => boolean;
+/**
+ * A property name to read, or a getter that returns an id — mirrors ngrx `selectId`, but a key string
+ * also works. Either form carries a branded id like `OptionId` into the generated lookups: a typed
+ * getter (e.g. `(entity) => entity.id2`) through its return type, a key (e.g. `'id2'`) through the
+ * property type it names. Omitting it falls back to `EntityId`.
+ */
+type IdAccessor<Id extends EntityId = EntityId> = string | ((entity: any) => Id);
+/**
+ * The id type a `selectId` accessor yields: a getter's return type, or the type of the property a key
+ * string names, so a branded id like `OptionId` flows into the generated lookups. Falls back to
+ * `EntityId` when no accessor is given, when a getter is untyped, or when a key does not resolve to an
+ * id. A key resolves against `Entity`, which is why the accessor's own type is captured and passed in —
+ * ngrx widens `selectId` to `EntityId` on an `entityConfig`, so re-reading the property is what keeps
+ * the brand when a config is spread into a relationship side.
+ */
+type IdOf<Accessor, Entity = unknown> = EntityId & (Accessor extends (entity: any) => infer Id ? Id : Accessor extends keyof Entity ? Entity[Accessor] : EntityId);
+/**
+ * Like {@link IdAccessor}, but for a foreign key that may be absent or plural — a getter may return a
+ * single id, an array of ids (for a side that links to more than one of the other), or `undefined`.
+ */
+type ForeignIdAccessor = string | ((entity: any) => EntityId | EntityId[] | undefined);
+/**
+ * One side of a relationship: the `collection` name, how many of it relate to one of the other side,
+ * and how its ids are read. The shape matches an `entityConfig(...)` result (`collection`, `selectId`),
+ * so `{ ...bookConfig, count: 'many' }` works — you only add the relationship-specific `count` (and
+ * optionally `plural` / `selectForeignId`).
+ */
+type RelationshipSide<Name extends string, Count extends Cardinality> = {
+    /** The ngrx collection name; the entity type is inferred from the store by this name. */
+    collection: Name;
+    /** How many of this side relate to a single entity of the other side. */
+    count: Count;
+    /** The plural of `collection`, used in every generated member that pluralizes it. Default: `` `${collection}s` ``. */
+    plural?: string;
+    /** How to read THIS entity's own id; keep it matching the collection's `selectId`. Default: the `'id'` property. */
+    selectId?: IdAccessor;
+    /**
+     * How to read THIS entity's foreign key to the other side — set ONLY if this entity actually stores it.
+     * Default key: `` `${otherName}Id` `` when this side links to one of the other, `` `${otherName}Ids` ``
+     * (an array, e.g. a book's `aisleIds`) when it links to more than one.
+     */
+    selectForeignId?: ForeignIdAccessor;
+};
+/** Flags to turn optional behavior on or off. */
+type RelationshipOptions = {
+    /** Auto-populate the index from foreign keys as entities change. Default: `true`. Set `false` for explicit links only. */
+    autoIndex?: boolean;
+    /**
+     * Let `remove`/`move` mutations and the ordering methods (`swap`/`reorder`/`move…ToIndex`) write the
+     * entities' foreign keys, so a change sticks for FK-derived links: `removeBookFromLibrary` clears the
+     * book's `libraryId`, `move` re-points it, and reordering an owner's members writes the new order into
+     * the owner's own array key (e.g. `cell.optionIds`). Default: `true`. Set `false` to never write
+     * entities (the FK stays the source of truth and those operations affect manual links only). Only works
+     * on a side whose `selectForeignId` is a property NAME (or defaulted) — a getter can't be written back,
+     * so getter sides are skipped; and reordering only writes a key the owner actually holds as an array.
+     */
+    syncForeignKeys?: boolean;
+    /**
+     * Generate the composite set-lookups (`bookByRows(...)` / `authorByBooks(...)`) for each side that
+     * relates to more than one of the other. Default: `true`. Set `false` to skip building those indexes.
+     */
+    compositeLookups?: boolean;
+};
+
+/** What withEntityAccessors needs from a config: the collection name, its `selectId` if not the `id` property, and its `plural` if not `+s`. An `entityConfig(...)` result works as-is. */
+type EntityAccessorConfig = {
+    entity?: unknown;
+    collection: string;
+    selectId?: SelectEntityId<any>;
+    plural?: string;
+};
+/** The collections a call targets: the passed configs' collections, or EVERY collection on the store when none are passed. */
+type TargetNames<Store extends SignalStoreFeatureResult, Configs extends readonly EntityAccessorConfig[]> = Configs extends readonly [] ? CollectionNames<Store['state']> : Configs[number]['collection'];
+/** A collection's plural, from its passed config if one names it, else `+s`. */
+type PluralOf<Configs extends readonly EntityAccessorConfig[], Name extends string> = [
+    Extract<Configs[number], {
+        collection: Name;
+    }>
+] extends [never] ? `${Name}s` : Extract<Configs[number], {
+    collection: Name;
+}> extends {
+    plural: infer Plural extends string;
+} ? Plural : `${Name}s`;
+/** Convenience signals added alongside ngrx's own `${collection}EntityMap` / `${collection}Ids` / `${collection}Entities`. */
+type EntityAccessorProps<Store, Configs extends readonly EntityAccessorConfig[], Names extends string> = {
+    [Name in Names as PluralOf<Configs, Name>]: Signal<EntityOf<Store, Name>[]>;
+} & {
+    [Name in Names as `${Name}Map`]: Signal<EntityMap<EntityOf<Store, Name>>>;
+} & {
+    [Name in Names as `${Name}Count`]: Signal<number>;
+};
+/** The standard collection methods, one per ngrx updater plus lookups, named by collection. */
+type EntityAccessorMethods<Store, Configs extends readonly EntityAccessorConfig[], Names extends string> = {
+    [Name in Names as `add${Capitalize<Name>}`]: (entity: EntityOf<Store, Name>) => void;
+} & {
+    [Name in Names as `add${Capitalize<PluralOf<Configs, Name>>}`]: (entities: EntityOf<Store, Name>[]) => void;
+} & {
+    [Name in Names as `prepend${Capitalize<Name>}`]: (entity: EntityOf<Store, Name>) => void;
+} & {
+    [Name in Names as `prepend${Capitalize<PluralOf<Configs, Name>>}`]: (entities: EntityOf<Store, Name>[]) => void;
+} & {
+    [Name in Names as `set${Capitalize<Name>}`]: (entity: EntityOf<Store, Name>) => void;
+} & {
+    [Name in Names as `set${Capitalize<PluralOf<Configs, Name>>}`]: (entities: EntityOf<Store, Name>[]) => void;
+} & {
+    [Name in Names as `setAll${Capitalize<PluralOf<Configs, Name>>}`]: (entities: EntityOf<Store, Name>[]) => void;
+} & {
+    [Name in Names as `upsert${Capitalize<Name>}`]: (entity: EntityOf<Store, Name>) => void;
+} & {
+    [Name in Names as `upsert${Capitalize<PluralOf<Configs, Name>>}`]: (entities: EntityOf<Store, Name>[]) => void;
+} & {
+    [Name in Names as `update${Capitalize<Name>}`]: (entity: EntityOf<Store, Name> | EntityId, changes: EntityChanges<EntityOf<Store, Name>>) => void;
+} & {
+    [Name in Names as `update${Capitalize<PluralOf<Configs, Name>>}`]: (entitiesOrPredicate: (EntityOf<Store, Name> | EntityId)[] | EntityPredicate<EntityOf<Store, Name>>, changes: EntityChanges<EntityOf<Store, Name>>) => void;
+} & {
+    [Name in Names as `updateAll${Capitalize<PluralOf<Configs, Name>>}`]: (changes: EntityChanges<EntityOf<Store, Name>>) => void;
+} & {
+    [Name in Names as `remove${Capitalize<Name>}`]: (entity: EntityOf<Store, Name> | EntityId) => void;
+} & {
+    [Name in Names as `remove${Capitalize<PluralOf<Configs, Name>>}`]: (entitiesOrPredicate: (EntityOf<Store, Name> | EntityId)[] | EntityPredicate<EntityOf<Store, Name>>) => void;
+} & {
+    [Name in Names as `removeAll${Capitalize<PluralOf<Configs, Name>>}`]: () => void;
+} & {
+    [Name in Names as `swap${Capitalize<PluralOf<Configs, Name>>}`]: (entityA: EntityOf<Store, Name> | EntityId, entityB: EntityOf<Store, Name> | EntityId) => void;
+} & {
+    [Name in Names as `reorder${Capitalize<PluralOf<Configs, Name>>}`]: (orderedEntities: (EntityOf<Store, Name> | EntityId)[]) => void;
+} & {
+    [Name in Names as `move${Capitalize<Name>}ToIndex`]: (entity: EntityOf<Store, Name> | EntityId, index: number) => void;
+} & {
+    [Name in Names as `${Name}ById`]: (id: EntityId) => EntityOf<Store, Name> | undefined;
+} & {
+    [Name in Names as `has${Capitalize<Name>}`]: (entity: EntityOf<Store, Name> | EntityId) => boolean;
+};
+type EntityAccessorsOutput<Store, Configs extends readonly EntityAccessorConfig[], Names extends string> = {
+    state: {};
+    props: EntityAccessorProps<Store, Configs, Names>;
+    methods: EntityAccessorMethods<Store, Configs, Names>;
+};
+/**
+ * Standard collection methods and convenience signals for the store's entities, named by collection — no args covers every collection, or pass configs to narrow and to honor a custom `selectId` / `plural`.
+ *
+ * @example
+ * signalStore(
+ *   withEntities(bookConfig),
+ *   withEntityAccessors(bookConfig),
+ * );
+ * // books(), bookMap(), bookCount(), bookById(id), hasBook(book | id)
+ * // addBook, addBooks, prependBook, setBook, setAllBooks, upsertBook
+ * // updateBook(book | id, changes), updateAllBooks(changes), removeBook(book | id), removeAllBooks()
+ * // swapBooks(a, b), reorderBooks(orderedBooks), moveBookToIndex(book | id, index) reorder the collection
+ */
+declare const withEntityAccessors: <const Configs extends readonly EntityAccessorConfig[], Store extends SignalStoreFeatureResult & RequiredEntityMaps<Configs[number]["collection"]>>(...configs: Configs) => SignalStoreFeature<Store, EntityAccessorsOutput<Store, Configs, TargetNames<Store, Configs> & string>>;
+
+type LinkState<FromName extends string, ToName extends string> = {
+    [Key in `_${FromName}${Capitalize<ToName>}Links`]: Record<EntityId, EntityId[]>;
+} & {
+    [Key in `_${ToName}${Capitalize<FromName>}Links`]: Record<EntityId, EntityId[]>;
+};
+type IndexProps<FromName extends string, ToName extends string> = {
+    [Key in `${FromName}${Capitalize<ToName>}Map`]: Signal<Record<EntityId, EntityId[]>>;
+} & {
+    [Key in `${ToName}${Capitalize<FromName>}Map`]: Signal<Record<EntityId, EntityId[]>>;
+};
+/**
+ * The two get-by lookups for one direction: return the related entity(ies) or their id(s), keyed by
+ * ONE entity of the other side — passed as the entity OR its id. The returned noun pluralizes by the
+ * returned side's own count; the shape is a single value for a 1-side, an array otherwise.
+ */
+type DirectionalLookup<ReturnEntity, ReturnName extends string, ReturnPlural extends string, ReturnCount extends Cardinality, ReturnId extends EntityId, InputEntity, InputName extends string> = {
+    [Key in `${Lead<ReturnName, ReturnPlural, ReturnCount>}By${Capitalize<InputName>}`]: (input: InputEntity | EntityId) => Related<ReturnEntity, ReturnCount>;
+} & {
+    [Key in `${IdLead<ReturnName, ReturnCount>}By${Capitalize<InputName>}`]: (input: InputEntity | EntityId) => Related<ReturnId, ReturnCount>;
+};
+/** Existence checks and counts across the link, both directions. Each entity argument accepts the entity or its id. */
+type HasCountMethods<FromEntity, FromName extends string, ToEntity, ToName extends string> = {
+    [Key in `${FromName}Has${Capitalize<ToName>}`]: (from: FromEntity | EntityId, to: ToEntity | EntityId) => boolean;
+} & {
+    [Key in `${ToName}Has${Capitalize<FromName>}`]: (to: ToEntity | EntityId, from: FromEntity | EntityId) => boolean;
+} & {
+    [Key in `${ToName}CountBy${Capitalize<FromName>}`]: (from: FromEntity | EntityId) => number;
+} & {
+    [Key in `${FromName}CountBy${Capitalize<ToName>}`]: (to: ToEntity | EntityId) => number;
+};
+type LookupMethods<FromEntity, FromName extends string, FromPlural extends string, FromCount extends Cardinality, FromId extends EntityId, ToEntity, ToName extends string, ToPlural extends string, ToCount extends Cardinality, ToId extends EntityId> = DirectionalLookup<ToEntity, ToName, ToPlural, ToCount, ToId, FromEntity, FromName> & DirectionalLookup<FromEntity, FromName, FromPlural, FromCount, FromId, ToEntity, ToName> & HasCountMethods<FromEntity, FromName, ToEntity, ToName>;
+/**
+ * When the INPUT side relates to MORE THAN ONE of the other (count is a number 2+ or `'many'`), the
+ * SET of that side's ids for a given other-side entity can be used as a key. This generates the
+ * variadic set-lookups: pass those entities or ids (any order), get the matching other-side
+ * entity(ies) or id(s). The result is a single value when the set is a candidate key (the keyed side
+ * has a fixed count 2+) or only one of the returned side can match (returned side is a 1-side);
+ * otherwise it's an array of every match. The method name goes singular / plural to match.
+ */
+type CompositeSetLookup<ReturnEntity, ReturnName extends string, ReturnPlural extends string, ReturnId extends EntityId, ReturnCount extends Cardinality, InputEntity, InputPlural extends string, InputCount extends Cardinality> = IsMulti<InputCount> extends true ? {
+    [Key in `${CompositeLead<ReturnName, ReturnPlural, InputCount, ReturnCount>}By${Capitalize<InputPlural>}`]: (...refs: (InputEntity | EntityId)[]) => CompositeResult<ReturnEntity, InputCount, ReturnCount>;
+} & {
+    [Key in `${CompositeIdLead<ReturnName, InputCount, ReturnCount>}By${Capitalize<InputPlural>}`]: (...refs: (InputEntity | EntityId)[]) => CompositeIdResult<ReturnId, InputCount, ReturnCount>;
+} : {};
+type MutationMethods<FromEntity, FromName extends string, ToEntity, ToName extends string> = {
+    [Key in `add${Capitalize<ToName>}To${Capitalize<FromName>}`]: (from: FromEntity | EntityId, to: ToEntity | EntityId) => void;
+} & {
+    [Key in `remove${Capitalize<ToName>}From${Capitalize<FromName>}`]: (from: FromEntity | EntityId, to: ToEntity | EntityId) => void;
+} & {
+    [Key in `move${Capitalize<ToName>}To${Capitalize<FromName>}`]: (to: ToEntity | EntityId, from: FromEntity | EntityId) => void;
+};
+/**
+ * The position of a member entity within its owner's ordered related list (as returned by the owner's
+ * get-by lookup), or -1 when the member is not linked. Takes only the member — the owner is the single
+ * entity the member belongs to. Generated only where the member has exactly one owner (the owner side
+ * is count 1) and that owner holds many members (the member side is `'many'` or a fixed count 2+); a
+ * many-to-many has no single owner to infer, so it gets none. The member is passed as the entity or its id.
+ */
+type IndexOfMethod<OwnerName extends string, OwnerCount extends Cardinality, MemberName extends string, MemberEntity, MemberCount extends Cardinality> = IsSingle<OwnerCount> extends true ? IsMulti<MemberCount> extends true ? {
+    [Key in `indexOf${Capitalize<OwnerName>}${Capitalize<MemberName>}`]: (member: MemberEntity | EntityId) => number;
+} : {} : {};
+/**
+ * Ordering mutations for a member within its owner's related list: swap two members, set the full
+ * order, or move one to an index. Generated in the same direction as {@link IndexOfMethod} — only where
+ * the member has a single owner (owner side is count 1) that holds many members. `reorder` takes the
+ * complete set of that owner's members and no-ops (with a warning) on an incomplete or foreign list.
+ * Members are passed as the entity or its id.
+ */
+type OrderingMethods<OwnerName extends string, OwnerCount extends Cardinality, MemberName extends string, MemberPlural extends string, MemberEntity, MemberCount extends Cardinality> = IsSingle<OwnerCount> extends true ? IsMulti<MemberCount> extends true ? {
+    [Key in `swap${Capitalize<OwnerName>}${Capitalize<MemberPlural>}`]: (memberA: MemberEntity | EntityId, memberB: MemberEntity | EntityId) => void;
+} & {
+    [Key in `reorder${Capitalize<OwnerName>}${Capitalize<MemberPlural>}`]: (orderedMembers: (MemberEntity | EntityId)[]) => void;
+} & {
+    [Key in `move${Capitalize<OwnerName>}${Capitalize<MemberName>}ToIndex`]: (member: MemberEntity | EntityId, index: number) => void;
+} : {} : {};
+/**
+ * The By-form of {@link OrderingMethods} plus indexOf, for a member that has MORE THAN ONE owner (owner
+ * side is not count 1) and belongs to more than one of each owner (member side is multi — a fixed count
+ * 2+ or `'many'`). The owner can't be inferred, so it is named explicitly as the last argument:
+ * `indexOfCellByOption(cell, option)`, or `indexOfOptionByCell(option, cell)` in the mirror direction.
+ * Members are passed as the entity or its id; `reorder` requires that owner's complete member set.
+ */
+type ByOrderingMethods<OwnerName extends string, OwnerEntity, OwnerCount extends Cardinality, MemberName extends string, MemberPlural extends string, MemberEntity, MemberCount extends Cardinality> = IsMulti<OwnerCount> extends true ? IsMulti<MemberCount> extends true ? {
+    [Key in `indexOf${Capitalize<MemberName>}By${Capitalize<OwnerName>}`]: (member: MemberEntity | EntityId, owner: OwnerEntity | EntityId) => number;
+} & {
+    [Key in `swap${Capitalize<MemberPlural>}By${Capitalize<OwnerName>}`]: (memberA: MemberEntity | EntityId, memberB: MemberEntity | EntityId, owner: OwnerEntity | EntityId) => void;
+} & {
+    [Key in `reorder${Capitalize<MemberPlural>}By${Capitalize<OwnerName>}`]: (orderedMembers: (MemberEntity | EntityId)[], owner: OwnerEntity | EntityId) => void;
+} & {
+    [Key in `move${Capitalize<MemberName>}By${Capitalize<OwnerName>}ToIndex`]: (member: MemberEntity | EntityId, index: number, owner: OwnerEntity | EntityId) => void;
+} : {} : {};
+/**
+ * Filtered directional lookups that keep only the owners where the member sits at EXACTLY the given
+ * index in that owner's ordered member list, so index 0 is the first slot and a member showing up at
+ * index 1 is ignored. Generated when BOTH sides are multi (neither is count 1): the owner then holds an
+ * ordered array of two-or-more members (a fixed count 2+ or `'many'`), and the member belongs to more
+ * than one owner, so the same member can occupy a different slot in each — which is what makes filtering
+ * by index meaningful. Both the entity and the id form are returned, in the same order as the base
+ * `${OwnerPlural}By${MemberName}` lookup. The member is passed as the entity or its id.
+ *
+ * @example ensemblesByMusicianAtIndex(musician, 3) — ensembles where that musician plays the 4th chair.
+ */
+type IndexedLookupMethods<OwnerName extends string, OwnerPlural extends string, OwnerEntity, OwnerId extends EntityId, OwnerCount extends Cardinality, MemberName extends string, MemberEntity, MemberCount extends Cardinality> = IsMulti<OwnerCount> extends true ? IsMulti<MemberCount> extends true ? {
+    [Key in `${OwnerPlural}By${Capitalize<MemberName>}AtIndex`]: (member: MemberEntity | EntityId, index: number) => OwnerEntity[];
+} & {
+    [Key in `${OwnerName}IdsBy${Capitalize<MemberName>}AtIndex`]: (member: MemberEntity | EntityId, index: number) => OwnerId[];
+} : {} : {};
+type RelationshipOutput<FromEntity, FromName extends string, FromPlural extends string, FromCount extends Cardinality, FromId extends EntityId, ToEntity, ToName extends string, ToPlural extends string, ToCount extends Cardinality, ToId extends EntityId> = {
+    state: LinkState<FromName, ToName>;
+    props: IndexProps<FromName, ToName>;
+    methods: LookupMethods<FromEntity, FromName, FromPlural, FromCount, FromId, ToEntity, ToName, ToPlural, ToCount, ToId> & CompositeSetLookup<ToEntity, ToName, ToPlural, ToId, ToCount, FromEntity, FromPlural, FromCount> & CompositeSetLookup<FromEntity, FromName, FromPlural, FromId, FromCount, ToEntity, ToPlural, ToCount> & IndexOfMethod<FromName, FromCount, ToName, ToEntity, ToCount> & IndexOfMethod<ToName, ToCount, FromName, FromEntity, FromCount> & OrderingMethods<FromName, FromCount, ToName, ToPlural, ToEntity, ToCount> & OrderingMethods<ToName, ToCount, FromName, FromPlural, FromEntity, FromCount> & ByOrderingMethods<FromName, FromEntity, FromCount, ToName, ToPlural, ToEntity, ToCount> & ByOrderingMethods<ToName, ToEntity, ToCount, FromName, FromPlural, FromEntity, FromCount> & IndexedLookupMethods<FromName, FromPlural, FromEntity, FromId, FromCount, ToName, ToEntity, ToCount> & IndexedLookupMethods<ToName, ToPlural, ToEntity, ToId, ToCount, FromName, FromEntity, FromCount> & MutationMethods<FromEntity, FromName, ToEntity, ToName>;
+};
+/**
+ * Relates two entity collections into typed cross-lookups, counts, composite set-lookups, and link mutations named by each side's `collection`; `count` (`1`, a number, or `'many'`) drives the names and shapes, and every lookup takes the entity or its id.
+ *
+ * @example
+ * signalStore(
+ *   withEntities(libraryConfig),
+ *   withEntities(bookConfig),
+ *   withEntityRelationship({ collection: 'library', count: 1 }, { collection: 'book', count: 'many' }),
+ * );
+ * // booksByLibrary(library | id) -> Book[]
+ * // libraryByBook(book | id) -> Library | undefined
+ * // libraryHasBook, bookCountByLibrary, addBookToLibrary, removeBookFromLibrary, moveBookToLibrary
+ * // indexOfLibraryBook(book | id) -> number (the book's position in its library, -1 if absent)
+ * // swapLibraryBooks(a, b), reorderLibraryBooks(orderedBooks), moveLibraryBookToIndex(book, index) reorder a library's books
+ * // book side is 'many', so a set-lookup keyed by a full book-set: libraryByBooks(...books | ids) -> Library
+ */
+declare const withEntityRelationship: <FromName extends string, FromCount extends Cardinality, ToName extends string, ToCount extends Cardinality, Store extends SignalStoreFeatureResult & RequiredEntityStore<FromName, ToName>, FromSelect extends IdAccessor = IdAccessor, ToSelect extends IdAccessor = IdAccessor, FromPlural extends string = `${FromName}s`, ToPlural extends string = `${ToName}s`>(from: {
+    collection: FromName;
+    count: FromCount;
+    plural?: FromPlural;
+    selectId?: FromSelect;
+    selectForeignId?: ForeignIdAccessor;
+}, to: {
+    collection: ToName;
+    count: ToCount;
+    plural?: ToPlural;
+    selectId?: ToSelect;
+    selectForeignId?: ForeignIdAccessor;
+}, options?: RelationshipOptions) => SignalStoreFeature<Store, RelationshipOutput<EntityOf<Store, FromName>, FromName, FromPlural, FromCount, IdOf<FromSelect, EntityOf<Store, FromName>>, EntityOf<Store, ToName>, ToName, ToPlural, ToCount, IdOf<ToSelect, EntityOf<Store, ToName>>>>;
+
+/**
+ * The read-only lookups a transitive relationship generates, both directions, arrays throughout
+ * (a chained walk can reach more than one of either endpoint). Each lookup accepts the endpoint
+ * entity OR its id, and returns the far endpoint entities or their ids.
+ */
+type TransitiveOutput<FromEntity, FromName extends string, FromPlural extends string, FromId extends EntityId, ToEntity, ToName extends string, ToPlural extends string, ToId extends EntityId> = {
+    state: {};
+    props: {};
+    methods: {
+        [Key in `${ToPlural}By${Capitalize<FromName>}`]: (from: FromEntity | EntityId) => ToEntity[];
+    } & {
+        [Key in `${ToName}IdsBy${Capitalize<FromName>}`]: (from: FromEntity | EntityId) => ToId[];
+    } & {
+        [Key in `${FromPlural}By${Capitalize<ToName>}`]: (to: ToEntity | EntityId) => FromEntity[];
+    } & {
+        [Key in `${FromName}IdsBy${Capitalize<ToName>}`]: (to: ToEntity | EntityId) => FromId[];
+    };
+};
+/**
+ * Read-only lookups between two collections that share no foreign key, by walking the intermediary collection(s) between them (`through` a single name or an ordered list); returns arrays both directions.
+ *
+ * @example
+ * signalStore(
+ *   withEntities(libraryConfig), withEntities(shelfConfig), withEntities(bookConfig),
+ *   withEntityRelationship({ collection: 'library', count: 1 }, { collection: 'shelf', count: 'many' }),
+ *   withEntityRelationship({ collection: 'shelf', count: 1 }, { collection: 'book', count: 'many' }),
+ *   withTransitiveRelationship({ from: 'library', to: 'book', through: 'shelf' }),
+ * );
+ * // booksByLibrary(library | id) -> Book[]
+ * // librariesByBook(book | id) -> Library[]
+ */
+declare const withTransitiveRelationship: <FromName extends string, ToName extends string, Store extends SignalStoreFeatureResult & RequiredEntityStore<FromName, ToName>, FromSelect extends IdAccessor = IdAccessor, ToSelect extends IdAccessor = IdAccessor, FromPlural extends string = `${FromName}s`, ToPlural extends string = `${ToName}s`>(config: {
+    from: FromName;
+    to: ToName;
+    through: string | string[];
+    fromPlural?: FromPlural;
+    toPlural?: ToPlural;
+    selectFromId?: FromSelect;
+    selectToId?: ToSelect;
+}) => SignalStoreFeature<Store, TransitiveOutput<EntityOf<Store, FromName>, FromName, FromPlural, IdOf<FromSelect>, EntityOf<Store, ToName>, ToName, ToPlural, IdOf<ToSelect>>>;
+
+export { withEntityAccessors, withEntityRelationship, withTransitiveRelationship };
+export type { Cardinality, EntityAccessorConfig, EntityPredicate, ForeignIdAccessor, IdAccessor, RelationshipOptions, RelationshipSide };