@a_team/prisma 3.2.4-win → 3.2.5-linux

package/dist/client/index.d.ts

@@ -158,6 +158,11 @@ export type WorkingHours = $Result.DefaultSelection<Prisma.$WorkingHoursPayload>
  * 
  */
 export type ClientRoleQuestion = $Result.DefaultSelection<Prisma.$ClientRoleQuestionPayload>
+/**
+ * Model Role
+ * 
+ */
+export type Role = $Result.DefaultSelection<Prisma.$RolePayload>
 /**
  * Model ClientRegistration
  * 
@@ -203,6 +208,11 @@ export type MissionSpec = $Result.DefaultSelection<Prisma.$MissionSpecPayload>
  * 
  */
 export type RoleCategory = $Result.DefaultSelection<Prisma.$RoleCategoryPayload>
+/**
+ * Model Solution
+ * 
+ */
+export type Solution = $Result.DefaultSelection<Prisma.$SolutionPayload>
 /**
  * Model TalentCategory
  * 
@@ -276,6 +286,21 @@ export const MissionSpecStatus: {
 export type MissionSpecStatus = (typeof MissionSpecStatus)[keyof typeof MissionSpecStatus]
 
 
+export const PresetID: {
+  custom_team: 'custom_team',
+  web_platform: 'web_platform',
+  mobile_app: 'mobile_app',
+  collaboration_tool: 'collaboration_tool',
+  marketing_website: 'marketing_website',
+  prototype: 'prototype',
+  data: 'data',
+  growth: 'growth',
+  ai: 'ai'
+};
+
+export type PresetID = (typeof PresetID)[keyof typeof PresetID]
+
+
 export const ContractPartyType: {
   BillingCustomer: 'BillingCustomer',
   MissionRole: 'MissionRole'
@@ -334,6 +359,10 @@ export type MissionSpecStatus = $Enums.MissionSpecStatus
 
 export const MissionSpecStatus: typeof $Enums.MissionSpecStatus
 
+export type PresetID = $Enums.PresetID
+
+export const PresetID: typeof $Enums.PresetID
+
 export type ContractPartyType = $Enums.ContractPartyType
 
 export const ContractPartyType: typeof $Enums.ContractPartyType
@@ -520,6 +549,16 @@ export class PrismaClient<
     */
   get roleCategory(): Prisma.RoleCategoryDelegate<ExtArgs>;
 
+  /**
+   * `prisma.solution`: Exposes CRUD operations for the **Solution** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Solutions
+    * const solutions = await prisma.solution.findMany()
+    * ```
+    */
+  get solution(): Prisma.SolutionDelegate<ExtArgs>;
+
   /**
    * `prisma.talentCategory`: Exposes CRUD operations for the **TalentCategory** model.
     * Example usage:
@@ -1034,6 +1073,7 @@ export namespace Prisma {
     MissionPrefill: 'MissionPrefill',
     MissionSpec: 'MissionSpec',
     RoleCategory: 'RoleCategory',
+    Solution: 'Solution',
     TalentCategory: 'TalentCategory',
     TalentIndustry: 'TalentIndustry',
     User: 'User'
@@ -1052,7 +1092,7 @@ export namespace Prisma {
 
   export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
     meta: {
-      modelProps: "account" | "clientCompany" | "company" | "contract" | "mission" | "missionPrefill" | "missionSpec" | "roleCategory" | "talentCategory" | "talentIndustry" | "user"
+      modelProps: "account" | "clientCompany" | "company" | "contract" | "mission" | "missionPrefill" | "missionSpec" | "roleCategory" | "solution" | "talentCategory" | "talentIndustry" | "user"
       txIsolationLevel: never
     }
     model: {
@@ -1648,6 +1688,80 @@ export namespace Prisma {
           }
         }
       }
+      Solution: {
+        payload: Prisma.$SolutionPayload<ExtArgs>
+        fields: Prisma.SolutionFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.SolutionFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.SolutionFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>
+          }
+          findFirst: {
+            args: Prisma.SolutionFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.SolutionFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>
+          }
+          findMany: {
+            args: Prisma.SolutionFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>[]
+          }
+          create: {
+            args: Prisma.SolutionCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>
+          }
+          createMany: {
+            args: Prisma.SolutionCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          delete: {
+            args: Prisma.SolutionDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>
+          }
+          update: {
+            args: Prisma.SolutionUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>
+          }
+          deleteMany: {
+            args: Prisma.SolutionDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.SolutionUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          upsert: {
+            args: Prisma.SolutionUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$SolutionPayload>
+          }
+          aggregate: {
+            args: Prisma.SolutionAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateSolution>
+          }
+          groupBy: {
+            args: Prisma.SolutionGroupByArgs<ExtArgs>
+            result: $Utils.Optional<SolutionGroupByOutputType>[]
+          }
+          findRaw: {
+            args: Prisma.SolutionFindRawArgs<ExtArgs>
+            result: JsonObject
+          }
+          aggregateRaw: {
+            args: Prisma.SolutionAggregateRawArgs<ExtArgs>
+            result: JsonObject
+          }
+          count: {
+            args: Prisma.SolutionCountArgs<ExtArgs>
+            result: $Utils.Optional<SolutionCountAggregateOutputType> | number
+          }
+        }
+      }
       TalentCategory: {
         payload: Prisma.$TalentCategoryPayload<ExtArgs>
         fields: Prisma.TalentCategoryFieldRefs
@@ -4252,6 +4366,59 @@ export namespace Prisma {
   }
 
 
+  /**
+   * Model Role
+   */
+
+
+
+
+
+  export type RoleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    category?: boolean
+  }, ExtArgs["result"]["role"]>
+
+
+  export type RoleSelectScalar = {
+    category?: boolean
+  }
+
+
+  export type $RolePayload = {
+    name: "Role"
+    objects: {}
+    scalars: {
+      category: string
+    }
+    composites: {}
+  }
+
+  type RoleGetPayload<S extends boolean | null | undefined | RoleDefaultArgs> = $Result.GetResult<Prisma.$RolePayload, S>
+
+
+
+
+
+  /**
+   * Fields of the Role model
+   */ 
+  interface RoleFieldRefs {
+    readonly category: FieldRef<"Role", 'String'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * Role without action
+   */
+  export type RoleDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Role
+     */
+    select?: RoleSelect<ExtArgs> | null
+  }
+
+
   /**
    * Model ClientRegistration
    */
@@ -12666,20 +12833,887 @@ export namespace Prisma {
             ? never
             : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
         }[OrderFields]
-    >(args: SubsetIntersection<T, RoleCategoryGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRoleCategoryGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+    >(args: SubsetIntersection<T, RoleCategoryGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRoleCategoryGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the RoleCategory model
+   */
+  readonly fields: RoleCategoryFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for RoleCategory.
+   * 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
+   */
+  export interface Prisma__RoleCategoryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    /**
+     * 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): $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): $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): $Utils.JsPromise<T>
+  }
+
+
+
+
+  /**
+   * Fields of the RoleCategory model
+   */ 
+  interface RoleCategoryFieldRefs {
+    readonly id: FieldRef<"RoleCategory", 'String'>
+    readonly anchors: FieldRef<"RoleCategory", 'String[]'>
+    readonly title: FieldRef<"RoleCategory", 'String'>
+    readonly deletedAt: FieldRef<"RoleCategory", 'DateTime'>
+    readonly group: FieldRef<"RoleCategory", 'String'>
+    readonly talentCategoryIds: FieldRef<"RoleCategory", 'String[]'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * RoleCategory findUnique
+   */
+  export type RoleCategoryFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * Filter, which RoleCategory to fetch.
+     */
+    where: RoleCategoryWhereUniqueInput
+  }
+
+  /**
+   * RoleCategory findUniqueOrThrow
+   */
+  export type RoleCategoryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * Filter, which RoleCategory to fetch.
+     */
+    where: RoleCategoryWhereUniqueInput
+  }
+
+  /**
+   * RoleCategory findFirst
+   */
+  export type RoleCategoryFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * Filter, which RoleCategory to fetch.
+     */
+    where?: RoleCategoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of RoleCategories to fetch.
+     */
+    orderBy?: RoleCategoryOrderByWithRelationInput | RoleCategoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for RoleCategories.
+     */
+    cursor?: RoleCategoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` RoleCategories 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` RoleCategories.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of RoleCategories.
+     */
+    distinct?: RoleCategoryScalarFieldEnum | RoleCategoryScalarFieldEnum[]
+  }
+
+  /**
+   * RoleCategory findFirstOrThrow
+   */
+  export type RoleCategoryFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * Filter, which RoleCategory to fetch.
+     */
+    where?: RoleCategoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of RoleCategories to fetch.
+     */
+    orderBy?: RoleCategoryOrderByWithRelationInput | RoleCategoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for RoleCategories.
+     */
+    cursor?: RoleCategoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` RoleCategories 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` RoleCategories.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of RoleCategories.
+     */
+    distinct?: RoleCategoryScalarFieldEnum | RoleCategoryScalarFieldEnum[]
+  }
+
+  /**
+   * RoleCategory findMany
+   */
+  export type RoleCategoryFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * Filter, which RoleCategories to fetch.
+     */
+    where?: RoleCategoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of RoleCategories to fetch.
+     */
+    orderBy?: RoleCategoryOrderByWithRelationInput | RoleCategoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing RoleCategories.
+     */
+    cursor?: RoleCategoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` RoleCategories 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` RoleCategories.
+     */
+    skip?: number
+    distinct?: RoleCategoryScalarFieldEnum | RoleCategoryScalarFieldEnum[]
+  }
+
+  /**
+   * RoleCategory create
+   */
+  export type RoleCategoryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * The data needed to create a RoleCategory.
+     */
+    data: XOR<RoleCategoryCreateInput, RoleCategoryUncheckedCreateInput>
+  }
+
+  /**
+   * RoleCategory createMany
+   */
+  export type RoleCategoryCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many RoleCategories.
+     */
+    data: RoleCategoryCreateManyInput | RoleCategoryCreateManyInput[]
+  }
+
+  /**
+   * RoleCategory update
+   */
+  export type RoleCategoryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * The data needed to update a RoleCategory.
+     */
+    data: XOR<RoleCategoryUpdateInput, RoleCategoryUncheckedUpdateInput>
+    /**
+     * Choose, which RoleCategory to update.
+     */
+    where: RoleCategoryWhereUniqueInput
+  }
+
+  /**
+   * RoleCategory updateMany
+   */
+  export type RoleCategoryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update RoleCategories.
+     */
+    data: XOR<RoleCategoryUpdateManyMutationInput, RoleCategoryUncheckedUpdateManyInput>
+    /**
+     * Filter which RoleCategories to update
+     */
+    where?: RoleCategoryWhereInput
+  }
+
+  /**
+   * RoleCategory upsert
+   */
+  export type RoleCategoryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * The filter to search for the RoleCategory to update in case it exists.
+     */
+    where: RoleCategoryWhereUniqueInput
+    /**
+     * In case the RoleCategory found by the `where` argument doesn't exist, create a new RoleCategory with this data.
+     */
+    create: XOR<RoleCategoryCreateInput, RoleCategoryUncheckedCreateInput>
+    /**
+     * In case the RoleCategory was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<RoleCategoryUpdateInput, RoleCategoryUncheckedUpdateInput>
+  }
+
+  /**
+   * RoleCategory delete
+   */
+  export type RoleCategoryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+    /**
+     * Filter which RoleCategory to delete.
+     */
+    where: RoleCategoryWhereUniqueInput
+  }
+
+  /**
+   * RoleCategory deleteMany
+   */
+  export type RoleCategoryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which RoleCategories to delete
+     */
+    where?: RoleCategoryWhereInput
+  }
+
+  /**
+   * RoleCategory findRaw
+   */
+  export type RoleCategoryFindRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The query predicate filter. If unspecified, then all documents in the collection will match the predicate. ${@link https://docs.mongodb.com/manual/reference/operator/query MongoDB Docs}.
+     */
+    filter?: InputJsonValue
+    /**
+     * Additional options to pass to the `find` command ${@link https://docs.mongodb.com/manual/reference/command/find/#command-fields MongoDB Docs}.
+     */
+    options?: InputJsonValue
+  }
+
+  /**
+   * RoleCategory aggregateRaw
+   */
+  export type RoleCategoryAggregateRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * An array of aggregation stages to process and transform the document stream via the aggregation pipeline. ${@link https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline MongoDB Docs}.
+     */
+    pipeline?: InputJsonValue[]
+    /**
+     * Additional options to pass to the `aggregate` command ${@link https://docs.mongodb.com/manual/reference/command/aggregate/#command-fields MongoDB Docs}.
+     */
+    options?: InputJsonValue
+  }
+
+  /**
+   * RoleCategory without action
+   */
+  export type RoleCategoryDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RoleCategory
+     */
+    select?: RoleCategorySelect<ExtArgs> | null
+  }
+
+
+  /**
+   * Model Solution
+   */
+
+  export type AggregateSolution = {
+    _count: SolutionCountAggregateOutputType | null
+    _min: SolutionMinAggregateOutputType | null
+    _max: SolutionMaxAggregateOutputType | null
+  }
+
+  export type SolutionMinAggregateOutputType = {
+    id: string | null
+    preset: $Enums.PresetID | null
+    title: string | null
+  }
+
+  export type SolutionMaxAggregateOutputType = {
+    id: string | null
+    preset: $Enums.PresetID | null
+    title: string | null
+  }
+
+  export type SolutionCountAggregateOutputType = {
+    id: number
+    preset: number
+    title: number
+    _all: number
+  }
+
+
+  export type SolutionMinAggregateInputType = {
+    id?: true
+    preset?: true
+    title?: true
+  }
+
+  export type SolutionMaxAggregateInputType = {
+    id?: true
+    preset?: true
+    title?: true
+  }
+
+  export type SolutionCountAggregateInputType = {
+    id?: true
+    preset?: true
+    title?: true
+    _all?: true
+  }
+
+  export type SolutionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which Solution to aggregate.
+     */
+    where?: SolutionWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of Solutions to fetch.
+     */
+    orderBy?: SolutionOrderByWithRelationInput | SolutionOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: SolutionWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` Solutions 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` Solutions.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned Solutions
+    **/
+    _count?: true | SolutionCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: SolutionMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: SolutionMaxAggregateInputType
+  }
+
+  export type GetSolutionAggregateType<T extends SolutionAggregateArgs> = {
+        [P in keyof T & keyof AggregateSolution]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateSolution[P]>
+      : GetScalarType<T[P], AggregateSolution[P]>
+  }
+
+
+
+
+  export type SolutionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: SolutionWhereInput
+    orderBy?: SolutionOrderByWithAggregationInput | SolutionOrderByWithAggregationInput[]
+    by: SolutionScalarFieldEnum[] | SolutionScalarFieldEnum
+    having?: SolutionScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: SolutionCountAggregateInputType | true
+    _min?: SolutionMinAggregateInputType
+    _max?: SolutionMaxAggregateInputType
+  }
+
+  export type SolutionGroupByOutputType = {
+    id: string
+    preset: $Enums.PresetID
+    title: string
+    _count: SolutionCountAggregateOutputType | null
+    _min: SolutionMinAggregateOutputType | null
+    _max: SolutionMaxAggregateOutputType | null
+  }
+
+  type GetSolutionGroupByPayload<T extends SolutionGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<SolutionGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof SolutionGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], SolutionGroupByOutputType[P]>
+            : GetScalarType<T[P], SolutionGroupByOutputType[P]>
+        }
+      >
+    >
+
+
+  export type SolutionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    preset?: boolean
+    title?: boolean
+    roles?: boolean | RoleDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["solution"]>
+
+
+  export type SolutionSelectScalar = {
+    id?: boolean
+    preset?: boolean
+    title?: boolean
+  }
+
+  export type SolutionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
+
+  export type $SolutionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "Solution"
+    objects: {}
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      preset: $Enums.PresetID
+      title: string
+    }, ExtArgs["result"]["solution"]>
+    composites: {
+      roles: Prisma.$RolePayload[]
+    }
+  }
+
+  type SolutionGetPayload<S extends boolean | null | undefined | SolutionDefaultArgs> = $Result.GetResult<Prisma.$SolutionPayload, S>
+
+  type SolutionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
+    Omit<SolutionFindManyArgs, 'select' | 'include' | 'distinct'> & {
+      select?: SolutionCountAggregateInputType | true
+    }
+
+  export interface SolutionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Solution'], meta: { name: 'Solution' } }
+    /**
+     * Find zero or one Solution that matches the filter.
+     * @param {SolutionFindUniqueArgs} args - Arguments to find a Solution
+     * @example
+     * // Get one Solution
+     * const solution = await prisma.solution.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends SolutionFindUniqueArgs>(args: SelectSubset<T, SolutionFindUniqueArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>
+
+    /**
+     * Find one Solution that matches the filter or throw an error with `error.code='P2025'` 
+     * if no matches were found.
+     * @param {SolutionFindUniqueOrThrowArgs} args - Arguments to find a Solution
+     * @example
+     * // Get one Solution
+     * const solution = await prisma.solution.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends SolutionFindUniqueOrThrowArgs>(args: SelectSubset<T, SolutionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>
+
+    /**
+     * Find the first Solution 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 {SolutionFindFirstArgs} args - Arguments to find a Solution
+     * @example
+     * // Get one Solution
+     * const solution = await prisma.solution.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends SolutionFindFirstArgs>(args?: SelectSubset<T, SolutionFindFirstArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>
+
+    /**
+     * Find the first Solution 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 {SolutionFindFirstOrThrowArgs} args - Arguments to find a Solution
+     * @example
+     * // Get one Solution
+     * const solution = await prisma.solution.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends SolutionFindFirstOrThrowArgs>(args?: SelectSubset<T, SolutionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>
+
+    /**
+     * Find zero or more Solutions 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 {SolutionFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Solutions
+     * const solutions = await prisma.solution.findMany()
+     * 
+     * // Get first 10 Solutions
+     * const solutions = await prisma.solution.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const solutionWithIdOnly = await prisma.solution.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends SolutionFindManyArgs>(args?: SelectSubset<T, SolutionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "findMany">>
+
+    /**
+     * Create a Solution.
+     * @param {SolutionCreateArgs} args - Arguments to create a Solution.
+     * @example
+     * // Create one Solution
+     * const Solution = await prisma.solution.create({
+     *   data: {
+     *     // ... data to create a Solution
+     *   }
+     * })
+     * 
+     */
+    create<T extends SolutionCreateArgs>(args: SelectSubset<T, SolutionCreateArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "create">, never, ExtArgs>
+
+    /**
+     * Create many Solutions.
+     * @param {SolutionCreateManyArgs} args - Arguments to create many Solutions.
+     * @example
+     * // Create many Solutions
+     * const solution = await prisma.solution.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends SolutionCreateManyArgs>(args?: SelectSubset<T, SolutionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Delete a Solution.
+     * @param {SolutionDeleteArgs} args - Arguments to delete one Solution.
+     * @example
+     * // Delete one Solution
+     * const Solution = await prisma.solution.delete({
+     *   where: {
+     *     // ... filter to delete one Solution
+     *   }
+     * })
+     * 
+     */
+    delete<T extends SolutionDeleteArgs>(args: SelectSubset<T, SolutionDeleteArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "delete">, never, ExtArgs>
+
+    /**
+     * Update one Solution.
+     * @param {SolutionUpdateArgs} args - Arguments to update one Solution.
+     * @example
+     * // Update one Solution
+     * const solution = await prisma.solution.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends SolutionUpdateArgs>(args: SelectSubset<T, SolutionUpdateArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "update">, never, ExtArgs>
+
+    /**
+     * Delete zero or more Solutions.
+     * @param {SolutionDeleteManyArgs} args - Arguments to filter Solutions to delete.
+     * @example
+     * // Delete a few Solutions
+     * const { count } = await prisma.solution.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends SolutionDeleteManyArgs>(args?: SelectSubset<T, SolutionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more Solutions.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {SolutionUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many Solutions
+     * const solution = await prisma.solution.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends SolutionUpdateManyArgs>(args: SelectSubset<T, SolutionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create or update one Solution.
+     * @param {SolutionUpsertArgs} args - Arguments to update or create a Solution.
+     * @example
+     * // Update or create a Solution
+     * const solution = await prisma.solution.upsert({
+     *   create: {
+     *     // ... data to create a Solution
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the Solution we want to update
+     *   }
+     * })
+     */
+    upsert<T extends SolutionUpsertArgs>(args: SelectSubset<T, SolutionUpsertArgs<ExtArgs>>): Prisma__SolutionClient<$Result.GetResult<Prisma.$SolutionPayload<ExtArgs>, T, "upsert">, never, ExtArgs>
+
+    /**
+     * Find zero or more Solutions that matches the filter.
+     * @param {SolutionFindRawArgs} args - Select which filters you would like to apply.
+     * @example
+     * const solution = await prisma.solution.findRaw({
+     *   filter: { age: { $gt: 25 } } 
+     * })
+     */
+    findRaw(args?: SolutionFindRawArgs): Prisma.PrismaPromise<JsonObject>
+
+    /**
+     * Perform aggregation operations on a Solution.
+     * @param {SolutionAggregateRawArgs} args - Select which aggregations you would like to apply.
+     * @example
+     * const solution = await prisma.solution.aggregateRaw({
+     *   pipeline: [
+     *     { $match: { status: "registered" } },
+     *     { $group: { _id: "$country", total: { $sum: 1 } } }
+     *   ]
+     * })
+     */
+    aggregateRaw(args?: SolutionAggregateRawArgs): Prisma.PrismaPromise<JsonObject>
+
+
+    /**
+     * Count the number of Solutions.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {SolutionCountArgs} args - Arguments to filter Solutions to count.
+     * @example
+     * // Count the number of Solutions
+     * const count = await prisma.solution.count({
+     *   where: {
+     *     // ... the filter for the Solutions we want to count
+     *   }
+     * })
+    **/
+    count<T extends SolutionCountArgs>(
+      args?: Subset<T, SolutionCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], SolutionCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a Solution.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {SolutionAggregateArgs} 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 SolutionAggregateArgs>(args: Subset<T, SolutionAggregateArgs>): Prisma.PrismaPromise<GetSolutionAggregateType<T>>
+
+    /**
+     * Group by Solution.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {SolutionGroupByArgs} 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 SolutionGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: SolutionGroupByArgs['orderBy'] }
+        : { orderBy?: SolutionGroupByArgs['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, SolutionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSolutionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
   /**
-   * Fields of the RoleCategory model
+   * Fields of the Solution model
    */
-  readonly fields: RoleCategoryFieldRefs;
+  readonly fields: SolutionFieldRefs;
   }
 
   /**
-   * The delegate class that acts as a "Promise-like" for RoleCategory.
+   * The delegate class that acts as a "Promise-like" for Solution.
    * 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
    */
-  export interface Prisma__RoleCategoryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
+  export interface Prisma__SolutionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
     readonly [Symbol.toStringTag]: "PrismaPromise"
     /**
      * Attaches callbacks for the resolution and/or rejection of the Promise.
@@ -12707,280 +13741,313 @@ export namespace Prisma {
 
 
   /**
-   * Fields of the RoleCategory model
+   * Fields of the Solution model
    */ 
-  interface RoleCategoryFieldRefs {
-    readonly id: FieldRef<"RoleCategory", 'String'>
-    readonly anchors: FieldRef<"RoleCategory", 'String[]'>
-    readonly title: FieldRef<"RoleCategory", 'String'>
-    readonly deletedAt: FieldRef<"RoleCategory", 'DateTime'>
-    readonly group: FieldRef<"RoleCategory", 'String'>
-    readonly talentCategoryIds: FieldRef<"RoleCategory", 'String[]'>
+  interface SolutionFieldRefs {
+    readonly id: FieldRef<"Solution", 'String'>
+    readonly preset: FieldRef<"Solution", 'PresetID'>
+    readonly title: FieldRef<"Solution", 'String'>
   }
     
 
   // Custom InputTypes
   /**
-   * RoleCategory findUnique
+   * Solution findUnique
    */
-  export type RoleCategoryFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * Filter, which RoleCategory to fetch.
+     * Choose, which related nodes to fetch as well
      */
-    where: RoleCategoryWhereUniqueInput
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * Filter, which Solution to fetch.
+     */
+    where: SolutionWhereUniqueInput
   }
 
   /**
-   * RoleCategory findUniqueOrThrow
+   * Solution findUniqueOrThrow
    */
-  export type RoleCategoryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * Filter, which RoleCategory to fetch.
+     * Choose, which related nodes to fetch as well
      */
-    where: RoleCategoryWhereUniqueInput
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * Filter, which Solution to fetch.
+     */
+    where: SolutionWhereUniqueInput
   }
 
   /**
-   * RoleCategory findFirst
+   * Solution findFirst
    */
-  export type RoleCategoryFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * Filter, which RoleCategory to fetch.
+     * Choose, which related nodes to fetch as well
      */
-    where?: RoleCategoryWhereInput
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * Filter, which Solution to fetch.
+     */
+    where?: SolutionWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of RoleCategories to fetch.
+     * Determine the order of Solutions to fetch.
      */
-    orderBy?: RoleCategoryOrderByWithRelationInput | RoleCategoryOrderByWithRelationInput[]
+    orderBy?: SolutionOrderByWithRelationInput | SolutionOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
-     * Sets the position for searching for RoleCategories.
+     * Sets the position for searching for Solutions.
      */
-    cursor?: RoleCategoryWhereUniqueInput
+    cursor?: SolutionWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` RoleCategories from the position of the cursor.
+     * Take `±n` Solutions 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` RoleCategories.
+     * Skip the first `n` Solutions.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
      * 
-     * Filter by unique combinations of RoleCategories.
+     * Filter by unique combinations of Solutions.
      */
-    distinct?: RoleCategoryScalarFieldEnum | RoleCategoryScalarFieldEnum[]
+    distinct?: SolutionScalarFieldEnum | SolutionScalarFieldEnum[]
   }
 
   /**
-   * RoleCategory findFirstOrThrow
+   * Solution findFirstOrThrow
    */
-  export type RoleCategoryFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * Filter, which RoleCategory to fetch.
+     * Choose, which related nodes to fetch as well
      */
-    where?: RoleCategoryWhereInput
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * Filter, which Solution to fetch.
+     */
+    where?: SolutionWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of RoleCategories to fetch.
+     * Determine the order of Solutions to fetch.
      */
-    orderBy?: RoleCategoryOrderByWithRelationInput | RoleCategoryOrderByWithRelationInput[]
+    orderBy?: SolutionOrderByWithRelationInput | SolutionOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
-     * Sets the position for searching for RoleCategories.
+     * Sets the position for searching for Solutions.
      */
-    cursor?: RoleCategoryWhereUniqueInput
+    cursor?: SolutionWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` RoleCategories from the position of the cursor.
+     * Take `±n` Solutions 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` RoleCategories.
+     * Skip the first `n` Solutions.
      */
     skip?: number
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
      * 
-     * Filter by unique combinations of RoleCategories.
+     * Filter by unique combinations of Solutions.
      */
-    distinct?: RoleCategoryScalarFieldEnum | RoleCategoryScalarFieldEnum[]
+    distinct?: SolutionScalarFieldEnum | SolutionScalarFieldEnum[]
   }
 
   /**
-   * RoleCategory findMany
+   * Solution findMany
    */
-  export type RoleCategoryFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * Filter, which RoleCategories to fetch.
+     * Choose, which related nodes to fetch as well
      */
-    where?: RoleCategoryWhereInput
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * Filter, which Solutions to fetch.
+     */
+    where?: SolutionWhereInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
      * 
-     * Determine the order of RoleCategories to fetch.
+     * Determine the order of Solutions to fetch.
      */
-    orderBy?: RoleCategoryOrderByWithRelationInput | RoleCategoryOrderByWithRelationInput[]
+    orderBy?: SolutionOrderByWithRelationInput | SolutionOrderByWithRelationInput[]
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
      * 
-     * Sets the position for listing RoleCategories.
+     * Sets the position for listing Solutions.
      */
-    cursor?: RoleCategoryWhereUniqueInput
+    cursor?: SolutionWhereUniqueInput
     /**
      * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
      * 
-     * Take `±n` RoleCategories from the position of the cursor.
+     * Take `±n` Solutions 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` RoleCategories.
+     * Skip the first `n` Solutions.
      */
     skip?: number
-    distinct?: RoleCategoryScalarFieldEnum | RoleCategoryScalarFieldEnum[]
+    distinct?: SolutionScalarFieldEnum | SolutionScalarFieldEnum[]
   }
 
   /**
-   * RoleCategory create
+   * Solution create
    */
-  export type RoleCategoryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * The data needed to create a RoleCategory.
+     * Choose, which related nodes to fetch as well
      */
-    data: XOR<RoleCategoryCreateInput, RoleCategoryUncheckedCreateInput>
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * The data needed to create a Solution.
+     */
+    data: XOR<SolutionCreateInput, SolutionUncheckedCreateInput>
   }
 
   /**
-   * RoleCategory createMany
+   * Solution createMany
    */
-  export type RoleCategoryCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * The data used to create many RoleCategories.
+     * The data used to create many Solutions.
      */
-    data: RoleCategoryCreateManyInput | RoleCategoryCreateManyInput[]
+    data: SolutionCreateManyInput | SolutionCreateManyInput[]
   }
 
   /**
-   * RoleCategory update
+   * Solution update
    */
-  export type RoleCategoryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * The data needed to update a RoleCategory.
+     * Choose, which related nodes to fetch as well
      */
-    data: XOR<RoleCategoryUpdateInput, RoleCategoryUncheckedUpdateInput>
+    include?: SolutionInclude<ExtArgs> | null
     /**
-     * Choose, which RoleCategory to update.
+     * The data needed to update a Solution.
      */
-    where: RoleCategoryWhereUniqueInput
+    data: XOR<SolutionUpdateInput, SolutionUncheckedUpdateInput>
+    /**
+     * Choose, which Solution to update.
+     */
+    where: SolutionWhereUniqueInput
   }
 
   /**
-   * RoleCategory updateMany
+   * Solution updateMany
    */
-  export type RoleCategoryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * The data used to update RoleCategories.
+     * The data used to update Solutions.
      */
-    data: XOR<RoleCategoryUpdateManyMutationInput, RoleCategoryUncheckedUpdateManyInput>
+    data: XOR<SolutionUpdateManyMutationInput, SolutionUncheckedUpdateManyInput>
     /**
-     * Filter which RoleCategories to update
+     * Filter which Solutions to update
      */
-    where?: RoleCategoryWhereInput
+    where?: SolutionWhereInput
   }
 
   /**
-   * RoleCategory upsert
+   * Solution upsert
    */
-  export type RoleCategoryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * The filter to search for the RoleCategory to update in case it exists.
+     * Choose, which related nodes to fetch as well
      */
-    where: RoleCategoryWhereUniqueInput
+    include?: SolutionInclude<ExtArgs> | null
     /**
-     * In case the RoleCategory found by the `where` argument doesn't exist, create a new RoleCategory with this data.
+     * The filter to search for the Solution to update in case it exists.
      */
-    create: XOR<RoleCategoryCreateInput, RoleCategoryUncheckedCreateInput>
+    where: SolutionWhereUniqueInput
     /**
-     * In case the RoleCategory was found with the provided `where` argument, update it with this data.
+     * In case the Solution found by the `where` argument doesn't exist, create a new Solution with this data.
      */
-    update: XOR<RoleCategoryUpdateInput, RoleCategoryUncheckedUpdateInput>
+    create: XOR<SolutionCreateInput, SolutionUncheckedCreateInput>
+    /**
+     * In case the Solution was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<SolutionUpdateInput, SolutionUncheckedUpdateInput>
   }
 
   /**
-   * RoleCategory delete
+   * Solution delete
    */
-  export type RoleCategoryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
     /**
-     * Filter which RoleCategory to delete.
+     * Choose, which related nodes to fetch as well
      */
-    where: RoleCategoryWhereUniqueInput
+    include?: SolutionInclude<ExtArgs> | null
+    /**
+     * Filter which Solution to delete.
+     */
+    where: SolutionWhereUniqueInput
   }
 
   /**
-   * RoleCategory deleteMany
+   * Solution deleteMany
    */
-  export type RoleCategoryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Filter which RoleCategories to delete
+     * Filter which Solutions to delete
      */
-    where?: RoleCategoryWhereInput
+    where?: SolutionWhereInput
   }
 
   /**
-   * RoleCategory findRaw
+   * Solution findRaw
    */
-  export type RoleCategoryFindRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionFindRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
      * The query predicate filter. If unspecified, then all documents in the collection will match the predicate. ${@link https://docs.mongodb.com/manual/reference/operator/query MongoDB Docs}.
      */
@@ -12992,9 +14059,9 @@ export namespace Prisma {
   }
 
   /**
-   * RoleCategory aggregateRaw
+   * Solution aggregateRaw
    */
-  export type RoleCategoryAggregateRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionAggregateRawArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
      * An array of aggregation stages to process and transform the document stream via the aggregation pipeline. ${@link https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline MongoDB Docs}.
      */
@@ -13006,13 +14073,17 @@ export namespace Prisma {
   }
 
   /**
-   * RoleCategory without action
+   * Solution without action
    */
-  export type RoleCategoryDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+  export type SolutionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     /**
-     * Select specific fields to fetch from the RoleCategory
+     * Select specific fields to fetch from the Solution
      */
-    select?: RoleCategorySelect<ExtArgs> | null
+    select?: SolutionSelect<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: SolutionInclude<ExtArgs> | null
   }
 
 
@@ -16095,6 +17166,15 @@ export namespace Prisma {
   export type RoleCategoryScalarFieldEnum = (typeof RoleCategoryScalarFieldEnum)[keyof typeof RoleCategoryScalarFieldEnum]
 
 
+  export const SolutionScalarFieldEnum: {
+    id: 'id',
+    preset: 'preset',
+    title: 'title'
+  };
+
+  export type SolutionScalarFieldEnum = (typeof SolutionScalarFieldEnum)[keyof typeof SolutionScalarFieldEnum]
+
+
   export const TalentCategoryScalarFieldEnum: {
     id: 'id',
     textId: 'textId',
@@ -16299,6 +17379,20 @@ export namespace Prisma {
     
 
 
+  /**
+   * Reference to a field of type 'PresetID'
+   */
+  export type EnumPresetIDFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PresetID'>
+    
+
+
+  /**
+   * Reference to a field of type 'PresetID[]'
+   */
+  export type ListEnumPresetIDFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PresetID[]'>
+    
+
+
   /**
    * Reference to a field of type 'ContractPartyType'
    */
@@ -17264,6 +18358,51 @@ export namespace Prisma {
     talentCategoryIds?: StringNullableListFilter<"RoleCategory">
   }
 
+  export type SolutionWhereInput = {
+    AND?: SolutionWhereInput | SolutionWhereInput[]
+    OR?: SolutionWhereInput[]
+    NOT?: SolutionWhereInput | SolutionWhereInput[]
+    id?: StringFilter<"Solution"> | string
+    preset?: EnumPresetIDFilter<"Solution"> | $Enums.PresetID
+    title?: StringFilter<"Solution"> | string
+    roles?: RoleCompositeListFilter | RoleObjectEqualityInput[]
+  }
+
+  export type SolutionOrderByWithRelationInput = {
+    id?: SortOrder
+    preset?: SortOrder
+    title?: SortOrder
+    roles?: RoleOrderByCompositeAggregateInput
+  }
+
+  export type SolutionWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    AND?: SolutionWhereInput | SolutionWhereInput[]
+    OR?: SolutionWhereInput[]
+    NOT?: SolutionWhereInput | SolutionWhereInput[]
+    preset?: EnumPresetIDFilter<"Solution"> | $Enums.PresetID
+    title?: StringFilter<"Solution"> | string
+    roles?: RoleCompositeListFilter | RoleObjectEqualityInput[]
+  }, "id">
+
+  export type SolutionOrderByWithAggregationInput = {
+    id?: SortOrder
+    preset?: SortOrder
+    title?: SortOrder
+    _count?: SolutionCountOrderByAggregateInput
+    _max?: SolutionMaxOrderByAggregateInput
+    _min?: SolutionMinOrderByAggregateInput
+  }
+
+  export type SolutionScalarWhereWithAggregatesInput = {
+    AND?: SolutionScalarWhereWithAggregatesInput | SolutionScalarWhereWithAggregatesInput[]
+    OR?: SolutionScalarWhereWithAggregatesInput[]
+    NOT?: SolutionScalarWhereWithAggregatesInput | SolutionScalarWhereWithAggregatesInput[]
+    id?: StringWithAggregatesFilter<"Solution"> | string
+    preset?: EnumPresetIDWithAggregatesFilter<"Solution"> | $Enums.PresetID
+    title?: StringWithAggregatesFilter<"Solution"> | string
+  }
+
   export type TalentCategoryWhereInput = {
     AND?: TalentCategoryWhereInput | TalentCategoryWhereInput[]
     OR?: TalentCategoryWhereInput[]
@@ -18560,6 +19699,51 @@ export namespace Prisma {
     talentCategoryIds?: RoleCategoryUpdatetalentCategoryIdsInput | string[]
   }
 
+  export type SolutionCreateInput = {
+    id?: string
+    preset: $Enums.PresetID
+    title: string
+    roles?: XOR<RoleListCreateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
+  export type SolutionUncheckedCreateInput = {
+    id?: string
+    preset: $Enums.PresetID
+    title: string
+    roles?: XOR<RoleListCreateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
+  export type SolutionUpdateInput = {
+    preset?: EnumPresetIDFieldUpdateOperationsInput | $Enums.PresetID
+    title?: StringFieldUpdateOperationsInput | string
+    roles?: XOR<RoleListUpdateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
+  export type SolutionUncheckedUpdateInput = {
+    preset?: EnumPresetIDFieldUpdateOperationsInput | $Enums.PresetID
+    title?: StringFieldUpdateOperationsInput | string
+    roles?: XOR<RoleListUpdateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
+  export type SolutionCreateManyInput = {
+    id?: string
+    preset: $Enums.PresetID
+    title: string
+    roles?: XOR<RoleListCreateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
+  export type SolutionUpdateManyMutationInput = {
+    preset?: EnumPresetIDFieldUpdateOperationsInput | $Enums.PresetID
+    title?: StringFieldUpdateOperationsInput | string
+    roles?: XOR<RoleListUpdateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
+  export type SolutionUncheckedUpdateManyInput = {
+    preset?: EnumPresetIDFieldUpdateOperationsInput | $Enums.PresetID
+    title?: StringFieldUpdateOperationsInput | string
+    roles?: XOR<RoleListUpdateEnvelopeInput, RoleCreateInput> | RoleCreateInput[]
+  }
+
   export type TalentCategoryCreateInput = {
     id?: string
     textId: string
@@ -20024,6 +21208,58 @@ export namespace Prisma {
     group?: SortOrder
   }
 
+  export type EnumPresetIDFilter<$PrismaModel = never> = {
+    equals?: $Enums.PresetID | EnumPresetIDFieldRefInput<$PrismaModel>
+    in?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    notIn?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    not?: NestedEnumPresetIDFilter<$PrismaModel> | $Enums.PresetID
+  }
+
+  export type RoleCompositeListFilter = {
+    equals?: RoleObjectEqualityInput[]
+    every?: RoleWhereInput
+    some?: RoleWhereInput
+    none?: RoleWhereInput
+    isEmpty?: boolean
+    isSet?: boolean
+  }
+
+  export type RoleObjectEqualityInput = {
+    category: string
+  }
+
+  export type RoleOrderByCompositeAggregateInput = {
+    _count?: SortOrder
+  }
+
+  export type SolutionCountOrderByAggregateInput = {
+    id?: SortOrder
+    preset?: SortOrder
+    title?: SortOrder
+  }
+
+  export type SolutionMaxOrderByAggregateInput = {
+    id?: SortOrder
+    preset?: SortOrder
+    title?: SortOrder
+  }
+
+  export type SolutionMinOrderByAggregateInput = {
+    id?: SortOrder
+    preset?: SortOrder
+    title?: SortOrder
+  }
+
+  export type EnumPresetIDWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.PresetID | EnumPresetIDFieldRefInput<$PrismaModel>
+    in?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    notIn?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    not?: NestedEnumPresetIDWithAggregatesFilter<$PrismaModel> | $Enums.PresetID
+    _count?: NestedIntFilter<$PrismaModel>
+    _min?: NestedEnumPresetIDFilter<$PrismaModel>
+    _max?: NestedEnumPresetIDFilter<$PrismaModel>
+  }
+
   export type TalentCategoryCountOrderByAggregateInput = {
     id?: SortOrder
     textId?: SortOrder
@@ -21165,6 +22401,25 @@ export namespace Prisma {
     push?: string | string[]
   }
 
+  export type RoleListCreateEnvelopeInput = {
+    set?: RoleCreateInput | RoleCreateInput[]
+  }
+
+  export type RoleCreateInput = {
+    category: string
+  }
+
+  export type EnumPresetIDFieldUpdateOperationsInput = {
+    set?: $Enums.PresetID
+  }
+
+  export type RoleListUpdateEnvelopeInput = {
+    set?: RoleCreateInput | RoleCreateInput[]
+    push?: RoleCreateInput | RoleCreateInput[]
+    updateMany?: RoleUpdateManyInput
+    deleteMany?: RoleDeleteManyInput
+  }
+
   export type TalentCategoryCreateparentTalentCategoryIdsInput = {
     set: string[]
   }
@@ -22059,6 +23314,30 @@ export namespace Prisma {
     not?: NestedFloatFilter<$PrismaModel> | number
   }
 
+  export type NestedEnumPresetIDFilter<$PrismaModel = never> = {
+    equals?: $Enums.PresetID | EnumPresetIDFieldRefInput<$PrismaModel>
+    in?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    notIn?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    not?: NestedEnumPresetIDFilter<$PrismaModel> | $Enums.PresetID
+  }
+
+  export type RoleWhereInput = {
+    AND?: RoleWhereInput | RoleWhereInput[]
+    OR?: RoleWhereInput[]
+    NOT?: RoleWhereInput | RoleWhereInput[]
+    category?: StringFilter<"Role"> | string
+  }
+
+  export type NestedEnumPresetIDWithAggregatesFilter<$PrismaModel = never> = {
+    equals?: $Enums.PresetID | EnumPresetIDFieldRefInput<$PrismaModel>
+    in?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    notIn?: $Enums.PresetID[] | ListEnumPresetIDFieldRefInput<$PrismaModel>
+    not?: NestedEnumPresetIDWithAggregatesFilter<$PrismaModel> | $Enums.PresetID
+    _count?: NestedIntFilter<$PrismaModel>
+    _min?: NestedEnumPresetIDFilter<$PrismaModel>
+    _max?: NestedEnumPresetIDFilter<$PrismaModel>
+  }
+
   export type NestedBoolFilter<$PrismaModel = never> = {
     equals?: boolean | BooleanFieldRefInput<$PrismaModel>
     not?: NestedBoolFilter<$PrismaModel> | boolean
@@ -24353,6 +25632,15 @@ export namespace Prisma {
     contracts?: ContractUncheckedUpdateManyWithoutMissionNestedInput
   }
 
+  export type RoleUpdateManyInput = {
+    where: RoleWhereInput
+    data: RoleUpdateInput
+  }
+
+  export type RoleDeleteManyInput = {
+    where: RoleWhereInput
+  }
+
   export type ClientRegistrationCreaterequestRolesInput = {
     set: string[]
   }
@@ -25782,6 +27070,10 @@ export namespace Prisma {
     numberOfMinutesOverlap?: NullableIntFieldUpdateOperationsInput | number | null
   }
 
+  export type RoleUpdateInput = {
+    category?: StringFieldUpdateOperationsInput | string
+  }
+
   export type MissionCreateManyCreatorModelInput = {
     mid?: string
     accountId?: string | null
@@ -27054,6 +28346,10 @@ export namespace Prisma {
      * @deprecated Use ClientRoleQuestionDefaultArgs instead
      */
     export type ClientRoleQuestionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ClientRoleQuestionDefaultArgs<ExtArgs>
+    /**
+     * @deprecated Use RoleDefaultArgs instead
+     */
+    export type RoleArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RoleDefaultArgs<ExtArgs>
     /**
      * @deprecated Use ClientRegistrationDefaultArgs instead
      */
@@ -27090,6 +28386,10 @@ export namespace Prisma {
      * @deprecated Use RoleCategoryDefaultArgs instead
      */
     export type RoleCategoryArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RoleCategoryDefaultArgs<ExtArgs>
+    /**
+     * @deprecated Use SolutionDefaultArgs instead
+     */
+    export type SolutionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SolutionDefaultArgs<ExtArgs>
     /**
      * @deprecated Use TalentCategoryDefaultArgs instead
      */