@constructive-io/sdk 0.30.0 → 0.30.1

package/esm/{config/orm/models/platformConfigDefinition.js → infra/orm/models/platformNamespace.js}

@@ -1,12 +1,12 @@
 import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
 import { connectionFieldsMap } from '../input-types';
-export class PlatformConfigDefinitionModel {
+export class PlatformNamespaceModel {
     client;
     constructor(client) {
         this.client = client;
     }
     findMany(args) {
-        const { document, variables } = buildFindManyDocument('PlatformConfigDefinition', 'platformConfigDefinitions', args.select, {
+        const { document, variables } = buildFindManyDocument('PlatformNamespace', 'platformNamespaces', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
             first: args?.first,
@@ -14,85 +14,85 @@ export class PlatformConfigDefinitionModel {
             after: args?.after,
             before: args?.before,
             offset: args?.offset,
-        }, 'PlatformConfigDefinitionFilter', 'PlatformConfigDefinitionOrderBy', connectionFieldsMap);
+        }, 'PlatformNamespaceFilter', 'PlatformNamespaceOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'PlatformConfigDefinition',
-            fieldName: 'platformConfigDefinitions',
+            operationName: 'PlatformNamespace',
+            fieldName: 'platformNamespaces',
             document,
             variables,
         });
     }
     findFirst(args) {
-        const { document, variables } = buildFindFirstDocument('PlatformConfigDefinition', 'platformConfigDefinitions', args.select, {
+        const { document, variables } = buildFindFirstDocument('PlatformNamespace', 'platformNamespaces', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
-        }, 'PlatformConfigDefinitionFilter', 'PlatformConfigDefinitionOrderBy', connectionFieldsMap);
+        }, 'PlatformNamespaceFilter', 'PlatformNamespaceOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'PlatformConfigDefinition',
-            fieldName: 'platformConfigDefinition',
+            operationName: 'PlatformNamespace',
+            fieldName: 'platformNamespace',
             document,
             variables,
             transform: (data) => ({
-                platformConfigDefinition: data.platformConfigDefinitions?.nodes?.[0] ?? null,
+                platformNamespace: data.platformNamespaces?.nodes?.[0] ?? null,
             }),
         });
     }
     findOne(args) {
-        const { document, variables } = buildFindManyDocument('PlatformConfigDefinition', 'platformConfigDefinitions', args.select, {
+        const { document, variables } = buildFindManyDocument('PlatformNamespace', 'platformNamespaces', args.select, {
             where: {
                 id: {
                     equalTo: args.id,
                 },
             },
             first: 1,
-        }, 'PlatformConfigDefinitionFilter', 'PlatformConfigDefinitionOrderBy', connectionFieldsMap);
+        }, 'PlatformNamespaceFilter', 'PlatformNamespaceOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'PlatformConfigDefinition',
-            fieldName: 'platformConfigDefinition',
+            operationName: 'PlatformNamespace',
+            fieldName: 'platformNamespace',
             document,
             variables,
             transform: (data) => ({
-                platformConfigDefinition: data.platformConfigDefinitions?.nodes?.[0] ?? null,
+                platformNamespace: data.platformNamespaces?.nodes?.[0] ?? null,
             }),
         });
     }
     create(args) {
-        const { document, variables } = buildCreateDocument('PlatformConfigDefinition', 'createPlatformConfigDefinition', 'platformConfigDefinition', args.select, args.data, 'CreatePlatformConfigDefinitionInput', connectionFieldsMap);
+        const { document, variables } = buildCreateDocument('PlatformNamespace', 'createPlatformNamespace', 'platformNamespace', args.select, args.data, 'CreatePlatformNamespaceInput', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'PlatformConfigDefinition',
-            fieldName: 'createPlatformConfigDefinition',
+            operationName: 'PlatformNamespace',
+            fieldName: 'createPlatformNamespace',
             document,
             variables,
         });
     }
     update(args) {
-        const { document, variables } = buildUpdateByPkDocument('PlatformConfigDefinition', 'updatePlatformConfigDefinition', 'platformConfigDefinition', args.select, args.where.id, args.data, 'UpdatePlatformConfigDefinitionInput', 'id', 'platformConfigDefinitionPatch', connectionFieldsMap, undefined);
+        const { document, variables } = buildUpdateByPkDocument('PlatformNamespace', 'updatePlatformNamespace', 'platformNamespace', args.select, args.where.id, args.data, 'UpdatePlatformNamespaceInput', 'id', 'platformNamespacePatch', connectionFieldsMap, undefined);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'PlatformConfigDefinition',
-            fieldName: 'updatePlatformConfigDefinition',
+            operationName: 'PlatformNamespace',
+            fieldName: 'updatePlatformNamespace',
             document,
             variables,
         });
     }
     delete(args) {
-        const { document, variables } = buildDeleteByPkDocument('PlatformConfigDefinition', 'deletePlatformConfigDefinition', 'platformConfigDefinition', {
+        const { document, variables } = buildDeleteByPkDocument('PlatformNamespace', 'deletePlatformNamespace', 'platformNamespace', {
             id: args.where.id,
-        }, 'DeletePlatformConfigDefinitionInput', args.select, connectionFieldsMap);
+        }, 'DeletePlatformNamespaceInput', args.select, connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'PlatformConfigDefinition',
-            fieldName: 'deletePlatformConfigDefinition',
+            operationName: 'PlatformNamespace',
+            fieldName: 'deletePlatformNamespace',
             document,
             variables,
         });

package/esm/infra/orm/models/platformNamespaceEvent.d.ts

@@ -0,0 +1,56 @@
+/**
+ * PlatformNamespaceEvent model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { PlatformNamespaceEventWithRelations, PlatformNamespaceEventSelect, PlatformNamespaceEventFilter, PlatformNamespaceEventOrderBy, CreatePlatformNamespaceEventInput, PlatformNamespaceEventPatch } from '../input-types';
+export declare class PlatformNamespaceEventModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends PlatformNamespaceEventSelect>(args: FindManyArgs<S, PlatformNamespaceEventFilter, PlatformNamespaceEventOrderBy> & {
+        select: S;
+    } & StrictSelect<S, PlatformNamespaceEventSelect>): QueryBuilder<{
+        platformNamespaceEvents: ConnectionResult<InferSelectResult<PlatformNamespaceEventWithRelations, S>>;
+    }>;
+    findFirst<S extends PlatformNamespaceEventSelect>(args: FindFirstArgs<S, PlatformNamespaceEventFilter, PlatformNamespaceEventOrderBy> & {
+        select: S;
+    } & StrictSelect<S, PlatformNamespaceEventSelect>): QueryBuilder<{
+        platformNamespaceEvent: InferSelectResult<PlatformNamespaceEventWithRelations, S> | null;
+    }>;
+    findOne<S extends PlatformNamespaceEventSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, PlatformNamespaceEventSelect>): QueryBuilder<{
+        platformNamespaceEvent: InferSelectResult<PlatformNamespaceEventWithRelations, S> | null;
+    }>;
+    create<S extends PlatformNamespaceEventSelect>(args: CreateArgs<S, CreatePlatformNamespaceEventInput['platformNamespaceEvent']> & {
+        select: S;
+    } & StrictSelect<S, PlatformNamespaceEventSelect>): QueryBuilder<{
+        createPlatformNamespaceEvent: {
+            platformNamespaceEvent: InferSelectResult<PlatformNamespaceEventWithRelations, S>;
+        };
+    }>;
+    update<S extends PlatformNamespaceEventSelect>(args: UpdateArgs<S, {
+        id: string;
+        createdAt: string;
+    }, PlatformNamespaceEventPatch> & {
+        select: S;
+    } & StrictSelect<S, PlatformNamespaceEventSelect>): QueryBuilder<{
+        updatePlatformNamespaceEvent: {
+            platformNamespaceEvent: InferSelectResult<PlatformNamespaceEventWithRelations, S>;
+        };
+    }>;
+    delete<S extends PlatformNamespaceEventSelect>(args: DeleteArgs<{
+        id: string;
+        createdAt: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, PlatformNamespaceEventSelect>): QueryBuilder<{
+        deletePlatformNamespaceEvent: {
+            platformNamespaceEvent: InferSelectResult<PlatformNamespaceEventWithRelations, S>;
+        };
+    }>;
+}

package/esm/infra/orm/models/platformNamespaceEvent.js

@@ -0,0 +1,103 @@
+import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export class PlatformNamespaceEventModel {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    findMany(args) {
+        const { document, variables } = buildFindManyDocument('PlatformNamespaceEvent', 'platformNamespaceEvents', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+            first: args?.first,
+            last: args?.last,
+            after: args?.after,
+            before: args?.before,
+            offset: args?.offset,
+        }, 'PlatformNamespaceEventFilter', 'PlatformNamespaceEventOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'PlatformNamespaceEvent',
+            fieldName: 'platformNamespaceEvents',
+            document,
+            variables,
+        });
+    }
+    findFirst(args) {
+        const { document, variables } = buildFindFirstDocument('PlatformNamespaceEvent', 'platformNamespaceEvents', args.select, {
+            where: args?.where,
+            orderBy: args?.orderBy,
+        }, 'PlatformNamespaceEventFilter', 'PlatformNamespaceEventOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'PlatformNamespaceEvent',
+            fieldName: 'platformNamespaceEvent',
+            document,
+            variables,
+            transform: (data) => ({
+                platformNamespaceEvent: data.platformNamespaceEvents?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    findOne(args) {
+        const { document, variables } = buildFindManyDocument('PlatformNamespaceEvent', 'platformNamespaceEvents', args.select, {
+            where: {
+                id: {
+                    equalTo: args.id,
+                },
+            },
+            first: 1,
+        }, 'PlatformNamespaceEventFilter', 'PlatformNamespaceEventOrderBy', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'query',
+            operationName: 'PlatformNamespaceEvent',
+            fieldName: 'platformNamespaceEvent',
+            document,
+            variables,
+            transform: (data) => ({
+                platformNamespaceEvent: data.platformNamespaceEvents?.nodes?.[0] ?? null,
+            }),
+        });
+    }
+    create(args) {
+        const { document, variables } = buildCreateDocument('PlatformNamespaceEvent', 'createPlatformNamespaceEvent', 'platformNamespaceEvent', args.select, args.data, 'CreatePlatformNamespaceEventInput', connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'PlatformNamespaceEvent',
+            fieldName: 'createPlatformNamespaceEvent',
+            document,
+            variables,
+        });
+    }
+    update(args) {
+        const { document, variables } = buildUpdateByPkDocument('PlatformNamespaceEvent', 'updatePlatformNamespaceEvent', 'platformNamespaceEvent', args.select, args.where.id, args.data, 'UpdatePlatformNamespaceEventInput', 'id', 'platformNamespaceEventPatch', connectionFieldsMap, {
+            createdAt: args.where.createdAt,
+        });
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'PlatformNamespaceEvent',
+            fieldName: 'updatePlatformNamespaceEvent',
+            document,
+            variables,
+        });
+    }
+    delete(args) {
+        const { document, variables } = buildDeleteByPkDocument('PlatformNamespaceEvent', 'deletePlatformNamespaceEvent', 'platformNamespaceEvent', {
+            id: args.where.id,
+            createdAt: args.where.createdAt,
+        }, 'DeletePlatformNamespaceEventInput', args.select, connectionFieldsMap);
+        return new QueryBuilder({
+            client: this.client,
+            operation: 'mutation',
+            operationName: 'PlatformNamespaceEvent',
+            fieldName: 'deletePlatformNamespaceEvent',
+            document,
+            variables,
+        });
+    }
+}

package/esm/infra/orm/mutation/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Custom mutation operations
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { InferSelectResult, StrictSelect } from '../select-types';
+import type { InfraInitEmptyRepoInput, InfraSetDataAtPathInput, InfraInsertNodeAtPathInput, ProvisionBucketInput, InfraInitEmptyRepoPayload, InfraSetDataAtPathPayload, InfraInsertNodeAtPathPayload, ProvisionBucketPayload, InfraInitEmptyRepoPayloadSelect, InfraSetDataAtPathPayloadSelect, InfraInsertNodeAtPathPayloadSelect, ProvisionBucketPayloadSelect } from '../input-types';
+export interface InfraInitEmptyRepoVariables {
+    input: InfraInitEmptyRepoInput;
+}
+export interface InfraSetDataAtPathVariables {
+    input: InfraSetDataAtPathInput;
+}
+export interface InfraInsertNodeAtPathVariables {
+    input: InfraInsertNodeAtPathInput;
+}
+/**
+ * Variables for provisionBucket
+ * Provision an S3 bucket for a logical bucket in the database.
+Reads the bucket config via RLS, then creates and configures
+the S3 bucket with the appropriate privacy policies, CORS rules,
+and lifecycle settings.
+ */
+export interface ProvisionBucketVariables {
+    input: ProvisionBucketInput;
+}
+export declare function createMutationOperations(client: OrmClient): {
+    infraInitEmptyRepo: <S extends InfraInitEmptyRepoPayloadSelect>(args: InfraInitEmptyRepoVariables, options: {
+        select: S;
+    } & StrictSelect<S, InfraInitEmptyRepoPayloadSelect>) => QueryBuilder<{
+        infraInitEmptyRepo: InferSelectResult<InfraInitEmptyRepoPayload, S> | null;
+    }>;
+    infraSetDataAtPath: <S extends InfraSetDataAtPathPayloadSelect>(args: InfraSetDataAtPathVariables, options: {
+        select: S;
+    } & StrictSelect<S, InfraSetDataAtPathPayloadSelect>) => QueryBuilder<{
+        infraSetDataAtPath: InferSelectResult<InfraSetDataAtPathPayload, S> | null;
+    }>;
+    infraInsertNodeAtPath: <S extends InfraInsertNodeAtPathPayloadSelect>(args: InfraInsertNodeAtPathVariables, options: {
+        select: S;
+    } & StrictSelect<S, InfraInsertNodeAtPathPayloadSelect>) => QueryBuilder<{
+        infraInsertNodeAtPath: InferSelectResult<InfraInsertNodeAtPathPayload, S> | null;
+    }>;
+    provisionBucket: <S extends ProvisionBucketPayloadSelect>(args: ProvisionBucketVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionBucketPayloadSelect>) => QueryBuilder<{
+        provisionBucket: InferSelectResult<ProvisionBucketPayload, S> | null;
+    }>;
+};

package/esm/infra/orm/mutation/index.js

@@ -0,0 +1,54 @@
+import { QueryBuilder, buildCustomDocument } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export function createMutationOperations(client) {
+    return {
+        infraInitEmptyRepo: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'InfraInitEmptyRepo',
+            fieldName: 'infraInitEmptyRepo',
+            ...buildCustomDocument('mutation', 'InfraInitEmptyRepo', 'infraInitEmptyRepo', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'InfraInitEmptyRepoInput!',
+                },
+            ], connectionFieldsMap, 'InfraInitEmptyRepoPayload'),
+        }),
+        infraSetDataAtPath: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'InfraSetDataAtPath',
+            fieldName: 'infraSetDataAtPath',
+            ...buildCustomDocument('mutation', 'InfraSetDataAtPath', 'infraSetDataAtPath', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'InfraSetDataAtPathInput!',
+                },
+            ], connectionFieldsMap, 'InfraSetDataAtPathPayload'),
+        }),
+        infraInsertNodeAtPath: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'InfraInsertNodeAtPath',
+            fieldName: 'infraInsertNodeAtPath',
+            ...buildCustomDocument('mutation', 'InfraInsertNodeAtPath', 'infraInsertNodeAtPath', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'InfraInsertNodeAtPathInput!',
+                },
+            ], connectionFieldsMap, 'InfraInsertNodeAtPathPayload'),
+        }),
+        provisionBucket: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionBucket',
+            fieldName: 'provisionBucket',
+            ...buildCustomDocument('mutation', 'ProvisionBucket', 'provisionBucket', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionBucketInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionBucketPayload'),
+        }),
+    };
+}

package/esm/infra/orm/query-builder.d.ts

@@ -0,0 +1,110 @@
+import type { FieldNode } from 'graphql';
+import { OrmClient, QueryResult } from './client';
+export interface QueryBuilderConfig<TResult> {
+    client: OrmClient;
+    operation: 'query' | 'mutation';
+    operationName: string;
+    fieldName: string;
+    document: string;
+    variables?: Record<string, unknown>;
+    transform?: (data: any) => TResult;
+}
+export declare class QueryBuilder<TResult> {
+    private config;
+    constructor(config: QueryBuilderConfig<TResult>);
+    /**
+     * Execute the query and return a discriminated union result
+     * Use result.ok to check success, or .unwrap() to throw on error
+     */
+    execute(): Promise<QueryResult<TResult>>;
+    /**
+     * Execute and unwrap the result, throwing GraphQLRequestError on failure
+     * @throws {GraphQLRequestError} If the query returns errors
+     */
+    unwrap(): Promise<TResult>;
+    /**
+     * Execute and unwrap, returning defaultValue on error instead of throwing
+     */
+    unwrapOr<D>(defaultValue: D): Promise<TResult | D>;
+    /**
+     * Execute and unwrap, calling onError callback on failure
+     */
+    unwrapOrElse<D>(onError: (errors: import('./client').GraphQLError[]) => D): Promise<TResult | D>;
+    toGraphQL(): string;
+    getVariables(): Record<string, unknown> | undefined;
+}
+export declare function buildSelections(select: Record<string, unknown> | undefined, connectionFieldsMap?: Record<string, Record<string, string>>, entityType?: string): FieldNode[];
+export declare function buildFindManyDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+    orderBy?: string[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}, filterTypeName: string, orderByTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindFirstDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+    orderBy?: string[];
+}, filterTypeName: string, orderByTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCreateDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, data: TData, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateDocument<TSelect, TWhere extends {
+    id: string;
+}, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string, patchFieldName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateByPkDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, id: string | number, data: TData, inputTypeName: string, idFieldName: string, patchFieldName: string, connectionFieldsMap?: Record<string, Record<string, string>>, extraKeys?: Record<string, unknown>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindOneDocument<TSelect>(operationName: string, queryField: string, id: string | number, select: TSelect, idArgName: string, idTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteDocument<TWhere extends {
+    id: string;
+}, TSelect = undefined>(operationName: string, mutationField: string, entityField: string, where: TWhere, inputTypeName: string, select?: TSelect, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteByPkDocument<TSelect = undefined>(operationName: string, mutationField: string, entityField: string, keys: Record<string, unknown>, inputTypeName: string, select?: TSelect, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildJunctionRemoveDocument(operationName: string, mutationField: string, keys: Record<string, unknown>, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCustomDocument<TSelect, TArgs>(operationType: 'query' | 'mutation', operationName: string, fieldName: string, select: TSelect, args: TArgs, variableDefinitions: Array<{
+    name: string;
+    type: string;
+}>, connectionFieldsMap?: Record<string, Record<string, string>>, entityType?: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkInsertDocument<TSelect, TData>(operationName: string, mutationField: string, select: TSelect, data: TData[], inputTypeName: string, onConflict?: unknown, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkUpsertDocument<TSelect, TData>(operationName: string, mutationField: string, select: TSelect, data: TData[], inputTypeName: string, onConflict: unknown, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkUpdateDocument<TSelect, TWhere, TData>(operationName: string, mutationField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkDeleteDocument<TSelect, TWhere>(operationName: string, mutationField: string, select: TSelect, where: TWhere, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};