@agentlang/agentmanager 0.0.3 → 0.0.4

package/dist/apps/monolith/apps/integrations/src/generated/prisma-postgres/models/IntegrationEntity.d.ts

@@ -0,0 +1,521 @@
+import type * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../internal/prismaNamespace";
+export type IntegrationEntityModel = runtime.Types.Result.DefaultSelection<Prisma.$IntegrationEntityPayload>;
+export type AggregateIntegrationEntity = {
+    _count: IntegrationEntityCountAggregateOutputType | null;
+    _min: IntegrationEntityMinAggregateOutputType | null;
+    _max: IntegrationEntityMaxAggregateOutputType | null;
+};
+export type IntegrationEntityMinAggregateOutputType = {
+    entity: string | null;
+    id: string | null;
+    tenantId: string | null;
+    providerId: string | null;
+    connectionId: string | null;
+    status: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+};
+export type IntegrationEntityMaxAggregateOutputType = {
+    entity: string | null;
+    id: string | null;
+    tenantId: string | null;
+    providerId: string | null;
+    connectionId: string | null;
+    status: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+};
+export type IntegrationEntityCountAggregateOutputType = {
+    entity: number;
+    id: number;
+    tenantId: number;
+    providerId: number;
+    connectionId: number;
+    status: number;
+    data: number;
+    createdAt: number;
+    updatedAt: number;
+    _all: number;
+};
+export type IntegrationEntityMinAggregateInputType = {
+    entity?: true;
+    id?: true;
+    tenantId?: true;
+    providerId?: true;
+    connectionId?: true;
+    status?: true;
+    createdAt?: true;
+    updatedAt?: true;
+};
+export type IntegrationEntityMaxAggregateInputType = {
+    entity?: true;
+    id?: true;
+    tenantId?: true;
+    providerId?: true;
+    connectionId?: true;
+    status?: true;
+    createdAt?: true;
+    updatedAt?: true;
+};
+export type IntegrationEntityCountAggregateInputType = {
+    entity?: true;
+    id?: true;
+    tenantId?: true;
+    providerId?: true;
+    connectionId?: true;
+    status?: true;
+    data?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    _all?: true;
+};
+export type IntegrationEntityAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: Prisma.IntegrationEntityWhereInput;
+    orderBy?: Prisma.IntegrationEntityOrderByWithRelationInput | Prisma.IntegrationEntityOrderByWithRelationInput[];
+    cursor?: Prisma.IntegrationEntityWhereUniqueInput;
+    take?: number;
+    skip?: number;
+    _count?: true | IntegrationEntityCountAggregateInputType;
+    _min?: IntegrationEntityMinAggregateInputType;
+    _max?: IntegrationEntityMaxAggregateInputType;
+};
+export type GetIntegrationEntityAggregateType<T extends IntegrationEntityAggregateArgs> = {
+    [P in keyof T & keyof AggregateIntegrationEntity]: P extends '_count' | 'count' ? T[P] extends true ? number : Prisma.GetScalarType<T[P], AggregateIntegrationEntity[P]> : Prisma.GetScalarType<T[P], AggregateIntegrationEntity[P]>;
+};
+export type IntegrationEntityGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: Prisma.IntegrationEntityWhereInput;
+    orderBy?: Prisma.IntegrationEntityOrderByWithAggregationInput | Prisma.IntegrationEntityOrderByWithAggregationInput[];
+    by: Prisma.IntegrationEntityScalarFieldEnum[] | Prisma.IntegrationEntityScalarFieldEnum;
+    having?: Prisma.IntegrationEntityScalarWhereWithAggregatesInput;
+    take?: number;
+    skip?: number;
+    _count?: IntegrationEntityCountAggregateInputType | true;
+    _min?: IntegrationEntityMinAggregateInputType;
+    _max?: IntegrationEntityMaxAggregateInputType;
+};
+export type IntegrationEntityGroupByOutputType = {
+    entity: string;
+    id: string;
+    tenantId: string | null;
+    providerId: string | null;
+    connectionId: string | null;
+    status: string | null;
+    data: runtime.JsonValue;
+    createdAt: Date;
+    updatedAt: Date;
+    _count: IntegrationEntityCountAggregateOutputType | null;
+    _min: IntegrationEntityMinAggregateOutputType | null;
+    _max: IntegrationEntityMaxAggregateOutputType | null;
+};
+type GetIntegrationEntityGroupByPayload<T extends IntegrationEntityGroupByArgs> = Prisma.PrismaPromise<Array<Prisma.PickEnumerable<IntegrationEntityGroupByOutputType, T['by']> & {
+    [P in ((keyof T) & (keyof IntegrationEntityGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : Prisma.GetScalarType<T[P], IntegrationEntityGroupByOutputType[P]> : Prisma.GetScalarType<T[P], IntegrationEntityGroupByOutputType[P]>;
+}>>;
+export type IntegrationEntityWhereInput = {
+    AND?: Prisma.IntegrationEntityWhereInput | Prisma.IntegrationEntityWhereInput[];
+    OR?: Prisma.IntegrationEntityWhereInput[];
+    NOT?: Prisma.IntegrationEntityWhereInput | Prisma.IntegrationEntityWhereInput[];
+    entity?: Prisma.StringFilter<"IntegrationEntity"> | string;
+    id?: Prisma.StringFilter<"IntegrationEntity"> | string;
+    tenantId?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    providerId?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    connectionId?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    status?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    data?: Prisma.JsonFilter<"IntegrationEntity">;
+    createdAt?: Prisma.DateTimeFilter<"IntegrationEntity"> | Date | string;
+    updatedAt?: Prisma.DateTimeFilter<"IntegrationEntity"> | Date | string;
+};
+export type IntegrationEntityOrderByWithRelationInput = {
+    entity?: Prisma.SortOrder;
+    id?: Prisma.SortOrder;
+    tenantId?: Prisma.SortOrderInput | Prisma.SortOrder;
+    providerId?: Prisma.SortOrderInput | Prisma.SortOrder;
+    connectionId?: Prisma.SortOrderInput | Prisma.SortOrder;
+    status?: Prisma.SortOrderInput | Prisma.SortOrder;
+    data?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    updatedAt?: Prisma.SortOrder;
+};
+export type IntegrationEntityWhereUniqueInput = Prisma.AtLeast<{
+    entity_id?: Prisma.IntegrationEntityEntityIdCompoundUniqueInput;
+    AND?: Prisma.IntegrationEntityWhereInput | Prisma.IntegrationEntityWhereInput[];
+    OR?: Prisma.IntegrationEntityWhereInput[];
+    NOT?: Prisma.IntegrationEntityWhereInput | Prisma.IntegrationEntityWhereInput[];
+    entity?: Prisma.StringFilter<"IntegrationEntity"> | string;
+    id?: Prisma.StringFilter<"IntegrationEntity"> | string;
+    tenantId?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    providerId?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    connectionId?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    status?: Prisma.StringNullableFilter<"IntegrationEntity"> | string | null;
+    data?: Prisma.JsonFilter<"IntegrationEntity">;
+    createdAt?: Prisma.DateTimeFilter<"IntegrationEntity"> | Date | string;
+    updatedAt?: Prisma.DateTimeFilter<"IntegrationEntity"> | Date | string;
+}, "entity_id">;
+export type IntegrationEntityOrderByWithAggregationInput = {
+    entity?: Prisma.SortOrder;
+    id?: Prisma.SortOrder;
+    tenantId?: Prisma.SortOrderInput | Prisma.SortOrder;
+    providerId?: Prisma.SortOrderInput | Prisma.SortOrder;
+    connectionId?: Prisma.SortOrderInput | Prisma.SortOrder;
+    status?: Prisma.SortOrderInput | Prisma.SortOrder;
+    data?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    updatedAt?: Prisma.SortOrder;
+    _count?: Prisma.IntegrationEntityCountOrderByAggregateInput;
+    _max?: Prisma.IntegrationEntityMaxOrderByAggregateInput;
+    _min?: Prisma.IntegrationEntityMinOrderByAggregateInput;
+};
+export type IntegrationEntityScalarWhereWithAggregatesInput = {
+    AND?: Prisma.IntegrationEntityScalarWhereWithAggregatesInput | Prisma.IntegrationEntityScalarWhereWithAggregatesInput[];
+    OR?: Prisma.IntegrationEntityScalarWhereWithAggregatesInput[];
+    NOT?: Prisma.IntegrationEntityScalarWhereWithAggregatesInput | Prisma.IntegrationEntityScalarWhereWithAggregatesInput[];
+    entity?: Prisma.StringWithAggregatesFilter<"IntegrationEntity"> | string;
+    id?: Prisma.StringWithAggregatesFilter<"IntegrationEntity"> | string;
+    tenantId?: Prisma.StringNullableWithAggregatesFilter<"IntegrationEntity"> | string | null;
+    providerId?: Prisma.StringNullableWithAggregatesFilter<"IntegrationEntity"> | string | null;
+    connectionId?: Prisma.StringNullableWithAggregatesFilter<"IntegrationEntity"> | string | null;
+    status?: Prisma.StringNullableWithAggregatesFilter<"IntegrationEntity"> | string | null;
+    data?: Prisma.JsonWithAggregatesFilter<"IntegrationEntity">;
+    createdAt?: Prisma.DateTimeWithAggregatesFilter<"IntegrationEntity"> | Date | string;
+    updatedAt?: Prisma.DateTimeWithAggregatesFilter<"IntegrationEntity"> | Date | string;
+};
+export type IntegrationEntityCreateInput = {
+    entity: string;
+    id: string;
+    tenantId?: string | null;
+    providerId?: string | null;
+    connectionId?: string | null;
+    status?: string | null;
+    data: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+};
+export type IntegrationEntityUncheckedCreateInput = {
+    entity: string;
+    id: string;
+    tenantId?: string | null;
+    providerId?: string | null;
+    connectionId?: string | null;
+    status?: string | null;
+    data: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+};
+export type IntegrationEntityUpdateInput = {
+    entity?: Prisma.StringFieldUpdateOperationsInput | string;
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    tenantId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    providerId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    connectionId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    status?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    data?: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type IntegrationEntityUncheckedUpdateInput = {
+    entity?: Prisma.StringFieldUpdateOperationsInput | string;
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    tenantId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    providerId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    connectionId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    status?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    data?: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type IntegrationEntityCreateManyInput = {
+    entity: string;
+    id: string;
+    tenantId?: string | null;
+    providerId?: string | null;
+    connectionId?: string | null;
+    status?: string | null;
+    data: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+};
+export type IntegrationEntityUpdateManyMutationInput = {
+    entity?: Prisma.StringFieldUpdateOperationsInput | string;
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    tenantId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    providerId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    connectionId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    status?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    data?: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type IntegrationEntityUncheckedUpdateManyInput = {
+    entity?: Prisma.StringFieldUpdateOperationsInput | string;
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    tenantId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    providerId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    connectionId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    status?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    data?: Prisma.JsonNullValueInput | runtime.InputJsonValue;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type IntegrationEntityEntityIdCompoundUniqueInput = {
+    entity: string;
+    id: string;
+};
+export type IntegrationEntityCountOrderByAggregateInput = {
+    entity?: Prisma.SortOrder;
+    id?: Prisma.SortOrder;
+    tenantId?: Prisma.SortOrder;
+    providerId?: Prisma.SortOrder;
+    connectionId?: Prisma.SortOrder;
+    status?: Prisma.SortOrder;
+    data?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    updatedAt?: Prisma.SortOrder;
+};
+export type IntegrationEntityMaxOrderByAggregateInput = {
+    entity?: Prisma.SortOrder;
+    id?: Prisma.SortOrder;
+    tenantId?: Prisma.SortOrder;
+    providerId?: Prisma.SortOrder;
+    connectionId?: Prisma.SortOrder;
+    status?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    updatedAt?: Prisma.SortOrder;
+};
+export type IntegrationEntityMinOrderByAggregateInput = {
+    entity?: Prisma.SortOrder;
+    id?: Prisma.SortOrder;
+    tenantId?: Prisma.SortOrder;
+    providerId?: Prisma.SortOrder;
+    connectionId?: Prisma.SortOrder;
+    status?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    updatedAt?: Prisma.SortOrder;
+};
+export type StringFieldUpdateOperationsInput = {
+    set?: string;
+};
+export type NullableStringFieldUpdateOperationsInput = {
+    set?: string | null;
+};
+export type DateTimeFieldUpdateOperationsInput = {
+    set?: Date | string;
+};
+export type IntegrationEntitySelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    entity?: boolean;
+    id?: boolean;
+    tenantId?: boolean;
+    providerId?: boolean;
+    connectionId?: boolean;
+    status?: boolean;
+    data?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+}, ExtArgs["result"]["integrationEntity"]>;
+export type IntegrationEntitySelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    entity?: boolean;
+    id?: boolean;
+    tenantId?: boolean;
+    providerId?: boolean;
+    connectionId?: boolean;
+    status?: boolean;
+    data?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+}, ExtArgs["result"]["integrationEntity"]>;
+export type IntegrationEntitySelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    entity?: boolean;
+    id?: boolean;
+    tenantId?: boolean;
+    providerId?: boolean;
+    connectionId?: boolean;
+    status?: boolean;
+    data?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+}, ExtArgs["result"]["integrationEntity"]>;
+export type IntegrationEntitySelectScalar = {
+    entity?: boolean;
+    id?: boolean;
+    tenantId?: boolean;
+    providerId?: boolean;
+    connectionId?: boolean;
+    status?: boolean;
+    data?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+};
+export type IntegrationEntityOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"entity" | "id" | "tenantId" | "providerId" | "connectionId" | "status" | "data" | "createdAt" | "updatedAt", ExtArgs["result"]["integrationEntity"]>;
+export type $IntegrationEntityPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    name: "IntegrationEntity";
+    objects: {};
+    scalars: runtime.Types.Extensions.GetPayloadResult<{
+        entity: string;
+        id: string;
+        tenantId: string | null;
+        providerId: string | null;
+        connectionId: string | null;
+        status: string | null;
+        data: runtime.JsonValue;
+        createdAt: Date;
+        updatedAt: Date;
+    }, ExtArgs["result"]["integrationEntity"]>;
+    composites: {};
+};
+export type IntegrationEntityGetPayload<S extends boolean | null | undefined | IntegrationEntityDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload, S>;
+export type IntegrationEntityCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<IntegrationEntityFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: IntegrationEntityCountAggregateInputType | true;
+};
+export interface IntegrationEntityDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: {
+        types: Prisma.TypeMap<ExtArgs>['model']['IntegrationEntity'];
+        meta: {
+            name: 'IntegrationEntity';
+        };
+    };
+    findUnique<T extends IntegrationEntityFindUniqueArgs>(args: Prisma.SelectSubset<T, IntegrationEntityFindUniqueArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    findUniqueOrThrow<T extends IntegrationEntityFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, IntegrationEntityFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    findFirst<T extends IntegrationEntityFindFirstArgs>(args?: Prisma.SelectSubset<T, IntegrationEntityFindFirstArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    findFirstOrThrow<T extends IntegrationEntityFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, IntegrationEntityFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    findMany<T extends IntegrationEntityFindManyArgs>(args?: Prisma.SelectSubset<T, IntegrationEntityFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
+    create<T extends IntegrationEntityCreateArgs>(args: Prisma.SelectSubset<T, IntegrationEntityCreateArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    createMany<T extends IntegrationEntityCreateManyArgs>(args?: Prisma.SelectSubset<T, IntegrationEntityCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    createManyAndReturn<T extends IntegrationEntityCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, IntegrationEntityCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
+    delete<T extends IntegrationEntityDeleteArgs>(args: Prisma.SelectSubset<T, IntegrationEntityDeleteArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    update<T extends IntegrationEntityUpdateArgs>(args: Prisma.SelectSubset<T, IntegrationEntityUpdateArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    deleteMany<T extends IntegrationEntityDeleteManyArgs>(args?: Prisma.SelectSubset<T, IntegrationEntityDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    updateMany<T extends IntegrationEntityUpdateManyArgs>(args: Prisma.SelectSubset<T, IntegrationEntityUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    updateManyAndReturn<T extends IntegrationEntityUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, IntegrationEntityUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
+    upsert<T extends IntegrationEntityUpsertArgs>(args: Prisma.SelectSubset<T, IntegrationEntityUpsertArgs<ExtArgs>>): Prisma.Prisma__IntegrationEntityClient<runtime.Types.Result.GetResult<Prisma.$IntegrationEntityPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    count<T extends IntegrationEntityCountArgs>(args?: Prisma.Subset<T, IntegrationEntityCountArgs>): Prisma.PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : Prisma.GetScalarType<T['select'], IntegrationEntityCountAggregateOutputType> : number>;
+    aggregate<T extends IntegrationEntityAggregateArgs>(args: Prisma.Subset<T, IntegrationEntityAggregateArgs>): Prisma.PrismaPromise<GetIntegrationEntityAggregateType<T>>;
+    groupBy<T extends IntegrationEntityGroupByArgs, HasSelectOrTake extends Prisma.Or<Prisma.Extends<'skip', Prisma.Keys<T>>, Prisma.Extends<'take', Prisma.Keys<T>>>, OrderByArg extends Prisma.True extends HasSelectOrTake ? {
+        orderBy: IntegrationEntityGroupByArgs['orderBy'];
+    } : {
+        orderBy?: IntegrationEntityGroupByArgs['orderBy'];
+    }, OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, ByFields extends Prisma.MaybeTupleToUnion<T['by']>, ByValid extends Prisma.Has<ByFields, OrderFields>, HavingFields extends Prisma.GetHavingFields<T['having']>, HavingValid extends Prisma.Has<ByFields, HavingFields>, ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, InputErrors extends ByEmpty extends Prisma.True ? `Error: "by" must not be empty.` : HavingValid extends Prisma.False ? {
+        [P in HavingFields]: P extends ByFields ? never : P extends string ? `Error: Field "${P}" used in "having" needs to be provided in "by".` : [
+            Error,
+            'Field ',
+            P,
+            ` in "having" needs to be provided in "by"`
+        ];
+    }[HavingFields] : 'take' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields] : 'Error: If you provide "take", you also need to provide "orderBy"' : 'skip' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields] : 'Error: If you provide "skip", you also need to provide "orderBy"' : ByValid extends Prisma.True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields]>(args: Prisma.SubsetIntersection<T, IntegrationEntityGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetIntegrationEntityGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>;
+    readonly fields: IntegrationEntityFieldRefs;
+}
+export interface Prisma__IntegrationEntityClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise";
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
+}
+export interface IntegrationEntityFieldRefs {
+    readonly entity: Prisma.FieldRef<"IntegrationEntity", 'String'>;
+    readonly id: Prisma.FieldRef<"IntegrationEntity", 'String'>;
+    readonly tenantId: Prisma.FieldRef<"IntegrationEntity", 'String'>;
+    readonly providerId: Prisma.FieldRef<"IntegrationEntity", 'String'>;
+    readonly connectionId: Prisma.FieldRef<"IntegrationEntity", 'String'>;
+    readonly status: Prisma.FieldRef<"IntegrationEntity", 'String'>;
+    readonly data: Prisma.FieldRef<"IntegrationEntity", 'Json'>;
+    readonly createdAt: Prisma.FieldRef<"IntegrationEntity", 'DateTime'>;
+    readonly updatedAt: Prisma.FieldRef<"IntegrationEntity", 'DateTime'>;
+}
+export type IntegrationEntityFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where: Prisma.IntegrationEntityWhereUniqueInput;
+};
+export type IntegrationEntityFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where: Prisma.IntegrationEntityWhereUniqueInput;
+};
+export type IntegrationEntityFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where?: Prisma.IntegrationEntityWhereInput;
+    orderBy?: Prisma.IntegrationEntityOrderByWithRelationInput | Prisma.IntegrationEntityOrderByWithRelationInput[];
+    cursor?: Prisma.IntegrationEntityWhereUniqueInput;
+    take?: number;
+    skip?: number;
+    distinct?: Prisma.IntegrationEntityScalarFieldEnum | Prisma.IntegrationEntityScalarFieldEnum[];
+};
+export type IntegrationEntityFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where?: Prisma.IntegrationEntityWhereInput;
+    orderBy?: Prisma.IntegrationEntityOrderByWithRelationInput | Prisma.IntegrationEntityOrderByWithRelationInput[];
+    cursor?: Prisma.IntegrationEntityWhereUniqueInput;
+    take?: number;
+    skip?: number;
+    distinct?: Prisma.IntegrationEntityScalarFieldEnum | Prisma.IntegrationEntityScalarFieldEnum[];
+};
+export type IntegrationEntityFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where?: Prisma.IntegrationEntityWhereInput;
+    orderBy?: Prisma.IntegrationEntityOrderByWithRelationInput | Prisma.IntegrationEntityOrderByWithRelationInput[];
+    cursor?: Prisma.IntegrationEntityWhereUniqueInput;
+    take?: number;
+    skip?: number;
+    distinct?: Prisma.IntegrationEntityScalarFieldEnum | Prisma.IntegrationEntityScalarFieldEnum[];
+};
+export type IntegrationEntityCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    data: Prisma.XOR<Prisma.IntegrationEntityCreateInput, Prisma.IntegrationEntityUncheckedCreateInput>;
+};
+export type IntegrationEntityCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    data: Prisma.IntegrationEntityCreateManyInput | Prisma.IntegrationEntityCreateManyInput[];
+    skipDuplicates?: boolean;
+};
+export type IntegrationEntityCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelectCreateManyAndReturn<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    data: Prisma.IntegrationEntityCreateManyInput | Prisma.IntegrationEntityCreateManyInput[];
+    skipDuplicates?: boolean;
+};
+export type IntegrationEntityUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    data: Prisma.XOR<Prisma.IntegrationEntityUpdateInput, Prisma.IntegrationEntityUncheckedUpdateInput>;
+    where: Prisma.IntegrationEntityWhereUniqueInput;
+};
+export type IntegrationEntityUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    data: Prisma.XOR<Prisma.IntegrationEntityUpdateManyMutationInput, Prisma.IntegrationEntityUncheckedUpdateManyInput>;
+    where?: Prisma.IntegrationEntityWhereInput;
+    limit?: number;
+};
+export type IntegrationEntityUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelectUpdateManyAndReturn<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    data: Prisma.XOR<Prisma.IntegrationEntityUpdateManyMutationInput, Prisma.IntegrationEntityUncheckedUpdateManyInput>;
+    where?: Prisma.IntegrationEntityWhereInput;
+    limit?: number;
+};
+export type IntegrationEntityUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where: Prisma.IntegrationEntityWhereUniqueInput;
+    create: Prisma.XOR<Prisma.IntegrationEntityCreateInput, Prisma.IntegrationEntityUncheckedCreateInput>;
+    update: Prisma.XOR<Prisma.IntegrationEntityUpdateInput, Prisma.IntegrationEntityUncheckedUpdateInput>;
+};
+export type IntegrationEntityDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+    where: Prisma.IntegrationEntityWhereUniqueInput;
+};
+export type IntegrationEntityDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: Prisma.IntegrationEntityWhereInput;
+    limit?: number;
+};
+export type IntegrationEntityDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    select?: Prisma.IntegrationEntitySelect<ExtArgs> | null;
+    omit?: Prisma.IntegrationEntityOmit<ExtArgs> | null;
+};
+export {};

package/dist/apps/monolith/apps/integrations/src/generated/prisma-postgres/models/IntegrationEntity.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IntegrationEntity.js.map

package/dist/apps/monolith/apps/integrations/src/generated/prisma-postgres/models/IntegrationEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IntegrationEntity.js","sourceRoot":"","sources":["../../../../../../../../../apps/integrations/src/generated/prisma-postgres/models/IntegrationEntity.ts"],"names":[],"mappings":""}

package/dist/apps/monolith/apps/integrations/src/generated/prisma-postgres/models.d.ts

@@ -0,0 +1,2 @@
+export type * from './models/IntegrationEntity';
+export type * from './commonInputTypes';

package/dist/apps/monolith/apps/integrations/src/generated/prisma-postgres/models.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=models.js.map

package/dist/apps/monolith/apps/integrations/src/generated/prisma-postgres/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../../../../apps/integrations/src/generated/prisma-postgres/models.ts"],"names":[],"mappings":""}

package/dist/apps/monolith/apps/integrations/src/generated/prisma-sqlite/client.d.ts

@@ -0,0 +1,9 @@
+import * as runtime from "@prisma/client/runtime/client";
+import * as $Class from "./internal/class";
+import * as Prisma from "./internal/prismaNamespace";
+export * as $Enums from './enums';
+export * from "./enums";
+export declare const PrismaClient: $Class.PrismaClientConstructor;
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+export { Prisma };
+export type IntegrationEntity = Prisma.IntegrationEntityModel;

package/dist/apps/monolith/apps/integrations/src/generated/prisma-sqlite/client.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prisma = exports.PrismaClient = exports.$Enums = void 0;
+const $Class = __importStar(require("./internal/class"));
+const Prisma = __importStar(require("./internal/prismaNamespace"));
+exports.Prisma = Prisma;
+exports.$Enums = __importStar(require("./enums"));
+__exportStar(require("./enums"), exports);
+exports.PrismaClient = $Class.getPrismaClientClass();
+//# sourceMappingURL=client.js.map

package/dist/apps/monolith/apps/integrations/src/generated/prisma-sqlite/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../../../../../apps/integrations/src/generated/prisma-sqlite/client.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,yDAA0C;AAC1C,mEAAoD;AAqB3C,wBAAM;AAnBf,kDAAiC;AACjC,0CAAuB;AAgBV,QAAA,YAAY,GAAG,MAAM,CAAC,oBAAoB,EAAE,CAAA"}