@distrohelena/canton-typescript-sdk 0.1.16 → 0.1.18

package/dist/query/grpc/grpc-contract-query-client.d.ts

@@ -1,6 +1,6 @@
 import { StateServiceClient } from "../../services/state/state-service-client.js";
 import { QueryCacheStore } from "../cache/query-cache-store.js";
-import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow } from "../model-types.js";
+import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow, JsonProjectionResult } from "../model-types.js";
 import { QueryClient } from "../query-client.js";
 import { QuerySource } from "../query-source.js";
 type ActiveContractsReader = Pick<StateServiceClient, "getActiveContractsPageAsync">;
@@ -11,10 +11,11 @@ export declare class GrpcContractQueryClient implements QueryClient {
     private readonly cacheScope;
     readonly source = QuerySource.grpc;
     readonly contracts: {
-        findMany: (args?: ContractFindManyArgs) => Promise<readonly ContractRow[]>;
-        findUnique: (args: ContractFindUniqueArgs) => Promise<ContractRow>;
+        findMany: <TArgs extends ContractFindManyArgs>(args?: TArgs) => Promise<readonly (ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>)[]>;
+        findUnique: <TArgs extends ContractFindUniqueArgs>(args: TArgs) => Promise<(ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>) | undefined>;
         count: (args?: ContractCountArgs) => Promise<number>;
         aggregate: () => Promise<never>;
+        groupBy: () => Promise<never>;
     };
     readonly contractTypes: QueryClient["contractTypes"];
     readonly events: QueryClient["events"];

package/dist/query/grpc/grpc-contract-query-client.js

@@ -8,9 +8,9 @@ export class GrpcContractQueryClient {
     cacheScope;
     source = QuerySource.grpc;
     contracts = {
-        findMany: (args = {}) => this.findManyAsync(args),
+        findMany: (args = {}) => this.findManyAsync(args).then((rows) => rows),
         findUnique: (args) => {
-            if (args.select !== undefined) {
+            if (args.select !== undefined || args.include !== undefined) {
                 return Promise.reject(new QueryCapabilityError(QuerySource.grpc, "contracts.findUnique"));
             }
             return this.findManyAsync({ where: { contractId: { equals: args.where.contractId } } }).then((rows) => rows[0]);
@@ -19,6 +19,9 @@ export class GrpcContractQueryClient {
         aggregate: async () => {
             throw new QueryCapabilityError(QuerySource.grpc, "contracts.aggregate");
         },
+        groupBy: async () => {
+            throw new QueryCapabilityError(QuerySource.grpc, "contracts.groupBy");
+        },
     };
     contractTypes = this.unsupported("contractTypes");
     events = this.unsupported("events");
@@ -48,7 +51,7 @@ export class GrpcContractQueryClient {
             throw new QueryCapabilityError(QuerySource.grpc, "contracts.findMany");
         }
         const findArgs = args;
-        if (findArgs.select !== undefined || findArgs.orderBy !== undefined || findArgs.skip !== undefined || findArgs.take !== undefined) {
+        if (findArgs.select !== undefined || findArgs.include !== undefined || findArgs.orderBy !== undefined || findArgs.skip !== undefined || findArgs.take !== undefined) {
             throw new QueryCapabilityError(QuerySource.grpc, "contracts.findMany");
         }
         const snapshot = await this.readSnapshotAsync(args.parties);
@@ -73,6 +76,9 @@ export class GrpcContractQueryClient {
             aggregate: async () => {
                 throw new QueryCapabilityError(QuerySource.grpc, `${operation}.aggregate`);
             },
+            groupBy: async () => {
+                throw new QueryCapabilityError(QuerySource.grpc, `${operation}.groupBy`);
+            },
         };
     }
     async readSnapshotAsync(parties) {
@@ -90,7 +96,9 @@ export class GrpcContractQueryClient {
                 : { parties, activeAtOffset, pageToken }));
             activeAtOffset ??= response.activeAtOffset;
             pageToken = response.nextPageToken;
-            rows.push(...response.contracts.map(mapGrpcContract));
+            rows.push(...response.activeContracts.map((response) => mapGrpcContract(response.contractEntry.oneofKind === "activeContract"
+                ? response.contractEntry.activeContract
+                : response)));
         } while (pageToken !== undefined && pageToken.length > 0);
         if (this.cache !== undefined && this.cacheTtlMs !== undefined) {
             await this.cache.setAsync(key, rows, this.cacheTtlMs);

package/dist/query/model-types.d.ts

@@ -18,16 +18,96 @@ export interface StringFilter extends OrderedFilter<string> {
 export interface ArrayMembershipFilter {
     readonly has: string;
 }
+export interface JsonPathFilter {
+    readonly path: readonly [string, ...readonly string[]];
+    readonly equals?: string;
+    readonly in?: readonly string[];
+    readonly lt?: string;
+    readonly lte?: string;
+    readonly gt?: string;
+    readonly gte?: string;
+    readonly like?: string;
+    readonly ilike?: string;
+    readonly is?: null;
+    readonly isNot?: null;
+}
+export interface RelationListFilter<TWhere> {
+    readonly some?: TWhere;
+    readonly none?: TWhere;
+    readonly every?: TWhere;
+}
 export type WhereExpression<TFields> = TFields & {
     readonly and?: readonly WhereExpression<TFields>[];
     readonly or?: readonly WhereExpression<TFields>[];
     readonly not?: WhereExpression<TFields>;
 };
-export type RowWhere<TRow, TOrdered extends keyof TRow = never, TPattern extends keyof TRow = never> = WhereExpression<Partial<{
-    readonly [TField in keyof TRow]: TRow[TField] extends readonly string[] ? ScalarFilter<TRow[TField]> | ArrayMembershipFilter : TField extends TPattern ? StringFilter : TField extends TOrdered ? OrderedFilter<TRow[TField]> : ScalarFilter<TRow[TField]>;
+export type RowWhere<TRow, TOrdered extends keyof TRow = never, TPattern extends keyof TRow = never, TJson extends keyof TRow = never> = WhereExpression<Partial<{
+    readonly [TField in keyof TRow]: TRow[TField] extends readonly string[] ? ScalarFilter<TRow[TField]> | ArrayMembershipFilter : TField extends TJson ? JsonPathFilter : TField extends TPattern ? StringFilter : TField extends TOrdered ? OrderedFilter<TRow[TField]> : ScalarFilter<TRow[TField]>;
 }>>;
-export type RowSelect<TRow> = Partial<Record<keyof TRow, boolean>>;
-export type RowOrderBy<TRow> = Partial<Record<keyof TRow, QueryOrder>>;
+export type RowSelect<TRow> = Partial<Record<keyof TRow, boolean>> & {
+    readonly json?: Readonly<Record<string, JsonFieldProjection>>;
+};
+export type OneFieldOrderBy<TRow> = {
+    readonly [TField in keyof TRow]: Readonly<{
+        readonly [TKey in TField]: QueryOrder;
+    }> & Partial<Record<Exclude<keyof TRow, TField>, never>>;
+}[keyof TRow];
+export type RowOrderBy<TRow> = readonly [
+    OneFieldOrderBy<TRow>,
+    ...readonly OneFieldOrderBy<TRow>[]
+];
+export type TimeBucket = "hour" | "day" | "week" | "month";
+export interface JsonPath {
+    readonly path: readonly [string, ...readonly string[]];
+}
+export type JsonScalarType = "text" | "numeric" | "boolean" | "timestamp";
+export interface JsonProjection extends JsonPath {
+    readonly as: JsonScalarType;
+}
+export interface JsonFieldProjection extends JsonProjection {
+    readonly field: string;
+}
+export type JsonProjectedValue<TProjection> = TProjection extends {
+    readonly as: "numeric";
+} ? string | null : TProjection extends {
+    readonly as: "boolean";
+} ? boolean | null : TProjection extends {
+    readonly as: "timestamp";
+} ? Date | null : string | null;
+export type JsonProjectionResult<TArgs> = TArgs extends {
+    readonly select?: {
+        readonly json?: infer TSelections;
+    };
+} ? TSelections extends Readonly<Record<string, JsonFieldProjection>> ? {
+    readonly [TName in keyof TSelections]: JsonProjectedValue<TSelections[TName]>;
+} : {} : {};
+export interface JsonGroupBy extends JsonProjection {
+    readonly name: string;
+}
+export type ToOneRelationArgs<TWhere, TSelect, TOrderBy, TInclude> = true | {
+    readonly where?: TWhere;
+    readonly select?: TSelect;
+    readonly orderBy?: TOrderBy;
+    readonly include?: TInclude;
+};
+export interface ToManyRelationArgs<TWhere, TSelect, TOrderBy, TInclude> extends QueryPageArgs {
+    readonly take: number;
+    readonly where?: TWhere;
+    readonly select?: TSelect;
+    readonly orderBy?: TOrderBy;
+    readonly include?: TInclude;
+}
+export interface GroupAggregateArgs<TNumericField extends string> {
+    readonly count?: true;
+    readonly min?: readonly TNumericField[];
+    readonly max?: readonly TNumericField[];
+    readonly sum?: readonly TNumericField[];
+}
+export interface GroupByArgs<TWhere, TKey, TNumericField extends string> {
+    readonly where?: TWhere;
+    readonly by: readonly [TKey, ...readonly TKey[]];
+    readonly aggregate: GroupAggregateArgs<TNumericField>;
+}
 export interface QueryPageArgs {
     readonly skip?: number;
     readonly take?: number;
@@ -44,6 +124,13 @@ export interface ContractRow {
     readonly archivedAt: Date | null;
     readonly active: boolean;
 }
+export interface ContractRelationRow {
+    readonly contractType?: ContractTypeRow;
+    readonly createdTransaction?: TransactionRow;
+    readonly archivedTransaction?: TransactionRow | null;
+    readonly exercises?: readonly ExerciseRow[];
+}
+export type ContractResult = ContractRow & ContractRelationRow;
 export interface TemplateId {
     readonly packageId: string;
     readonly moduleName: string;
@@ -129,27 +216,41 @@ type ContractWhereFields = {
         readonly has: string;
     };
     readonly payload?: ContractPayloadFilter;
+    readonly contractType?: ContractTypeWhere;
+    readonly createdTransaction?: TransactionWhere;
+    readonly archivedTransaction?: TransactionWhere;
+    readonly exercises?: RelationListFilter<ExerciseWhere>;
 };
 export type ContractWhere = WhereExpression<ContractWhereFields>;
 export type ContractOrderField = "contractId" | "createdEventOffset" | "createdAt" | "archivedEventOffset" | "archivedAt";
-export type ContractOrderBy = Partial<Record<ContractOrderField, QueryOrder>>;
-export type ContractSelect = Partial<Record<keyof ContractRow, boolean>>;
+export type ContractOrderBy = readonly [
+    OneFieldOrderBy<Pick<ContractRow, ContractOrderField>>,
+    ...readonly OneFieldOrderBy<Pick<ContractRow, ContractOrderField>>[]
+];
+export type ContractSelect = RowSelect<ContractRow>;
 export interface ContractFindManyArgs extends QueryPageArgs {
     readonly parties?: readonly string[];
     readonly where?: ContractWhere;
     readonly orderBy?: ContractOrderBy;
     readonly select?: ContractSelect;
+    readonly include?: ContractInclude;
 }
 export interface ContractFindUniqueArgs {
     readonly where: {
         readonly contractId: string;
     };
     readonly select?: ContractSelect;
+    readonly include?: ContractInclude;
 }
 export interface ContractCountArgs {
     readonly parties?: readonly string[];
     readonly where?: ContractWhere;
 }
+export type ContractGroupByKey = ContractOrderField | "witnesses" | {
+    readonly payload: JsonGroupBy;
+};
+export type ContractGroupByArgs = GroupByArgs<ContractWhere, ContractGroupByKey, "createdEventOffset" | "archivedEventOffset">;
+export type ContractGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
 export interface ContractTypeRow {
     readonly pk: string;
     readonly payloadType: string;
@@ -176,7 +277,7 @@ export interface ExerciseRow {
     readonly redactionId: string | null;
     readonly packagePk: string;
     readonly controllers: readonly string[];
-    readonly lastDescendantNodeId: number;
+    readonly lastDescendantNodeId: string;
     readonly witnesses: readonly string[];
 }
 export interface ExerciseTypeRow {
@@ -213,28 +314,73 @@ export interface WatermarkRow {
     readonly offset: string | null;
     readonly instanceId: string | null;
 }
-export type ContractTypeWhere = RowWhere<ContractTypeRow, "pk", "payloadType" | "packageName" | "moduleName" | "entityName" | "templateFqn">;
+export type ContractTypeResult = ContractTypeRow & {
+    readonly contracts?: readonly ContractResult[];
+    readonly exercises?: readonly ExerciseResult[];
+};
+export type EventResult = EventRow & {
+    readonly transaction?: TransactionResult;
+    readonly exercises?: readonly ExerciseResult[];
+};
+export type ExerciseResult = ExerciseRow & {
+    readonly exerciseType?: ExerciseTypeResult;
+    readonly contractType?: ContractTypeResult;
+    readonly event?: EventResult | null;
+    readonly transaction?: TransactionResult | null;
+    readonly package?: PackageResult;
+    readonly contract?: ContractResult;
+};
+export type ExerciseTypeResult = ExerciseTypeRow & {
+    readonly exercises?: readonly ExerciseResult[];
+};
+export type PackageResult = PackageRow & {
+    readonly exercises?: readonly ExerciseResult[];
+};
+export type TransactionResult = TransactionRow & {
+    readonly events?: readonly EventResult[];
+    readonly createdContracts?: readonly ContractResult[];
+    readonly archivedContracts?: readonly ContractResult[];
+    readonly exercises?: readonly ExerciseResult[];
+};
+export type ContractTypeWhere = RowWhere<ContractTypeRow, "pk", "payloadType" | "packageName" | "moduleName" | "entityName" | "templateFqn"> & {
+    readonly contracts?: RelationListFilter<ContractWhere>;
+    readonly exercises?: RelationListFilter<ExerciseWhere>;
+};
 export type ContractTypeSelect = RowSelect<ContractTypeRow>;
 export type ContractTypeOrderBy = RowOrderBy<ContractTypeRow>;
 export type ContractTypeUnique = {
     readonly pk: string;
 };
-export type EventWhere = RowWhere<EventRow, "pk" | "txIx", "eventId" | "type">;
+export type EventWhere = RowWhere<EventRow, "pk" | "txIx", "eventId" | "type"> & {
+    readonly transaction?: TransactionWhere;
+    readonly exercises?: RelationListFilter<ExerciseWhere>;
+};
 export type EventSelect = RowSelect<EventRow>;
 export type EventOrderBy = RowOrderBy<EventRow>;
 export type EventUnique = {
     readonly pk: string;
 };
-export type ExerciseWhere = RowWhere<ExerciseRow, "tpePk" | "contractTpePk" | "exerciseEventPk" | "exercisedAtIx" | "packagePk" | "lastDescendantNodeId", "contractId" | "redactionId">;
+export type ExerciseWhere = RowWhere<ExerciseRow, "tpePk" | "contractTpePk" | "exerciseEventPk" | "exercisedAtIx" | "packagePk" | "lastDescendantNodeId", "contractId" | "redactionId", "argument" | "result"> & {
+    readonly exerciseType?: ExerciseTypeWhere;
+    readonly contractType?: ContractTypeWhere;
+    readonly event?: EventWhere;
+    readonly transaction?: TransactionWhere;
+    readonly package?: PackageWhere;
+    readonly contract?: ContractWhere;
+};
 export type ExerciseSelect = RowSelect<ExerciseRow>;
 export type ExerciseOrderBy = RowOrderBy<ExerciseRow>;
-export type ExerciseTypeWhere = RowWhere<ExerciseTypeRow, "pk", "choice" | "packageName" | "moduleName" | "entityName" | "templateFqn" | "choiceFqn">;
+export type ExerciseTypeWhere = RowWhere<ExerciseTypeRow, "pk", "choice" | "packageName" | "moduleName" | "entityName" | "templateFqn" | "choiceFqn"> & {
+    readonly exercises?: RelationListFilter<ExerciseWhere>;
+};
 export type ExerciseTypeSelect = RowSelect<ExerciseTypeRow>;
 export type ExerciseTypeOrderBy = RowOrderBy<ExerciseTypeRow>;
 export type ExerciseTypeUnique = {
     readonly pk: string;
 };
-export type PackageWhere = RowWhere<PackageRow, "pk", "name" | "version" | "id">;
+export type PackageWhere = RowWhere<PackageRow, "pk", "name" | "version" | "id"> & {
+    readonly exercises?: RelationListFilter<ExerciseWhere>;
+};
 export type PackageSelect = RowSelect<PackageRow>;
 export type PackageOrderBy = RowOrderBy<PackageRow>;
 export type PackageUnique = {
@@ -242,7 +388,12 @@ export type PackageUnique = {
 } | {
     readonly id: string;
 };
-export type TransactionWhere = RowWhere<TransactionRow, "ix" | "offset" | "effectiveAt" | "paidTrafficCost", "transactionId" | "workflowId" | "domainId">;
+export type TransactionWhere = RowWhere<TransactionRow, "ix" | "offset" | "effectiveAt" | "paidTrafficCost", "transactionId" | "workflowId" | "domainId", "traceContext"> & {
+    readonly events?: RelationListFilter<EventWhere>;
+    readonly createdContracts?: RelationListFilter<ContractWhere>;
+    readonly archivedContracts?: RelationListFilter<ContractWhere>;
+    readonly exercises?: RelationListFilter<ExerciseWhere>;
+};
 export type TransactionSelect = RowSelect<TransactionRow>;
 export type TransactionOrderBy = RowOrderBy<TransactionRow>;
 export type TransactionUnique = {
@@ -256,6 +407,73 @@ export type WatermarkOrderBy = RowOrderBy<WatermarkRow>;
 export type WatermarkUnique = {
     readonly singleton: boolean;
 };
+export interface ContractInclude {
+    readonly contractType?: ToOneRelationArgs<ContractTypeWhere, ContractTypeSelect, ContractTypeOrderBy, ContractTypeInclude>;
+    readonly createdTransaction?: ToOneRelationArgs<TransactionWhere, TransactionSelect, TransactionOrderBy, TransactionInclude>;
+    readonly archivedTransaction?: ToOneRelationArgs<TransactionWhere, TransactionSelect, TransactionOrderBy, TransactionInclude>;
+    readonly exercises?: ToManyRelationArgs<ExerciseWhere, ExerciseSelect, ExerciseOrderBy, ExerciseInclude>;
+}
+export interface ContractTypeInclude {
+    readonly contracts?: ToManyRelationArgs<ContractWhere, ContractSelect, ContractOrderBy, ContractInclude>;
+    readonly exercises?: ToManyRelationArgs<ExerciseWhere, ExerciseSelect, ExerciseOrderBy, ExerciseInclude>;
+}
+export interface EventInclude {
+    readonly transaction?: ToOneRelationArgs<TransactionWhere, TransactionSelect, TransactionOrderBy, TransactionInclude>;
+    readonly exercises?: ToManyRelationArgs<ExerciseWhere, ExerciseSelect, ExerciseOrderBy, ExerciseInclude>;
+}
+export interface ExerciseInclude {
+    readonly exerciseType?: ToOneRelationArgs<ExerciseTypeWhere, ExerciseTypeSelect, ExerciseTypeOrderBy, ExerciseTypeInclude>;
+    readonly contractType?: ToOneRelationArgs<ContractTypeWhere, ContractTypeSelect, ContractTypeOrderBy, ContractTypeInclude>;
+    readonly event?: ToOneRelationArgs<EventWhere, EventSelect, EventOrderBy, EventInclude>;
+    readonly transaction?: ToOneRelationArgs<TransactionWhere, TransactionSelect, TransactionOrderBy, TransactionInclude>;
+    readonly package?: ToOneRelationArgs<PackageWhere, PackageSelect, PackageOrderBy, PackageInclude>;
+    readonly contract?: ToOneRelationArgs<ContractWhere, ContractSelect, ContractOrderBy, ContractInclude>;
+}
+export interface ExerciseTypeInclude {
+    readonly exercises?: ToManyRelationArgs<ExerciseWhere, ExerciseSelect, ExerciseOrderBy, ExerciseInclude>;
+}
+export interface PackageInclude {
+    readonly exercises?: ToManyRelationArgs<ExerciseWhere, ExerciseSelect, ExerciseOrderBy, ExerciseInclude>;
+}
+export interface TransactionInclude {
+    readonly events?: ToManyRelationArgs<EventWhere, EventSelect, EventOrderBy, EventInclude>;
+    readonly createdContracts?: ToManyRelationArgs<ContractWhere, ContractSelect, ContractOrderBy, ContractInclude>;
+    readonly archivedContracts?: ToManyRelationArgs<ContractWhere, ContractSelect, ContractOrderBy, ContractInclude>;
+    readonly exercises?: ToManyRelationArgs<ExerciseWhere, ExerciseSelect, ExerciseOrderBy, ExerciseInclude>;
+}
+export type EventGroupByKey = keyof EventRow | {
+    readonly transaction: {
+        readonly effectiveAt: {
+            readonly bucket: TimeBucket;
+        };
+    };
+};
+export type EventGroupByArgs = GroupByArgs<EventWhere, EventGroupByKey, "pk" | "txIx">;
+export type EventGroupRow = Readonly<Record<string, string | number | Date | null>>;
+export type ExerciseGroupByKey = keyof ExerciseRow | {
+    readonly argument: JsonGroupBy;
+} | {
+    readonly result: JsonGroupBy;
+};
+export type ExerciseGroupByArgs = GroupByArgs<ExerciseWhere, ExerciseGroupByKey, "tpePk" | "contractTpePk" | "exerciseEventPk" | "exercisedAtIx" | "packagePk" | "lastDescendantNodeId">;
+export type ExerciseGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
+export type TransactionGroupByKey = keyof TransactionRow | {
+    readonly effectiveAt: {
+        readonly bucket: TimeBucket;
+    };
+} | {
+    readonly traceContext: JsonGroupBy;
+};
+export type TransactionGroupByArgs = GroupByArgs<TransactionWhere, TransactionGroupByKey, "ix" | "offset" | "paidTrafficCost">;
+export type TransactionGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
+export type ContractTypeGroupByArgs = GroupByArgs<ContractTypeWhere, keyof ContractTypeRow, "pk">;
+export type ContractTypeGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
+export type ExerciseTypeGroupByArgs = GroupByArgs<ExerciseTypeWhere, keyof ExerciseTypeRow, "pk">;
+export type ExerciseTypeGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
+export type PackageGroupByArgs = GroupByArgs<PackageWhere, keyof PackageRow, "pk">;
+export type PackageGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
+export type WatermarkGroupByArgs = GroupByArgs<WatermarkWhere, keyof WatermarkRow, "ix" | "offset">;
+export type WatermarkGroupRow = Readonly<Record<string, string | number | boolean | Date | null>>;
 export declare function assertQueryPageArgs(args: QueryPageArgs): void;
-export declare function assertQueryOrderBy(orderBy: Readonly<Record<string, QueryOrder>>): void;
+export declare function assertQueryOrderBy(orderBy: readonly Readonly<Record<string, QueryOrder>>[]): void;
 export {};

package/dist/query/model-types.js

@@ -3,8 +3,8 @@ export function assertQueryPageArgs(args) {
     assertPageValue(args.take, "take");
 }
 export function assertQueryOrderBy(orderBy) {
-    if (Object.keys(orderBy).length !== 1) {
-        throw new Error("orderBy must specify exactly one field");
+    if (orderBy.length === 0 || orderBy.some((entry) => Object.keys(entry).length !== 1)) {
+        throw new Error("orderBy must be a non-empty list of one-field entries");
     }
 }
 function assertPageValue(value, name) {

package/dist/query/pqs/pqs-query-client.d.ts

@@ -1,4 +1,4 @@
-import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractRow } from "../model-types.js";
+import { ContractCountArgs, ContractFindManyArgs, ContractFindUniqueArgs, ContractGroupByArgs, ContractRow, ContractResult, JsonProjectionResult } from "../model-types.js";
 import { QueryClient } from "../query-client.js";
 import { QuerySource } from "../query-source.js";
 import { PqsSchemaProfileV1 } from "./pqs-schema-profile.js";
@@ -13,8 +13,8 @@ export declare class PqsQueryClient implements QueryClient {
     private readonly ready;
     readonly source = QuerySource.pqs;
     readonly contracts: {
-        findMany: (args?: ContractFindManyArgs) => Promise<readonly ContractRow[]>;
-        findUnique: (args: ContractFindUniqueArgs) => Promise<ContractRow>;
+        findMany: <TArgs extends ContractFindManyArgs>(args?: TArgs) => Promise<readonly (ContractResult & JsonProjectionResult<TArgs>)[]>;
+        findUnique: <TArgs extends ContractFindUniqueArgs>(args: TArgs) => Promise<(ContractRow & import("../model-types.js").ContractRelationRow & JsonProjectionResult<TArgs>) | undefined>;
         count: (args?: ContractCountArgs) => Promise<number>;
         aggregate: (args: Parameters<QueryClient["contracts"]["aggregate"]>[0]) => Promise<{
             readonly count?: number;
@@ -22,6 +22,7 @@ export declare class PqsQueryClient implements QueryClient {
             readonly max?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
             readonly sum?: Readonly<Partial<Record<import("../query-client.js").ContractNumericField, string | null>>>;
         }>;
+        groupBy: (args: ContractGroupByArgs) => Promise<readonly Readonly<Record<string, string | number | boolean | Date | null>>[]>;
     };
     readonly contractTypes: QueryClient["contractTypes"];
     readonly events: QueryClient["events"];
@@ -33,9 +34,11 @@ export declare class PqsQueryClient implements QueryClient {
     constructor(executor: PqsQueryExecutor, profile: PqsSchemaProfileV1, ready?: Promise<void>);
     $queryRaw<TRow>(sql: string, values?: readonly unknown[]): Promise<readonly TRow[]>;
     private createPhysicalDelegate;
+    private groupPhysicalAsync;
     private readPhysicalAsync;
     private aggregatePhysicalAsync;
     private compileWhere;
+    private compileLogicalContractWhere;
     private selectedFields;
     private compileOrderBy;
     private assertUniqueWhere;
@@ -43,7 +46,15 @@ export declare class PqsQueryClient implements QueryClient {
     private field;
     private assertPage;
     private mapPhysicalRow;
+    private mapRelatedValue;
+    private mapLogicalContractValue;
+    private compileIncludes;
+    private compileJsonSelections;
+    private compileIncludedExpression;
+    private compileLogicalContractSelections;
+    private compileLogicalContractJsonSelections;
     private findContractsAsync;
     private aggregateContractsAsync;
+    private groupContractsAsync;
     private wrap;
 }