@squidcloud/client 1.0.145 → 1.0.146-beta

package/dist/typescript-client/src/query/join-query-builder.factory.d.ts

@@ -1,161 +1,316 @@
-import { Alias, BaseQueryBuilder, DocumentData, FieldName, FieldSort, HasDereference, Operator, Pagination, PaginationOptions, PrimitiveFieldType, SerializedJoinQuery, SimpleCondition, SnapshotEmitter } from '@squidcloud/common';
-import { Observable } from 'rxjs';
-import { DocumentReference } from '../document-reference';
-import { QueryBuilder } from './query-builder.factory';
-type WithDocumentReferences<T extends Record<any, DocumentData>> = {
-    [k in keyof T]: DocumentReference<Required<T>[k]>;
-};
-type Grouped<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, RootAlias extends Alias> = Aliases[RootAlias] extends [] ? Required<ReturnType>[RootAlias] : Record<RootAlias, Required<ReturnType>[RootAlias]> & OtherGroups<Aliases, ReturnType, Aliases[RootAlias]>;
-type OtherGroups<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, ManyRootAliases extends Alias[]> = ManyRootAliases extends [infer First extends Alias, ...infer Rest extends Alias[]] ? Record<First, Array<Grouped<Aliases, ReturnType, First>>> & OtherGroups<Aliases, ReturnType, Rest> : Record<Alias, never>;
-interface HasGrouped {
-    /**
-     * Transforms this join query result to a nested data structure. For example, a join between teachers and students
-     * normally returns a result of the form:
-     *   [
-     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'John Doe'} },
-     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'Jane Smith'} },
-     *     { teacher: {name: 'Mr. EmptyClass'}, student: undefined },
-     *   ]
-     * into a result of the form:
-     *   [
-     *    { teacher: {name: 'Mr. Smith'}, students: [
-     *      { name: 'John Doe' },
-     *      { name: 'Jane Smith' },
-     *    ]},
-     *    { teacher: {name: 'Mr. EmptyClass'}, students: [] },
-     *   ]
-     */
-    grouped(): any;
-}
-/**
- * A query builder that can participate in a join.
- * To learn more about join queries, see the
- * {@link https://docs.squid.cloud/docs/development-tools/client-sdk/queries#joining-data-across-collections-and-integrations documentation}.
- */
-export declare class JoinQueryBuilder<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, LatestAlias extends Alias, RootAlias extends Alias> extends BaseQueryBuilder<ReturnType> implements SnapshotEmitter<WithDocumentReferences<ReturnType>>, HasGrouped, HasDereference {
-    private readonly collectionName;
-    private readonly integrationId;
-    private readonly querySubscriptionManager;
-    private readonly documentReferenceFactory;
-    private readonly queryBuilderFactory;
-    private readonly latestAlias;
-    private readonly joins;
-    private readonly joinConditions;
-    private readonly queryBuilder;
-    /**
-     * Adds a condition to the query.
-     *
-     * @param fieldName The name of the field to query
-     * @param operator The operator to use
-     * @param value The value to compare against
-     * @returns The query builder
-     */
-    where(fieldName: (keyof ReturnType[LatestAlias] & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
-    /**
-     * Sets a limit to the number of results returned by the query. The maximum limit is 20,000 and the default is 1,000
-     * if none is provided.
-     *
-     * @param limit The maximum number of results to return
-     * @returns The query builder
-     */
-    limit(limit: number): this;
-    getLimit(): number;
-    /**
-     * Adds a sort order to the query. You can add multiple sort orders to the query. The order in which you add them
-     * determines the order in which they are applied.
-     * @param fieldName The name of the field to sort by
-     * @param asc Whether to sort in ascending order. Defaults to true.
-     * @returns The query builder
-     */
-    sortBy(fieldName: keyof ReturnType[RootAlias] & FieldName, asc?: boolean): this;
-    /**
-     * Joins this query with another join query and return a new query builder that can be used to query the joined
-     * documents.
-     * @param queryBuilder The query builder to join with
-     * @param alias TODO
-     * @param joinFields TODO
-     * @param options TODO
-     * @returns A new query builder that can be used to query the joined documents
-     */
-    join<NewAlias extends string, NewReturnType extends DocumentData, LeftAlias extends Extract<keyof ReturnType, Alias>, IsInner extends boolean = false>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
-        left: keyof Required<ReturnType>[LeftAlias] & FieldName;
-        right: keyof NewReturnType & FieldName;
-    }, options: {
-        leftAlias: LeftAlias;
-        isInner?: IsInner;
-    }): JoinQueryBuilder<Omit<Aliases, LeftAlias> & Record<LeftAlias, [...Aliases[LeftAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & (IsInner extends true ? Record<NewAlias, NewReturnType> : Partial<Record<NewAlias, NewReturnType>>), NewAlias, RootAlias>;
-    join<NewAlias extends string, NewReturnType extends DocumentData, IsInner extends boolean = false>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
-        left: keyof Required<ReturnType>[LatestAlias] & FieldName;
-        right: keyof NewReturnType & FieldName;
-    }, options?: {
-        isInner?: IsInner;
-    }): JoinQueryBuilder<Omit<Aliases, LatestAlias> & Record<LatestAlias, [...Aliases[LatestAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & (IsInner extends true ? Record<NewAlias, NewReturnType> : Partial<Record<NewAlias, NewReturnType>>), NewAlias, RootAlias>;
-    /** @inheritDoc */
-    snapshot(): Promise<Array<WithDocumentReferences<ReturnType>>>;
-    /** @inheritDoc */
-    snapshots(subscribe?: boolean): Observable<Array<WithDocumentReferences<ReturnType>>>;
-    /**
-     * @inheritDoc
-     */
-    peek(): Array<WithDocumentReferences<ReturnType>>;
-    /** @inheritDoc */
-    grouped(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    /** @inheritDoc */
-    dereference(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    flipSortOrder(): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    extractData(data: WithDocumentReferences<ReturnType>): any;
-    serialize(): SerializedJoinQuery;
-    paginate(options?: Partial<PaginationOptions>): Pagination<WithDocumentReferences<ReturnType>>;
-}
-declare class DereferencedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<ReturnType>, HasGrouped {
-    private readonly joinQueryBuilder;
-    constructor(joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>);
-    /** @inheritDoc */
-    grouped(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
-    /** @inheritDoc */
-    snapshot(): Promise<Array<ReturnType>>;
-    /** @inheritDoc */
-    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
-    /**
-     * @inheritDoc
-     */
-    peek(): Array<ReturnType>;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    flipSortOrder(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    limit(limit: number): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    extractData(data: ReturnType): any;
-    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
-    serialize(): SerializedJoinQuery;
-    getLimit(): number;
-}
-declare class GroupedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>, HasDereference {
-    readonly joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
-    /** internal */
-    constructor(joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>);
-    /** @inheritDoc */
-    snapshot(): Promise<Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>>;
-    /** @inheritDoc */
-    snapshots(subscribe?: boolean): Observable<Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>>;
-    /**
-     * @inheritDoc
-     */
-    peek(): Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>;
-    /** @inheritDoc */
-    dereference(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
-    private groupData;
-    getSortOrders(): Array<FieldSort<any>>;
-    clone(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    addCompositeCondition(conditions: Array<SimpleCondition>): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    flipSortOrder(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    limit(limit: number): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
-    getLimit(): number;
-    extractData(data: Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>): any;
-    serialize(): SerializedJoinQuery;
-    paginate(options?: Partial<PaginationOptions>): Pagination<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>;
-}
-export {};
+import { Observable } from 'rxjs';
+import { DocumentReference } from '../document-reference';
+import { Alias, DocumentData, FieldName, FieldSort, Operator, PrimitiveFieldType, Query, SerializedJoinQuery, SimpleCondition } from '../public-types';
+import { Pagination, PaginationOptions } from './pagination';
+import { BaseQueryBuilder, HasDereference, QueryBuilder } from './query-builder.factory';
+import { SnapshotEmitter } from './snapshot-emitter';
+/**
+ * Represents the result of a join query where each property is a document reference,
+ * grouped by alias instead of containing DocumentData.
+ * @category Database
+ */
+export type WithDocumentReferences<T extends Record<any, DocumentData>> = {
+    [k in keyof T]: DocumentReference<Required<T>[k]>;
+};
+/**
+ * Defines the fields used for joining two collections in a query.
+ * Specifies the left and right fields that establish the join relationship.
+ * @category Database
+ */
+export interface JoinFields<ReturnType> {
+    /** Field from the left collection to be used in the join. */
+    left: FieldName;
+    /** Field from the right collection to be used in the join. */
+    right: keyof ReturnType & FieldName;
+}
+/**
+ * Options for configuring a join query.
+ * Specifies aliasing and whether the join is inner or outer.
+ * @category Database
+ */
+export interface JoinOptions {
+    /** Alias for the left collection in the join. */
+    leftAlias: Alias;
+    /** Whether the join should be an inner join (default is outer join). */
+    isInner?: boolean;
+}
+/**
+ * A join query result that has been grouped by alias.
+ * @category Database
+ */
+export type Grouped<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, RootAlias extends Alias> = Aliases[RootAlias] extends [] ? Required<ReturnType>[RootAlias] : Record<RootAlias, Required<ReturnType>[RootAlias]> & OtherGroups<Aliases, ReturnType, Aliases[RootAlias]>;
+/**
+ * A helper type for Groups.
+ * @category Database
+ */
+export type OtherGroups<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, any>, ManyRootAliases extends Alias[]> = ManyRootAliases extends [infer First extends Alias, ...infer Rest extends Alias[]] ? Record<First, Array<Grouped<Aliases, ReturnType, First>>> & OtherGroups<Aliases, ReturnType, Rest> : Record<Alias, never>;
+/**
+ * A join query result that has been grouped by alias.
+ * @category Database
+ */
+export interface HasGrouped {
+    /**
+     * Transforms this join query result to a nested data structure. For example, a join between teachers and students
+     * normally returns a result of the form:
+     *   [
+     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'John Doe'} },
+     *     { teacher: {name: 'Mr. Smith'}, student: {name: 'Jane Smith'} },
+     *     { teacher: {name: 'Mr. EmptyClass'}, student: undefined },
+     *   ]
+     * into a result of the form:
+     *   [
+     *    { teacher: {name: 'Mr. Smith'}, students: [
+     *      { name: 'John Doe' },
+     *      { name: 'Jane Smith' },
+     *    ]},
+     *    { teacher: {name: 'Mr. EmptyClass'}, students: [] },
+     *   ]
+     */
+    grouped(): any;
+}
+/**
+ * A query builder that can participate in a join.
+ * To learn more about join queries, see the
+ * {@link https://docs.getsquid.ai/docs/sdk/client-sdk/database/queries#joining-data-across-collections-and-connectors
+ * documentation}.
+ * @category Database
+ */
+export declare class JoinQueryBuilder<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, LatestAlias extends Alias, RootAlias extends Alias> extends BaseQueryBuilder<ReturnType> implements SnapshotEmitter<WithDocumentReferences<ReturnType>>, HasGrouped, HasDereference {
+    private readonly collectionName;
+    private readonly integrationId;
+    private readonly querySubscriptionManager;
+    private readonly documentReferenceFactory;
+    private readonly queryBuilderFactory;
+    private readonly latestAlias;
+    private readonly joins;
+    private readonly joinConditions;
+    private readonly queryBuilder;
+    /**
+     * Adds a condition to the query.
+     *
+     * @param fieldName The name of the field to query
+     * @param operator The operator to use
+     * @param value The value to compare against
+     * @returns The query builder
+     */
+    where(fieldName: (keyof ReturnType[LatestAlias] & FieldName) | string, operator: Operator | 'in' | 'not in', value: PrimitiveFieldType | Array<PrimitiveFieldType>): this;
+    /**
+     * Sets a limit to the number of results returned by the query. The maximum limit is 20,000 and the default is 1,000
+     * if none is provided.
+     *
+     * @param limit The maximum number of results to return
+     * @returns The query builder
+     */
+    limit(limit: number): this;
+    /**
+     * Adds a sort order to the query. You can add multiple sort orders to the query. The order in which you add them
+     * determines the order in which they are applied.
+     * @param fieldName The name of the field to sort by
+     * @param asc Whether to sort in ascending order. Defaults to true.
+     * @returns The query builder
+     */
+    sortBy(fieldName: (keyof ReturnType[RootAlias] & FieldName) | string, asc?: boolean): this;
+    /**
+     * Joins this query with another collection using a specified alias from the left side of the join,
+     * allowing you to build complex multi-level joins. The join is defined by specifying which fields
+     * to use on both sides of the relationship.
+     *
+     * @param queryBuilder - The query builder for the collection you want to join with.
+     * @param alias - A unique alias for the joined collection. Must not conflict with existing aliases.
+     * @param joinFields - The join condition specifying which fields to join: `left` is from the `leftAlias` collection,
+     *   `right` is from the joined collection.
+     * @param options - Configuration for the join:
+     *    - `leftAlias`: the alias of the collection on the left-hand side of the join.
+     *    - `isInner`: whether this should be an inner join (default is outer join).
+     * @returns A new `JoinQueryBuilder` instance including the joined collection, allowing you to continue building the
+     *   query.
+     */
+    join<NewAlias extends string, NewReturnType extends DocumentData, LeftAlias extends Extract<keyof ReturnType, Alias>, IsInner extends boolean = false>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
+        left: keyof Required<ReturnType>[LeftAlias] & FieldName;
+        right: keyof NewReturnType & FieldName;
+    }, options: {
+        leftAlias: LeftAlias;
+        isInner?: IsInner;
+    }): Omit<JoinQueryBuilder<Omit<Aliases, LeftAlias> & Record<LeftAlias, [...Aliases[LeftAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & (IsInner extends true ? Record<NewAlias, NewReturnType> : Partial<Record<NewAlias, NewReturnType>>), NewAlias, RootAlias>, 'limit' | 'getLimit'>;
+    /**
+     * Joins this query with another collection using a specified alias from the left side.
+     *
+     * @param queryBuilder - The query builder for the collection to be joined.
+     * @param alias - A unique alias for the joined collection.
+     * @param joinFields - Fields that define the join relationship (`left` and `right`).
+     * @param options - Options including the left alias to join from and whether the join is inner.
+     * @returns A new `JoinQueryBuilder` including the joined collection.
+     */
+    join<NewAlias extends string, NewReturnType extends DocumentData, IsInner extends boolean = false>(queryBuilder: QueryBuilder<NewReturnType>, alias: Exclude<NewAlias, keyof ReturnType>, joinFields: {
+        left: keyof Required<ReturnType>[LatestAlias] & FieldName;
+        right: keyof NewReturnType & FieldName;
+    }, options?: {
+        isInner?: IsInner;
+    }): Omit<JoinQueryBuilder<Omit<Aliases, LatestAlias> & Record<LatestAlias, [...Aliases[LatestAlias], NewAlias]> & Record<NewAlias, []>, ReturnType & (IsInner extends true ? Record<NewAlias, NewReturnType> : Partial<Record<NewAlias, NewReturnType>>), NewAlias, RootAlias>, 'limit' | 'getLimit'>;
+    /** @inheritDoc */
+    snapshot(): Promise<Array<WithDocumentReferences<ReturnType>>>;
+    /** @inheritDoc */
+    snapshots(subscribe?: boolean): Observable<Array<WithDocumentReferences<ReturnType>>>;
+    /**
+     * @inheritDoc
+     */
+    peek(): Array<WithDocumentReferences<ReturnType>>;
+    /** @inheritDoc */
+    grouped(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    dereference(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    build(): Query;
+    /**
+     * Gets the list of sort orders applied to the query.
+     *
+     * @returns An array of field sort configurations.
+     */
+    getSortOrders(): Array<FieldSort<any>>;
+    /**
+     * Creates a deep copy of the current query builder.
+     *
+     * @returns A cloned instance of the query builder.
+     */
+    clone(): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
+    /**
+     * Adds a composite condition (AND of multiple conditions) to the query.
+     *
+     * @param conditions An array of simple conditions to apply.
+     * @returns The updated query builder.
+     */
+    addCompositeCondition(conditions: Array<SimpleCondition>): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
+    /**
+     * Reverses the current sort order(s) of the query.
+     *
+     * @returns The updated query builder with reversed sort order(s).
+     */
+    flipSortOrder(): JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
+    /**
+     * Extracts the root document's data from a join query result.
+     *
+     * @param data A result object with document references.
+     * @returns The root alias's document reference data.
+     */
+    extractData(data: WithDocumentReferences<ReturnType>): Required<ReturnType>[RootAlias];
+    /**
+     * Serializes the join query into a plain object.
+     *
+     * @returns A serialized representation of the query, suitable for transport or logging.
+     */
+    serialize(): SerializedJoinQuery;
+    /**
+     * Enables pagination for the join query results.
+     *
+     * @param options Optional pagination configuration such as page size and cursor.
+     * @returns A {@link Pagination} object for fetching paginated results.
+     */
+    paginate(options?: Partial<PaginationOptions>): Pagination<WithDocumentReferences<ReturnType>>;
+    /**
+     * Checks whether the join query contains any inner joins.
+     *
+     * @returns `true` if at least one join is inner; otherwise `false`.
+     */
+    hasIsInner(): boolean;
+}
+/**
+ * A join query result that has been grouped by alias and returns the DocumentData.
+ * @category Database
+ */
+export declare class DereferencedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<ReturnType>, HasGrouped {
+    private readonly joinQueryBuilder;
+    /** @inheritDoc */
+    grouped(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
+    /** @inheritDoc */
+    snapshot(): Promise<Array<ReturnType>>;
+    /** @inheritDoc */
+    snapshots(subscribe?: boolean): Observable<Array<ReturnType>>;
+    /**
+     * @inheritDoc
+     */
+    peek(): Array<ReturnType>;
+    /**
+     * Returns the current sort orders applied to the query.
+     *
+     * @returns An array of field sort definitions.
+     */
+    getSortOrders(): Array<FieldSort<any>>;
+    /**
+     * Clones the current join query builder instance.
+     *
+     * @returns A deep copy of the join query builder.
+     */
+    clone(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /**
+     * Adds multiple conditions that are combined with an AND operator.
+     *
+     * @param conditions An array of conditions to be applied together.
+     * @returns The updated query builder.
+     */
+    addCompositeCondition(conditions: Array<SimpleCondition>): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /**
+     * Reverses the direction of all currently applied sort orders.
+     *
+     * @returns The updated query builder.
+     */
+    flipSortOrder(): DereferencedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /**
+     * Extracts the root document's data from the given join result.
+     *
+     * @param data A record containing document references.
+     * @returns The root document's data.
+     */
+    extractData(data: ReturnType): any;
+    /**
+     * Enables pagination for the join query results.
+     *
+     * @param options Optional pagination configuration such as page size and cursor.
+     * @returns A {@link Pagination} object for fetching paginated results.
+     */
+    paginate(options?: Partial<PaginationOptions>): Pagination<ReturnType>;
+    /**
+     * Serializes the join query into a plain object.
+     *
+     * @returns A serialized representation of the query, suitable for transport or logging.
+     */
+    serialize(): SerializedJoinQuery;
+}
+/**
+ * A join query result that has been grouped by alias.
+ * @category Database
+ */
+export declare class GroupedJoin<Aliases extends Record<Alias, Alias[]>, ReturnType extends Record<Alias, DocumentData>, RootAlias extends Alias, LatestAlias extends Alias> implements SnapshotEmitter<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>, HasDereference {
+    readonly joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>;
+    /** internal */
+    constructor(joinQueryBuilder: JoinQueryBuilder<Aliases, ReturnType, LatestAlias, RootAlias>);
+    /** @inheritDoc */
+    snapshot(): Promise<Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>>;
+    /** @inheritDoc */
+    snapshots(subscribe?: boolean): Observable<Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>>;
+    /**
+     * @inheritDoc
+     */
+    peek(): Array<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>;
+    /** @inheritDoc */
+    dereference(): SnapshotEmitter<Grouped<Aliases, ReturnType, RootAlias>>;
+    /** @inheritDoc */
+    getSortOrders(): Array<FieldSort<any>>;
+    /** @inheritDoc */
+    clone(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    addCompositeCondition(conditions: Array<SimpleCondition>): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    flipSortOrder(): GroupedJoin<Aliases, ReturnType, RootAlias, LatestAlias>;
+    /** @inheritDoc */
+    extractData(data: Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>): any;
+    /** @inheritDoc */
+    serialize(): SerializedJoinQuery;
+    /**
+     * Enables pagination for the join query results.
+     *
+     * @param options Optional pagination configuration such as page size and cursor.
+     * @returns A {@link Pagination} object for fetching paginated results.
+     */
+    paginate(options?: Partial<PaginationOptions>): Pagination<Grouped<Aliases, WithDocumentReferences<ReturnType>, RootAlias>>;
+    private groupData;
+}

package/dist/typescript-client/src/query/local-query-manager.d.ts

@@ -1,9 +1 @@
-import { DocumentReferenceFactory } from '../document-reference.factory';
-import { DocumentStore } from '../document-store';
-import { QuerySubscriptionManager } from './query-subscription.manager';
-export declare class LocalQueryManager {
-    private readonly documentStore;
-    private readonly documentReferenceFactory;
-    private readonly querySubscriptionManager;
-    constructor(documentStore: DocumentStore, documentReferenceFactory: DocumentReferenceFactory, querySubscriptionManager: QuerySubscriptionManager);
-}
+export {};

package/dist/{common → typescript-client}/src/query/pagination.d.ts

@@ -1,62 +1,65 @@
-import { Observable } from 'rxjs';
-/** The state of a pagination. */
-export interface PaginationState<ReturnType> {
-    /** The page data. */
-    data: Array<ReturnType>;
-    /** Whether there is a next page. */
-    hasNext: boolean;
-    /** Whether there is a previous page. */
-    hasPrev: boolean;
-}
-/** Pagination options */
-export interface PaginationOptions {
-    /** Whether to show real-time updates. Defaults to true. */
-    subscribe: boolean;
-    /** The number of items in a page. Defaults to 100. */
-    pageSize: number;
-}
-interface InternalState<ReturnType> {
-    data: ReturnType[];
-    extractedData: any[];
-    numBefore: number;
-    numAfter: number;
-}
-export declare class Pagination<ReturnType> {
-    private readonly options;
-    private internalStateObserver;
-    private firstElement;
-    private readonly isDestroyed;
-    private templateSnapshotEmitter;
-    private snapshotSubject;
-    private onFirstPage;
-    private navigatingToLastPage;
-    private lastElement;
-    private goToFirstPage;
-    private static compareValues;
-    private compare;
-    private dataReceived;
-    private doNewQuery;
-    private waitForInternalState;
-    private internalStateToState;
-    /** Unsubscribes from the pagination. */
-    unsubscribe(): void;
-    prevInternal(internalState: InternalState<ReturnType>): void;
-    /** Returns a promise that resolves when the previous page of data is available. */
-    prev(): Promise<PaginationState<ReturnType>>;
-    /** Returns a promise that resolves when the next page of data is available. */
-    next(): Promise<PaginationState<ReturnType>>;
-    /** Returns a promise that resolves when the page data is available. */
-    waitForData(): Promise<PaginationState<ReturnType>>;
-    /** Returns an observable that emits the current state of the pagination. */
-    observeState(): Observable<PaginationState<ReturnType>>;
-    /** Jumps to the first page of the pagination. */
-    first(): Promise<PaginationState<ReturnType>>;
-    /** Refreshes the current page of the pagination. */
-    refreshPage(): Promise<PaginationState<ReturnType>>;
-    /**
-     * Jumps to the last page of the pagination. This page will always have the last <pageSize> elements of the
-     * underlying query, regardless of whether the total document count is evenly divisible by the page size.
-     */
-    last(): Promise<PaginationState<ReturnType>>;
-}
-export {};
+import { Observable } from 'rxjs';
+/**
+ * The state of a pagination.
+ * @category Database
+ */
+export interface PaginationState<ReturnType> {
+    /** The page data. */
+    data: Array<ReturnType>;
+    /** Whether there is a next page. */
+    hasNext: boolean;
+    /** Whether there is a previous page. */
+    hasPrev: boolean;
+}
+/**
+ * Pagination options.
+ * @category Database
+ */
+export interface PaginationOptions {
+    /** Whether to show real-time updates. Defaults to true. */
+    subscribe: boolean;
+    /** The number of items in a page. Defaults to 100. */
+    pageSize: number;
+}
+/**
+ * Pagination provides a paginated view over a dataset, supporting navigation
+ * through pages, real-time updates, and sorting based on predefined criteria.
+ * @category Database
+ */
+export declare class Pagination<ReturnType> {
+    private readonly paginateOptions;
+    private internalStateObserver;
+    private firstElement;
+    private readonly isDestroyed;
+    private templateSnapshotEmitter;
+    private snapshotSubject;
+    private onFirstPage;
+    private navigatingToLastPage;
+    private lastElement;
+    /** Unsubscribes from the pagination. */
+    unsubscribe(): void;
+    /** Returns a promise that resolves when the previous page of data is available. */
+    prev(): Promise<PaginationState<ReturnType>>;
+    /** Returns a promise that resolves when the next page of data is available. */
+    next(): Promise<PaginationState<ReturnType>>;
+    /** Returns a promise that resolves when the page data is available. */
+    waitForData(): Promise<PaginationState<ReturnType>>;
+    /** Returns an observable that emits the current state of the pagination. */
+    observeState(): Observable<PaginationState<ReturnType>>;
+    /** Jumps to the first page of the pagination. */
+    first(): Promise<PaginationState<ReturnType>>;
+    /** Refreshes the current page of the pagination. */
+    refreshPage(): Promise<PaginationState<ReturnType>>;
+    /**
+     * Jumps to the last page of the pagination. This page will always have the last `pageSize` elements of the
+     * underlying query, regardless of whether the total document count is evenly divisible by the page size.
+     */
+    last(): Promise<PaginationState<ReturnType>>;
+    private goToFirstPage;
+    private compareObjects;
+    private dataReceived;
+    private doNewQuery;
+    private waitForInternalState;
+    private internalStateToState;
+    private prevInternal;
+}