@roastery-adapters/models 0.0.2

package/dist/class-0p_HeQd8.d.ts

@@ -0,0 +1,3643 @@
+import * as runtime from '@prisma/client/runtime/client';
+
+/**
+ * Model ModelType
+ *
+ */
+type ModelTypeModel = runtime.Types.Result.DefaultSelection<$ModelTypePayload>;
+type AggregateModelType = {
+    _count: ModelTypeCountAggregateOutputType | null;
+    _min: ModelTypeMinAggregateOutputType | null;
+    _max: ModelTypeMaxAggregateOutputType | null;
+};
+type ModelTypeMinAggregateOutputType = {
+    id: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    name: string | null;
+    slug: string | null;
+    schema: string | null;
+};
+type ModelTypeMaxAggregateOutputType = {
+    id: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    name: string | null;
+    slug: string | null;
+    schema: string | null;
+};
+type ModelTypeCountAggregateOutputType = {
+    id: number;
+    createdAt: number;
+    updatedAt: number;
+    name: number;
+    slug: number;
+    schema: number;
+    _all: number;
+};
+type ModelTypeMinAggregateInputType = {
+    id?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    name?: true;
+    slug?: true;
+    schema?: true;
+};
+type ModelTypeMaxAggregateInputType = {
+    id?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    name?: true;
+    slug?: true;
+    schema?: true;
+};
+type ModelTypeCountAggregateInputType = {
+    id?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    name?: true;
+    slug?: true;
+    schema?: true;
+    _all?: true;
+};
+type ModelTypeAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which ModelType to aggregate.
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of ModelTypes to fetch.
+     */
+    orderBy?: ModelTypeOrderByWithRelationInput | ModelTypeOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the start position
+     */
+    cursor?: ModelTypeWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` ModelTypes from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` ModelTypes.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Count returned ModelTypes
+    **/
+    _count?: true | ModelTypeCountAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the minimum value
+    **/
+    _min?: ModelTypeMinAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the maximum value
+    **/
+    _max?: ModelTypeMaxAggregateInputType;
+};
+type GetModelTypeAggregateType<T extends ModelTypeAggregateArgs> = {
+    [P in keyof T & keyof AggregateModelType]: P extends '_count' | 'count' ? T[P] extends true ? number : GetScalarType<T[P], AggregateModelType[P]> : GetScalarType<T[P], AggregateModelType[P]>;
+};
+type ModelTypeGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: ModelTypeWhereInput;
+    orderBy?: ModelTypeOrderByWithAggregationInput | ModelTypeOrderByWithAggregationInput[];
+    by: ModelTypeScalarFieldEnum[] | ModelTypeScalarFieldEnum;
+    having?: ModelTypeScalarWhereWithAggregatesInput;
+    take?: number;
+    skip?: number;
+    _count?: ModelTypeCountAggregateInputType | true;
+    _min?: ModelTypeMinAggregateInputType;
+    _max?: ModelTypeMaxAggregateInputType;
+};
+type ModelTypeGroupByOutputType = {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date | null;
+    name: string;
+    slug: string;
+    schema: string;
+    _count: ModelTypeCountAggregateOutputType | null;
+    _min: ModelTypeMinAggregateOutputType | null;
+    _max: ModelTypeMaxAggregateOutputType | null;
+};
+type GetModelTypeGroupByPayload<T extends ModelTypeGroupByArgs> = PrismaPromise<Array<PickEnumerable<ModelTypeGroupByOutputType, T['by']> & {
+    [P in ((keyof T) & (keyof ModelTypeGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : GetScalarType<T[P], ModelTypeGroupByOutputType[P]> : GetScalarType<T[P], ModelTypeGroupByOutputType[P]>;
+}>>;
+type ModelTypeWhereInput = {
+    AND?: ModelTypeWhereInput | ModelTypeWhereInput[];
+    OR?: ModelTypeWhereInput[];
+    NOT?: ModelTypeWhereInput | ModelTypeWhereInput[];
+    id?: StringFilter<"ModelType"> | string;
+    createdAt?: DateTimeFilter<"ModelType"> | Date | string;
+    updatedAt?: DateTimeNullableFilter<"ModelType"> | Date | string | null;
+    name?: StringFilter<"ModelType"> | string;
+    slug?: StringFilter<"ModelType"> | string;
+    schema?: StringFilter<"ModelType"> | string;
+    models?: ModelListRelationFilter;
+};
+type ModelTypeOrderByWithRelationInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrderInput | SortOrder;
+    name?: SortOrder;
+    slug?: SortOrder;
+    schema?: SortOrder;
+    models?: ModelOrderByRelationAggregateInput;
+};
+type ModelTypeWhereUniqueInput = AtLeast<{
+    id?: string;
+    name?: string;
+    slug?: string;
+    AND?: ModelTypeWhereInput | ModelTypeWhereInput[];
+    OR?: ModelTypeWhereInput[];
+    NOT?: ModelTypeWhereInput | ModelTypeWhereInput[];
+    createdAt?: DateTimeFilter<"ModelType"> | Date | string;
+    updatedAt?: DateTimeNullableFilter<"ModelType"> | Date | string | null;
+    schema?: StringFilter<"ModelType"> | string;
+    models?: ModelListRelationFilter;
+}, "id" | "name" | "slug">;
+type ModelTypeOrderByWithAggregationInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrderInput | SortOrder;
+    name?: SortOrder;
+    slug?: SortOrder;
+    schema?: SortOrder;
+    _count?: ModelTypeCountOrderByAggregateInput;
+    _max?: ModelTypeMaxOrderByAggregateInput;
+    _min?: ModelTypeMinOrderByAggregateInput;
+};
+type ModelTypeScalarWhereWithAggregatesInput = {
+    AND?: ModelTypeScalarWhereWithAggregatesInput | ModelTypeScalarWhereWithAggregatesInput[];
+    OR?: ModelTypeScalarWhereWithAggregatesInput[];
+    NOT?: ModelTypeScalarWhereWithAggregatesInput | ModelTypeScalarWhereWithAggregatesInput[];
+    id?: StringWithAggregatesFilter<"ModelType"> | string;
+    createdAt?: DateTimeWithAggregatesFilter<"ModelType"> | Date | string;
+    updatedAt?: DateTimeNullableWithAggregatesFilter<"ModelType"> | Date | string | null;
+    name?: StringWithAggregatesFilter<"ModelType"> | string;
+    slug?: StringWithAggregatesFilter<"ModelType"> | string;
+    schema?: StringWithAggregatesFilter<"ModelType"> | string;
+};
+type ModelTypeCreateInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    name: string;
+    slug: string;
+    schema: string;
+    models?: ModelCreateNestedManyWithoutModelTypeInput;
+};
+type ModelTypeUncheckedCreateInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    name: string;
+    slug: string;
+    schema: string;
+    models?: ModelUncheckedCreateNestedManyWithoutModelTypeInput;
+};
+type ModelTypeUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    name?: StringFieldUpdateOperationsInput | string;
+    slug?: StringFieldUpdateOperationsInput | string;
+    schema?: StringFieldUpdateOperationsInput | string;
+    models?: ModelUpdateManyWithoutModelTypeNestedInput;
+};
+type ModelTypeUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    name?: StringFieldUpdateOperationsInput | string;
+    slug?: StringFieldUpdateOperationsInput | string;
+    schema?: StringFieldUpdateOperationsInput | string;
+    models?: ModelUncheckedUpdateManyWithoutModelTypeNestedInput;
+};
+type ModelTypeCreateManyInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    name: string;
+    slug: string;
+    schema: string;
+};
+type ModelTypeUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    name?: StringFieldUpdateOperationsInput | string;
+    slug?: StringFieldUpdateOperationsInput | string;
+    schema?: StringFieldUpdateOperationsInput | string;
+};
+type ModelTypeUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    name?: StringFieldUpdateOperationsInput | string;
+    slug?: StringFieldUpdateOperationsInput | string;
+    schema?: StringFieldUpdateOperationsInput | string;
+};
+type ModelTypeCountOrderByAggregateInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrder;
+    name?: SortOrder;
+    slug?: SortOrder;
+    schema?: SortOrder;
+};
+type ModelTypeMaxOrderByAggregateInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrder;
+    name?: SortOrder;
+    slug?: SortOrder;
+    schema?: SortOrder;
+};
+type ModelTypeMinOrderByAggregateInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrder;
+    name?: SortOrder;
+    slug?: SortOrder;
+    schema?: SortOrder;
+};
+type ModelTypeScalarRelationFilter = {
+    is?: ModelTypeWhereInput;
+    isNot?: ModelTypeWhereInput;
+};
+type StringFieldUpdateOperationsInput = {
+    set?: string;
+};
+type DateTimeFieldUpdateOperationsInput = {
+    set?: Date | string;
+};
+type NullableDateTimeFieldUpdateOperationsInput = {
+    set?: Date | string | null;
+};
+type ModelTypeCreateNestedOneWithoutModelsInput = {
+    create?: XOR<ModelTypeCreateWithoutModelsInput, ModelTypeUncheckedCreateWithoutModelsInput>;
+    connectOrCreate?: ModelTypeCreateOrConnectWithoutModelsInput;
+    connect?: ModelTypeWhereUniqueInput;
+};
+type ModelTypeUpdateOneRequiredWithoutModelsNestedInput = {
+    create?: XOR<ModelTypeCreateWithoutModelsInput, ModelTypeUncheckedCreateWithoutModelsInput>;
+    connectOrCreate?: ModelTypeCreateOrConnectWithoutModelsInput;
+    upsert?: ModelTypeUpsertWithoutModelsInput;
+    connect?: ModelTypeWhereUniqueInput;
+    update?: XOR<XOR<ModelTypeUpdateToOneWithWhereWithoutModelsInput, ModelTypeUpdateWithoutModelsInput>, ModelTypeUncheckedUpdateWithoutModelsInput>;
+};
+type ModelTypeCreateWithoutModelsInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    name: string;
+    slug: string;
+    schema: string;
+};
+type ModelTypeUncheckedCreateWithoutModelsInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    name: string;
+    slug: string;
+    schema: string;
+};
+type ModelTypeCreateOrConnectWithoutModelsInput = {
+    where: ModelTypeWhereUniqueInput;
+    create: XOR<ModelTypeCreateWithoutModelsInput, ModelTypeUncheckedCreateWithoutModelsInput>;
+};
+type ModelTypeUpsertWithoutModelsInput = {
+    update: XOR<ModelTypeUpdateWithoutModelsInput, ModelTypeUncheckedUpdateWithoutModelsInput>;
+    create: XOR<ModelTypeCreateWithoutModelsInput, ModelTypeUncheckedCreateWithoutModelsInput>;
+    where?: ModelTypeWhereInput;
+};
+type ModelTypeUpdateToOneWithWhereWithoutModelsInput = {
+    where?: ModelTypeWhereInput;
+    data: XOR<ModelTypeUpdateWithoutModelsInput, ModelTypeUncheckedUpdateWithoutModelsInput>;
+};
+type ModelTypeUpdateWithoutModelsInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    name?: StringFieldUpdateOperationsInput | string;
+    slug?: StringFieldUpdateOperationsInput | string;
+    schema?: StringFieldUpdateOperationsInput | string;
+};
+type ModelTypeUncheckedUpdateWithoutModelsInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    name?: StringFieldUpdateOperationsInput | string;
+    slug?: StringFieldUpdateOperationsInput | string;
+    schema?: StringFieldUpdateOperationsInput | string;
+};
+/**
+ * Count Type ModelTypeCountOutputType
+ */
+type ModelTypeCountOutputType = {
+    models: number;
+};
+type ModelTypeCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    models?: boolean | ModelTypeCountOutputTypeCountModelsArgs;
+};
+/**
+ * ModelTypeCountOutputType without action
+ */
+type ModelTypeCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelTypeCountOutputType
+     */
+    select?: ModelTypeCountOutputTypeSelect<ExtArgs> | null;
+};
+/**
+ * ModelTypeCountOutputType without action
+ */
+type ModelTypeCountOutputTypeCountModelsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: ModelWhereInput;
+};
+type ModelTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    name?: boolean;
+    slug?: boolean;
+    schema?: boolean;
+    models?: boolean | ModelType$modelsArgs<ExtArgs>;
+    _count?: boolean | ModelTypeCountOutputTypeDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["modelType"]>;
+type ModelTypeSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    name?: boolean;
+    slug?: boolean;
+    schema?: boolean;
+}, ExtArgs["result"]["modelType"]>;
+type ModelTypeSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    name?: boolean;
+    slug?: boolean;
+    schema?: boolean;
+}, ExtArgs["result"]["modelType"]>;
+type ModelTypeSelectScalar = {
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    name?: boolean;
+    slug?: boolean;
+    schema?: boolean;
+};
+type ModelTypeOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "createdAt" | "updatedAt" | "name" | "slug" | "schema", ExtArgs["result"]["modelType"]>;
+type ModelTypeInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    models?: boolean | ModelType$modelsArgs<ExtArgs>;
+    _count?: boolean | ModelTypeCountOutputTypeDefaultArgs<ExtArgs>;
+};
+type ModelTypeIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {};
+type ModelTypeIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {};
+type $ModelTypePayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    name: "ModelType";
+    objects: {
+        models: $ModelPayload<ExtArgs>[];
+    };
+    scalars: runtime.Types.Extensions.GetPayloadResult<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        name: string;
+        slug: string;
+        schema: string;
+    }, ExtArgs["result"]["modelType"]>;
+    composites: {};
+};
+type ModelTypeGetPayload<S extends boolean | null | undefined | ModelTypeDefaultArgs> = runtime.Types.Result.GetResult<$ModelTypePayload, S>;
+type ModelTypeCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<ModelTypeFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: ModelTypeCountAggregateInputType | true;
+};
+interface ModelTypeDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: {
+        types: TypeMap<ExtArgs>['model']['ModelType'];
+        meta: {
+            name: 'ModelType';
+        };
+    };
+    /**
+     * Find zero or one ModelType that matches the filter.
+     * @param {ModelTypeFindUniqueArgs} args - Arguments to find a ModelType
+     * @example
+     * // Get one ModelType
+     * const modelType = await prisma.modelType.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends ModelTypeFindUniqueArgs>(args: SelectSubset<T, ModelTypeFindUniqueArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find one ModelType that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {ModelTypeFindUniqueOrThrowArgs} args - Arguments to find a ModelType
+     * @example
+     * // Get one ModelType
+     * const modelType = await prisma.modelType.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends ModelTypeFindUniqueOrThrowArgs>(args: SelectSubset<T, ModelTypeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first ModelType that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeFindFirstArgs} args - Arguments to find a ModelType
+     * @example
+     * // Get one ModelType
+     * const modelType = await prisma.modelType.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends ModelTypeFindFirstArgs>(args?: SelectSubset<T, ModelTypeFindFirstArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first ModelType that matches the filter or
+     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeFindFirstOrThrowArgs} args - Arguments to find a ModelType
+     * @example
+     * // Get one ModelType
+     * const modelType = await prisma.modelType.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends ModelTypeFindFirstOrThrowArgs>(args?: SelectSubset<T, ModelTypeFindFirstOrThrowArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find zero or more ModelTypes that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all ModelTypes
+     * const modelTypes = await prisma.modelType.findMany()
+     *
+     * // Get first 10 ModelTypes
+     * const modelTypes = await prisma.modelType.findMany({ take: 10 })
+     *
+     * // Only select the `id`
+     * const modelTypeWithIdOnly = await prisma.modelType.findMany({ select: { id: true } })
+     *
+     */
+    findMany<T extends ModelTypeFindManyArgs>(args?: SelectSubset<T, ModelTypeFindManyArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
+    /**
+     * Create a ModelType.
+     * @param {ModelTypeCreateArgs} args - Arguments to create a ModelType.
+     * @example
+     * // Create one ModelType
+     * const ModelType = await prisma.modelType.create({
+     *   data: {
+     *     // ... data to create a ModelType
+     *   }
+     * })
+     *
+     */
+    create<T extends ModelTypeCreateArgs>(args: SelectSubset<T, ModelTypeCreateArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Create many ModelTypes.
+     * @param {ModelTypeCreateManyArgs} args - Arguments to create many ModelTypes.
+     * @example
+     * // Create many ModelTypes
+     * const modelType = await prisma.modelType.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     */
+    createMany<T extends ModelTypeCreateManyArgs>(args?: SelectSubset<T, ModelTypeCreateManyArgs<ExtArgs>>): PrismaPromise<BatchPayload>;
+    /**
+     * Create many ModelTypes and returns the data saved in the database.
+     * @param {ModelTypeCreateManyAndReturnArgs} args - Arguments to create many ModelTypes.
+     * @example
+     * // Create many ModelTypes
+     * const modelType = await prisma.modelType.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Create many ModelTypes and only return the `id`
+     * const modelTypeWithIdOnly = await prisma.modelType.createManyAndReturn({
+     *   select: { id: true },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     *
+     */
+    createManyAndReturn<T extends ModelTypeCreateManyAndReturnArgs>(args?: SelectSubset<T, ModelTypeCreateManyAndReturnArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Delete a ModelType.
+     * @param {ModelTypeDeleteArgs} args - Arguments to delete one ModelType.
+     * @example
+     * // Delete one ModelType
+     * const ModelType = await prisma.modelType.delete({
+     *   where: {
+     *     // ... filter to delete one ModelType
+     *   }
+     * })
+     *
+     */
+    delete<T extends ModelTypeDeleteArgs>(args: SelectSubset<T, ModelTypeDeleteArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Update one ModelType.
+     * @param {ModelTypeUpdateArgs} args - Arguments to update one ModelType.
+     * @example
+     * // Update one ModelType
+     * const modelType = await prisma.modelType.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    update<T extends ModelTypeUpdateArgs>(args: SelectSubset<T, ModelTypeUpdateArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Delete zero or more ModelTypes.
+     * @param {ModelTypeDeleteManyArgs} args - Arguments to filter ModelTypes to delete.
+     * @example
+     * // Delete a few ModelTypes
+     * const { count } = await prisma.modelType.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     *
+     */
+    deleteMany<T extends ModelTypeDeleteManyArgs>(args?: SelectSubset<T, ModelTypeDeleteManyArgs<ExtArgs>>): PrismaPromise<BatchPayload>;
+    /**
+     * Update zero or more ModelTypes.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many ModelTypes
+     * const modelType = await prisma.modelType.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    updateMany<T extends ModelTypeUpdateManyArgs>(args: SelectSubset<T, ModelTypeUpdateManyArgs<ExtArgs>>): PrismaPromise<BatchPayload>;
+    /**
+     * Update zero or more ModelTypes and returns the data updated in the database.
+     * @param {ModelTypeUpdateManyAndReturnArgs} args - Arguments to update many ModelTypes.
+     * @example
+     * // Update many ModelTypes
+     * const modelType = await prisma.modelType.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Update zero or more ModelTypes and only return the `id`
+     * const modelTypeWithIdOnly = await prisma.modelType.updateManyAndReturn({
+     *   select: { id: true },
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     *
+     */
+    updateManyAndReturn<T extends ModelTypeUpdateManyAndReturnArgs>(args: SelectSubset<T, ModelTypeUpdateManyAndReturnArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Create or update one ModelType.
+     * @param {ModelTypeUpsertArgs} args - Arguments to update or create a ModelType.
+     * @example
+     * // Update or create a ModelType
+     * const modelType = await prisma.modelType.upsert({
+     *   create: {
+     *     // ... data to create a ModelType
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the ModelType we want to update
+     *   }
+     * })
+     */
+    upsert<T extends ModelTypeUpsertArgs>(args: SelectSubset<T, ModelTypeUpsertArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Count the number of ModelTypes.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeCountArgs} args - Arguments to filter ModelTypes to count.
+     * @example
+     * // Count the number of ModelTypes
+     * const count = await prisma.modelType.count({
+     *   where: {
+     *     // ... the filter for the ModelTypes we want to count
+     *   }
+     * })
+    **/
+    count<T extends ModelTypeCountArgs>(args?: Subset<T, ModelTypeCountArgs>): PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : GetScalarType<T['select'], ModelTypeCountAggregateOutputType> : number>;
+    /**
+     * Allows you to perform aggregations operations on a ModelType.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+     * @example
+     * // Ordered by age ascending
+     * // Where email contains prisma.io
+     * // Limited to the 10 users
+     * const aggregations = await prisma.user.aggregate({
+     *   _avg: {
+     *     age: true,
+     *   },
+     *   where: {
+     *     email: {
+     *       contains: "prisma.io",
+     *     },
+     *   },
+     *   orderBy: {
+     *     age: "asc",
+     *   },
+     *   take: 10,
+     * })
+    **/
+    aggregate<T extends ModelTypeAggregateArgs>(args: Subset<T, ModelTypeAggregateArgs>): PrismaPromise<GetModelTypeAggregateType<T>>;
+    /**
+     * Group by ModelType.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelTypeGroupByArgs} args - Group by arguments.
+     * @example
+     * // Group by city, order by createdAt, get count
+     * const result = await prisma.user.groupBy({
+     *   by: ['city', 'createdAt'],
+     *   orderBy: {
+     *     createdAt: true
+     *   },
+     *   _count: {
+     *     _all: true
+     *   },
+     * })
+     *
+    **/
+    groupBy<T extends ModelTypeGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T>>, Extends<'take', Keys<T>>>, OrderByArg extends True extends HasSelectOrTake ? {
+        orderBy: ModelTypeGroupByArgs['orderBy'];
+    } : {
+        orderBy?: ModelTypeGroupByArgs['orderBy'];
+    }, OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>, ByFields extends MaybeTupleToUnion<T['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends T['by'] extends never[] ? True : False, InputErrors extends ByEmpty extends True ? `Error: "by" must not be empty.` : HavingValid extends 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 Keys<T> ? 'orderBy' extends Keys<T> ? ByValid extends 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 Keys<T> ? 'orderBy' extends Keys<T> ? ByValid extends 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 True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields]>(args: SubsetIntersection<T, ModelTypeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetModelTypeGroupByPayload<T> : PrismaPromise<InputErrors>;
+    /**
+     * Fields of the ModelType model
+     */
+    readonly fields: ModelTypeFieldRefs;
+}
+/**
+ * The delegate class that acts as a "Promise-like" for ModelType.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+interface Prisma__ModelTypeClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise";
+    models<T extends ModelType$modelsArgs<ExtArgs> = {}>(args?: Subset<T, ModelType$modelsArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    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>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
+}
+/**
+ * Fields of the ModelType model
+ */
+interface ModelTypeFieldRefs {
+    readonly id: FieldRef<"ModelType", 'String'>;
+    readonly createdAt: FieldRef<"ModelType", 'DateTime'>;
+    readonly updatedAt: FieldRef<"ModelType", 'DateTime'>;
+    readonly name: FieldRef<"ModelType", 'String'>;
+    readonly slug: FieldRef<"ModelType", 'String'>;
+    readonly schema: FieldRef<"ModelType", 'String'>;
+}
+/**
+ * ModelType findUnique
+ */
+type ModelTypeFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * Filter, which ModelType to fetch.
+     */
+    where: ModelTypeWhereUniqueInput;
+};
+/**
+ * ModelType findUniqueOrThrow
+ */
+type ModelTypeFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * Filter, which ModelType to fetch.
+     */
+    where: ModelTypeWhereUniqueInput;
+};
+/**
+ * ModelType findFirst
+ */
+type ModelTypeFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * Filter, which ModelType to fetch.
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of ModelTypes to fetch.
+     */
+    orderBy?: ModelTypeOrderByWithRelationInput | ModelTypeOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for ModelTypes.
+     */
+    cursor?: ModelTypeWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` ModelTypes from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` ModelTypes.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of ModelTypes.
+     */
+    distinct?: ModelTypeScalarFieldEnum | ModelTypeScalarFieldEnum[];
+};
+/**
+ * ModelType findFirstOrThrow
+ */
+type ModelTypeFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * Filter, which ModelType to fetch.
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of ModelTypes to fetch.
+     */
+    orderBy?: ModelTypeOrderByWithRelationInput | ModelTypeOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for ModelTypes.
+     */
+    cursor?: ModelTypeWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` ModelTypes from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` ModelTypes.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of ModelTypes.
+     */
+    distinct?: ModelTypeScalarFieldEnum | ModelTypeScalarFieldEnum[];
+};
+/**
+ * ModelType findMany
+ */
+type ModelTypeFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * Filter, which ModelTypes to fetch.
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of ModelTypes to fetch.
+     */
+    orderBy?: ModelTypeOrderByWithRelationInput | ModelTypeOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for listing ModelTypes.
+     */
+    cursor?: ModelTypeWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` ModelTypes from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` ModelTypes.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of ModelTypes.
+     */
+    distinct?: ModelTypeScalarFieldEnum | ModelTypeScalarFieldEnum[];
+};
+/**
+ * ModelType create
+ */
+type ModelTypeCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * The data needed to create a ModelType.
+     */
+    data: XOR<ModelTypeCreateInput, ModelTypeUncheckedCreateInput>;
+};
+/**
+ * ModelType createMany
+ */
+type ModelTypeCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many ModelTypes.
+     */
+    data: ModelTypeCreateManyInput | ModelTypeCreateManyInput[];
+    skipDuplicates?: boolean;
+};
+/**
+ * ModelType createManyAndReturn
+ */
+type ModelTypeCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelectCreateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * The data used to create many ModelTypes.
+     */
+    data: ModelTypeCreateManyInput | ModelTypeCreateManyInput[];
+    skipDuplicates?: boolean;
+};
+/**
+ * ModelType update
+ */
+type ModelTypeUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * The data needed to update a ModelType.
+     */
+    data: XOR<ModelTypeUpdateInput, ModelTypeUncheckedUpdateInput>;
+    /**
+     * Choose, which ModelType to update.
+     */
+    where: ModelTypeWhereUniqueInput;
+};
+/**
+ * ModelType updateMany
+ */
+type ModelTypeUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to update ModelTypes.
+     */
+    data: XOR<ModelTypeUpdateManyMutationInput, ModelTypeUncheckedUpdateManyInput>;
+    /**
+     * Filter which ModelTypes to update
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * Limit how many ModelTypes to update.
+     */
+    limit?: number;
+};
+/**
+ * ModelType updateManyAndReturn
+ */
+type ModelTypeUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelectUpdateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * The data used to update ModelTypes.
+     */
+    data: XOR<ModelTypeUpdateManyMutationInput, ModelTypeUncheckedUpdateManyInput>;
+    /**
+     * Filter which ModelTypes to update
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * Limit how many ModelTypes to update.
+     */
+    limit?: number;
+};
+/**
+ * ModelType upsert
+ */
+type ModelTypeUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * The filter to search for the ModelType to update in case it exists.
+     */
+    where: ModelTypeWhereUniqueInput;
+    /**
+     * In case the ModelType found by the `where` argument doesn't exist, create a new ModelType with this data.
+     */
+    create: XOR<ModelTypeCreateInput, ModelTypeUncheckedCreateInput>;
+    /**
+     * In case the ModelType was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<ModelTypeUpdateInput, ModelTypeUncheckedUpdateInput>;
+};
+/**
+ * ModelType delete
+ */
+type ModelTypeDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+    /**
+     * Filter which ModelType to delete.
+     */
+    where: ModelTypeWhereUniqueInput;
+};
+/**
+ * ModelType deleteMany
+ */
+type ModelTypeDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which ModelTypes to delete
+     */
+    where?: ModelTypeWhereInput;
+    /**
+     * Limit how many ModelTypes to delete.
+     */
+    limit?: number;
+};
+/**
+ * ModelType.models
+ */
+type ModelType$modelsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    where?: ModelWhereInput;
+    orderBy?: ModelOrderByWithRelationInput | ModelOrderByWithRelationInput[];
+    cursor?: ModelWhereUniqueInput;
+    take?: number;
+    skip?: number;
+    distinct?: ModelScalarFieldEnum | ModelScalarFieldEnum[];
+};
+/**
+ * ModelType without action
+ */
+type ModelTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ModelType
+     */
+    select?: ModelTypeSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the ModelType
+     */
+    omit?: ModelTypeOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelTypeInclude<ExtArgs> | null;
+};
+
+/**
+ * Model Model
+ *
+ */
+type ModelModel = runtime.Types.Result.DefaultSelection<$ModelPayload>;
+type AggregateModel = {
+    _count: ModelCountAggregateOutputType | null;
+    _min: ModelMinAggregateOutputType | null;
+    _max: ModelMaxAggregateOutputType | null;
+};
+type ModelMinAggregateOutputType = {
+    id: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    modelTypeId: string | null;
+};
+type ModelMaxAggregateOutputType = {
+    id: string | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    modelTypeId: string | null;
+};
+type ModelCountAggregateOutputType = {
+    id: number;
+    createdAt: number;
+    updatedAt: number;
+    modelTypeId: number;
+    data: number;
+    _all: number;
+};
+type ModelMinAggregateInputType = {
+    id?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    modelTypeId?: true;
+};
+type ModelMaxAggregateInputType = {
+    id?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    modelTypeId?: true;
+};
+type ModelCountAggregateInputType = {
+    id?: true;
+    createdAt?: true;
+    updatedAt?: true;
+    modelTypeId?: true;
+    data?: true;
+    _all?: true;
+};
+type ModelAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which Model to aggregate.
+     */
+    where?: ModelWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Models to fetch.
+     */
+    orderBy?: ModelOrderByWithRelationInput | ModelOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the start position
+     */
+    cursor?: ModelWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Models from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` Models.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Count returned Models
+    **/
+    _count?: true | ModelCountAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the minimum value
+    **/
+    _min?: ModelMinAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the maximum value
+    **/
+    _max?: ModelMaxAggregateInputType;
+};
+type GetModelAggregateType<T extends ModelAggregateArgs> = {
+    [P in keyof T & keyof AggregateModel]: P extends '_count' | 'count' ? T[P] extends true ? number : GetScalarType<T[P], AggregateModel[P]> : GetScalarType<T[P], AggregateModel[P]>;
+};
+type ModelGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: ModelWhereInput;
+    orderBy?: ModelOrderByWithAggregationInput | ModelOrderByWithAggregationInput[];
+    by: ModelScalarFieldEnum[] | ModelScalarFieldEnum;
+    having?: ModelScalarWhereWithAggregatesInput;
+    take?: number;
+    skip?: number;
+    _count?: ModelCountAggregateInputType | true;
+    _min?: ModelMinAggregateInputType;
+    _max?: ModelMaxAggregateInputType;
+};
+type ModelGroupByOutputType = {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date | null;
+    modelTypeId: string;
+    data: runtime.JsonValue;
+    _count: ModelCountAggregateOutputType | null;
+    _min: ModelMinAggregateOutputType | null;
+    _max: ModelMaxAggregateOutputType | null;
+};
+type GetModelGroupByPayload<T extends ModelGroupByArgs> = PrismaPromise<Array<PickEnumerable<ModelGroupByOutputType, T['by']> & {
+    [P in ((keyof T) & (keyof ModelGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : GetScalarType<T[P], ModelGroupByOutputType[P]> : GetScalarType<T[P], ModelGroupByOutputType[P]>;
+}>>;
+type ModelWhereInput = {
+    AND?: ModelWhereInput | ModelWhereInput[];
+    OR?: ModelWhereInput[];
+    NOT?: ModelWhereInput | ModelWhereInput[];
+    id?: StringFilter<"Model"> | string;
+    createdAt?: DateTimeFilter<"Model"> | Date | string;
+    updatedAt?: DateTimeNullableFilter<"Model"> | Date | string | null;
+    modelTypeId?: StringFilter<"Model"> | string;
+    data?: JsonFilter<"Model">;
+    modelType?: XOR<ModelTypeScalarRelationFilter, ModelTypeWhereInput>;
+};
+type ModelOrderByWithRelationInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrderInput | SortOrder;
+    modelTypeId?: SortOrder;
+    data?: SortOrder;
+    modelType?: ModelTypeOrderByWithRelationInput;
+};
+type ModelWhereUniqueInput = AtLeast<{
+    id?: string;
+    AND?: ModelWhereInput | ModelWhereInput[];
+    OR?: ModelWhereInput[];
+    NOT?: ModelWhereInput | ModelWhereInput[];
+    createdAt?: DateTimeFilter<"Model"> | Date | string;
+    updatedAt?: DateTimeNullableFilter<"Model"> | Date | string | null;
+    modelTypeId?: StringFilter<"Model"> | string;
+    data?: JsonFilter<"Model">;
+    modelType?: XOR<ModelTypeScalarRelationFilter, ModelTypeWhereInput>;
+}, "id">;
+type ModelOrderByWithAggregationInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrderInput | SortOrder;
+    modelTypeId?: SortOrder;
+    data?: SortOrder;
+    _count?: ModelCountOrderByAggregateInput;
+    _max?: ModelMaxOrderByAggregateInput;
+    _min?: ModelMinOrderByAggregateInput;
+};
+type ModelScalarWhereWithAggregatesInput = {
+    AND?: ModelScalarWhereWithAggregatesInput | ModelScalarWhereWithAggregatesInput[];
+    OR?: ModelScalarWhereWithAggregatesInput[];
+    NOT?: ModelScalarWhereWithAggregatesInput | ModelScalarWhereWithAggregatesInput[];
+    id?: StringWithAggregatesFilter<"Model"> | string;
+    createdAt?: DateTimeWithAggregatesFilter<"Model"> | Date | string;
+    updatedAt?: DateTimeNullableWithAggregatesFilter<"Model"> | Date | string | null;
+    modelTypeId?: StringWithAggregatesFilter<"Model"> | string;
+    data?: JsonWithAggregatesFilter<"Model">;
+};
+type ModelCreateInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    data: JsonNullValueInput | runtime.InputJsonValue;
+    modelType: ModelTypeCreateNestedOneWithoutModelsInput;
+};
+type ModelUncheckedCreateInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    modelTypeId: string;
+    data: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+    modelType?: ModelTypeUpdateOneRequiredWithoutModelsNestedInput;
+};
+type ModelUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    modelTypeId?: StringFieldUpdateOperationsInput | string;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelCreateManyInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    modelTypeId: string;
+    data: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    modelTypeId?: StringFieldUpdateOperationsInput | string;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelListRelationFilter = {
+    every?: ModelWhereInput;
+    some?: ModelWhereInput;
+    none?: ModelWhereInput;
+};
+type ModelOrderByRelationAggregateInput = {
+    _count?: SortOrder;
+};
+type ModelCountOrderByAggregateInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrder;
+    modelTypeId?: SortOrder;
+    data?: SortOrder;
+};
+type ModelMaxOrderByAggregateInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrder;
+    modelTypeId?: SortOrder;
+};
+type ModelMinOrderByAggregateInput = {
+    id?: SortOrder;
+    createdAt?: SortOrder;
+    updatedAt?: SortOrder;
+    modelTypeId?: SortOrder;
+};
+type ModelCreateNestedManyWithoutModelTypeInput = {
+    create?: XOR<ModelCreateWithoutModelTypeInput, ModelUncheckedCreateWithoutModelTypeInput> | ModelCreateWithoutModelTypeInput[] | ModelUncheckedCreateWithoutModelTypeInput[];
+    connectOrCreate?: ModelCreateOrConnectWithoutModelTypeInput | ModelCreateOrConnectWithoutModelTypeInput[];
+    createMany?: ModelCreateManyModelTypeInputEnvelope;
+    connect?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+};
+type ModelUncheckedCreateNestedManyWithoutModelTypeInput = {
+    create?: XOR<ModelCreateWithoutModelTypeInput, ModelUncheckedCreateWithoutModelTypeInput> | ModelCreateWithoutModelTypeInput[] | ModelUncheckedCreateWithoutModelTypeInput[];
+    connectOrCreate?: ModelCreateOrConnectWithoutModelTypeInput | ModelCreateOrConnectWithoutModelTypeInput[];
+    createMany?: ModelCreateManyModelTypeInputEnvelope;
+    connect?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+};
+type ModelUpdateManyWithoutModelTypeNestedInput = {
+    create?: XOR<ModelCreateWithoutModelTypeInput, ModelUncheckedCreateWithoutModelTypeInput> | ModelCreateWithoutModelTypeInput[] | ModelUncheckedCreateWithoutModelTypeInput[];
+    connectOrCreate?: ModelCreateOrConnectWithoutModelTypeInput | ModelCreateOrConnectWithoutModelTypeInput[];
+    upsert?: ModelUpsertWithWhereUniqueWithoutModelTypeInput | ModelUpsertWithWhereUniqueWithoutModelTypeInput[];
+    createMany?: ModelCreateManyModelTypeInputEnvelope;
+    set?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    disconnect?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    delete?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    connect?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    update?: ModelUpdateWithWhereUniqueWithoutModelTypeInput | ModelUpdateWithWhereUniqueWithoutModelTypeInput[];
+    updateMany?: ModelUpdateManyWithWhereWithoutModelTypeInput | ModelUpdateManyWithWhereWithoutModelTypeInput[];
+    deleteMany?: ModelScalarWhereInput | ModelScalarWhereInput[];
+};
+type ModelUncheckedUpdateManyWithoutModelTypeNestedInput = {
+    create?: XOR<ModelCreateWithoutModelTypeInput, ModelUncheckedCreateWithoutModelTypeInput> | ModelCreateWithoutModelTypeInput[] | ModelUncheckedCreateWithoutModelTypeInput[];
+    connectOrCreate?: ModelCreateOrConnectWithoutModelTypeInput | ModelCreateOrConnectWithoutModelTypeInput[];
+    upsert?: ModelUpsertWithWhereUniqueWithoutModelTypeInput | ModelUpsertWithWhereUniqueWithoutModelTypeInput[];
+    createMany?: ModelCreateManyModelTypeInputEnvelope;
+    set?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    disconnect?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    delete?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    connect?: ModelWhereUniqueInput | ModelWhereUniqueInput[];
+    update?: ModelUpdateWithWhereUniqueWithoutModelTypeInput | ModelUpdateWithWhereUniqueWithoutModelTypeInput[];
+    updateMany?: ModelUpdateManyWithWhereWithoutModelTypeInput | ModelUpdateManyWithWhereWithoutModelTypeInput[];
+    deleteMany?: ModelScalarWhereInput | ModelScalarWhereInput[];
+};
+type ModelCreateWithoutModelTypeInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    data: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUncheckedCreateWithoutModelTypeInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    data: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelCreateOrConnectWithoutModelTypeInput = {
+    where: ModelWhereUniqueInput;
+    create: XOR<ModelCreateWithoutModelTypeInput, ModelUncheckedCreateWithoutModelTypeInput>;
+};
+type ModelCreateManyModelTypeInputEnvelope = {
+    data: ModelCreateManyModelTypeInput | ModelCreateManyModelTypeInput[];
+    skipDuplicates?: boolean;
+};
+type ModelUpsertWithWhereUniqueWithoutModelTypeInput = {
+    where: ModelWhereUniqueInput;
+    update: XOR<ModelUpdateWithoutModelTypeInput, ModelUncheckedUpdateWithoutModelTypeInput>;
+    create: XOR<ModelCreateWithoutModelTypeInput, ModelUncheckedCreateWithoutModelTypeInput>;
+};
+type ModelUpdateWithWhereUniqueWithoutModelTypeInput = {
+    where: ModelWhereUniqueInput;
+    data: XOR<ModelUpdateWithoutModelTypeInput, ModelUncheckedUpdateWithoutModelTypeInput>;
+};
+type ModelUpdateManyWithWhereWithoutModelTypeInput = {
+    where: ModelScalarWhereInput;
+    data: XOR<ModelUpdateManyMutationInput, ModelUncheckedUpdateManyWithoutModelTypeInput>;
+};
+type ModelScalarWhereInput = {
+    AND?: ModelScalarWhereInput | ModelScalarWhereInput[];
+    OR?: ModelScalarWhereInput[];
+    NOT?: ModelScalarWhereInput | ModelScalarWhereInput[];
+    id?: StringFilter<"Model"> | string;
+    createdAt?: DateTimeFilter<"Model"> | Date | string;
+    updatedAt?: DateTimeNullableFilter<"Model"> | Date | string | null;
+    modelTypeId?: StringFilter<"Model"> | string;
+    data?: JsonFilter<"Model">;
+};
+type ModelCreateManyModelTypeInput = {
+    id?: string;
+    createdAt: Date | string;
+    updatedAt?: Date | string | null;
+    data: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUpdateWithoutModelTypeInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUncheckedUpdateWithoutModelTypeInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelUncheckedUpdateManyWithoutModelTypeInput = {
+    id?: StringFieldUpdateOperationsInput | string;
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string;
+    updatedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: JsonNullValueInput | runtime.InputJsonValue;
+};
+type ModelSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    modelTypeId?: boolean;
+    data?: boolean;
+    modelType?: boolean | ModelTypeDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["model"]>;
+type ModelSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    modelTypeId?: boolean;
+    data?: boolean;
+    modelType?: boolean | ModelTypeDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["model"]>;
+type ModelSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    modelTypeId?: boolean;
+    data?: boolean;
+    modelType?: boolean | ModelTypeDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["model"]>;
+type ModelSelectScalar = {
+    id?: boolean;
+    createdAt?: boolean;
+    updatedAt?: boolean;
+    modelTypeId?: boolean;
+    data?: boolean;
+};
+type ModelOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "createdAt" | "updatedAt" | "modelTypeId" | "data", ExtArgs["result"]["model"]>;
+type ModelInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    modelType?: boolean | ModelTypeDefaultArgs<ExtArgs>;
+};
+type ModelIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    modelType?: boolean | ModelTypeDefaultArgs<ExtArgs>;
+};
+type ModelIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    modelType?: boolean | ModelTypeDefaultArgs<ExtArgs>;
+};
+type $ModelPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    name: "Model";
+    objects: {
+        modelType: $ModelTypePayload<ExtArgs>;
+    };
+    scalars: runtime.Types.Extensions.GetPayloadResult<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        modelTypeId: string;
+        data: runtime.JsonValue;
+    }, ExtArgs["result"]["model"]>;
+    composites: {};
+};
+type ModelGetPayload<S extends boolean | null | undefined | ModelDefaultArgs> = runtime.Types.Result.GetResult<$ModelPayload, S>;
+type ModelCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<ModelFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: ModelCountAggregateInputType | true;
+};
+interface ModelDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: {
+        types: TypeMap<ExtArgs>['model']['Model'];
+        meta: {
+            name: 'Model';
+        };
+    };
+    /**
+     * Find zero or one Model that matches the filter.
+     * @param {ModelFindUniqueArgs} args - Arguments to find a Model
+     * @example
+     * // Get one Model
+     * const model = await prisma.model.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends ModelFindUniqueArgs>(args: SelectSubset<T, ModelFindUniqueArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find one Model that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {ModelFindUniqueOrThrowArgs} args - Arguments to find a Model
+     * @example
+     * // Get one Model
+     * const model = await prisma.model.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends ModelFindUniqueOrThrowArgs>(args: SelectSubset<T, ModelFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first Model that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelFindFirstArgs} args - Arguments to find a Model
+     * @example
+     * // Get one Model
+     * const model = await prisma.model.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends ModelFindFirstArgs>(args?: SelectSubset<T, ModelFindFirstArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first Model that matches the filter or
+     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelFindFirstOrThrowArgs} args - Arguments to find a Model
+     * @example
+     * // Get one Model
+     * const model = await prisma.model.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends ModelFindFirstOrThrowArgs>(args?: SelectSubset<T, ModelFindFirstOrThrowArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find zero or more Models that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Models
+     * const models = await prisma.model.findMany()
+     *
+     * // Get first 10 Models
+     * const models = await prisma.model.findMany({ take: 10 })
+     *
+     * // Only select the `id`
+     * const modelWithIdOnly = await prisma.model.findMany({ select: { id: true } })
+     *
+     */
+    findMany<T extends ModelFindManyArgs>(args?: SelectSubset<T, ModelFindManyArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
+    /**
+     * Create a Model.
+     * @param {ModelCreateArgs} args - Arguments to create a Model.
+     * @example
+     * // Create one Model
+     * const Model = await prisma.model.create({
+     *   data: {
+     *     // ... data to create a Model
+     *   }
+     * })
+     *
+     */
+    create<T extends ModelCreateArgs>(args: SelectSubset<T, ModelCreateArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Create many Models.
+     * @param {ModelCreateManyArgs} args - Arguments to create many Models.
+     * @example
+     * // Create many Models
+     * const model = await prisma.model.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     */
+    createMany<T extends ModelCreateManyArgs>(args?: SelectSubset<T, ModelCreateManyArgs<ExtArgs>>): PrismaPromise<BatchPayload>;
+    /**
+     * Create many Models and returns the data saved in the database.
+     * @param {ModelCreateManyAndReturnArgs} args - Arguments to create many Models.
+     * @example
+     * // Create many Models
+     * const model = await prisma.model.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Create many Models and only return the `id`
+     * const modelWithIdOnly = await prisma.model.createManyAndReturn({
+     *   select: { id: true },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     *
+     */
+    createManyAndReturn<T extends ModelCreateManyAndReturnArgs>(args?: SelectSubset<T, ModelCreateManyAndReturnArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Delete a Model.
+     * @param {ModelDeleteArgs} args - Arguments to delete one Model.
+     * @example
+     * // Delete one Model
+     * const Model = await prisma.model.delete({
+     *   where: {
+     *     // ... filter to delete one Model
+     *   }
+     * })
+     *
+     */
+    delete<T extends ModelDeleteArgs>(args: SelectSubset<T, ModelDeleteArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Update one Model.
+     * @param {ModelUpdateArgs} args - Arguments to update one Model.
+     * @example
+     * // Update one Model
+     * const model = await prisma.model.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    update<T extends ModelUpdateArgs>(args: SelectSubset<T, ModelUpdateArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Delete zero or more Models.
+     * @param {ModelDeleteManyArgs} args - Arguments to filter Models to delete.
+     * @example
+     * // Delete a few Models
+     * const { count } = await prisma.model.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     *
+     */
+    deleteMany<T extends ModelDeleteManyArgs>(args?: SelectSubset<T, ModelDeleteManyArgs<ExtArgs>>): PrismaPromise<BatchPayload>;
+    /**
+     * Update zero or more Models.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many Models
+     * const model = await prisma.model.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    updateMany<T extends ModelUpdateManyArgs>(args: SelectSubset<T, ModelUpdateManyArgs<ExtArgs>>): PrismaPromise<BatchPayload>;
+    /**
+     * Update zero or more Models and returns the data updated in the database.
+     * @param {ModelUpdateManyAndReturnArgs} args - Arguments to update many Models.
+     * @example
+     * // Update many Models
+     * const model = await prisma.model.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Update zero or more Models and only return the `id`
+     * const modelWithIdOnly = await prisma.model.updateManyAndReturn({
+     *   select: { id: true },
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     *
+     */
+    updateManyAndReturn<T extends ModelUpdateManyAndReturnArgs>(args: SelectSubset<T, ModelUpdateManyAndReturnArgs<ExtArgs>>): PrismaPromise<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Create or update one Model.
+     * @param {ModelUpsertArgs} args - Arguments to update or create a Model.
+     * @example
+     * // Update or create a Model
+     * const model = await prisma.model.upsert({
+     *   create: {
+     *     // ... data to create a Model
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the Model we want to update
+     *   }
+     * })
+     */
+    upsert<T extends ModelUpsertArgs>(args: SelectSubset<T, ModelUpsertArgs<ExtArgs>>): Prisma__ModelClient<runtime.Types.Result.GetResult<$ModelPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Count the number of Models.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelCountArgs} args - Arguments to filter Models to count.
+     * @example
+     * // Count the number of Models
+     * const count = await prisma.model.count({
+     *   where: {
+     *     // ... the filter for the Models we want to count
+     *   }
+     * })
+    **/
+    count<T extends ModelCountArgs>(args?: Subset<T, ModelCountArgs>): PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : GetScalarType<T['select'], ModelCountAggregateOutputType> : number>;
+    /**
+     * Allows you to perform aggregations operations on a Model.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+     * @example
+     * // Ordered by age ascending
+     * // Where email contains prisma.io
+     * // Limited to the 10 users
+     * const aggregations = await prisma.user.aggregate({
+     *   _avg: {
+     *     age: true,
+     *   },
+     *   where: {
+     *     email: {
+     *       contains: "prisma.io",
+     *     },
+     *   },
+     *   orderBy: {
+     *     age: "asc",
+     *   },
+     *   take: 10,
+     * })
+    **/
+    aggregate<T extends ModelAggregateArgs>(args: Subset<T, ModelAggregateArgs>): PrismaPromise<GetModelAggregateType<T>>;
+    /**
+     * Group by Model.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ModelGroupByArgs} args - Group by arguments.
+     * @example
+     * // Group by city, order by createdAt, get count
+     * const result = await prisma.user.groupBy({
+     *   by: ['city', 'createdAt'],
+     *   orderBy: {
+     *     createdAt: true
+     *   },
+     *   _count: {
+     *     _all: true
+     *   },
+     * })
+     *
+    **/
+    groupBy<T extends ModelGroupByArgs, HasSelectOrTake extends Or<Extends<'skip', Keys<T>>, Extends<'take', Keys<T>>>, OrderByArg extends True extends HasSelectOrTake ? {
+        orderBy: ModelGroupByArgs['orderBy'];
+    } : {
+        orderBy?: ModelGroupByArgs['orderBy'];
+    }, OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>, ByFields extends MaybeTupleToUnion<T['by']>, ByValid extends Has<ByFields, OrderFields>, HavingFields extends GetHavingFields<T['having']>, HavingValid extends Has<ByFields, HavingFields>, ByEmpty extends T['by'] extends never[] ? True : False, InputErrors extends ByEmpty extends True ? `Error: "by" must not be empty.` : HavingValid extends 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 Keys<T> ? 'orderBy' extends Keys<T> ? ByValid extends 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 Keys<T> ? 'orderBy' extends Keys<T> ? ByValid extends 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 True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields]>(args: SubsetIntersection<T, ModelGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetModelGroupByPayload<T> : PrismaPromise<InputErrors>;
+    /**
+     * Fields of the Model model
+     */
+    readonly fields: ModelFieldRefs;
+}
+/**
+ * The delegate class that acts as a "Promise-like" for Model.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+interface Prisma__ModelClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise";
+    modelType<T extends ModelTypeDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ModelTypeDefaultArgs<ExtArgs>>): Prisma__ModelTypeClient<runtime.Types.Result.GetResult<$ModelTypePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    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>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
+}
+/**
+ * Fields of the Model model
+ */
+interface ModelFieldRefs {
+    readonly id: FieldRef<"Model", 'String'>;
+    readonly createdAt: FieldRef<"Model", 'DateTime'>;
+    readonly updatedAt: FieldRef<"Model", 'DateTime'>;
+    readonly modelTypeId: FieldRef<"Model", 'String'>;
+    readonly data: FieldRef<"Model", 'Json'>;
+}
+/**
+ * Model findUnique
+ */
+type ModelFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * Filter, which Model to fetch.
+     */
+    where: ModelWhereUniqueInput;
+};
+/**
+ * Model findUniqueOrThrow
+ */
+type ModelFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * Filter, which Model to fetch.
+     */
+    where: ModelWhereUniqueInput;
+};
+/**
+ * Model findFirst
+ */
+type ModelFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * Filter, which Model to fetch.
+     */
+    where?: ModelWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Models to fetch.
+     */
+    orderBy?: ModelOrderByWithRelationInput | ModelOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for Models.
+     */
+    cursor?: ModelWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Models from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` Models.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of Models.
+     */
+    distinct?: ModelScalarFieldEnum | ModelScalarFieldEnum[];
+};
+/**
+ * Model findFirstOrThrow
+ */
+type ModelFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * Filter, which Model to fetch.
+     */
+    where?: ModelWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Models to fetch.
+     */
+    orderBy?: ModelOrderByWithRelationInput | ModelOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for Models.
+     */
+    cursor?: ModelWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Models from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` Models.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of Models.
+     */
+    distinct?: ModelScalarFieldEnum | ModelScalarFieldEnum[];
+};
+/**
+ * Model findMany
+ */
+type ModelFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * Filter, which Models to fetch.
+     */
+    where?: ModelWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Models to fetch.
+     */
+    orderBy?: ModelOrderByWithRelationInput | ModelOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for listing Models.
+     */
+    cursor?: ModelWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Models from the position of the cursor.
+     */
+    take?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Skip the first `n` Models.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of Models.
+     */
+    distinct?: ModelScalarFieldEnum | ModelScalarFieldEnum[];
+};
+/**
+ * Model create
+ */
+type ModelCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * The data needed to create a Model.
+     */
+    data: XOR<ModelCreateInput, ModelUncheckedCreateInput>;
+};
+/**
+ * Model createMany
+ */
+type ModelCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many Models.
+     */
+    data: ModelCreateManyInput | ModelCreateManyInput[];
+    skipDuplicates?: boolean;
+};
+/**
+ * Model createManyAndReturn
+ */
+type ModelCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelectCreateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * The data used to create many Models.
+     */
+    data: ModelCreateManyInput | ModelCreateManyInput[];
+    skipDuplicates?: boolean;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelIncludeCreateManyAndReturn<ExtArgs> | null;
+};
+/**
+ * Model update
+ */
+type ModelUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * The data needed to update a Model.
+     */
+    data: XOR<ModelUpdateInput, ModelUncheckedUpdateInput>;
+    /**
+     * Choose, which Model to update.
+     */
+    where: ModelWhereUniqueInput;
+};
+/**
+ * Model updateMany
+ */
+type ModelUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to update Models.
+     */
+    data: XOR<ModelUpdateManyMutationInput, ModelUncheckedUpdateManyInput>;
+    /**
+     * Filter which Models to update
+     */
+    where?: ModelWhereInput;
+    /**
+     * Limit how many Models to update.
+     */
+    limit?: number;
+};
+/**
+ * Model updateManyAndReturn
+ */
+type ModelUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelectUpdateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * The data used to update Models.
+     */
+    data: XOR<ModelUpdateManyMutationInput, ModelUncheckedUpdateManyInput>;
+    /**
+     * Filter which Models to update
+     */
+    where?: ModelWhereInput;
+    /**
+     * Limit how many Models to update.
+     */
+    limit?: number;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelIncludeUpdateManyAndReturn<ExtArgs> | null;
+};
+/**
+ * Model upsert
+ */
+type ModelUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * The filter to search for the Model to update in case it exists.
+     */
+    where: ModelWhereUniqueInput;
+    /**
+     * In case the Model found by the `where` argument doesn't exist, create a new Model with this data.
+     */
+    create: XOR<ModelCreateInput, ModelUncheckedCreateInput>;
+    /**
+     * In case the Model was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<ModelUpdateInput, ModelUncheckedUpdateInput>;
+};
+/**
+ * Model delete
+ */
+type ModelDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+    /**
+     * Filter which Model to delete.
+     */
+    where: ModelWhereUniqueInput;
+};
+/**
+ * Model deleteMany
+ */
+type ModelDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which Models to delete
+     */
+    where?: ModelWhereInput;
+    /**
+     * Limit how many Models to delete.
+     */
+    limit?: number;
+};
+/**
+ * Model without action
+ */
+type ModelDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Model
+     */
+    select?: ModelSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Model
+     */
+    omit?: ModelOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: ModelInclude<ExtArgs> | null;
+};
+
+type StringFilter<$PrismaModel = never> = {
+    equals?: string | StringFieldRefInput<$PrismaModel>;
+    in?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | StringFieldRefInput<$PrismaModel>;
+    lte?: string | StringFieldRefInput<$PrismaModel>;
+    gt?: string | StringFieldRefInput<$PrismaModel>;
+    gte?: string | StringFieldRefInput<$PrismaModel>;
+    contains?: string | StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | StringFieldRefInput<$PrismaModel>;
+    mode?: QueryMode;
+    not?: NestedStringFilter<$PrismaModel> | string;
+};
+type DateTimeFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeFilter<$PrismaModel> | Date | string;
+};
+type DateTimeNullableFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null;
+};
+type SortOrderInput = {
+    sort: SortOrder;
+    nulls?: NullsOrder;
+};
+type StringWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: string | StringFieldRefInput<$PrismaModel>;
+    in?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | StringFieldRefInput<$PrismaModel>;
+    lte?: string | StringFieldRefInput<$PrismaModel>;
+    gt?: string | StringFieldRefInput<$PrismaModel>;
+    gte?: string | StringFieldRefInput<$PrismaModel>;
+    contains?: string | StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | StringFieldRefInput<$PrismaModel>;
+    mode?: QueryMode;
+    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string;
+    _count?: NestedIntFilter<$PrismaModel>;
+    _min?: NestedStringFilter<$PrismaModel>;
+    _max?: NestedStringFilter<$PrismaModel>;
+};
+type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string;
+    _count?: NestedIntFilter<$PrismaModel>;
+    _min?: NestedDateTimeFilter<$PrismaModel>;
+    _max?: NestedDateTimeFilter<$PrismaModel>;
+};
+type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null;
+    _count?: NestedIntNullableFilter<$PrismaModel>;
+    _min?: NestedDateTimeNullableFilter<$PrismaModel>;
+    _max?: NestedDateTimeNullableFilter<$PrismaModel>;
+};
+type JsonFilter<$PrismaModel = never> = PatchUndefined<Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>, Required<JsonFilterBase<$PrismaModel>>> | OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>;
+type JsonFilterBase<$PrismaModel = never> = {
+    equals?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter;
+    path?: string[];
+    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>;
+    string_contains?: string | StringFieldRefInput<$PrismaModel>;
+    string_starts_with?: string | StringFieldRefInput<$PrismaModel>;
+    string_ends_with?: string | StringFieldRefInput<$PrismaModel>;
+    array_starts_with?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    array_ends_with?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    array_contains?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    lt?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    lte?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    gt?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    gte?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    not?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter;
+};
+type JsonWithAggregatesFilter<$PrismaModel = never> = PatchUndefined<Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>, Required<JsonWithAggregatesFilterBase<$PrismaModel>>> | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>;
+type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
+    equals?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter;
+    path?: string[];
+    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>;
+    string_contains?: string | StringFieldRefInput<$PrismaModel>;
+    string_starts_with?: string | StringFieldRefInput<$PrismaModel>;
+    string_ends_with?: string | StringFieldRefInput<$PrismaModel>;
+    array_starts_with?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    array_ends_with?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    array_contains?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    lt?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    lte?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    gt?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    gte?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    not?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter;
+    _count?: NestedIntFilter<$PrismaModel>;
+    _min?: NestedJsonFilter<$PrismaModel>;
+    _max?: NestedJsonFilter<$PrismaModel>;
+};
+type NestedStringFilter<$PrismaModel = never> = {
+    equals?: string | StringFieldRefInput<$PrismaModel>;
+    in?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | StringFieldRefInput<$PrismaModel>;
+    lte?: string | StringFieldRefInput<$PrismaModel>;
+    gt?: string | StringFieldRefInput<$PrismaModel>;
+    gte?: string | StringFieldRefInput<$PrismaModel>;
+    contains?: string | StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | StringFieldRefInput<$PrismaModel>;
+    not?: NestedStringFilter<$PrismaModel> | string;
+};
+type NestedDateTimeFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeFilter<$PrismaModel> | Date | string;
+};
+type NestedDateTimeNullableFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null;
+};
+type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: string | StringFieldRefInput<$PrismaModel>;
+    in?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>;
+    lt?: string | StringFieldRefInput<$PrismaModel>;
+    lte?: string | StringFieldRefInput<$PrismaModel>;
+    gt?: string | StringFieldRefInput<$PrismaModel>;
+    gte?: string | StringFieldRefInput<$PrismaModel>;
+    contains?: string | StringFieldRefInput<$PrismaModel>;
+    startsWith?: string | StringFieldRefInput<$PrismaModel>;
+    endsWith?: string | StringFieldRefInput<$PrismaModel>;
+    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string;
+    _count?: NestedIntFilter<$PrismaModel>;
+    _min?: NestedStringFilter<$PrismaModel>;
+    _max?: NestedStringFilter<$PrismaModel>;
+};
+type NestedIntFilter<$PrismaModel = never> = {
+    equals?: number | IntFieldRefInput<$PrismaModel>;
+    in?: number[] | ListIntFieldRefInput<$PrismaModel>;
+    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>;
+    lt?: number | IntFieldRefInput<$PrismaModel>;
+    lte?: number | IntFieldRefInput<$PrismaModel>;
+    gt?: number | IntFieldRefInput<$PrismaModel>;
+    gte?: number | IntFieldRefInput<$PrismaModel>;
+    not?: NestedIntFilter<$PrismaModel> | number;
+};
+type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string;
+    _count?: NestedIntFilter<$PrismaModel>;
+    _min?: NestedDateTimeFilter<$PrismaModel>;
+    _max?: NestedDateTimeFilter<$PrismaModel>;
+};
+type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null;
+    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null;
+    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>;
+    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null;
+    _count?: NestedIntNullableFilter<$PrismaModel>;
+    _min?: NestedDateTimeNullableFilter<$PrismaModel>;
+    _max?: NestedDateTimeNullableFilter<$PrismaModel>;
+};
+type NestedIntNullableFilter<$PrismaModel = never> = {
+    equals?: number | IntFieldRefInput<$PrismaModel> | null;
+    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null;
+    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null;
+    lt?: number | IntFieldRefInput<$PrismaModel>;
+    lte?: number | IntFieldRefInput<$PrismaModel>;
+    gt?: number | IntFieldRefInput<$PrismaModel>;
+    gte?: number | IntFieldRefInput<$PrismaModel>;
+    not?: NestedIntNullableFilter<$PrismaModel> | number | null;
+};
+type NestedJsonFilter<$PrismaModel = never> = PatchUndefined<Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>, Required<NestedJsonFilterBase<$PrismaModel>>> | OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>;
+type NestedJsonFilterBase<$PrismaModel = never> = {
+    equals?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter;
+    path?: string[];
+    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>;
+    string_contains?: string | StringFieldRefInput<$PrismaModel>;
+    string_starts_with?: string | StringFieldRefInput<$PrismaModel>;
+    string_ends_with?: string | StringFieldRefInput<$PrismaModel>;
+    array_starts_with?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    array_ends_with?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    array_contains?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | null;
+    lt?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    lte?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    gt?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    gte?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel>;
+    not?: runtime.InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter;
+};
+
+type DMMF = typeof runtime.DMMF;
+type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>;
+/**
+ * Prisma Errors
+ */
+declare const PrismaClientKnownRequestError: typeof runtime.PrismaClientKnownRequestError;
+type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError;
+declare const PrismaClientUnknownRequestError: typeof runtime.PrismaClientUnknownRequestError;
+type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError;
+declare const PrismaClientRustPanicError: typeof runtime.PrismaClientRustPanicError;
+type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError;
+declare const PrismaClientInitializationError: typeof runtime.PrismaClientInitializationError;
+type PrismaClientInitializationError = runtime.PrismaClientInitializationError;
+declare const PrismaClientValidationError: typeof runtime.PrismaClientValidationError;
+type PrismaClientValidationError = runtime.PrismaClientValidationError;
+/**
+ * Re-export of sql-template-tag
+ */
+declare const sql: typeof runtime.sqltag;
+declare const empty: runtime.Sql;
+declare const join: typeof runtime.join;
+declare const raw: typeof runtime.raw;
+declare const Sql: typeof runtime.Sql;
+type Sql = runtime.Sql;
+/**
+ * Decimal.js
+ */
+declare const Decimal: typeof runtime.Decimal;
+type Decimal = runtime.Decimal;
+type DecimalJsLike = runtime.DecimalJsLike;
+/**
+* Extensions
+*/
+type Extension = runtime.Types.Extensions.UserArgs;
+declare const getExtensionContext: typeof runtime.Extensions.getExtensionContext;
+type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>;
+type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>;
+type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>;
+type Exact<A, W> = runtime.Types.Public.Exact<A, W>;
+type PrismaVersion = {
+    client: string;
+    engine: string;
+};
+/**
+ * Prisma Client JS version: 7.7.0
+ * Query Engine version: 75cbdc1eb7150937890ad5465d861175c6624711
+ */
+declare const prismaVersion: PrismaVersion;
+/**
+ * Utility Types
+ */
+type Bytes = runtime.Bytes;
+type JsonObject = runtime.JsonObject;
+type JsonArray = runtime.JsonArray;
+type JsonValue = runtime.JsonValue;
+type InputJsonObject = runtime.InputJsonObject;
+type InputJsonArray = runtime.InputJsonArray;
+type InputJsonValue = runtime.InputJsonValue;
+declare const NullTypes: {
+    DbNull: (new (secret: never) => typeof runtime.DbNull);
+    JsonNull: (new (secret: never) => typeof runtime.JsonNull);
+    AnyNull: (new (secret: never) => typeof runtime.AnyNull);
+};
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+declare const DbNull: runtime.DbNullClass;
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+declare const JsonNull: runtime.JsonNullClass;
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+declare const AnyNull: runtime.AnyNullClass;
+type SelectAndInclude = {
+    select: any;
+    include: any;
+};
+type SelectAndOmit = {
+    select: any;
+    omit: any;
+};
+/**
+ * From T, pick a set of properties whose keys are in the union K
+ */
+type Prisma__Pick<T, K extends keyof T> = {
+    [P in K]: T[P];
+};
+type Enumerable<T> = T | Array<T>;
+/**
+ * Subset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
+ */
+type Subset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+};
+/**
+ * SelectSubset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
+ * Additionally, it validates, if both select and include are present. If the case, it errors.
+ */
+type SelectSubset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+} & (T extends SelectAndInclude ? 'Please either choose `select` or `include`.' : T extends SelectAndOmit ? 'Please either choose `select` or `omit`.' : {});
+/**
+ * Subset + Intersection
+ * @desc From `T` pick properties that exist in `U` and intersect `K`
+ */
+type SubsetIntersection<T, U, K> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+} & K;
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+/**
+ * XOR is needed to have a real mutually exclusive union type
+ * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
+ */
+type XOR<T, U> = T extends object ? U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : U : T;
+/**
+ * Is T a Record?
+ */
+type IsObject<T extends any> = T extends Array<any> ? False : T extends Date ? False : T extends Uint8Array ? False : T extends BigInt ? False : T extends object ? True : False;
+/**
+ * If it's T[], return T
+ */
+type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T;
+/**
+ * From ts-toolbelt
+ */
+type __Either<O extends object, K extends Key> = Omit<O, K> & {
+    [P in K]: Prisma__Pick<O, P & keyof O>;
+}[K];
+type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>;
+type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>;
+type _Either<O extends object, K extends Key, strict extends Boolean> = {
+    1: EitherStrict<O, K>;
+    0: EitherLoose<O, K>;
+}[strict];
+type Either<O extends object, K extends Key, strict extends Boolean = 1> = O extends unknown ? _Either<O, K, strict> : never;
+type Union = any;
+type PatchUndefined<O extends object, O1 extends object> = {
+    [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K];
+} & {};
+/** Helper Types for "Merge" **/
+type IntersectOf<U extends Union> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type Overwrite<O extends object, O1 extends object> = {
+    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
+} & {};
+type _Merge<U extends object> = IntersectOf<Overwrite<U, {
+    [K in keyof U]-?: At<U, K>;
+}>>;
+type Key = string | number | symbol;
+type AtStrict<O extends object, K extends Key> = O[K & keyof O];
+type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
+type At<O extends object, K extends Key, strict extends Boolean = 1> = {
+    1: AtStrict<O, K>;
+    0: AtLoose<O, K>;
+}[strict];
+type ComputeRaw<A extends any> = A extends Function ? A : {
+    [K in keyof A]: A[K];
+} & {};
+type OptionalFlat<O> = {
+    [K in keyof O]?: O[K];
+} & {};
+type _Record<K extends keyof any, T> = {
+    [P in K]: T;
+};
+type NoExpand<T> = T extends unknown ? T : never;
+type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
+    [P in K]: O[P];
+} & O : O) | {
+    [P in keyof O as P extends K ? P : never]-?: O[P];
+} & O : never>;
+type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
+type Strict<U extends object> = ComputeRaw<_Strict<U>>;
+/** End Helper Types for "Merge" **/
+type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+type Boolean = True | False;
+type True = 1;
+type False = 0;
+type Not<B extends Boolean> = {
+    0: 1;
+    1: 0;
+}[B];
+type Extends<A1 extends any, A2 extends any> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
+type Has<U extends Union, U1 extends Union> = Not<Extends<Exclude<U1, U>, U1>>;
+type Or<B1 extends Boolean, B2 extends Boolean> = {
+    0: {
+        0: 0;
+        1: 1;
+    };
+    1: {
+        0: 1;
+        1: 1;
+    };
+}[B1][B2];
+type Keys<U extends Union> = U extends unknown ? keyof U : never;
+type GetScalarType<T, O> = O extends object ? {
+    [P in keyof T]: P extends keyof O ? O[P] : never;
+} : never;
+type FieldPaths<T, U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>> = IsObject<T> extends True ? U : T;
+type GetHavingFields<T> = {
+    [K in keyof T]: Or<Or<Extends<'OR', K>, Extends<'AND', K>>, Extends<'NOT', K>> extends True ? T[K] extends infer TK ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never> : never : {} extends FieldPaths<T[K]> ? never : K;
+}[keyof T];
+/**
+ * Convert tuple to union
+ */
+type _TupleToUnion<T> = T extends (infer E)[] ? E : never;
+type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>;
+type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T;
+/**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>;
+/**
+ * Exclude all keys with underscores
+ */
+type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T;
+type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>;
+type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>;
+declare const ModelName: {
+    readonly ModelType: "ModelType";
+    readonly Model: "Model";
+};
+type ModelName = (typeof ModelName)[keyof typeof ModelName];
+interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{
+    extArgs: runtime.Types.Extensions.InternalArgs;
+}, runtime.Types.Utils.Record<string, any>> {
+    returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>;
+}
+type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
+    globalOmitOptions: {
+        omit: GlobalOmitOptions;
+    };
+    meta: {
+        modelProps: "modelType" | "model";
+        txIsolationLevel: TransactionIsolationLevel;
+    };
+    model: {
+        ModelType: {
+            payload: $ModelTypePayload<ExtArgs>;
+            fields: ModelTypeFieldRefs;
+            operations: {
+                findUnique: {
+                    args: ModelTypeFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: ModelTypeFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>;
+                };
+                findFirst: {
+                    args: ModelTypeFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: ModelTypeFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>;
+                };
+                findMany: {
+                    args: ModelTypeFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>[];
+                };
+                create: {
+                    args: ModelTypeCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>;
+                };
+                createMany: {
+                    args: ModelTypeCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: ModelTypeCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>[];
+                };
+                delete: {
+                    args: ModelTypeDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>;
+                };
+                update: {
+                    args: ModelTypeUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>;
+                };
+                deleteMany: {
+                    args: ModelTypeDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: ModelTypeUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: ModelTypeUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>[];
+                };
+                upsert: {
+                    args: ModelTypeUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelTypePayload>;
+                };
+                aggregate: {
+                    args: ModelTypeAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<AggregateModelType>;
+                };
+                groupBy: {
+                    args: ModelTypeGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<ModelTypeGroupByOutputType>[];
+                };
+                count: {
+                    args: ModelTypeCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<ModelTypeCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Model: {
+            payload: $ModelPayload<ExtArgs>;
+            fields: ModelFieldRefs;
+            operations: {
+                findUnique: {
+                    args: ModelFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: ModelFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>;
+                };
+                findFirst: {
+                    args: ModelFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: ModelFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>;
+                };
+                findMany: {
+                    args: ModelFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>[];
+                };
+                create: {
+                    args: ModelCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>;
+                };
+                createMany: {
+                    args: ModelCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: ModelCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>[];
+                };
+                delete: {
+                    args: ModelDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>;
+                };
+                update: {
+                    args: ModelUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>;
+                };
+                deleteMany: {
+                    args: ModelDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: ModelUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: ModelUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>[];
+                };
+                upsert: {
+                    args: ModelUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<$ModelPayload>;
+                };
+                aggregate: {
+                    args: ModelAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<AggregateModel>;
+                };
+                groupBy: {
+                    args: ModelGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<ModelGroupByOutputType>[];
+                };
+                count: {
+                    args: ModelCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<ModelCountAggregateOutputType> | number;
+                };
+            };
+        };
+    };
+} & {
+    other: {
+        payload: any;
+        operations: {
+            $executeRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $executeRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+            $queryRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $queryRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+        };
+    };
+};
+/**
+ * Enums
+ */
+declare const TransactionIsolationLevel: {
+    readonly ReadUncommitted: "ReadUncommitted";
+    readonly ReadCommitted: "ReadCommitted";
+    readonly RepeatableRead: "RepeatableRead";
+    readonly Serializable: "Serializable";
+};
+type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel];
+declare const ModelTypeScalarFieldEnum: {
+    readonly id: "id";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly name: "name";
+    readonly slug: "slug";
+    readonly schema: "schema";
+};
+type ModelTypeScalarFieldEnum = (typeof ModelTypeScalarFieldEnum)[keyof typeof ModelTypeScalarFieldEnum];
+declare const ModelScalarFieldEnum: {
+    readonly id: "id";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly modelTypeId: "modelTypeId";
+    readonly data: "data";
+};
+type ModelScalarFieldEnum = (typeof ModelScalarFieldEnum)[keyof typeof ModelScalarFieldEnum];
+declare const SortOrder: {
+    readonly asc: "asc";
+    readonly desc: "desc";
+};
+type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+declare const JsonNullValueInput: {
+    readonly JsonNull: runtime.JsonNullClass;
+};
+type JsonNullValueInput = (typeof JsonNullValueInput)[keyof typeof JsonNullValueInput];
+declare const QueryMode: {
+    readonly default: "default";
+    readonly insensitive: "insensitive";
+};
+type QueryMode = (typeof QueryMode)[keyof typeof QueryMode];
+declare const NullsOrder: {
+    readonly first: "first";
+    readonly last: "last";
+};
+type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder];
+declare const JsonNullValueFilter: {
+    readonly DbNull: runtime.DbNullClass;
+    readonly JsonNull: runtime.JsonNullClass;
+    readonly AnyNull: runtime.AnyNullClass;
+};
+type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter];
+/**
+ * Field references
+ */
+/**
+ * Reference to a field of type 'String'
+ */
+type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>;
+/**
+ * Reference to a field of type 'String[]'
+ */
+type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>;
+/**
+ * Reference to a field of type 'DateTime'
+ */
+type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>;
+/**
+ * Reference to a field of type 'DateTime[]'
+ */
+type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>;
+/**
+ * Reference to a field of type 'Json'
+ */
+type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>;
+/**
+ * Reference to a field of type 'QueryMode'
+ */
+type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>;
+/**
+ * Reference to a field of type 'Int'
+ */
+type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
+/**
+ * Reference to a field of type 'Int[]'
+ */
+type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>;
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
+type BatchPayload = {
+    count: number;
+};
+declare const defineExtension: runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs>;
+type DefaultPrismaClient = PrismaClient;
+type ErrorFormat = 'pretty' | 'colorless' | 'minimal';
+type PrismaClientOptions = ({
+    /**
+     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+     */
+    adapter: runtime.SqlDriverAdapterFactory;
+    accelerateUrl?: never;
+} | {
+    /**
+     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+     */
+    accelerateUrl: string;
+    adapter?: never;
+}) & {
+    /**
+     * @default "colorless"
+     */
+    errorFormat?: ErrorFormat;
+    /**
+     * @example
+     * ```
+     * // Shorthand for `emit: 'stdout'`
+     * log: ['query', 'info', 'warn', 'error']
+     *
+     * // Emit as events only
+     * log: [
+     *   { emit: 'event', level: 'query' },
+     *   { emit: 'event', level: 'info' },
+     *   { emit: 'event', level: 'warn' }
+     *   { emit: 'event', level: 'error' }
+     * ]
+     *
+     * / Emit as events and log to stdout
+     * og: [
+     *  { emit: 'stdout', level: 'query' },
+     *  { emit: 'stdout', level: 'info' },
+     *  { emit: 'stdout', level: 'warn' }
+     *  { emit: 'stdout', level: 'error' }
+     *
+     * ```
+     * Read more in our [docs](https://pris.ly/d/logging).
+     */
+    log?: (LogLevel | LogDefinition)[];
+    /**
+     * The default values for transactionOptions
+     * maxWait ?= 2000
+     * timeout ?= 5000
+     */
+    transactionOptions?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: TransactionIsolationLevel;
+    };
+    /**
+     * Global configuration for omitting model fields by default.
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   omit: {
+     *     user: {
+     *       password: true
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    omit?: GlobalOmitConfig;
+    /**
+     * SQL commenter plugins that add metadata to SQL queries as comments.
+     * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   adapter,
+     *   comments: [
+     *     traceContext(),
+     *     queryInsights(),
+     *   ],
+     * })
+     * ```
+     */
+    comments?: runtime.SqlCommenterPlugin[];
+};
+type GlobalOmitConfig = {
+    modelType?: ModelTypeOmit;
+    model?: ModelOmit;
+};
+type LogLevel = 'info' | 'query' | 'warn' | 'error';
+type LogDefinition = {
+    level: LogLevel;
+    emit: 'stdout' | 'event';
+};
+type CheckIsLogLevel<T> = T extends LogLevel ? T : never;
+type GetLogType<T> = CheckIsLogLevel<T extends LogDefinition ? T['level'] : T>;
+type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition> ? GetLogType<T[number]> : never;
+type QueryEvent = {
+    timestamp: Date;
+    query: string;
+    params: string;
+    duration: number;
+    target: string;
+};
+type LogEvent = {
+    timestamp: Date;
+    message: string;
+    target: string;
+};
+type PrismaAction = 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'executeRaw' | 'queryRaw' | 'aggregate' | 'count' | 'runCommandRaw' | 'findRaw' | 'groupBy';
+/**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>;
+
+type prismaNamespace_$ModelPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $ModelPayload<ExtArgs>;
+type prismaNamespace_$ModelTypePayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $ModelTypePayload<ExtArgs>;
+type prismaNamespace_AggregateModel = AggregateModel;
+type prismaNamespace_AggregateModelType = AggregateModelType;
+declare const prismaNamespace_AnyNull: typeof AnyNull;
+type prismaNamespace_Args<T, F extends runtime.Operation> = Args<T, F>;
+type prismaNamespace_At<O extends object, K extends Key, strict extends Boolean = 1> = At<O, K, strict>;
+type prismaNamespace_AtLeast<O extends object, K extends string> = AtLeast<O, K>;
+type prismaNamespace_BatchPayload = BatchPayload;
+type prismaNamespace_Boolean = Boolean;
+type prismaNamespace_Bytes = Bytes;
+type prismaNamespace_CheckIsLogLevel<T> = CheckIsLogLevel<T>;
+type prismaNamespace_ComputeRaw<A extends any> = ComputeRaw<A>;
+type prismaNamespace_DMMF = DMMF;
+type prismaNamespace_DateTimeFieldRefInput<$PrismaModel> = DateTimeFieldRefInput<$PrismaModel>;
+type prismaNamespace_DateTimeFieldUpdateOperationsInput = DateTimeFieldUpdateOperationsInput;
+type prismaNamespace_DateTimeFilter<$PrismaModel = never> = DateTimeFilter<$PrismaModel>;
+type prismaNamespace_DateTimeNullableFilter<$PrismaModel = never> = DateTimeNullableFilter<$PrismaModel>;
+type prismaNamespace_DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = DateTimeNullableWithAggregatesFilter<$PrismaModel>;
+type prismaNamespace_DateTimeWithAggregatesFilter<$PrismaModel = never> = DateTimeWithAggregatesFilter<$PrismaModel>;
+declare const prismaNamespace_DbNull: typeof DbNull;
+type prismaNamespace_Decimal = Decimal;
+type prismaNamespace_DecimalJsLike = DecimalJsLike;
+type prismaNamespace_DefaultPrismaClient = DefaultPrismaClient;
+type prismaNamespace_Either<O extends object, K extends Key, strict extends Boolean = 1> = Either<O, K, strict>;
+type prismaNamespace_EnumQueryModeFieldRefInput<$PrismaModel> = EnumQueryModeFieldRefInput<$PrismaModel>;
+type prismaNamespace_Enumerable<T> = Enumerable<T>;
+type prismaNamespace_ErrorFormat = ErrorFormat;
+type prismaNamespace_Exact<A, W> = Exact<A, W>;
+type prismaNamespace_ExcludeUnderscoreKeys<T extends string> = ExcludeUnderscoreKeys<T>;
+type prismaNamespace_Extends<A1 extends any, A2 extends any> = Extends<A1, A2>;
+type prismaNamespace_Extension = Extension;
+type prismaNamespace_False = False;
+type prismaNamespace_FieldRef<Model, FieldType> = FieldRef<Model, FieldType>;
+type prismaNamespace_GetEvents<T extends any[]> = GetEvents<T>;
+type prismaNamespace_GetHavingFields<T> = GetHavingFields<T>;
+type prismaNamespace_GetLogType<T> = GetLogType<T>;
+type prismaNamespace_GetModelAggregateType<T extends ModelAggregateArgs> = GetModelAggregateType<T>;
+type prismaNamespace_GetModelGroupByPayload<T extends ModelGroupByArgs> = GetModelGroupByPayload<T>;
+type prismaNamespace_GetModelTypeAggregateType<T extends ModelTypeAggregateArgs> = GetModelTypeAggregateType<T>;
+type prismaNamespace_GetModelTypeGroupByPayload<T extends ModelTypeGroupByArgs> = GetModelTypeGroupByPayload<T>;
+type prismaNamespace_GetScalarType<T, O> = GetScalarType<T, O>;
+type prismaNamespace_GlobalOmitConfig = GlobalOmitConfig;
+type prismaNamespace_Has<U extends Union, U1 extends Union> = Has<U, U1>;
+type prismaNamespace_InputJsonArray = InputJsonArray;
+type prismaNamespace_InputJsonObject = InputJsonObject;
+type prismaNamespace_InputJsonValue = InputJsonValue;
+type prismaNamespace_IntFieldRefInput<$PrismaModel> = IntFieldRefInput<$PrismaModel>;
+type prismaNamespace_IntersectOf<U extends Union> = IntersectOf<U>;
+type prismaNamespace_JsonArray = JsonArray;
+type prismaNamespace_JsonFieldRefInput<$PrismaModel> = JsonFieldRefInput<$PrismaModel>;
+type prismaNamespace_JsonFilter<$PrismaModel = never> = JsonFilter<$PrismaModel>;
+type prismaNamespace_JsonFilterBase<$PrismaModel = never> = JsonFilterBase<$PrismaModel>;
+declare const prismaNamespace_JsonNull: typeof JsonNull;
+type prismaNamespace_JsonNullValueFilter = JsonNullValueFilter;
+type prismaNamespace_JsonNullValueInput = JsonNullValueInput;
+type prismaNamespace_JsonObject = JsonObject;
+type prismaNamespace_JsonValue = JsonValue;
+type prismaNamespace_JsonWithAggregatesFilter<$PrismaModel = never> = JsonWithAggregatesFilter<$PrismaModel>;
+type prismaNamespace_JsonWithAggregatesFilterBase<$PrismaModel = never> = JsonWithAggregatesFilterBase<$PrismaModel>;
+type prismaNamespace_Keys<U extends Union> = Keys<U>;
+type prismaNamespace_ListDateTimeFieldRefInput<$PrismaModel> = ListDateTimeFieldRefInput<$PrismaModel>;
+type prismaNamespace_ListIntFieldRefInput<$PrismaModel> = ListIntFieldRefInput<$PrismaModel>;
+type prismaNamespace_ListStringFieldRefInput<$PrismaModel> = ListStringFieldRefInput<$PrismaModel>;
+type prismaNamespace_LogDefinition = LogDefinition;
+type prismaNamespace_LogEvent = LogEvent;
+type prismaNamespace_LogLevel = LogLevel;
+type prismaNamespace_MaybeTupleToUnion<T> = MaybeTupleToUnion<T>;
+type prismaNamespace_Merge<U extends object> = Merge<U>;
+type prismaNamespace_ModelAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelAggregateArgs<ExtArgs>;
+type prismaNamespace_ModelCountAggregateInputType = ModelCountAggregateInputType;
+type prismaNamespace_ModelCountAggregateOutputType = ModelCountAggregateOutputType;
+type prismaNamespace_ModelCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelCountArgs<ExtArgs>;
+type prismaNamespace_ModelCountOrderByAggregateInput = ModelCountOrderByAggregateInput;
+type prismaNamespace_ModelCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelCreateArgs<ExtArgs>;
+type prismaNamespace_ModelCreateInput = ModelCreateInput;
+type prismaNamespace_ModelCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelCreateManyAndReturnArgs<ExtArgs>;
+type prismaNamespace_ModelCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelCreateManyArgs<ExtArgs>;
+type prismaNamespace_ModelCreateManyInput = ModelCreateManyInput;
+type prismaNamespace_ModelCreateManyModelTypeInput = ModelCreateManyModelTypeInput;
+type prismaNamespace_ModelCreateManyModelTypeInputEnvelope = ModelCreateManyModelTypeInputEnvelope;
+type prismaNamespace_ModelCreateNestedManyWithoutModelTypeInput = ModelCreateNestedManyWithoutModelTypeInput;
+type prismaNamespace_ModelCreateOrConnectWithoutModelTypeInput = ModelCreateOrConnectWithoutModelTypeInput;
+type prismaNamespace_ModelCreateWithoutModelTypeInput = ModelCreateWithoutModelTypeInput;
+type prismaNamespace_ModelDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelDefaultArgs<ExtArgs>;
+type prismaNamespace_ModelDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = ModelDelegate<ExtArgs, GlobalOmitOptions>;
+type prismaNamespace_ModelDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelDeleteArgs<ExtArgs>;
+type prismaNamespace_ModelDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelDeleteManyArgs<ExtArgs>;
+type prismaNamespace_ModelFieldRefs = ModelFieldRefs;
+type prismaNamespace_ModelFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelFindFirstArgs<ExtArgs>;
+type prismaNamespace_ModelFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelFindFirstOrThrowArgs<ExtArgs>;
+type prismaNamespace_ModelFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelFindManyArgs<ExtArgs>;
+type prismaNamespace_ModelFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelFindUniqueArgs<ExtArgs>;
+type prismaNamespace_ModelFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelFindUniqueOrThrowArgs<ExtArgs>;
+type prismaNamespace_ModelGetPayload<S extends boolean | null | undefined | ModelDefaultArgs> = ModelGetPayload<S>;
+type prismaNamespace_ModelGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelGroupByArgs<ExtArgs>;
+type prismaNamespace_ModelGroupByOutputType = ModelGroupByOutputType;
+type prismaNamespace_ModelInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelInclude<ExtArgs>;
+type prismaNamespace_ModelIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelIncludeCreateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelIncludeUpdateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelListRelationFilter = ModelListRelationFilter;
+type prismaNamespace_ModelMaxAggregateInputType = ModelMaxAggregateInputType;
+type prismaNamespace_ModelMaxAggregateOutputType = ModelMaxAggregateOutputType;
+type prismaNamespace_ModelMaxOrderByAggregateInput = ModelMaxOrderByAggregateInput;
+type prismaNamespace_ModelMinAggregateInputType = ModelMinAggregateInputType;
+type prismaNamespace_ModelMinAggregateOutputType = ModelMinAggregateOutputType;
+type prismaNamespace_ModelMinOrderByAggregateInput = ModelMinOrderByAggregateInput;
+type prismaNamespace_ModelModel = ModelModel;
+type prismaNamespace_ModelName = ModelName;
+type prismaNamespace_ModelOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelOmit<ExtArgs>;
+type prismaNamespace_ModelOrderByRelationAggregateInput = ModelOrderByRelationAggregateInput;
+type prismaNamespace_ModelOrderByWithAggregationInput = ModelOrderByWithAggregationInput;
+type prismaNamespace_ModelOrderByWithRelationInput = ModelOrderByWithRelationInput;
+type prismaNamespace_ModelScalarFieldEnum = ModelScalarFieldEnum;
+type prismaNamespace_ModelScalarWhereInput = ModelScalarWhereInput;
+type prismaNamespace_ModelScalarWhereWithAggregatesInput = ModelScalarWhereWithAggregatesInput;
+type prismaNamespace_ModelSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelSelect<ExtArgs>;
+type prismaNamespace_ModelSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelSelectCreateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelSelectScalar = ModelSelectScalar;
+type prismaNamespace_ModelSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelSelectUpdateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelType$modelsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelType$modelsArgs<ExtArgs>;
+type prismaNamespace_ModelTypeAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeAggregateArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCountAggregateInputType = ModelTypeCountAggregateInputType;
+type prismaNamespace_ModelTypeCountAggregateOutputType = ModelTypeCountAggregateOutputType;
+type prismaNamespace_ModelTypeCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCountArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCountOrderByAggregateInput = ModelTypeCountOrderByAggregateInput;
+type prismaNamespace_ModelTypeCountOutputType = ModelTypeCountOutputType;
+type prismaNamespace_ModelTypeCountOutputTypeCountModelsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCountOutputTypeCountModelsArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCountOutputTypeDefaultArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCountOutputTypeSelect<ExtArgs>;
+type prismaNamespace_ModelTypeCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCreateArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCreateInput = ModelTypeCreateInput;
+type prismaNamespace_ModelTypeCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCreateManyAndReturnArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeCreateManyArgs<ExtArgs>;
+type prismaNamespace_ModelTypeCreateManyInput = ModelTypeCreateManyInput;
+type prismaNamespace_ModelTypeCreateNestedOneWithoutModelsInput = ModelTypeCreateNestedOneWithoutModelsInput;
+type prismaNamespace_ModelTypeCreateOrConnectWithoutModelsInput = ModelTypeCreateOrConnectWithoutModelsInput;
+type prismaNamespace_ModelTypeCreateWithoutModelsInput = ModelTypeCreateWithoutModelsInput;
+type prismaNamespace_ModelTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeDefaultArgs<ExtArgs>;
+type prismaNamespace_ModelTypeDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = ModelTypeDelegate<ExtArgs, GlobalOmitOptions>;
+type prismaNamespace_ModelTypeDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeDeleteArgs<ExtArgs>;
+type prismaNamespace_ModelTypeDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeDeleteManyArgs<ExtArgs>;
+type prismaNamespace_ModelTypeFieldRefs = ModelTypeFieldRefs;
+type prismaNamespace_ModelTypeFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeFindFirstArgs<ExtArgs>;
+type prismaNamespace_ModelTypeFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeFindFirstOrThrowArgs<ExtArgs>;
+type prismaNamespace_ModelTypeFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeFindManyArgs<ExtArgs>;
+type prismaNamespace_ModelTypeFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeFindUniqueArgs<ExtArgs>;
+type prismaNamespace_ModelTypeFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeFindUniqueOrThrowArgs<ExtArgs>;
+type prismaNamespace_ModelTypeGetPayload<S extends boolean | null | undefined | ModelTypeDefaultArgs> = ModelTypeGetPayload<S>;
+type prismaNamespace_ModelTypeGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeGroupByArgs<ExtArgs>;
+type prismaNamespace_ModelTypeGroupByOutputType = ModelTypeGroupByOutputType;
+type prismaNamespace_ModelTypeInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeInclude<ExtArgs>;
+type prismaNamespace_ModelTypeIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeIncludeCreateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelTypeIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeIncludeUpdateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelTypeMaxAggregateInputType = ModelTypeMaxAggregateInputType;
+type prismaNamespace_ModelTypeMaxAggregateOutputType = ModelTypeMaxAggregateOutputType;
+type prismaNamespace_ModelTypeMaxOrderByAggregateInput = ModelTypeMaxOrderByAggregateInput;
+type prismaNamespace_ModelTypeMinAggregateInputType = ModelTypeMinAggregateInputType;
+type prismaNamespace_ModelTypeMinAggregateOutputType = ModelTypeMinAggregateOutputType;
+type prismaNamespace_ModelTypeMinOrderByAggregateInput = ModelTypeMinOrderByAggregateInput;
+type prismaNamespace_ModelTypeModel = ModelTypeModel;
+type prismaNamespace_ModelTypeOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeOmit<ExtArgs>;
+type prismaNamespace_ModelTypeOrderByWithAggregationInput = ModelTypeOrderByWithAggregationInput;
+type prismaNamespace_ModelTypeOrderByWithRelationInput = ModelTypeOrderByWithRelationInput;
+type prismaNamespace_ModelTypeScalarFieldEnum = ModelTypeScalarFieldEnum;
+type prismaNamespace_ModelTypeScalarRelationFilter = ModelTypeScalarRelationFilter;
+type prismaNamespace_ModelTypeScalarWhereWithAggregatesInput = ModelTypeScalarWhereWithAggregatesInput;
+type prismaNamespace_ModelTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeSelect<ExtArgs>;
+type prismaNamespace_ModelTypeSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeSelectCreateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelTypeSelectScalar = ModelTypeSelectScalar;
+type prismaNamespace_ModelTypeSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeSelectUpdateManyAndReturn<ExtArgs>;
+type prismaNamespace_ModelTypeUncheckedCreateInput = ModelTypeUncheckedCreateInput;
+type prismaNamespace_ModelTypeUncheckedCreateWithoutModelsInput = ModelTypeUncheckedCreateWithoutModelsInput;
+type prismaNamespace_ModelTypeUncheckedUpdateInput = ModelTypeUncheckedUpdateInput;
+type prismaNamespace_ModelTypeUncheckedUpdateManyInput = ModelTypeUncheckedUpdateManyInput;
+type prismaNamespace_ModelTypeUncheckedUpdateWithoutModelsInput = ModelTypeUncheckedUpdateWithoutModelsInput;
+type prismaNamespace_ModelTypeUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeUpdateArgs<ExtArgs>;
+type prismaNamespace_ModelTypeUpdateInput = ModelTypeUpdateInput;
+type prismaNamespace_ModelTypeUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeUpdateManyAndReturnArgs<ExtArgs>;
+type prismaNamespace_ModelTypeUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeUpdateManyArgs<ExtArgs>;
+type prismaNamespace_ModelTypeUpdateManyMutationInput = ModelTypeUpdateManyMutationInput;
+type prismaNamespace_ModelTypeUpdateOneRequiredWithoutModelsNestedInput = ModelTypeUpdateOneRequiredWithoutModelsNestedInput;
+type prismaNamespace_ModelTypeUpdateToOneWithWhereWithoutModelsInput = ModelTypeUpdateToOneWithWhereWithoutModelsInput;
+type prismaNamespace_ModelTypeUpdateWithoutModelsInput = ModelTypeUpdateWithoutModelsInput;
+type prismaNamespace_ModelTypeUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelTypeUpsertArgs<ExtArgs>;
+type prismaNamespace_ModelTypeUpsertWithoutModelsInput = ModelTypeUpsertWithoutModelsInput;
+type prismaNamespace_ModelTypeWhereInput = ModelTypeWhereInput;
+type prismaNamespace_ModelTypeWhereUniqueInput = ModelTypeWhereUniqueInput;
+type prismaNamespace_ModelUncheckedCreateInput = ModelUncheckedCreateInput;
+type prismaNamespace_ModelUncheckedCreateNestedManyWithoutModelTypeInput = ModelUncheckedCreateNestedManyWithoutModelTypeInput;
+type prismaNamespace_ModelUncheckedCreateWithoutModelTypeInput = ModelUncheckedCreateWithoutModelTypeInput;
+type prismaNamespace_ModelUncheckedUpdateInput = ModelUncheckedUpdateInput;
+type prismaNamespace_ModelUncheckedUpdateManyInput = ModelUncheckedUpdateManyInput;
+type prismaNamespace_ModelUncheckedUpdateManyWithoutModelTypeInput = ModelUncheckedUpdateManyWithoutModelTypeInput;
+type prismaNamespace_ModelUncheckedUpdateManyWithoutModelTypeNestedInput = ModelUncheckedUpdateManyWithoutModelTypeNestedInput;
+type prismaNamespace_ModelUncheckedUpdateWithoutModelTypeInput = ModelUncheckedUpdateWithoutModelTypeInput;
+type prismaNamespace_ModelUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelUpdateArgs<ExtArgs>;
+type prismaNamespace_ModelUpdateInput = ModelUpdateInput;
+type prismaNamespace_ModelUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelUpdateManyAndReturnArgs<ExtArgs>;
+type prismaNamespace_ModelUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelUpdateManyArgs<ExtArgs>;
+type prismaNamespace_ModelUpdateManyMutationInput = ModelUpdateManyMutationInput;
+type prismaNamespace_ModelUpdateManyWithWhereWithoutModelTypeInput = ModelUpdateManyWithWhereWithoutModelTypeInput;
+type prismaNamespace_ModelUpdateManyWithoutModelTypeNestedInput = ModelUpdateManyWithoutModelTypeNestedInput;
+type prismaNamespace_ModelUpdateWithWhereUniqueWithoutModelTypeInput = ModelUpdateWithWhereUniqueWithoutModelTypeInput;
+type prismaNamespace_ModelUpdateWithoutModelTypeInput = ModelUpdateWithoutModelTypeInput;
+type prismaNamespace_ModelUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = ModelUpsertArgs<ExtArgs>;
+type prismaNamespace_ModelUpsertWithWhereUniqueWithoutModelTypeInput = ModelUpsertWithWhereUniqueWithoutModelTypeInput;
+type prismaNamespace_ModelWhereInput = ModelWhereInput;
+type prismaNamespace_ModelWhereUniqueInput = ModelWhereUniqueInput;
+type prismaNamespace_NestedDateTimeFilter<$PrismaModel = never> = NestedDateTimeFilter<$PrismaModel>;
+type prismaNamespace_NestedDateTimeNullableFilter<$PrismaModel = never> = NestedDateTimeNullableFilter<$PrismaModel>;
+type prismaNamespace_NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = NestedDateTimeNullableWithAggregatesFilter<$PrismaModel>;
+type prismaNamespace_NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = NestedDateTimeWithAggregatesFilter<$PrismaModel>;
+type prismaNamespace_NestedIntFilter<$PrismaModel = never> = NestedIntFilter<$PrismaModel>;
+type prismaNamespace_NestedIntNullableFilter<$PrismaModel = never> = NestedIntNullableFilter<$PrismaModel>;
+type prismaNamespace_NestedJsonFilter<$PrismaModel = never> = NestedJsonFilter<$PrismaModel>;
+type prismaNamespace_NestedJsonFilterBase<$PrismaModel = never> = NestedJsonFilterBase<$PrismaModel>;
+type prismaNamespace_NestedStringFilter<$PrismaModel = never> = NestedStringFilter<$PrismaModel>;
+type prismaNamespace_NestedStringWithAggregatesFilter<$PrismaModel = never> = NestedStringWithAggregatesFilter<$PrismaModel>;
+type prismaNamespace_Not<B extends Boolean> = Not<B>;
+declare const prismaNamespace_NullTypes: typeof NullTypes;
+type prismaNamespace_NullableDateTimeFieldUpdateOperationsInput = NullableDateTimeFieldUpdateOperationsInput;
+type prismaNamespace_NullsOrder = NullsOrder;
+type prismaNamespace_OptionalFlat<O> = OptionalFlat<O>;
+type prismaNamespace_Or<B1 extends Boolean, B2 extends Boolean> = Or<B1, B2>;
+type prismaNamespace_Overwrite<O extends object, O1 extends object> = Overwrite<O, O1>;
+type prismaNamespace_PatchUndefined<O extends object, O1 extends object> = PatchUndefined<O, O1>;
+type prismaNamespace_Payload<T, F extends runtime.Operation = never> = Payload<T, F>;
+type prismaNamespace_PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = PickEnumerable<T, K>;
+type prismaNamespace_PrismaAction = PrismaAction;
+type prismaNamespace_PrismaClientInitializationError = PrismaClientInitializationError;
+type prismaNamespace_PrismaClientKnownRequestError = PrismaClientKnownRequestError;
+type prismaNamespace_PrismaClientOptions = PrismaClientOptions;
+type prismaNamespace_PrismaClientRustPanicError = PrismaClientRustPanicError;
+type prismaNamespace_PrismaClientUnknownRequestError = PrismaClientUnknownRequestError;
+type prismaNamespace_PrismaClientValidationError = PrismaClientValidationError;
+type prismaNamespace_PrismaPromise<T> = PrismaPromise<T>;
+type prismaNamespace_PrismaVersion = PrismaVersion;
+type prismaNamespace_Prisma__ModelClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = Prisma__ModelClient<T, Null, ExtArgs, GlobalOmitOptions>;
+type prismaNamespace_Prisma__ModelTypeClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = Prisma__ModelTypeClient<T, Null, ExtArgs, GlobalOmitOptions>;
+type prismaNamespace_QueryEvent = QueryEvent;
+type prismaNamespace_QueryMode = QueryMode;
+type prismaNamespace_Result<T, A, F extends runtime.Operation> = Result<T, A, F>;
+type prismaNamespace_SelectSubset<T, U> = SelectSubset<T, U>;
+type prismaNamespace_SortOrder = SortOrder;
+type prismaNamespace_SortOrderInput = SortOrderInput;
+type prismaNamespace_Sql = Sql;
+type prismaNamespace_Strict<U extends object> = Strict<U>;
+type prismaNamespace_StringFieldRefInput<$PrismaModel> = StringFieldRefInput<$PrismaModel>;
+type prismaNamespace_StringFieldUpdateOperationsInput = StringFieldUpdateOperationsInput;
+type prismaNamespace_StringFilter<$PrismaModel = never> = StringFilter<$PrismaModel>;
+type prismaNamespace_StringWithAggregatesFilter<$PrismaModel = never> = StringWithAggregatesFilter<$PrismaModel>;
+type prismaNamespace_Subset<T, U> = Subset<T, U>;
+type prismaNamespace_SubsetIntersection<T, U, K> = SubsetIntersection<T, U, K>;
+type prismaNamespace_TransactionClient = TransactionClient;
+type prismaNamespace_TransactionIsolationLevel = TransactionIsolationLevel;
+type prismaNamespace_True = True;
+type prismaNamespace_TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = TypeMap<ExtArgs, GlobalOmitOptions>;
+type prismaNamespace_TypeMapCb<GlobalOmitOptions = {}> = TypeMapCb<GlobalOmitOptions>;
+type prismaNamespace_UnEnumerate<T extends unknown> = UnEnumerate<T>;
+type prismaNamespace_Union = Union;
+type prismaNamespace_XOR<T, U> = XOR<T, U>;
+declare const prismaNamespace_defineExtension: typeof defineExtension;
+declare const prismaNamespace_empty: typeof empty;
+declare const prismaNamespace_getExtensionContext: typeof getExtensionContext;
+declare const prismaNamespace_join: typeof join;
+declare const prismaNamespace_prismaVersion: typeof prismaVersion;
+declare const prismaNamespace_raw: typeof raw;
+declare const prismaNamespace_sql: typeof sql;
+declare namespace prismaNamespace {
+  export { type prismaNamespace_$ModelPayload as $ModelPayload, type prismaNamespace_$ModelTypePayload as $ModelTypePayload, type prismaNamespace_AggregateModel as AggregateModel, type prismaNamespace_AggregateModelType as AggregateModelType, prismaNamespace_AnyNull as AnyNull, type prismaNamespace_Args as Args, type prismaNamespace_At as At, type prismaNamespace_AtLeast as AtLeast, type prismaNamespace_BatchPayload as BatchPayload, type prismaNamespace_Boolean as Boolean, type prismaNamespace_Bytes as Bytes, type prismaNamespace_CheckIsLogLevel as CheckIsLogLevel, type prismaNamespace_ComputeRaw as ComputeRaw, type prismaNamespace_DMMF as DMMF, type prismaNamespace_DateTimeFieldRefInput as DateTimeFieldRefInput, type prismaNamespace_DateTimeFieldUpdateOperationsInput as DateTimeFieldUpdateOperationsInput, type prismaNamespace_DateTimeFilter as DateTimeFilter, type prismaNamespace_DateTimeNullableFilter as DateTimeNullableFilter, type prismaNamespace_DateTimeNullableWithAggregatesFilter as DateTimeNullableWithAggregatesFilter, type prismaNamespace_DateTimeWithAggregatesFilter as DateTimeWithAggregatesFilter, prismaNamespace_DbNull as DbNull, type prismaNamespace_Decimal as Decimal, type prismaNamespace_DecimalJsLike as DecimalJsLike, type prismaNamespace_DefaultPrismaClient as DefaultPrismaClient, type prismaNamespace_Either as Either, type prismaNamespace_EnumQueryModeFieldRefInput as EnumQueryModeFieldRefInput, type prismaNamespace_Enumerable as Enumerable, type prismaNamespace_ErrorFormat as ErrorFormat, type prismaNamespace_Exact as Exact, type prismaNamespace_ExcludeUnderscoreKeys as ExcludeUnderscoreKeys, type prismaNamespace_Extends as Extends, type prismaNamespace_Extension as Extension, type prismaNamespace_False as False, type prismaNamespace_FieldRef as FieldRef, type prismaNamespace_GetEvents as GetEvents, type prismaNamespace_GetHavingFields as GetHavingFields, type prismaNamespace_GetLogType as GetLogType, type prismaNamespace_GetModelAggregateType as GetModelAggregateType, type prismaNamespace_GetModelGroupByPayload as GetModelGroupByPayload, type prismaNamespace_GetModelTypeAggregateType as GetModelTypeAggregateType, type prismaNamespace_GetModelTypeGroupByPayload as GetModelTypeGroupByPayload, type prismaNamespace_GetScalarType as GetScalarType, type prismaNamespace_GlobalOmitConfig as GlobalOmitConfig, type prismaNamespace_Has as Has, type prismaNamespace_InputJsonArray as InputJsonArray, type prismaNamespace_InputJsonObject as InputJsonObject, type prismaNamespace_InputJsonValue as InputJsonValue, type prismaNamespace_IntFieldRefInput as IntFieldRefInput, type prismaNamespace_IntersectOf as IntersectOf, type prismaNamespace_JsonArray as JsonArray, type prismaNamespace_JsonFieldRefInput as JsonFieldRefInput, type prismaNamespace_JsonFilter as JsonFilter, type prismaNamespace_JsonFilterBase as JsonFilterBase, prismaNamespace_JsonNull as JsonNull, type prismaNamespace_JsonNullValueFilter as JsonNullValueFilter, type prismaNamespace_JsonNullValueInput as JsonNullValueInput, type prismaNamespace_JsonObject as JsonObject, type prismaNamespace_JsonValue as JsonValue, type prismaNamespace_JsonWithAggregatesFilter as JsonWithAggregatesFilter, type prismaNamespace_JsonWithAggregatesFilterBase as JsonWithAggregatesFilterBase, type prismaNamespace_Keys as Keys, type prismaNamespace_ListDateTimeFieldRefInput as ListDateTimeFieldRefInput, type prismaNamespace_ListIntFieldRefInput as ListIntFieldRefInput, type prismaNamespace_ListStringFieldRefInput as ListStringFieldRefInput, type prismaNamespace_LogDefinition as LogDefinition, type prismaNamespace_LogEvent as LogEvent, type prismaNamespace_LogLevel as LogLevel, type prismaNamespace_MaybeTupleToUnion as MaybeTupleToUnion, type prismaNamespace_Merge as Merge, type prismaNamespace_ModelAggregateArgs as ModelAggregateArgs, type prismaNamespace_ModelCountAggregateInputType as ModelCountAggregateInputType, type prismaNamespace_ModelCountAggregateOutputType as ModelCountAggregateOutputType, type prismaNamespace_ModelCountArgs as ModelCountArgs, type prismaNamespace_ModelCountOrderByAggregateInput as ModelCountOrderByAggregateInput, type prismaNamespace_ModelCreateArgs as ModelCreateArgs, type prismaNamespace_ModelCreateInput as ModelCreateInput, type prismaNamespace_ModelCreateManyAndReturnArgs as ModelCreateManyAndReturnArgs, type prismaNamespace_ModelCreateManyArgs as ModelCreateManyArgs, type prismaNamespace_ModelCreateManyInput as ModelCreateManyInput, type prismaNamespace_ModelCreateManyModelTypeInput as ModelCreateManyModelTypeInput, type prismaNamespace_ModelCreateManyModelTypeInputEnvelope as ModelCreateManyModelTypeInputEnvelope, type prismaNamespace_ModelCreateNestedManyWithoutModelTypeInput as ModelCreateNestedManyWithoutModelTypeInput, type prismaNamespace_ModelCreateOrConnectWithoutModelTypeInput as ModelCreateOrConnectWithoutModelTypeInput, type prismaNamespace_ModelCreateWithoutModelTypeInput as ModelCreateWithoutModelTypeInput, type prismaNamespace_ModelDefaultArgs as ModelDefaultArgs, type prismaNamespace_ModelDelegate as ModelDelegate, type prismaNamespace_ModelDeleteArgs as ModelDeleteArgs, type prismaNamespace_ModelDeleteManyArgs as ModelDeleteManyArgs, type prismaNamespace_ModelFieldRefs as ModelFieldRefs, type prismaNamespace_ModelFindFirstArgs as ModelFindFirstArgs, type prismaNamespace_ModelFindFirstOrThrowArgs as ModelFindFirstOrThrowArgs, type prismaNamespace_ModelFindManyArgs as ModelFindManyArgs, type prismaNamespace_ModelFindUniqueArgs as ModelFindUniqueArgs, type prismaNamespace_ModelFindUniqueOrThrowArgs as ModelFindUniqueOrThrowArgs, type prismaNamespace_ModelGetPayload as ModelGetPayload, type prismaNamespace_ModelGroupByArgs as ModelGroupByArgs, type prismaNamespace_ModelGroupByOutputType as ModelGroupByOutputType, type prismaNamespace_ModelInclude as ModelInclude, type prismaNamespace_ModelIncludeCreateManyAndReturn as ModelIncludeCreateManyAndReturn, type prismaNamespace_ModelIncludeUpdateManyAndReturn as ModelIncludeUpdateManyAndReturn, type prismaNamespace_ModelListRelationFilter as ModelListRelationFilter, type prismaNamespace_ModelMaxAggregateInputType as ModelMaxAggregateInputType, type prismaNamespace_ModelMaxAggregateOutputType as ModelMaxAggregateOutputType, type prismaNamespace_ModelMaxOrderByAggregateInput as ModelMaxOrderByAggregateInput, type prismaNamespace_ModelMinAggregateInputType as ModelMinAggregateInputType, type prismaNamespace_ModelMinAggregateOutputType as ModelMinAggregateOutputType, type prismaNamespace_ModelMinOrderByAggregateInput as ModelMinOrderByAggregateInput, type prismaNamespace_ModelModel as ModelModel, type prismaNamespace_ModelName as ModelName, type prismaNamespace_ModelOmit as ModelOmit, type prismaNamespace_ModelOrderByRelationAggregateInput as ModelOrderByRelationAggregateInput, type prismaNamespace_ModelOrderByWithAggregationInput as ModelOrderByWithAggregationInput, type prismaNamespace_ModelOrderByWithRelationInput as ModelOrderByWithRelationInput, type prismaNamespace_ModelScalarFieldEnum as ModelScalarFieldEnum, type prismaNamespace_ModelScalarWhereInput as ModelScalarWhereInput, type prismaNamespace_ModelScalarWhereWithAggregatesInput as ModelScalarWhereWithAggregatesInput, type prismaNamespace_ModelSelect as ModelSelect, type prismaNamespace_ModelSelectCreateManyAndReturn as ModelSelectCreateManyAndReturn, type prismaNamespace_ModelSelectScalar as ModelSelectScalar, type prismaNamespace_ModelSelectUpdateManyAndReturn as ModelSelectUpdateManyAndReturn, type prismaNamespace_ModelType$modelsArgs as ModelType$modelsArgs, type prismaNamespace_ModelTypeAggregateArgs as ModelTypeAggregateArgs, type prismaNamespace_ModelTypeCountAggregateInputType as ModelTypeCountAggregateInputType, type prismaNamespace_ModelTypeCountAggregateOutputType as ModelTypeCountAggregateOutputType, type prismaNamespace_ModelTypeCountArgs as ModelTypeCountArgs, type prismaNamespace_ModelTypeCountOrderByAggregateInput as ModelTypeCountOrderByAggregateInput, type prismaNamespace_ModelTypeCountOutputType as ModelTypeCountOutputType, type prismaNamespace_ModelTypeCountOutputTypeCountModelsArgs as ModelTypeCountOutputTypeCountModelsArgs, type prismaNamespace_ModelTypeCountOutputTypeDefaultArgs as ModelTypeCountOutputTypeDefaultArgs, type prismaNamespace_ModelTypeCountOutputTypeSelect as ModelTypeCountOutputTypeSelect, type prismaNamespace_ModelTypeCreateArgs as ModelTypeCreateArgs, type prismaNamespace_ModelTypeCreateInput as ModelTypeCreateInput, type prismaNamespace_ModelTypeCreateManyAndReturnArgs as ModelTypeCreateManyAndReturnArgs, type prismaNamespace_ModelTypeCreateManyArgs as ModelTypeCreateManyArgs, type prismaNamespace_ModelTypeCreateManyInput as ModelTypeCreateManyInput, type prismaNamespace_ModelTypeCreateNestedOneWithoutModelsInput as ModelTypeCreateNestedOneWithoutModelsInput, type prismaNamespace_ModelTypeCreateOrConnectWithoutModelsInput as ModelTypeCreateOrConnectWithoutModelsInput, type prismaNamespace_ModelTypeCreateWithoutModelsInput as ModelTypeCreateWithoutModelsInput, type prismaNamespace_ModelTypeDefaultArgs as ModelTypeDefaultArgs, type prismaNamespace_ModelTypeDelegate as ModelTypeDelegate, type prismaNamespace_ModelTypeDeleteArgs as ModelTypeDeleteArgs, type prismaNamespace_ModelTypeDeleteManyArgs as ModelTypeDeleteManyArgs, type prismaNamespace_ModelTypeFieldRefs as ModelTypeFieldRefs, type prismaNamespace_ModelTypeFindFirstArgs as ModelTypeFindFirstArgs, type prismaNamespace_ModelTypeFindFirstOrThrowArgs as ModelTypeFindFirstOrThrowArgs, type prismaNamespace_ModelTypeFindManyArgs as ModelTypeFindManyArgs, type prismaNamespace_ModelTypeFindUniqueArgs as ModelTypeFindUniqueArgs, type prismaNamespace_ModelTypeFindUniqueOrThrowArgs as ModelTypeFindUniqueOrThrowArgs, type prismaNamespace_ModelTypeGetPayload as ModelTypeGetPayload, type prismaNamespace_ModelTypeGroupByArgs as ModelTypeGroupByArgs, type prismaNamespace_ModelTypeGroupByOutputType as ModelTypeGroupByOutputType, type prismaNamespace_ModelTypeInclude as ModelTypeInclude, type prismaNamespace_ModelTypeIncludeCreateManyAndReturn as ModelTypeIncludeCreateManyAndReturn, type prismaNamespace_ModelTypeIncludeUpdateManyAndReturn as ModelTypeIncludeUpdateManyAndReturn, type prismaNamespace_ModelTypeMaxAggregateInputType as ModelTypeMaxAggregateInputType, type prismaNamespace_ModelTypeMaxAggregateOutputType as ModelTypeMaxAggregateOutputType, type prismaNamespace_ModelTypeMaxOrderByAggregateInput as ModelTypeMaxOrderByAggregateInput, type prismaNamespace_ModelTypeMinAggregateInputType as ModelTypeMinAggregateInputType, type prismaNamespace_ModelTypeMinAggregateOutputType as ModelTypeMinAggregateOutputType, type prismaNamespace_ModelTypeMinOrderByAggregateInput as ModelTypeMinOrderByAggregateInput, type prismaNamespace_ModelTypeModel as ModelTypeModel, type prismaNamespace_ModelTypeOmit as ModelTypeOmit, type prismaNamespace_ModelTypeOrderByWithAggregationInput as ModelTypeOrderByWithAggregationInput, type prismaNamespace_ModelTypeOrderByWithRelationInput as ModelTypeOrderByWithRelationInput, type prismaNamespace_ModelTypeScalarFieldEnum as ModelTypeScalarFieldEnum, type prismaNamespace_ModelTypeScalarRelationFilter as ModelTypeScalarRelationFilter, type prismaNamespace_ModelTypeScalarWhereWithAggregatesInput as ModelTypeScalarWhereWithAggregatesInput, type prismaNamespace_ModelTypeSelect as ModelTypeSelect, type prismaNamespace_ModelTypeSelectCreateManyAndReturn as ModelTypeSelectCreateManyAndReturn, type prismaNamespace_ModelTypeSelectScalar as ModelTypeSelectScalar, type prismaNamespace_ModelTypeSelectUpdateManyAndReturn as ModelTypeSelectUpdateManyAndReturn, type prismaNamespace_ModelTypeUncheckedCreateInput as ModelTypeUncheckedCreateInput, type prismaNamespace_ModelTypeUncheckedCreateWithoutModelsInput as ModelTypeUncheckedCreateWithoutModelsInput, type prismaNamespace_ModelTypeUncheckedUpdateInput as ModelTypeUncheckedUpdateInput, type prismaNamespace_ModelTypeUncheckedUpdateManyInput as ModelTypeUncheckedUpdateManyInput, type prismaNamespace_ModelTypeUncheckedUpdateWithoutModelsInput as ModelTypeUncheckedUpdateWithoutModelsInput, type prismaNamespace_ModelTypeUpdateArgs as ModelTypeUpdateArgs, type prismaNamespace_ModelTypeUpdateInput as ModelTypeUpdateInput, type prismaNamespace_ModelTypeUpdateManyAndReturnArgs as ModelTypeUpdateManyAndReturnArgs, type prismaNamespace_ModelTypeUpdateManyArgs as ModelTypeUpdateManyArgs, type prismaNamespace_ModelTypeUpdateManyMutationInput as ModelTypeUpdateManyMutationInput, type prismaNamespace_ModelTypeUpdateOneRequiredWithoutModelsNestedInput as ModelTypeUpdateOneRequiredWithoutModelsNestedInput, type prismaNamespace_ModelTypeUpdateToOneWithWhereWithoutModelsInput as ModelTypeUpdateToOneWithWhereWithoutModelsInput, type prismaNamespace_ModelTypeUpdateWithoutModelsInput as ModelTypeUpdateWithoutModelsInput, type prismaNamespace_ModelTypeUpsertArgs as ModelTypeUpsertArgs, type prismaNamespace_ModelTypeUpsertWithoutModelsInput as ModelTypeUpsertWithoutModelsInput, type prismaNamespace_ModelTypeWhereInput as ModelTypeWhereInput, type prismaNamespace_ModelTypeWhereUniqueInput as ModelTypeWhereUniqueInput, type prismaNamespace_ModelUncheckedCreateInput as ModelUncheckedCreateInput, type prismaNamespace_ModelUncheckedCreateNestedManyWithoutModelTypeInput as ModelUncheckedCreateNestedManyWithoutModelTypeInput, type prismaNamespace_ModelUncheckedCreateWithoutModelTypeInput as ModelUncheckedCreateWithoutModelTypeInput, type prismaNamespace_ModelUncheckedUpdateInput as ModelUncheckedUpdateInput, type prismaNamespace_ModelUncheckedUpdateManyInput as ModelUncheckedUpdateManyInput, type prismaNamespace_ModelUncheckedUpdateManyWithoutModelTypeInput as ModelUncheckedUpdateManyWithoutModelTypeInput, type prismaNamespace_ModelUncheckedUpdateManyWithoutModelTypeNestedInput as ModelUncheckedUpdateManyWithoutModelTypeNestedInput, type prismaNamespace_ModelUncheckedUpdateWithoutModelTypeInput as ModelUncheckedUpdateWithoutModelTypeInput, type prismaNamespace_ModelUpdateArgs as ModelUpdateArgs, type prismaNamespace_ModelUpdateInput as ModelUpdateInput, type prismaNamespace_ModelUpdateManyAndReturnArgs as ModelUpdateManyAndReturnArgs, type prismaNamespace_ModelUpdateManyArgs as ModelUpdateManyArgs, type prismaNamespace_ModelUpdateManyMutationInput as ModelUpdateManyMutationInput, type prismaNamespace_ModelUpdateManyWithWhereWithoutModelTypeInput as ModelUpdateManyWithWhereWithoutModelTypeInput, type prismaNamespace_ModelUpdateManyWithoutModelTypeNestedInput as ModelUpdateManyWithoutModelTypeNestedInput, type prismaNamespace_ModelUpdateWithWhereUniqueWithoutModelTypeInput as ModelUpdateWithWhereUniqueWithoutModelTypeInput, type prismaNamespace_ModelUpdateWithoutModelTypeInput as ModelUpdateWithoutModelTypeInput, type prismaNamespace_ModelUpsertArgs as ModelUpsertArgs, type prismaNamespace_ModelUpsertWithWhereUniqueWithoutModelTypeInput as ModelUpsertWithWhereUniqueWithoutModelTypeInput, type prismaNamespace_ModelWhereInput as ModelWhereInput, type prismaNamespace_ModelWhereUniqueInput as ModelWhereUniqueInput, type prismaNamespace_NestedDateTimeFilter as NestedDateTimeFilter, type prismaNamespace_NestedDateTimeNullableFilter as NestedDateTimeNullableFilter, type prismaNamespace_NestedDateTimeNullableWithAggregatesFilter as NestedDateTimeNullableWithAggregatesFilter, type prismaNamespace_NestedDateTimeWithAggregatesFilter as NestedDateTimeWithAggregatesFilter, type prismaNamespace_NestedIntFilter as NestedIntFilter, type prismaNamespace_NestedIntNullableFilter as NestedIntNullableFilter, type prismaNamespace_NestedJsonFilter as NestedJsonFilter, type prismaNamespace_NestedJsonFilterBase as NestedJsonFilterBase, type prismaNamespace_NestedStringFilter as NestedStringFilter, type prismaNamespace_NestedStringWithAggregatesFilter as NestedStringWithAggregatesFilter, type prismaNamespace_Not as Not, prismaNamespace_NullTypes as NullTypes, type prismaNamespace_NullableDateTimeFieldUpdateOperationsInput as NullableDateTimeFieldUpdateOperationsInput, type prismaNamespace_NullsOrder as NullsOrder, type prismaNamespace_OptionalFlat as OptionalFlat, type prismaNamespace_Or as Or, type prismaNamespace_Overwrite as Overwrite, type prismaNamespace_PatchUndefined as PatchUndefined, type prismaNamespace_Payload as Payload, type prismaNamespace_PickEnumerable as PickEnumerable, type prismaNamespace_PrismaAction as PrismaAction, type prismaNamespace_PrismaClientInitializationError as PrismaClientInitializationError, type prismaNamespace_PrismaClientKnownRequestError as PrismaClientKnownRequestError, type prismaNamespace_PrismaClientOptions as PrismaClientOptions, type prismaNamespace_PrismaClientRustPanicError as PrismaClientRustPanicError, type prismaNamespace_PrismaClientUnknownRequestError as PrismaClientUnknownRequestError, type prismaNamespace_PrismaClientValidationError as PrismaClientValidationError, type prismaNamespace_PrismaPromise as PrismaPromise, type prismaNamespace_PrismaVersion as PrismaVersion, type prismaNamespace_Prisma__ModelClient as Prisma__ModelClient, type prismaNamespace_Prisma__ModelTypeClient as Prisma__ModelTypeClient, type prismaNamespace_QueryEvent as QueryEvent, type prismaNamespace_QueryMode as QueryMode, type prismaNamespace_Result as Result, type prismaNamespace_SelectSubset as SelectSubset, type prismaNamespace_SortOrder as SortOrder, type prismaNamespace_SortOrderInput as SortOrderInput, type prismaNamespace_Sql as Sql, type prismaNamespace_Strict as Strict, type prismaNamespace_StringFieldRefInput as StringFieldRefInput, type prismaNamespace_StringFieldUpdateOperationsInput as StringFieldUpdateOperationsInput, type prismaNamespace_StringFilter as StringFilter, type prismaNamespace_StringWithAggregatesFilter as StringWithAggregatesFilter, type prismaNamespace_Subset as Subset, type prismaNamespace_SubsetIntersection as SubsetIntersection, type prismaNamespace_TransactionClient as TransactionClient, type prismaNamespace_TransactionIsolationLevel as TransactionIsolationLevel, type prismaNamespace_True as True, type prismaNamespace_TypeMap as TypeMap, type prismaNamespace_TypeMapCb as TypeMapCb, type prismaNamespace_UnEnumerate as UnEnumerate, type prismaNamespace_Union as Union, type prismaNamespace_XOR as XOR, prismaNamespace_defineExtension as defineExtension, prismaNamespace_empty as empty, prismaNamespace_getExtensionContext as getExtensionContext, prismaNamespace_join as join, prismaNamespace_prismaVersion as prismaVersion, prismaNamespace_raw as raw, prismaNamespace_sql as sql };
+}
+
+type LogOptions<ClientOptions extends PrismaClientOptions> = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<LogLevel | LogDefinition> ? GetEvents<ClientOptions['log']> : never : never;
+interface PrismaClientConstructor {
+    /**
+   * ## Prisma Client
+   *
+   * Type-safe database client for TypeScript
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+   * })
+   * // Fetch zero or more ModelTypes
+   * const modelTypes = await prisma.modelType.findMany()
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/client).
+   */
+    new <Options extends PrismaClientOptions = PrismaClientOptions, LogOpts extends LogOptions<Options> = LogOptions<Options>, OmitOpts extends PrismaClientOptions['omit'] = Options extends {
+        omit: infer U;
+    } ? U : PrismaClientOptions['omit'], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs>(options: Subset<Options, PrismaClientOptions>): PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+}
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more ModelTypes
+ * const modelTypes = await prisma.modelType.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+interface PrismaClient<in LogOpts extends LogLevel = never, in out OmitOpts extends PrismaClientOptions['omit'] = undefined, in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> {
+    [K: symbol]: {
+        types: TypeMap<ExtArgs>['other'];
+    };
+    $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? QueryEvent : LogEvent) => void): PrismaClient;
+    /**
+     * Connect with the database
+     */
+    $connect(): runtime.Types.Utils.JsPromise<void>;
+    /**
+     * Disconnect from the database
+     */
+    $disconnect(): runtime.Types.Utils.JsPromise<void>;
+    /**
+       * Executes a prepared raw query and returns the number of affected rows.
+       * @example
+       * ```
+       * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
+       * ```
+       *
+       * Read more in our [docs](https://pris.ly/d/raw-queries).
+       */
+    $executeRaw<T = unknown>(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise<number>;
+    /**
+     * Executes a raw query and returns the number of affected rows.
+     * Susceptible to SQL injections, see documentation.
+     * @example
+     * ```
+     * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
+     * ```
+     *
+     * Read more in our [docs](https://pris.ly/d/raw-queries).
+     */
+    $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): PrismaPromise<number>;
+    /**
+     * Performs a prepared raw query and returns the `SELECT` data.
+     * @example
+     * ```
+     * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
+     * ```
+     *
+     * Read more in our [docs](https://pris.ly/d/raw-queries).
+     */
+    $queryRaw<T = unknown>(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise<T>;
+    /**
+     * Performs a raw query and returns the `SELECT` data.
+     * Susceptible to SQL injections, see documentation.
+     * @example
+     * ```
+     * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
+     * ```
+     *
+     * Read more in our [docs](https://pris.ly/d/raw-queries).
+     */
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): PrismaPromise<T>;
+    /**
+     * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
+     * @example
+     * ```
+     * const [george, bob, alice] = await prisma.$transaction([
+     *   prisma.user.create({ data: { name: 'George' } }),
+     *   prisma.user.create({ data: { name: 'Bob' } }),
+     *   prisma.user.create({ data: { name: 'Alice' } }),
+     * ])
+     * ```
+     *
+     * Read more in our [docs](https://www.prisma.io/docs/orm/prisma-client/queries/transactions).
+     */
+    $transaction<P extends PrismaPromise<any>[]>(arg: [...P], options?: {
+        isolationLevel?: TransactionIsolationLevel;
+    }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>;
+    $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: TransactionIsolationLevel;
+    }): runtime.Types.Utils.JsPromise<R>;
+    $extends: runtime.Types.Extensions.ExtendsHook<"extends", TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<TypeMapCb<OmitOpts>, {
+        extArgs: ExtArgs;
+    }>>;
+    /**
+ * `prisma.modelType`: Exposes CRUD operations for the **ModelType** model.
+  * Example usage:
+  * ```ts
+  * // Fetch zero or more ModelTypes
+  * const modelTypes = await prisma.modelType.findMany()
+  * ```
+  */
+    get modelType(): ModelTypeDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+    /**
+     * `prisma.model`: Exposes CRUD operations for the **Model** model.
+      * Example usage:
+      * ```ts
+      * // Fetch zero or more Models
+      * const models = await prisma.model.findMany()
+      * ```
+      */
+    get model(): ModelDelegate<ExtArgs, {
+        omit: OmitOpts;
+    }>;
+}
+declare function getPrismaClientClass(): PrismaClientConstructor;
+
+export { type $ModelPayload as $, type AggregateModel as A, type BatchPayload as B, type CheckIsLogLevel as C, type DMMF as D, type Either as E, type Extension as F, type False as G, type FieldRef as H, type GetEvents as I, type GetHavingFields as J, type GetLogType as K, type LogLevel as L, type ModelModel as M, type GetModelAggregateType as N, type GetModelGroupByPayload as O, type PrismaClientConstructor as P, type GetModelTypeAggregateType as Q, type GetModelTypeGroupByPayload as R, type GetScalarType as S, type GlobalOmitConfig as T, type Has as U, type InputJsonArray as V, type InputJsonObject as W, type InputJsonValue as X, type IntFieldRefInput as Y, type IntersectOf as Z, type JsonArray as _, type ModelTypeModel as a, type ModelType$modelsArgs as a$, type JsonFieldRefInput as a0, type JsonFilter as a1, type JsonFilterBase as a2, type JsonObject as a3, type JsonValue as a4, type JsonWithAggregatesFilter as a5, type JsonWithAggregatesFilterBase as a6, type Keys as a7, type ListDateTimeFieldRefInput as a8, type ListIntFieldRefInput as a9, type ModelFindFirstOrThrowArgs as aA, type ModelFindManyArgs as aB, type ModelFindUniqueArgs as aC, type ModelFindUniqueOrThrowArgs as aD, type ModelGetPayload as aE, type ModelGroupByArgs as aF, type ModelGroupByOutputType as aG, type ModelInclude as aH, type ModelIncludeCreateManyAndReturn as aI, type ModelIncludeUpdateManyAndReturn as aJ, type ModelListRelationFilter as aK, type ModelMaxAggregateInputType as aL, type ModelMaxAggregateOutputType as aM, type ModelMaxOrderByAggregateInput as aN, type ModelMinAggregateInputType as aO, type ModelMinAggregateOutputType as aP, type ModelMinOrderByAggregateInput as aQ, type ModelOmit as aR, type ModelOrderByRelationAggregateInput as aS, type ModelOrderByWithAggregationInput as aT, type ModelOrderByWithRelationInput as aU, type ModelScalarWhereInput as aV, type ModelScalarWhereWithAggregatesInput as aW, type ModelSelect as aX, type ModelSelectCreateManyAndReturn as aY, type ModelSelectScalar as aZ, type ModelSelectUpdateManyAndReturn as a_, type ListStringFieldRefInput as aa, type LogDefinition as ab, type LogEvent as ac, type MaybeTupleToUnion as ad, type Merge as ae, type ModelAggregateArgs as af, type ModelCountAggregateInputType as ag, type ModelCountAggregateOutputType as ah, type ModelCountArgs as ai, type ModelCountOrderByAggregateInput as aj, type ModelCreateArgs as ak, type ModelCreateInput as al, type ModelCreateManyAndReturnArgs as am, type ModelCreateManyArgs as an, type ModelCreateManyInput as ao, type ModelCreateManyModelTypeInput as ap, type ModelCreateManyModelTypeInputEnvelope as aq, type ModelCreateNestedManyWithoutModelTypeInput as ar, type ModelCreateOrConnectWithoutModelTypeInput as as, type ModelCreateWithoutModelTypeInput as at, type ModelDefaultArgs as au, type ModelDelegate as av, type ModelDeleteArgs as aw, type ModelDeleteManyArgs as ax, type ModelFieldRefs as ay, type ModelFindFirstArgs as az, type PrismaClientOptions as b, type ModelTypeWhereInput as b$, type ModelTypeAggregateArgs as b0, type ModelTypeCountAggregateInputType as b1, type ModelTypeCountAggregateOutputType as b2, type ModelTypeCountArgs as b3, type ModelTypeCountOrderByAggregateInput as b4, type ModelTypeCountOutputType as b5, type ModelTypeCountOutputTypeCountModelsArgs as b6, type ModelTypeCountOutputTypeDefaultArgs as b7, type ModelTypeCountOutputTypeSelect as b8, type ModelTypeCreateArgs as b9, type ModelTypeMinAggregateInputType as bA, type ModelTypeMinAggregateOutputType as bB, type ModelTypeMinOrderByAggregateInput as bC, type ModelTypeOmit as bD, type ModelTypeOrderByWithAggregationInput as bE, type ModelTypeOrderByWithRelationInput as bF, type ModelTypeScalarRelationFilter as bG, type ModelTypeScalarWhereWithAggregatesInput as bH, type ModelTypeSelect as bI, type ModelTypeSelectCreateManyAndReturn as bJ, type ModelTypeSelectScalar as bK, type ModelTypeSelectUpdateManyAndReturn as bL, type ModelTypeUncheckedCreateInput as bM, type ModelTypeUncheckedCreateWithoutModelsInput as bN, type ModelTypeUncheckedUpdateInput as bO, type ModelTypeUncheckedUpdateManyInput as bP, type ModelTypeUncheckedUpdateWithoutModelsInput as bQ, type ModelTypeUpdateArgs as bR, type ModelTypeUpdateInput as bS, type ModelTypeUpdateManyAndReturnArgs as bT, type ModelTypeUpdateManyArgs as bU, type ModelTypeUpdateManyMutationInput as bV, type ModelTypeUpdateOneRequiredWithoutModelsNestedInput as bW, type ModelTypeUpdateToOneWithWhereWithoutModelsInput as bX, type ModelTypeUpdateWithoutModelsInput as bY, type ModelTypeUpsertArgs as bZ, type ModelTypeUpsertWithoutModelsInput as b_, type ModelTypeCreateInput as ba, type ModelTypeCreateManyAndReturnArgs as bb, type ModelTypeCreateManyArgs as bc, type ModelTypeCreateManyInput as bd, type ModelTypeCreateNestedOneWithoutModelsInput as be, type ModelTypeCreateOrConnectWithoutModelsInput as bf, type ModelTypeCreateWithoutModelsInput as bg, type ModelTypeDefaultArgs as bh, type ModelTypeDelegate as bi, type ModelTypeDeleteArgs as bj, type ModelTypeDeleteManyArgs as bk, type ModelTypeFieldRefs as bl, type ModelTypeFindFirstArgs as bm, type ModelTypeFindFirstOrThrowArgs as bn, type ModelTypeFindManyArgs as bo, type ModelTypeFindUniqueArgs as bp, type ModelTypeFindUniqueOrThrowArgs as bq, type ModelTypeGetPayload as br, type ModelTypeGroupByArgs as bs, type ModelTypeGroupByOutputType as bt, type ModelTypeInclude as bu, type ModelTypeIncludeCreateManyAndReturn as bv, type ModelTypeIncludeUpdateManyAndReturn as bw, type ModelTypeMaxAggregateInputType as bx, type ModelTypeMaxAggregateOutputType as by, type ModelTypeMaxOrderByAggregateInput as bz, type PrismaClient as c, type True as c$, type ModelTypeWhereUniqueInput as c0, type ModelUncheckedCreateInput as c1, type ModelUncheckedCreateNestedManyWithoutModelTypeInput as c2, type ModelUncheckedCreateWithoutModelTypeInput as c3, type ModelUncheckedUpdateInput as c4, type ModelUncheckedUpdateManyInput as c5, type ModelUncheckedUpdateManyWithoutModelTypeInput as c6, type ModelUncheckedUpdateManyWithoutModelTypeNestedInput as c7, type ModelUncheckedUpdateWithoutModelTypeInput as c8, type ModelUpdateArgs as c9, type Overwrite as cA, type PatchUndefined as cB, type Payload as cC, type PickEnumerable as cD, type PrismaAction as cE, PrismaClientInitializationError as cF, PrismaClientKnownRequestError as cG, PrismaClientRustPanicError as cH, PrismaClientUnknownRequestError as cI, PrismaClientValidationError as cJ, type PrismaPromise as cK, type PrismaVersion as cL, type Prisma__ModelClient as cM, type Prisma__ModelTypeClient as cN, type QueryEvent as cO, type Result as cP, type SelectSubset as cQ, type SortOrderInput as cR, Sql as cS, type Strict as cT, type StringFieldRefInput as cU, type StringFieldUpdateOperationsInput as cV, type StringFilter as cW, type StringWithAggregatesFilter as cX, type Subset as cY, type SubsetIntersection as cZ, type TransactionClient as c_, type ModelUpdateInput as ca, type ModelUpdateManyAndReturnArgs as cb, type ModelUpdateManyArgs as cc, type ModelUpdateManyMutationInput as cd, type ModelUpdateManyWithWhereWithoutModelTypeInput as ce, type ModelUpdateManyWithoutModelTypeNestedInput as cf, type ModelUpdateWithWhereUniqueWithoutModelTypeInput as cg, type ModelUpdateWithoutModelTypeInput as ch, type ModelUpsertArgs as ci, type ModelUpsertWithWhereUniqueWithoutModelTypeInput as cj, type ModelWhereInput as ck, type ModelWhereUniqueInput as cl, type NestedDateTimeFilter as cm, type NestedDateTimeNullableFilter as cn, type NestedDateTimeNullableWithAggregatesFilter as co, type NestedDateTimeWithAggregatesFilter as cp, type NestedIntFilter as cq, type NestedIntNullableFilter as cr, type NestedJsonFilter as cs, type NestedJsonFilterBase as ct, type NestedStringFilter as cu, type NestedStringWithAggregatesFilter as cv, type Not as cw, type NullableDateTimeFieldUpdateOperationsInput as cx, type OptionalFlat as cy, type Or as cz, type $ModelTypePayload as d, type TypeMap as d0, type TypeMapCb as d1, type UnEnumerate as d2, type Union as d3, type XOR as d4, defineExtension as d5, empty as d6, getExtensionContext as d7, join as d8, prismaVersion as d9, raw as da, sql as db, AnyNull as dc, DbNull as dd, Decimal as de, JsonNull as df, JsonNullValueFilter as dg, JsonNullValueInput as dh, ModelName as di, ModelScalarFieldEnum as dj, ModelTypeScalarFieldEnum as dk, NullTypes as dl, NullsOrder as dm, QueryMode as dn, SortOrder as dp, TransactionIsolationLevel as dq, type LogOptions as dr, getPrismaClientClass as ds, type AggregateModelType as e, type Args as f, type At as g, type AtLeast as h, type Boolean as i, type Bytes as j, type ComputeRaw as k, type DateTimeFieldRefInput as l, type DateTimeFieldUpdateOperationsInput as m, type DateTimeFilter as n, type DateTimeNullableFilter as o, prismaNamespace as p, type DateTimeNullableWithAggregatesFilter as q, type DateTimeWithAggregatesFilter as r, type DecimalJsLike as s, type DefaultPrismaClient as t, type EnumQueryModeFieldRefInput as u, type Enumerable as v, type ErrorFormat as w, type Exact as x, type ExcludeUnderscoreKeys as y, type Extends as z };