@cerbos/orm-prisma 4.0.0 → 4.1.0

package/src/generated/prisma-adversarial-v6/index.d.ts

@@ -38,6 +38,16 @@ export type AdversarialSubCategory = $Result.DefaultSelection<Prisma.$Adversaria
  * 
  */
 export type AdversarialLabel = $Result.DefaultSelection<Prisma.$AdversarialLabelPayload>
+/**
+ * Model AdversarialParent
+ * 
+ */
+export type AdversarialParent = $Result.DefaultSelection<Prisma.$AdversarialParentPayload>
+/**
+ * Model AdversarialInner
+ * 
+ */
+export type AdversarialInner = $Result.DefaultSelection<Prisma.$AdversarialInnerPayload>
 
 /**
  * ##  Prisma Client ʲˢ
@@ -206,6 +216,26 @@ export class PrismaClient<
     * ```
     */
   get adversarialLabel(): Prisma.AdversarialLabelDelegate<ExtArgs, ClientOptions>;
+
+  /**
+   * `prisma.adversarialParent`: Exposes CRUD operations for the **AdversarialParent** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more AdversarialParents
+    * const adversarialParents = await prisma.adversarialParent.findMany()
+    * ```
+    */
+  get adversarialParent(): Prisma.AdversarialParentDelegate<ExtArgs, ClientOptions>;
+
+  /**
+   * `prisma.adversarialInner`: Exposes CRUD operations for the **AdversarialInner** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more AdversarialInners
+    * const adversarialInners = await prisma.adversarialInner.findMany()
+    * ```
+    */
+  get adversarialInner(): Prisma.AdversarialInnerDelegate<ExtArgs, ClientOptions>;
 }
 
 export namespace Prisma {
@@ -651,7 +681,9 @@ export namespace Prisma {
     AdversarialTag: 'AdversarialTag',
     AdversarialCategory: 'AdversarialCategory',
     AdversarialSubCategory: 'AdversarialSubCategory',
-    AdversarialLabel: 'AdversarialLabel'
+    AdversarialLabel: 'AdversarialLabel',
+    AdversarialParent: 'AdversarialParent',
+    AdversarialInner: 'AdversarialInner'
   };
 
   export type ModelName = (typeof ModelName)[keyof typeof ModelName]
@@ -670,7 +702,7 @@ export namespace Prisma {
       omit: GlobalOmitOptions
     }
     meta: {
-      modelProps: "adversarialResource" | "adversarialTag" | "adversarialCategory" | "adversarialSubCategory" | "adversarialLabel"
+      modelProps: "adversarialResource" | "adversarialTag" | "adversarialCategory" | "adversarialSubCategory" | "adversarialLabel" | "adversarialParent" | "adversarialInner"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -1044,6 +1076,154 @@ export namespace Prisma {
           }
         }
       }
+      AdversarialParent: {
+        payload: Prisma.$AdversarialParentPayload<ExtArgs>
+        fields: Prisma.AdversarialParentFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.AdversarialParentFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.AdversarialParentFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>
+          }
+          findFirst: {
+            args: Prisma.AdversarialParentFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.AdversarialParentFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>
+          }
+          findMany: {
+            args: Prisma.AdversarialParentFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>[]
+          }
+          create: {
+            args: Prisma.AdversarialParentCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>
+          }
+          createMany: {
+            args: Prisma.AdversarialParentCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          createManyAndReturn: {
+            args: Prisma.AdversarialParentCreateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>[]
+          }
+          delete: {
+            args: Prisma.AdversarialParentDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>
+          }
+          update: {
+            args: Prisma.AdversarialParentUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>
+          }
+          deleteMany: {
+            args: Prisma.AdversarialParentDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.AdversarialParentUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateManyAndReturn: {
+            args: Prisma.AdversarialParentUpdateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>[]
+          }
+          upsert: {
+            args: Prisma.AdversarialParentUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialParentPayload>
+          }
+          aggregate: {
+            args: Prisma.AdversarialParentAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateAdversarialParent>
+          }
+          groupBy: {
+            args: Prisma.AdversarialParentGroupByArgs<ExtArgs>
+            result: $Utils.Optional<AdversarialParentGroupByOutputType>[]
+          }
+          count: {
+            args: Prisma.AdversarialParentCountArgs<ExtArgs>
+            result: $Utils.Optional<AdversarialParentCountAggregateOutputType> | number
+          }
+        }
+      }
+      AdversarialInner: {
+        payload: Prisma.$AdversarialInnerPayload<ExtArgs>
+        fields: Prisma.AdversarialInnerFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.AdversarialInnerFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.AdversarialInnerFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>
+          }
+          findFirst: {
+            args: Prisma.AdversarialInnerFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.AdversarialInnerFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>
+          }
+          findMany: {
+            args: Prisma.AdversarialInnerFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>[]
+          }
+          create: {
+            args: Prisma.AdversarialInnerCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>
+          }
+          createMany: {
+            args: Prisma.AdversarialInnerCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          createManyAndReturn: {
+            args: Prisma.AdversarialInnerCreateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>[]
+          }
+          delete: {
+            args: Prisma.AdversarialInnerDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>
+          }
+          update: {
+            args: Prisma.AdversarialInnerUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>
+          }
+          deleteMany: {
+            args: Prisma.AdversarialInnerDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.AdversarialInnerUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateManyAndReturn: {
+            args: Prisma.AdversarialInnerUpdateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>[]
+          }
+          upsert: {
+            args: Prisma.AdversarialInnerUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$AdversarialInnerPayload>
+          }
+          aggregate: {
+            args: Prisma.AdversarialInnerAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateAdversarialInner>
+          }
+          groupBy: {
+            args: Prisma.AdversarialInnerGroupByArgs<ExtArgs>
+            result: $Utils.Optional<AdversarialInnerGroupByOutputType>[]
+          }
+          count: {
+            args: Prisma.AdversarialInnerCountArgs<ExtArgs>
+            result: $Utils.Optional<AdversarialInnerCountAggregateOutputType> | number
+          }
+        }
+      }
     }
   } & {
     other: {
@@ -1145,6 +1325,8 @@ export namespace Prisma {
     adversarialCategory?: AdversarialCategoryOmit
     adversarialSubCategory?: AdversarialSubCategoryOmit
     adversarialLabel?: AdversarialLabelOmit
+    adversarialParent?: AdversarialParentOmit
+    adversarialInner?: AdversarialInnerOmit
   }
 
   /* Types for Logging */
@@ -1562,6 +1744,7 @@ export namespace Prisma {
     createdAt?: boolean
     tags?: boolean | AdversarialResource$tagsArgs<ExtArgs>
     categories?: boolean | AdversarialResource$categoriesArgs<ExtArgs>
+    parent?: boolean | AdversarialResource$parentArgs<ExtArgs>
     _count?: boolean | AdversarialResourceCountOutputTypeDefaultArgs<ExtArgs>
   }, ExtArgs["result"]["adversarialResource"]>
 
@@ -1605,6 +1788,7 @@ export namespace Prisma {
   export type AdversarialResourceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
     tags?: boolean | AdversarialResource$tagsArgs<ExtArgs>
     categories?: boolean | AdversarialResource$categoriesArgs<ExtArgs>
+    parent?: boolean | AdversarialResource$parentArgs<ExtArgs>
     _count?: boolean | AdversarialResourceCountOutputTypeDefaultArgs<ExtArgs>
   }
   export type AdversarialResourceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
@@ -1615,6 +1799,7 @@ export namespace Prisma {
     objects: {
       tags: Prisma.$AdversarialTagPayload<ExtArgs>[]
       categories: Prisma.$AdversarialCategoryPayload<ExtArgs>[]
+      parent: Prisma.$AdversarialParentPayload<ExtArgs> | null
     }
     scalars: $Extensions.GetPayloadResult<{
       id: string
@@ -2022,6 +2207,7 @@ export namespace Prisma {
     readonly [Symbol.toStringTag]: "PrismaPromise"
     tags<T extends AdversarialResource$tagsArgs<ExtArgs> = {}>(args?: Subset<T, AdversarialResource$tagsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialTagPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
     categories<T extends AdversarialResource$categoriesArgs<ExtArgs> = {}>(args?: Subset<T, AdversarialResource$categoriesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialCategoryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+    parent<T extends AdversarialResource$parentArgs<ExtArgs> = {}>(args?: Subset<T, AdversarialResource$parentArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<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.
@@ -2493,6 +2679,25 @@ export namespace Prisma {
     distinct?: AdversarialCategoryScalarFieldEnum | AdversarialCategoryScalarFieldEnum[]
   }
 
+  /**
+   * AdversarialResource.parent
+   */
+  export type AdversarialResource$parentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    where?: AdversarialParentWhereInput
+  }
+
   /**
    * AdversarialResource without action
    */
@@ -6706,66 +6911,2319 @@ export namespace Prisma {
 
 
   /**
-   * Enums
+   * Model AdversarialParent
    */
 
-  export const TransactionIsolationLevel: {
-    Serializable: 'Serializable'
-  };
+  export type AggregateAdversarialParent = {
+    _count: AdversarialParentCountAggregateOutputType | null
+    _avg: AdversarialParentAvgAggregateOutputType | null
+    _sum: AdversarialParentSumAggregateOutputType | null
+    _min: AdversarialParentMinAggregateOutputType | null
+    _max: AdversarialParentMaxAggregateOutputType | null
+  }
 
-  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+  export type AdversarialParentAvgAggregateOutputType = {
+    aNumber: number | null
+  }
 
+  export type AdversarialParentSumAggregateOutputType = {
+    aNumber: number | null
+  }
 
-  export const AdversarialResourceScalarFieldEnum: {
-    id: 'id',
-    aBool: 'aBool',
-    aString: 'aString',
-    aNumber: 'aNumber',
-    aDouble: 'aDouble',
-    aOptionalString: 'aOptionalString',
-    createdBy: 'createdBy',
-    scope: 'scope',
-    createdAt: 'createdAt'
-  };
+  export type AdversarialParentMinAggregateOutputType = {
+    id: string | null
+    aBool: boolean | null
+    aString: string | null
+    aNumber: number | null
+    aOptionalString: string | null
+    resourceId: string | null
+  }
 
-  export type AdversarialResourceScalarFieldEnum = (typeof AdversarialResourceScalarFieldEnum)[keyof typeof AdversarialResourceScalarFieldEnum]
+  export type AdversarialParentMaxAggregateOutputType = {
+    id: string | null
+    aBool: boolean | null
+    aString: string | null
+    aNumber: number | null
+    aOptionalString: string | null
+    resourceId: string | null
+  }
 
+  export type AdversarialParentCountAggregateOutputType = {
+    id: number
+    aBool: number
+    aString: number
+    aNumber: number
+    aOptionalString: number
+    resourceId: number
+    _all: number
+  }
 
-  export const AdversarialTagScalarFieldEnum: {
-    id: 'id',
-    tagId: 'tagId',
-    name: 'name',
-    resourceId: 'resourceId'
-  };
 
-  export type AdversarialTagScalarFieldEnum = (typeof AdversarialTagScalarFieldEnum)[keyof typeof AdversarialTagScalarFieldEnum]
+  export type AdversarialParentAvgAggregateInputType = {
+    aNumber?: true
+  }
 
+  export type AdversarialParentSumAggregateInputType = {
+    aNumber?: true
+  }
 
-  export const AdversarialCategoryScalarFieldEnum: {
-    id: 'id',
-    name: 'name',
-    resourceId: 'resourceId'
-  };
+  export type AdversarialParentMinAggregateInputType = {
+    id?: true
+    aBool?: true
+    aString?: true
+    aNumber?: true
+    aOptionalString?: true
+    resourceId?: true
+  }
 
-  export type AdversarialCategoryScalarFieldEnum = (typeof AdversarialCategoryScalarFieldEnum)[keyof typeof AdversarialCategoryScalarFieldEnum]
+  export type AdversarialParentMaxAggregateInputType = {
+    id?: true
+    aBool?: true
+    aString?: true
+    aNumber?: true
+    aOptionalString?: true
+    resourceId?: true
+  }
 
+  export type AdversarialParentCountAggregateInputType = {
+    id?: true
+    aBool?: true
+    aString?: true
+    aNumber?: true
+    aOptionalString?: true
+    resourceId?: true
+    _all?: true
+  }
 
-  export const AdversarialSubCategoryScalarFieldEnum: {
-    id: 'id',
-    name: 'name',
-    categoryId: 'categoryId'
-  };
+  export type AdversarialParentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which AdversarialParent to aggregate.
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialParents to fetch.
+     */
+    orderBy?: AdversarialParentOrderByWithRelationInput | AdversarialParentOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: AdversarialParentWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialParents 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` AdversarialParents.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned AdversarialParents
+    **/
+    _count?: true | AdversarialParentCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to average
+    **/
+    _avg?: AdversarialParentAvgAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to sum
+    **/
+    _sum?: AdversarialParentSumAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: AdversarialParentMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: AdversarialParentMaxAggregateInputType
+  }
 
-  export type AdversarialSubCategoryScalarFieldEnum = (typeof AdversarialSubCategoryScalarFieldEnum)[keyof typeof AdversarialSubCategoryScalarFieldEnum]
+  export type GetAdversarialParentAggregateType<T extends AdversarialParentAggregateArgs> = {
+        [P in keyof T & keyof AggregateAdversarialParent]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateAdversarialParent[P]>
+      : GetScalarType<T[P], AggregateAdversarialParent[P]>
+  }
 
 
-  export const AdversarialLabelScalarFieldEnum: {
-    id: 'id',
-    name: 'name',
-    subCategoryId: 'subCategoryId'
-  };
 
-  export type AdversarialLabelScalarFieldEnum = (typeof AdversarialLabelScalarFieldEnum)[keyof typeof AdversarialLabelScalarFieldEnum]
+
+  export type AdversarialParentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: AdversarialParentWhereInput
+    orderBy?: AdversarialParentOrderByWithAggregationInput | AdversarialParentOrderByWithAggregationInput[]
+    by: AdversarialParentScalarFieldEnum[] | AdversarialParentScalarFieldEnum
+    having?: AdversarialParentScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: AdversarialParentCountAggregateInputType | true
+    _avg?: AdversarialParentAvgAggregateInputType
+    _sum?: AdversarialParentSumAggregateInputType
+    _min?: AdversarialParentMinAggregateInputType
+    _max?: AdversarialParentMaxAggregateInputType
+  }
+
+  export type AdversarialParentGroupByOutputType = {
+    id: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString: string | null
+    resourceId: string
+    _count: AdversarialParentCountAggregateOutputType | null
+    _avg: AdversarialParentAvgAggregateOutputType | null
+    _sum: AdversarialParentSumAggregateOutputType | null
+    _min: AdversarialParentMinAggregateOutputType | null
+    _max: AdversarialParentMaxAggregateOutputType | null
+  }
+
+  type GetAdversarialParentGroupByPayload<T extends AdversarialParentGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<AdversarialParentGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof AdversarialParentGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], AdversarialParentGroupByOutputType[P]>
+            : GetScalarType<T[P], AdversarialParentGroupByOutputType[P]>
+        }
+      >
+    >
+
+
+  export type AdversarialParentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    resourceId?: boolean
+    resource?: boolean | AdversarialResourceDefaultArgs<ExtArgs>
+    inner?: boolean | AdversarialParent$innerArgs<ExtArgs>
+  }, ExtArgs["result"]["adversarialParent"]>
+
+  export type AdversarialParentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    resourceId?: boolean
+    resource?: boolean | AdversarialResourceDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["adversarialParent"]>
+
+  export type AdversarialParentSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    resourceId?: boolean
+    resource?: boolean | AdversarialResourceDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["adversarialParent"]>
+
+  export type AdversarialParentSelectScalar = {
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    resourceId?: boolean
+  }
+
+  export type AdversarialParentOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "aBool" | "aString" | "aNumber" | "aOptionalString" | "resourceId", ExtArgs["result"]["adversarialParent"]>
+  export type AdversarialParentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    resource?: boolean | AdversarialResourceDefaultArgs<ExtArgs>
+    inner?: boolean | AdversarialParent$innerArgs<ExtArgs>
+  }
+  export type AdversarialParentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    resource?: boolean | AdversarialResourceDefaultArgs<ExtArgs>
+  }
+  export type AdversarialParentIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    resource?: boolean | AdversarialResourceDefaultArgs<ExtArgs>
+  }
+
+  export type $AdversarialParentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "AdversarialParent"
+    objects: {
+      resource: Prisma.$AdversarialResourcePayload<ExtArgs>
+      inner: Prisma.$AdversarialInnerPayload<ExtArgs> | null
+    }
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      aBool: boolean
+      aString: string
+      aNumber: number
+      aOptionalString: string | null
+      resourceId: string
+    }, ExtArgs["result"]["adversarialParent"]>
+    composites: {}
+  }
+
+  type AdversarialParentGetPayload<S extends boolean | null | undefined | AdversarialParentDefaultArgs> = $Result.GetResult<Prisma.$AdversarialParentPayload, S>
+
+  type AdversarialParentCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
+    Omit<AdversarialParentFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+      select?: AdversarialParentCountAggregateInputType | true
+    }
+
+  export interface AdversarialParentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['AdversarialParent'], meta: { name: 'AdversarialParent' } }
+    /**
+     * Find zero or one AdversarialParent that matches the filter.
+     * @param {AdversarialParentFindUniqueArgs} args - Arguments to find a AdversarialParent
+     * @example
+     * // Get one AdversarialParent
+     * const adversarialParent = await prisma.adversarialParent.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends AdversarialParentFindUniqueArgs>(args: SelectSubset<T, AdversarialParentFindUniqueArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find one AdversarialParent that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {AdversarialParentFindUniqueOrThrowArgs} args - Arguments to find a AdversarialParent
+     * @example
+     * // Get one AdversarialParent
+     * const adversarialParent = await prisma.adversarialParent.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends AdversarialParentFindUniqueOrThrowArgs>(args: SelectSubset<T, AdversarialParentFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first AdversarialParent 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 {AdversarialParentFindFirstArgs} args - Arguments to find a AdversarialParent
+     * @example
+     * // Get one AdversarialParent
+     * const adversarialParent = await prisma.adversarialParent.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends AdversarialParentFindFirstArgs>(args?: SelectSubset<T, AdversarialParentFindFirstArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first AdversarialParent 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 {AdversarialParentFindFirstOrThrowArgs} args - Arguments to find a AdversarialParent
+     * @example
+     * // Get one AdversarialParent
+     * const adversarialParent = await prisma.adversarialParent.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends AdversarialParentFindFirstOrThrowArgs>(args?: SelectSubset<T, AdversarialParentFindFirstOrThrowArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find zero or more AdversarialParents 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 {AdversarialParentFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all AdversarialParents
+     * const adversarialParents = await prisma.adversarialParent.findMany()
+     * 
+     * // Get first 10 AdversarialParents
+     * const adversarialParents = await prisma.adversarialParent.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const adversarialParentWithIdOnly = await prisma.adversarialParent.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends AdversarialParentFindManyArgs>(args?: SelectSubset<T, AdversarialParentFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+    /**
+     * Create a AdversarialParent.
+     * @param {AdversarialParentCreateArgs} args - Arguments to create a AdversarialParent.
+     * @example
+     * // Create one AdversarialParent
+     * const AdversarialParent = await prisma.adversarialParent.create({
+     *   data: {
+     *     // ... data to create a AdversarialParent
+     *   }
+     * })
+     * 
+     */
+    create<T extends AdversarialParentCreateArgs>(args: SelectSubset<T, AdversarialParentCreateArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Create many AdversarialParents.
+     * @param {AdversarialParentCreateManyArgs} args - Arguments to create many AdversarialParents.
+     * @example
+     * // Create many AdversarialParents
+     * const adversarialParent = await prisma.adversarialParent.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends AdversarialParentCreateManyArgs>(args?: SelectSubset<T, AdversarialParentCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many AdversarialParents and returns the data saved in the database.
+     * @param {AdversarialParentCreateManyAndReturnArgs} args - Arguments to create many AdversarialParents.
+     * @example
+     * // Create many AdversarialParents
+     * const adversarialParent = await prisma.adversarialParent.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many AdversarialParents and only return the `id`
+     * const adversarialParentWithIdOnly = await prisma.adversarialParent.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 AdversarialParentCreateManyAndReturnArgs>(args?: SelectSubset<T, AdversarialParentCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+    /**
+     * Delete a AdversarialParent.
+     * @param {AdversarialParentDeleteArgs} args - Arguments to delete one AdversarialParent.
+     * @example
+     * // Delete one AdversarialParent
+     * const AdversarialParent = await prisma.adversarialParent.delete({
+     *   where: {
+     *     // ... filter to delete one AdversarialParent
+     *   }
+     * })
+     * 
+     */
+    delete<T extends AdversarialParentDeleteArgs>(args: SelectSubset<T, AdversarialParentDeleteArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Update one AdversarialParent.
+     * @param {AdversarialParentUpdateArgs} args - Arguments to update one AdversarialParent.
+     * @example
+     * // Update one AdversarialParent
+     * const adversarialParent = await prisma.adversarialParent.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends AdversarialParentUpdateArgs>(args: SelectSubset<T, AdversarialParentUpdateArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Delete zero or more AdversarialParents.
+     * @param {AdversarialParentDeleteManyArgs} args - Arguments to filter AdversarialParents to delete.
+     * @example
+     * // Delete a few AdversarialParents
+     * const { count } = await prisma.adversarialParent.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends AdversarialParentDeleteManyArgs>(args?: SelectSubset<T, AdversarialParentDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more AdversarialParents.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialParentUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many AdversarialParents
+     * const adversarialParent = await prisma.adversarialParent.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends AdversarialParentUpdateManyArgs>(args: SelectSubset<T, AdversarialParentUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more AdversarialParents and returns the data updated in the database.
+     * @param {AdversarialParentUpdateManyAndReturnArgs} args - Arguments to update many AdversarialParents.
+     * @example
+     * // Update many AdversarialParents
+     * const adversarialParent = await prisma.adversarialParent.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Update zero or more AdversarialParents and only return the `id`
+     * const adversarialParentWithIdOnly = await prisma.adversarialParent.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 AdversarialParentUpdateManyAndReturnArgs>(args: SelectSubset<T, AdversarialParentUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+    /**
+     * Create or update one AdversarialParent.
+     * @param {AdversarialParentUpsertArgs} args - Arguments to update or create a AdversarialParent.
+     * @example
+     * // Update or create a AdversarialParent
+     * const adversarialParent = await prisma.adversarialParent.upsert({
+     *   create: {
+     *     // ... data to create a AdversarialParent
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the AdversarialParent we want to update
+     *   }
+     * })
+     */
+    upsert<T extends AdversarialParentUpsertArgs>(args: SelectSubset<T, AdversarialParentUpsertArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+    /**
+     * Count the number of AdversarialParents.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialParentCountArgs} args - Arguments to filter AdversarialParents to count.
+     * @example
+     * // Count the number of AdversarialParents
+     * const count = await prisma.adversarialParent.count({
+     *   where: {
+     *     // ... the filter for the AdversarialParents we want to count
+     *   }
+     * })
+    **/
+    count<T extends AdversarialParentCountArgs>(
+      args?: Subset<T, AdversarialParentCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], AdversarialParentCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a AdversarialParent.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialParentAggregateArgs} 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 AdversarialParentAggregateArgs>(args: Subset<T, AdversarialParentAggregateArgs>): Prisma.PrismaPromise<GetAdversarialParentAggregateType<T>>
+
+    /**
+     * Group by AdversarialParent.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialParentGroupByArgs} 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 AdversarialParentGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: AdversarialParentGroupByArgs['orderBy'] }
+        : { orderBy?: AdversarialParentGroupByArgs['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, AdversarialParentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdversarialParentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the AdversarialParent model
+   */
+  readonly fields: AdversarialParentFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for AdversarialParent.
+   * 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__AdversarialParentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    resource<T extends AdversarialResourceDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AdversarialResourceDefaultArgs<ExtArgs>>): Prisma__AdversarialResourceClient<$Result.GetResult<Prisma.$AdversarialResourcePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+    inner<T extends AdversarialParent$innerArgs<ExtArgs> = {}>(args?: Subset<T, AdversarialParent$innerArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<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): $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 AdversarialParent model
+   */
+  interface AdversarialParentFieldRefs {
+    readonly id: FieldRef<"AdversarialParent", 'String'>
+    readonly aBool: FieldRef<"AdversarialParent", 'Boolean'>
+    readonly aString: FieldRef<"AdversarialParent", 'String'>
+    readonly aNumber: FieldRef<"AdversarialParent", 'Int'>
+    readonly aOptionalString: FieldRef<"AdversarialParent", 'String'>
+    readonly resourceId: FieldRef<"AdversarialParent", 'String'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * AdversarialParent findUnique
+   */
+  export type AdversarialParentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialParent to fetch.
+     */
+    where: AdversarialParentWhereUniqueInput
+  }
+
+  /**
+   * AdversarialParent findUniqueOrThrow
+   */
+  export type AdversarialParentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialParent to fetch.
+     */
+    where: AdversarialParentWhereUniqueInput
+  }
+
+  /**
+   * AdversarialParent findFirst
+   */
+  export type AdversarialParentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialParent to fetch.
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialParents to fetch.
+     */
+    orderBy?: AdversarialParentOrderByWithRelationInput | AdversarialParentOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for AdversarialParents.
+     */
+    cursor?: AdversarialParentWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialParents 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` AdversarialParents.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of AdversarialParents.
+     */
+    distinct?: AdversarialParentScalarFieldEnum | AdversarialParentScalarFieldEnum[]
+  }
+
+  /**
+   * AdversarialParent findFirstOrThrow
+   */
+  export type AdversarialParentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialParent to fetch.
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialParents to fetch.
+     */
+    orderBy?: AdversarialParentOrderByWithRelationInput | AdversarialParentOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for AdversarialParents.
+     */
+    cursor?: AdversarialParentWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialParents 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` AdversarialParents.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of AdversarialParents.
+     */
+    distinct?: AdversarialParentScalarFieldEnum | AdversarialParentScalarFieldEnum[]
+  }
+
+  /**
+   * AdversarialParent findMany
+   */
+  export type AdversarialParentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialParents to fetch.
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialParents to fetch.
+     */
+    orderBy?: AdversarialParentOrderByWithRelationInput | AdversarialParentOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing AdversarialParents.
+     */
+    cursor?: AdversarialParentWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialParents 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` AdversarialParents.
+     */
+    skip?: number
+    distinct?: AdversarialParentScalarFieldEnum | AdversarialParentScalarFieldEnum[]
+  }
+
+  /**
+   * AdversarialParent create
+   */
+  export type AdversarialParentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * The data needed to create a AdversarialParent.
+     */
+    data: XOR<AdversarialParentCreateInput, AdversarialParentUncheckedCreateInput>
+  }
+
+  /**
+   * AdversarialParent createMany
+   */
+  export type AdversarialParentCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many AdversarialParents.
+     */
+    data: AdversarialParentCreateManyInput | AdversarialParentCreateManyInput[]
+  }
+
+  /**
+   * AdversarialParent createManyAndReturn
+   */
+  export type AdversarialParentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelectCreateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * The data used to create many AdversarialParents.
+     */
+    data: AdversarialParentCreateManyInput | AdversarialParentCreateManyInput[]
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentIncludeCreateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * AdversarialParent update
+   */
+  export type AdversarialParentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * The data needed to update a AdversarialParent.
+     */
+    data: XOR<AdversarialParentUpdateInput, AdversarialParentUncheckedUpdateInput>
+    /**
+     * Choose, which AdversarialParent to update.
+     */
+    where: AdversarialParentWhereUniqueInput
+  }
+
+  /**
+   * AdversarialParent updateMany
+   */
+  export type AdversarialParentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update AdversarialParents.
+     */
+    data: XOR<AdversarialParentUpdateManyMutationInput, AdversarialParentUncheckedUpdateManyInput>
+    /**
+     * Filter which AdversarialParents to update
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * Limit how many AdversarialParents to update.
+     */
+    limit?: number
+  }
+
+  /**
+   * AdversarialParent updateManyAndReturn
+   */
+  export type AdversarialParentUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelectUpdateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * The data used to update AdversarialParents.
+     */
+    data: XOR<AdversarialParentUpdateManyMutationInput, AdversarialParentUncheckedUpdateManyInput>
+    /**
+     * Filter which AdversarialParents to update
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * Limit how many AdversarialParents to update.
+     */
+    limit?: number
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentIncludeUpdateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * AdversarialParent upsert
+   */
+  export type AdversarialParentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * The filter to search for the AdversarialParent to update in case it exists.
+     */
+    where: AdversarialParentWhereUniqueInput
+    /**
+     * In case the AdversarialParent found by the `where` argument doesn't exist, create a new AdversarialParent with this data.
+     */
+    create: XOR<AdversarialParentCreateInput, AdversarialParentUncheckedCreateInput>
+    /**
+     * In case the AdversarialParent was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<AdversarialParentUpdateInput, AdversarialParentUncheckedUpdateInput>
+  }
+
+  /**
+   * AdversarialParent delete
+   */
+  export type AdversarialParentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+    /**
+     * Filter which AdversarialParent to delete.
+     */
+    where: AdversarialParentWhereUniqueInput
+  }
+
+  /**
+   * AdversarialParent deleteMany
+   */
+  export type AdversarialParentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which AdversarialParents to delete
+     */
+    where?: AdversarialParentWhereInput
+    /**
+     * Limit how many AdversarialParents to delete.
+     */
+    limit?: number
+  }
+
+  /**
+   * AdversarialParent.inner
+   */
+  export type AdversarialParent$innerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    where?: AdversarialInnerWhereInput
+  }
+
+  /**
+   * AdversarialParent without action
+   */
+  export type AdversarialParentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialParent
+     */
+    select?: AdversarialParentSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialParent
+     */
+    omit?: AdversarialParentOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialParentInclude<ExtArgs> | null
+  }
+
+
+  /**
+   * Model AdversarialInner
+   */
+
+  export type AggregateAdversarialInner = {
+    _count: AdversarialInnerCountAggregateOutputType | null
+    _avg: AdversarialInnerAvgAggregateOutputType | null
+    _sum: AdversarialInnerSumAggregateOutputType | null
+    _min: AdversarialInnerMinAggregateOutputType | null
+    _max: AdversarialInnerMaxAggregateOutputType | null
+  }
+
+  export type AdversarialInnerAvgAggregateOutputType = {
+    aNumber: number | null
+  }
+
+  export type AdversarialInnerSumAggregateOutputType = {
+    aNumber: number | null
+  }
+
+  export type AdversarialInnerMinAggregateOutputType = {
+    id: string | null
+    aBool: boolean | null
+    aString: string | null
+    aNumber: number | null
+    aOptionalString: string | null
+    parentId: string | null
+  }
+
+  export type AdversarialInnerMaxAggregateOutputType = {
+    id: string | null
+    aBool: boolean | null
+    aString: string | null
+    aNumber: number | null
+    aOptionalString: string | null
+    parentId: string | null
+  }
+
+  export type AdversarialInnerCountAggregateOutputType = {
+    id: number
+    aBool: number
+    aString: number
+    aNumber: number
+    aOptionalString: number
+    parentId: number
+    _all: number
+  }
+
+
+  export type AdversarialInnerAvgAggregateInputType = {
+    aNumber?: true
+  }
+
+  export type AdversarialInnerSumAggregateInputType = {
+    aNumber?: true
+  }
+
+  export type AdversarialInnerMinAggregateInputType = {
+    id?: true
+    aBool?: true
+    aString?: true
+    aNumber?: true
+    aOptionalString?: true
+    parentId?: true
+  }
+
+  export type AdversarialInnerMaxAggregateInputType = {
+    id?: true
+    aBool?: true
+    aString?: true
+    aNumber?: true
+    aOptionalString?: true
+    parentId?: true
+  }
+
+  export type AdversarialInnerCountAggregateInputType = {
+    id?: true
+    aBool?: true
+    aString?: true
+    aNumber?: true
+    aOptionalString?: true
+    parentId?: true
+    _all?: true
+  }
+
+  export type AdversarialInnerAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which AdversarialInner to aggregate.
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialInners to fetch.
+     */
+    orderBy?: AdversarialInnerOrderByWithRelationInput | AdversarialInnerOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: AdversarialInnerWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialInners 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` AdversarialInners.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned AdversarialInners
+    **/
+    _count?: true | AdversarialInnerCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to average
+    **/
+    _avg?: AdversarialInnerAvgAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to sum
+    **/
+    _sum?: AdversarialInnerSumAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: AdversarialInnerMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: AdversarialInnerMaxAggregateInputType
+  }
+
+  export type GetAdversarialInnerAggregateType<T extends AdversarialInnerAggregateArgs> = {
+        [P in keyof T & keyof AggregateAdversarialInner]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateAdversarialInner[P]>
+      : GetScalarType<T[P], AggregateAdversarialInner[P]>
+  }
+
+
+
+
+  export type AdversarialInnerGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: AdversarialInnerWhereInput
+    orderBy?: AdversarialInnerOrderByWithAggregationInput | AdversarialInnerOrderByWithAggregationInput[]
+    by: AdversarialInnerScalarFieldEnum[] | AdversarialInnerScalarFieldEnum
+    having?: AdversarialInnerScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: AdversarialInnerCountAggregateInputType | true
+    _avg?: AdversarialInnerAvgAggregateInputType
+    _sum?: AdversarialInnerSumAggregateInputType
+    _min?: AdversarialInnerMinAggregateInputType
+    _max?: AdversarialInnerMaxAggregateInputType
+  }
+
+  export type AdversarialInnerGroupByOutputType = {
+    id: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString: string | null
+    parentId: string
+    _count: AdversarialInnerCountAggregateOutputType | null
+    _avg: AdversarialInnerAvgAggregateOutputType | null
+    _sum: AdversarialInnerSumAggregateOutputType | null
+    _min: AdversarialInnerMinAggregateOutputType | null
+    _max: AdversarialInnerMaxAggregateOutputType | null
+  }
+
+  type GetAdversarialInnerGroupByPayload<T extends AdversarialInnerGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<AdversarialInnerGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof AdversarialInnerGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], AdversarialInnerGroupByOutputType[P]>
+            : GetScalarType<T[P], AdversarialInnerGroupByOutputType[P]>
+        }
+      >
+    >
+
+
+  export type AdversarialInnerSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    parentId?: boolean
+    parent?: boolean | AdversarialParentDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["adversarialInner"]>
+
+  export type AdversarialInnerSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    parentId?: boolean
+    parent?: boolean | AdversarialParentDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["adversarialInner"]>
+
+  export type AdversarialInnerSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    parentId?: boolean
+    parent?: boolean | AdversarialParentDefaultArgs<ExtArgs>
+  }, ExtArgs["result"]["adversarialInner"]>
+
+  export type AdversarialInnerSelectScalar = {
+    id?: boolean
+    aBool?: boolean
+    aString?: boolean
+    aNumber?: boolean
+    aOptionalString?: boolean
+    parentId?: boolean
+  }
+
+  export type AdversarialInnerOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "aBool" | "aString" | "aNumber" | "aOptionalString" | "parentId", ExtArgs["result"]["adversarialInner"]>
+  export type AdversarialInnerInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    parent?: boolean | AdversarialParentDefaultArgs<ExtArgs>
+  }
+  export type AdversarialInnerIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    parent?: boolean | AdversarialParentDefaultArgs<ExtArgs>
+  }
+  export type AdversarialInnerIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    parent?: boolean | AdversarialParentDefaultArgs<ExtArgs>
+  }
+
+  export type $AdversarialInnerPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "AdversarialInner"
+    objects: {
+      parent: Prisma.$AdversarialParentPayload<ExtArgs>
+    }
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      aBool: boolean
+      aString: string
+      aNumber: number
+      aOptionalString: string | null
+      parentId: string
+    }, ExtArgs["result"]["adversarialInner"]>
+    composites: {}
+  }
+
+  type AdversarialInnerGetPayload<S extends boolean | null | undefined | AdversarialInnerDefaultArgs> = $Result.GetResult<Prisma.$AdversarialInnerPayload, S>
+
+  type AdversarialInnerCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
+    Omit<AdversarialInnerFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+      select?: AdversarialInnerCountAggregateInputType | true
+    }
+
+  export interface AdversarialInnerDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['AdversarialInner'], meta: { name: 'AdversarialInner' } }
+    /**
+     * Find zero or one AdversarialInner that matches the filter.
+     * @param {AdversarialInnerFindUniqueArgs} args - Arguments to find a AdversarialInner
+     * @example
+     * // Get one AdversarialInner
+     * const adversarialInner = await prisma.adversarialInner.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends AdversarialInnerFindUniqueArgs>(args: SelectSubset<T, AdversarialInnerFindUniqueArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find one AdversarialInner that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {AdversarialInnerFindUniqueOrThrowArgs} args - Arguments to find a AdversarialInner
+     * @example
+     * // Get one AdversarialInner
+     * const adversarialInner = await prisma.adversarialInner.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends AdversarialInnerFindUniqueOrThrowArgs>(args: SelectSubset<T, AdversarialInnerFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first AdversarialInner 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 {AdversarialInnerFindFirstArgs} args - Arguments to find a AdversarialInner
+     * @example
+     * // Get one AdversarialInner
+     * const adversarialInner = await prisma.adversarialInner.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends AdversarialInnerFindFirstArgs>(args?: SelectSubset<T, AdversarialInnerFindFirstArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first AdversarialInner 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 {AdversarialInnerFindFirstOrThrowArgs} args - Arguments to find a AdversarialInner
+     * @example
+     * // Get one AdversarialInner
+     * const adversarialInner = await prisma.adversarialInner.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends AdversarialInnerFindFirstOrThrowArgs>(args?: SelectSubset<T, AdversarialInnerFindFirstOrThrowArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find zero or more AdversarialInners 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 {AdversarialInnerFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all AdversarialInners
+     * const adversarialInners = await prisma.adversarialInner.findMany()
+     * 
+     * // Get first 10 AdversarialInners
+     * const adversarialInners = await prisma.adversarialInner.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const adversarialInnerWithIdOnly = await prisma.adversarialInner.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends AdversarialInnerFindManyArgs>(args?: SelectSubset<T, AdversarialInnerFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+    /**
+     * Create a AdversarialInner.
+     * @param {AdversarialInnerCreateArgs} args - Arguments to create a AdversarialInner.
+     * @example
+     * // Create one AdversarialInner
+     * const AdversarialInner = await prisma.adversarialInner.create({
+     *   data: {
+     *     // ... data to create a AdversarialInner
+     *   }
+     * })
+     * 
+     */
+    create<T extends AdversarialInnerCreateArgs>(args: SelectSubset<T, AdversarialInnerCreateArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Create many AdversarialInners.
+     * @param {AdversarialInnerCreateManyArgs} args - Arguments to create many AdversarialInners.
+     * @example
+     * // Create many AdversarialInners
+     * const adversarialInner = await prisma.adversarialInner.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends AdversarialInnerCreateManyArgs>(args?: SelectSubset<T, AdversarialInnerCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many AdversarialInners and returns the data saved in the database.
+     * @param {AdversarialInnerCreateManyAndReturnArgs} args - Arguments to create many AdversarialInners.
+     * @example
+     * // Create many AdversarialInners
+     * const adversarialInner = await prisma.adversarialInner.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many AdversarialInners and only return the `id`
+     * const adversarialInnerWithIdOnly = await prisma.adversarialInner.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 AdversarialInnerCreateManyAndReturnArgs>(args?: SelectSubset<T, AdversarialInnerCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+    /**
+     * Delete a AdversarialInner.
+     * @param {AdversarialInnerDeleteArgs} args - Arguments to delete one AdversarialInner.
+     * @example
+     * // Delete one AdversarialInner
+     * const AdversarialInner = await prisma.adversarialInner.delete({
+     *   where: {
+     *     // ... filter to delete one AdversarialInner
+     *   }
+     * })
+     * 
+     */
+    delete<T extends AdversarialInnerDeleteArgs>(args: SelectSubset<T, AdversarialInnerDeleteArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Update one AdversarialInner.
+     * @param {AdversarialInnerUpdateArgs} args - Arguments to update one AdversarialInner.
+     * @example
+     * // Update one AdversarialInner
+     * const adversarialInner = await prisma.adversarialInner.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends AdversarialInnerUpdateArgs>(args: SelectSubset<T, AdversarialInnerUpdateArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Delete zero or more AdversarialInners.
+     * @param {AdversarialInnerDeleteManyArgs} args - Arguments to filter AdversarialInners to delete.
+     * @example
+     * // Delete a few AdversarialInners
+     * const { count } = await prisma.adversarialInner.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends AdversarialInnerDeleteManyArgs>(args?: SelectSubset<T, AdversarialInnerDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more AdversarialInners.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialInnerUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many AdversarialInners
+     * const adversarialInner = await prisma.adversarialInner.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends AdversarialInnerUpdateManyArgs>(args: SelectSubset<T, AdversarialInnerUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more AdversarialInners and returns the data updated in the database.
+     * @param {AdversarialInnerUpdateManyAndReturnArgs} args - Arguments to update many AdversarialInners.
+     * @example
+     * // Update many AdversarialInners
+     * const adversarialInner = await prisma.adversarialInner.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Update zero or more AdversarialInners and only return the `id`
+     * const adversarialInnerWithIdOnly = await prisma.adversarialInner.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 AdversarialInnerUpdateManyAndReturnArgs>(args: SelectSubset<T, AdversarialInnerUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+    /**
+     * Create or update one AdversarialInner.
+     * @param {AdversarialInnerUpsertArgs} args - Arguments to update or create a AdversarialInner.
+     * @example
+     * // Update or create a AdversarialInner
+     * const adversarialInner = await prisma.adversarialInner.upsert({
+     *   create: {
+     *     // ... data to create a AdversarialInner
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the AdversarialInner we want to update
+     *   }
+     * })
+     */
+    upsert<T extends AdversarialInnerUpsertArgs>(args: SelectSubset<T, AdversarialInnerUpsertArgs<ExtArgs>>): Prisma__AdversarialInnerClient<$Result.GetResult<Prisma.$AdversarialInnerPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+    /**
+     * Count the number of AdversarialInners.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialInnerCountArgs} args - Arguments to filter AdversarialInners to count.
+     * @example
+     * // Count the number of AdversarialInners
+     * const count = await prisma.adversarialInner.count({
+     *   where: {
+     *     // ... the filter for the AdversarialInners we want to count
+     *   }
+     * })
+    **/
+    count<T extends AdversarialInnerCountArgs>(
+      args?: Subset<T, AdversarialInnerCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], AdversarialInnerCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a AdversarialInner.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialInnerAggregateArgs} 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 AdversarialInnerAggregateArgs>(args: Subset<T, AdversarialInnerAggregateArgs>): Prisma.PrismaPromise<GetAdversarialInnerAggregateType<T>>
+
+    /**
+     * Group by AdversarialInner.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {AdversarialInnerGroupByArgs} 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 AdversarialInnerGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: AdversarialInnerGroupByArgs['orderBy'] }
+        : { orderBy?: AdversarialInnerGroupByArgs['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, AdversarialInnerGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAdversarialInnerGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the AdversarialInner model
+   */
+  readonly fields: AdversarialInnerFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for AdversarialInner.
+   * 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__AdversarialInnerClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    parent<T extends AdversarialParentDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AdversarialParentDefaultArgs<ExtArgs>>): Prisma__AdversarialParentClient<$Result.GetResult<Prisma.$AdversarialParentPayload<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): $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 AdversarialInner model
+   */
+  interface AdversarialInnerFieldRefs {
+    readonly id: FieldRef<"AdversarialInner", 'String'>
+    readonly aBool: FieldRef<"AdversarialInner", 'Boolean'>
+    readonly aString: FieldRef<"AdversarialInner", 'String'>
+    readonly aNumber: FieldRef<"AdversarialInner", 'Int'>
+    readonly aOptionalString: FieldRef<"AdversarialInner", 'String'>
+    readonly parentId: FieldRef<"AdversarialInner", 'String'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * AdversarialInner findUnique
+   */
+  export type AdversarialInnerFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialInner to fetch.
+     */
+    where: AdversarialInnerWhereUniqueInput
+  }
+
+  /**
+   * AdversarialInner findUniqueOrThrow
+   */
+  export type AdversarialInnerFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialInner to fetch.
+     */
+    where: AdversarialInnerWhereUniqueInput
+  }
+
+  /**
+   * AdversarialInner findFirst
+   */
+  export type AdversarialInnerFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialInner to fetch.
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialInners to fetch.
+     */
+    orderBy?: AdversarialInnerOrderByWithRelationInput | AdversarialInnerOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for AdversarialInners.
+     */
+    cursor?: AdversarialInnerWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialInners 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` AdversarialInners.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of AdversarialInners.
+     */
+    distinct?: AdversarialInnerScalarFieldEnum | AdversarialInnerScalarFieldEnum[]
+  }
+
+  /**
+   * AdversarialInner findFirstOrThrow
+   */
+  export type AdversarialInnerFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialInner to fetch.
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialInners to fetch.
+     */
+    orderBy?: AdversarialInnerOrderByWithRelationInput | AdversarialInnerOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for AdversarialInners.
+     */
+    cursor?: AdversarialInnerWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialInners 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` AdversarialInners.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of AdversarialInners.
+     */
+    distinct?: AdversarialInnerScalarFieldEnum | AdversarialInnerScalarFieldEnum[]
+  }
+
+  /**
+   * AdversarialInner findMany
+   */
+  export type AdversarialInnerFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * Filter, which AdversarialInners to fetch.
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of AdversarialInners to fetch.
+     */
+    orderBy?: AdversarialInnerOrderByWithRelationInput | AdversarialInnerOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing AdversarialInners.
+     */
+    cursor?: AdversarialInnerWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` AdversarialInners 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` AdversarialInners.
+     */
+    skip?: number
+    distinct?: AdversarialInnerScalarFieldEnum | AdversarialInnerScalarFieldEnum[]
+  }
+
+  /**
+   * AdversarialInner create
+   */
+  export type AdversarialInnerCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * The data needed to create a AdversarialInner.
+     */
+    data: XOR<AdversarialInnerCreateInput, AdversarialInnerUncheckedCreateInput>
+  }
+
+  /**
+   * AdversarialInner createMany
+   */
+  export type AdversarialInnerCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many AdversarialInners.
+     */
+    data: AdversarialInnerCreateManyInput | AdversarialInnerCreateManyInput[]
+  }
+
+  /**
+   * AdversarialInner createManyAndReturn
+   */
+  export type AdversarialInnerCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelectCreateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * The data used to create many AdversarialInners.
+     */
+    data: AdversarialInnerCreateManyInput | AdversarialInnerCreateManyInput[]
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerIncludeCreateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * AdversarialInner update
+   */
+  export type AdversarialInnerUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * The data needed to update a AdversarialInner.
+     */
+    data: XOR<AdversarialInnerUpdateInput, AdversarialInnerUncheckedUpdateInput>
+    /**
+     * Choose, which AdversarialInner to update.
+     */
+    where: AdversarialInnerWhereUniqueInput
+  }
+
+  /**
+   * AdversarialInner updateMany
+   */
+  export type AdversarialInnerUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update AdversarialInners.
+     */
+    data: XOR<AdversarialInnerUpdateManyMutationInput, AdversarialInnerUncheckedUpdateManyInput>
+    /**
+     * Filter which AdversarialInners to update
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * Limit how many AdversarialInners to update.
+     */
+    limit?: number
+  }
+
+  /**
+   * AdversarialInner updateManyAndReturn
+   */
+  export type AdversarialInnerUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelectUpdateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * The data used to update AdversarialInners.
+     */
+    data: XOR<AdversarialInnerUpdateManyMutationInput, AdversarialInnerUncheckedUpdateManyInput>
+    /**
+     * Filter which AdversarialInners to update
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * Limit how many AdversarialInners to update.
+     */
+    limit?: number
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerIncludeUpdateManyAndReturn<ExtArgs> | null
+  }
+
+  /**
+   * AdversarialInner upsert
+   */
+  export type AdversarialInnerUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * The filter to search for the AdversarialInner to update in case it exists.
+     */
+    where: AdversarialInnerWhereUniqueInput
+    /**
+     * In case the AdversarialInner found by the `where` argument doesn't exist, create a new AdversarialInner with this data.
+     */
+    create: XOR<AdversarialInnerCreateInput, AdversarialInnerUncheckedCreateInput>
+    /**
+     * In case the AdversarialInner was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<AdversarialInnerUpdateInput, AdversarialInnerUncheckedUpdateInput>
+  }
+
+  /**
+   * AdversarialInner delete
+   */
+  export type AdversarialInnerDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+    /**
+     * Filter which AdversarialInner to delete.
+     */
+    where: AdversarialInnerWhereUniqueInput
+  }
+
+  /**
+   * AdversarialInner deleteMany
+   */
+  export type AdversarialInnerDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which AdversarialInners to delete
+     */
+    where?: AdversarialInnerWhereInput
+    /**
+     * Limit how many AdversarialInners to delete.
+     */
+    limit?: number
+  }
+
+  /**
+   * AdversarialInner without action
+   */
+  export type AdversarialInnerDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the AdversarialInner
+     */
+    select?: AdversarialInnerSelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the AdversarialInner
+     */
+    omit?: AdversarialInnerOmit<ExtArgs> | null
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: AdversarialInnerInclude<ExtArgs> | null
+  }
+
+
+  /**
+   * Enums
+   */
+
+  export const TransactionIsolationLevel: {
+    Serializable: 'Serializable'
+  };
+
+  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+  export const AdversarialResourceScalarFieldEnum: {
+    id: 'id',
+    aBool: 'aBool',
+    aString: 'aString',
+    aNumber: 'aNumber',
+    aDouble: 'aDouble',
+    aOptionalString: 'aOptionalString',
+    createdBy: 'createdBy',
+    scope: 'scope',
+    createdAt: 'createdAt'
+  };
+
+  export type AdversarialResourceScalarFieldEnum = (typeof AdversarialResourceScalarFieldEnum)[keyof typeof AdversarialResourceScalarFieldEnum]
+
+
+  export const AdversarialTagScalarFieldEnum: {
+    id: 'id',
+    tagId: 'tagId',
+    name: 'name',
+    resourceId: 'resourceId'
+  };
+
+  export type AdversarialTagScalarFieldEnum = (typeof AdversarialTagScalarFieldEnum)[keyof typeof AdversarialTagScalarFieldEnum]
+
+
+  export const AdversarialCategoryScalarFieldEnum: {
+    id: 'id',
+    name: 'name',
+    resourceId: 'resourceId'
+  };
+
+  export type AdversarialCategoryScalarFieldEnum = (typeof AdversarialCategoryScalarFieldEnum)[keyof typeof AdversarialCategoryScalarFieldEnum]
+
+
+  export const AdversarialSubCategoryScalarFieldEnum: {
+    id: 'id',
+    name: 'name',
+    categoryId: 'categoryId'
+  };
+
+  export type AdversarialSubCategoryScalarFieldEnum = (typeof AdversarialSubCategoryScalarFieldEnum)[keyof typeof AdversarialSubCategoryScalarFieldEnum]
+
+
+  export const AdversarialLabelScalarFieldEnum: {
+    id: 'id',
+    name: 'name',
+    subCategoryId: 'subCategoryId'
+  };
+
+  export type AdversarialLabelScalarFieldEnum = (typeof AdversarialLabelScalarFieldEnum)[keyof typeof AdversarialLabelScalarFieldEnum]
+
+
+  export const AdversarialParentScalarFieldEnum: {
+    id: 'id',
+    aBool: 'aBool',
+    aString: 'aString',
+    aNumber: 'aNumber',
+    aOptionalString: 'aOptionalString',
+    resourceId: 'resourceId'
+  };
+
+  export type AdversarialParentScalarFieldEnum = (typeof AdversarialParentScalarFieldEnum)[keyof typeof AdversarialParentScalarFieldEnum]
+
+
+  export const AdversarialInnerScalarFieldEnum: {
+    id: 'id',
+    aBool: 'aBool',
+    aString: 'aString',
+    aNumber: 'aNumber',
+    aOptionalString: 'aOptionalString',
+    parentId: 'parentId'
+  };
+
+  export type AdversarialInnerScalarFieldEnum = (typeof AdversarialInnerScalarFieldEnum)[keyof typeof AdversarialInnerScalarFieldEnum]
 
 
   export const SortOrder: {
@@ -6842,6 +9300,7 @@ export namespace Prisma {
     createdAt?: DateTimeNullableFilter<"AdversarialResource"> | Date | string | null
     tags?: AdversarialTagListRelationFilter
     categories?: AdversarialCategoryListRelationFilter
+    parent?: XOR<AdversarialParentNullableScalarRelationFilter, AdversarialParentWhereInput> | null
   }
 
   export type AdversarialResourceOrderByWithRelationInput = {
@@ -6856,6 +9315,7 @@ export namespace Prisma {
     createdAt?: SortOrderInput | SortOrder
     tags?: AdversarialTagOrderByRelationAggregateInput
     categories?: AdversarialCategoryOrderByRelationAggregateInput
+    parent?: AdversarialParentOrderByWithRelationInput
   }
 
   export type AdversarialResourceWhereUniqueInput = Prisma.AtLeast<{
@@ -6873,6 +9333,7 @@ export namespace Prisma {
     createdAt?: DateTimeNullableFilter<"AdversarialResource"> | Date | string | null
     tags?: AdversarialTagListRelationFilter
     categories?: AdversarialCategoryListRelationFilter
+    parent?: XOR<AdversarialParentNullableScalarRelationFilter, AdversarialParentWhereInput> | null
   }, "id">
 
   export type AdversarialResourceOrderByWithAggregationInput = {
@@ -7098,6 +9559,133 @@ export namespace Prisma {
     subCategoryId?: StringWithAggregatesFilter<"AdversarialLabel"> | string
   }
 
+  export type AdversarialParentWhereInput = {
+    AND?: AdversarialParentWhereInput | AdversarialParentWhereInput[]
+    OR?: AdversarialParentWhereInput[]
+    NOT?: AdversarialParentWhereInput | AdversarialParentWhereInput[]
+    id?: StringFilter<"AdversarialParent"> | string
+    aBool?: BoolFilter<"AdversarialParent"> | boolean
+    aString?: StringFilter<"AdversarialParent"> | string
+    aNumber?: IntFilter<"AdversarialParent"> | number
+    aOptionalString?: StringNullableFilter<"AdversarialParent"> | string | null
+    resourceId?: StringFilter<"AdversarialParent"> | string
+    resource?: XOR<AdversarialResourceScalarRelationFilter, AdversarialResourceWhereInput>
+    inner?: XOR<AdversarialInnerNullableScalarRelationFilter, AdversarialInnerWhereInput> | null
+  }
+
+  export type AdversarialParentOrderByWithRelationInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrderInput | SortOrder
+    resourceId?: SortOrder
+    resource?: AdversarialResourceOrderByWithRelationInput
+    inner?: AdversarialInnerOrderByWithRelationInput
+  }
+
+  export type AdversarialParentWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    resourceId?: string
+    AND?: AdversarialParentWhereInput | AdversarialParentWhereInput[]
+    OR?: AdversarialParentWhereInput[]
+    NOT?: AdversarialParentWhereInput | AdversarialParentWhereInput[]
+    aBool?: BoolFilter<"AdversarialParent"> | boolean
+    aString?: StringFilter<"AdversarialParent"> | string
+    aNumber?: IntFilter<"AdversarialParent"> | number
+    aOptionalString?: StringNullableFilter<"AdversarialParent"> | string | null
+    resource?: XOR<AdversarialResourceScalarRelationFilter, AdversarialResourceWhereInput>
+    inner?: XOR<AdversarialInnerNullableScalarRelationFilter, AdversarialInnerWhereInput> | null
+  }, "id" | "resourceId">
+
+  export type AdversarialParentOrderByWithAggregationInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrderInput | SortOrder
+    resourceId?: SortOrder
+    _count?: AdversarialParentCountOrderByAggregateInput
+    _avg?: AdversarialParentAvgOrderByAggregateInput
+    _max?: AdversarialParentMaxOrderByAggregateInput
+    _min?: AdversarialParentMinOrderByAggregateInput
+    _sum?: AdversarialParentSumOrderByAggregateInput
+  }
+
+  export type AdversarialParentScalarWhereWithAggregatesInput = {
+    AND?: AdversarialParentScalarWhereWithAggregatesInput | AdversarialParentScalarWhereWithAggregatesInput[]
+    OR?: AdversarialParentScalarWhereWithAggregatesInput[]
+    NOT?: AdversarialParentScalarWhereWithAggregatesInput | AdversarialParentScalarWhereWithAggregatesInput[]
+    id?: StringWithAggregatesFilter<"AdversarialParent"> | string
+    aBool?: BoolWithAggregatesFilter<"AdversarialParent"> | boolean
+    aString?: StringWithAggregatesFilter<"AdversarialParent"> | string
+    aNumber?: IntWithAggregatesFilter<"AdversarialParent"> | number
+    aOptionalString?: StringNullableWithAggregatesFilter<"AdversarialParent"> | string | null
+    resourceId?: StringWithAggregatesFilter<"AdversarialParent"> | string
+  }
+
+  export type AdversarialInnerWhereInput = {
+    AND?: AdversarialInnerWhereInput | AdversarialInnerWhereInput[]
+    OR?: AdversarialInnerWhereInput[]
+    NOT?: AdversarialInnerWhereInput | AdversarialInnerWhereInput[]
+    id?: StringFilter<"AdversarialInner"> | string
+    aBool?: BoolFilter<"AdversarialInner"> | boolean
+    aString?: StringFilter<"AdversarialInner"> | string
+    aNumber?: IntFilter<"AdversarialInner"> | number
+    aOptionalString?: StringNullableFilter<"AdversarialInner"> | string | null
+    parentId?: StringFilter<"AdversarialInner"> | string
+    parent?: XOR<AdversarialParentScalarRelationFilter, AdversarialParentWhereInput>
+  }
+
+  export type AdversarialInnerOrderByWithRelationInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrderInput | SortOrder
+    parentId?: SortOrder
+    parent?: AdversarialParentOrderByWithRelationInput
+  }
+
+  export type AdversarialInnerWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    parentId?: string
+    AND?: AdversarialInnerWhereInput | AdversarialInnerWhereInput[]
+    OR?: AdversarialInnerWhereInput[]
+    NOT?: AdversarialInnerWhereInput | AdversarialInnerWhereInput[]
+    aBool?: BoolFilter<"AdversarialInner"> | boolean
+    aString?: StringFilter<"AdversarialInner"> | string
+    aNumber?: IntFilter<"AdversarialInner"> | number
+    aOptionalString?: StringNullableFilter<"AdversarialInner"> | string | null
+    parent?: XOR<AdversarialParentScalarRelationFilter, AdversarialParentWhereInput>
+  }, "id" | "parentId">
+
+  export type AdversarialInnerOrderByWithAggregationInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrderInput | SortOrder
+    parentId?: SortOrder
+    _count?: AdversarialInnerCountOrderByAggregateInput
+    _avg?: AdversarialInnerAvgOrderByAggregateInput
+    _max?: AdversarialInnerMaxOrderByAggregateInput
+    _min?: AdversarialInnerMinOrderByAggregateInput
+    _sum?: AdversarialInnerSumOrderByAggregateInput
+  }
+
+  export type AdversarialInnerScalarWhereWithAggregatesInput = {
+    AND?: AdversarialInnerScalarWhereWithAggregatesInput | AdversarialInnerScalarWhereWithAggregatesInput[]
+    OR?: AdversarialInnerScalarWhereWithAggregatesInput[]
+    NOT?: AdversarialInnerScalarWhereWithAggregatesInput | AdversarialInnerScalarWhereWithAggregatesInput[]
+    id?: StringWithAggregatesFilter<"AdversarialInner"> | string
+    aBool?: BoolWithAggregatesFilter<"AdversarialInner"> | boolean
+    aString?: StringWithAggregatesFilter<"AdversarialInner"> | string
+    aNumber?: IntWithAggregatesFilter<"AdversarialInner"> | number
+    aOptionalString?: StringNullableWithAggregatesFilter<"AdversarialInner"> | string | null
+    parentId?: StringWithAggregatesFilter<"AdversarialInner"> | string
+  }
+
   export type AdversarialResourceCreateInput = {
     id: string
     aBool: boolean
@@ -7110,6 +9698,7 @@ export namespace Prisma {
     createdAt?: Date | string | null
     tags?: AdversarialTagCreateNestedManyWithoutResourceInput
     categories?: AdversarialCategoryCreateNestedManyWithoutResourceInput
+    parent?: AdversarialParentCreateNestedOneWithoutResourceInput
   }
 
   export type AdversarialResourceUncheckedCreateInput = {
@@ -7124,6 +9713,7 @@ export namespace Prisma {
     createdAt?: Date | string | null
     tags?: AdversarialTagUncheckedCreateNestedManyWithoutResourceInput
     categories?: AdversarialCategoryUncheckedCreateNestedManyWithoutResourceInput
+    parent?: AdversarialParentUncheckedCreateNestedOneWithoutResourceInput
   }
 
   export type AdversarialResourceUpdateInput = {
@@ -7138,6 +9728,7 @@ export namespace Prisma {
     createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     tags?: AdversarialTagUpdateManyWithoutResourceNestedInput
     categories?: AdversarialCategoryUpdateManyWithoutResourceNestedInput
+    parent?: AdversarialParentUpdateOneWithoutResourceNestedInput
   }
 
   export type AdversarialResourceUncheckedUpdateInput = {
@@ -7152,6 +9743,7 @@ export namespace Prisma {
     createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     tags?: AdversarialTagUncheckedUpdateManyWithoutResourceNestedInput
     categories?: AdversarialCategoryUncheckedUpdateManyWithoutResourceNestedInput
+    parent?: AdversarialParentUncheckedUpdateOneWithoutResourceNestedInput
   }
 
   export type AdversarialResourceCreateManyInput = {
@@ -7369,6 +9961,134 @@ export namespace Prisma {
     subCategoryId?: StringFieldUpdateOperationsInput | string
   }
 
+  export type AdversarialParentCreateInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    resource: AdversarialResourceCreateNestedOneWithoutParentInput
+    inner?: AdversarialInnerCreateNestedOneWithoutParentInput
+  }
+
+  export type AdversarialParentUncheckedCreateInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    resourceId: string
+    inner?: AdversarialInnerUncheckedCreateNestedOneWithoutParentInput
+  }
+
+  export type AdversarialParentUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    resource?: AdversarialResourceUpdateOneRequiredWithoutParentNestedInput
+    inner?: AdversarialInnerUpdateOneWithoutParentNestedInput
+  }
+
+  export type AdversarialParentUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    resourceId?: StringFieldUpdateOperationsInput | string
+    inner?: AdversarialInnerUncheckedUpdateOneWithoutParentNestedInput
+  }
+
+  export type AdversarialParentCreateManyInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    resourceId: string
+  }
+
+  export type AdversarialParentUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+  }
+
+  export type AdversarialParentUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    resourceId?: StringFieldUpdateOperationsInput | string
+  }
+
+  export type AdversarialInnerCreateInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    parent: AdversarialParentCreateNestedOneWithoutInnerInput
+  }
+
+  export type AdversarialInnerUncheckedCreateInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    parentId: string
+  }
+
+  export type AdversarialInnerUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    parent?: AdversarialParentUpdateOneRequiredWithoutInnerNestedInput
+  }
+
+  export type AdversarialInnerUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    parentId?: StringFieldUpdateOperationsInput | string
+  }
+
+  export type AdversarialInnerCreateManyInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    parentId: string
+  }
+
+  export type AdversarialInnerUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+  }
+
+  export type AdversarialInnerUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    parentId?: StringFieldUpdateOperationsInput | string
+  }
+
   export type StringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[]
@@ -7447,6 +10167,11 @@ export namespace Prisma {
     none?: AdversarialCategoryWhereInput
   }
 
+  export type AdversarialParentNullableScalarRelationFilter = {
+    is?: AdversarialParentWhereInput | null
+    isNot?: AdversarialParentWhereInput | null
+  }
+
   export type SortOrderInput = {
     sort: SortOrder
     nulls?: NullsOrder
@@ -7704,6 +10429,86 @@ export namespace Prisma {
     subCategoryId?: SortOrder
   }
 
+  export type AdversarialInnerNullableScalarRelationFilter = {
+    is?: AdversarialInnerWhereInput | null
+    isNot?: AdversarialInnerWhereInput | null
+  }
+
+  export type AdversarialParentCountOrderByAggregateInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrder
+    resourceId?: SortOrder
+  }
+
+  export type AdversarialParentAvgOrderByAggregateInput = {
+    aNumber?: SortOrder
+  }
+
+  export type AdversarialParentMaxOrderByAggregateInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrder
+    resourceId?: SortOrder
+  }
+
+  export type AdversarialParentMinOrderByAggregateInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrder
+    resourceId?: SortOrder
+  }
+
+  export type AdversarialParentSumOrderByAggregateInput = {
+    aNumber?: SortOrder
+  }
+
+  export type AdversarialParentScalarRelationFilter = {
+    is?: AdversarialParentWhereInput
+    isNot?: AdversarialParentWhereInput
+  }
+
+  export type AdversarialInnerCountOrderByAggregateInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrder
+    parentId?: SortOrder
+  }
+
+  export type AdversarialInnerAvgOrderByAggregateInput = {
+    aNumber?: SortOrder
+  }
+
+  export type AdversarialInnerMaxOrderByAggregateInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrder
+    parentId?: SortOrder
+  }
+
+  export type AdversarialInnerMinOrderByAggregateInput = {
+    id?: SortOrder
+    aBool?: SortOrder
+    aString?: SortOrder
+    aNumber?: SortOrder
+    aOptionalString?: SortOrder
+    parentId?: SortOrder
+  }
+
+  export type AdversarialInnerSumOrderByAggregateInput = {
+    aNumber?: SortOrder
+  }
+
   export type AdversarialTagCreateNestedManyWithoutResourceInput = {
     create?: XOR<AdversarialTagCreateWithoutResourceInput, AdversarialTagUncheckedCreateWithoutResourceInput> | AdversarialTagCreateWithoutResourceInput[] | AdversarialTagUncheckedCreateWithoutResourceInput[]
     connectOrCreate?: AdversarialTagCreateOrConnectWithoutResourceInput | AdversarialTagCreateOrConnectWithoutResourceInput[]
@@ -7718,6 +10523,12 @@ export namespace Prisma {
     connect?: AdversarialCategoryWhereUniqueInput | AdversarialCategoryWhereUniqueInput[]
   }
 
+  export type AdversarialParentCreateNestedOneWithoutResourceInput = {
+    create?: XOR<AdversarialParentCreateWithoutResourceInput, AdversarialParentUncheckedCreateWithoutResourceInput>
+    connectOrCreate?: AdversarialParentCreateOrConnectWithoutResourceInput
+    connect?: AdversarialParentWhereUniqueInput
+  }
+
   export type AdversarialTagUncheckedCreateNestedManyWithoutResourceInput = {
     create?: XOR<AdversarialTagCreateWithoutResourceInput, AdversarialTagUncheckedCreateWithoutResourceInput> | AdversarialTagCreateWithoutResourceInput[] | AdversarialTagUncheckedCreateWithoutResourceInput[]
     connectOrCreate?: AdversarialTagCreateOrConnectWithoutResourceInput | AdversarialTagCreateOrConnectWithoutResourceInput[]
@@ -7732,6 +10543,12 @@ export namespace Prisma {
     connect?: AdversarialCategoryWhereUniqueInput | AdversarialCategoryWhereUniqueInput[]
   }
 
+  export type AdversarialParentUncheckedCreateNestedOneWithoutResourceInput = {
+    create?: XOR<AdversarialParentCreateWithoutResourceInput, AdversarialParentUncheckedCreateWithoutResourceInput>
+    connectOrCreate?: AdversarialParentCreateOrConnectWithoutResourceInput
+    connect?: AdversarialParentWhereUniqueInput
+  }
+
   export type StringFieldUpdateOperationsInput = {
     set?: string
   }
@@ -7792,6 +10609,16 @@ export namespace Prisma {
     deleteMany?: AdversarialCategoryScalarWhereInput | AdversarialCategoryScalarWhereInput[]
   }
 
+  export type AdversarialParentUpdateOneWithoutResourceNestedInput = {
+    create?: XOR<AdversarialParentCreateWithoutResourceInput, AdversarialParentUncheckedCreateWithoutResourceInput>
+    connectOrCreate?: AdversarialParentCreateOrConnectWithoutResourceInput
+    upsert?: AdversarialParentUpsertWithoutResourceInput
+    disconnect?: AdversarialParentWhereInput | boolean
+    delete?: AdversarialParentWhereInput | boolean
+    connect?: AdversarialParentWhereUniqueInput
+    update?: XOR<XOR<AdversarialParentUpdateToOneWithWhereWithoutResourceInput, AdversarialParentUpdateWithoutResourceInput>, AdversarialParentUncheckedUpdateWithoutResourceInput>
+  }
+
   export type AdversarialTagUncheckedUpdateManyWithoutResourceNestedInput = {
     create?: XOR<AdversarialTagCreateWithoutResourceInput, AdversarialTagUncheckedCreateWithoutResourceInput> | AdversarialTagCreateWithoutResourceInput[] | AdversarialTagUncheckedCreateWithoutResourceInput[]
     connectOrCreate?: AdversarialTagCreateOrConnectWithoutResourceInput | AdversarialTagCreateOrConnectWithoutResourceInput[]
@@ -7820,6 +10647,16 @@ export namespace Prisma {
     deleteMany?: AdversarialCategoryScalarWhereInput | AdversarialCategoryScalarWhereInput[]
   }
 
+  export type AdversarialParentUncheckedUpdateOneWithoutResourceNestedInput = {
+    create?: XOR<AdversarialParentCreateWithoutResourceInput, AdversarialParentUncheckedCreateWithoutResourceInput>
+    connectOrCreate?: AdversarialParentCreateOrConnectWithoutResourceInput
+    upsert?: AdversarialParentUpsertWithoutResourceInput
+    disconnect?: AdversarialParentWhereInput | boolean
+    delete?: AdversarialParentWhereInput | boolean
+    connect?: AdversarialParentWhereUniqueInput
+    update?: XOR<XOR<AdversarialParentUpdateToOneWithWhereWithoutResourceInput, AdversarialParentUpdateWithoutResourceInput>, AdversarialParentUncheckedUpdateWithoutResourceInput>
+  }
+
   export type AdversarialResourceCreateNestedOneWithoutTagsInput = {
     create?: XOR<AdversarialResourceCreateWithoutTagsInput, AdversarialResourceUncheckedCreateWithoutTagsInput>
     connectOrCreate?: AdversarialResourceCreateOrConnectWithoutTagsInput
@@ -7960,6 +10797,66 @@ export namespace Prisma {
     update?: XOR<XOR<AdversarialSubCategoryUpdateToOneWithWhereWithoutLabelsInput, AdversarialSubCategoryUpdateWithoutLabelsInput>, AdversarialSubCategoryUncheckedUpdateWithoutLabelsInput>
   }
 
+  export type AdversarialResourceCreateNestedOneWithoutParentInput = {
+    create?: XOR<AdversarialResourceCreateWithoutParentInput, AdversarialResourceUncheckedCreateWithoutParentInput>
+    connectOrCreate?: AdversarialResourceCreateOrConnectWithoutParentInput
+    connect?: AdversarialResourceWhereUniqueInput
+  }
+
+  export type AdversarialInnerCreateNestedOneWithoutParentInput = {
+    create?: XOR<AdversarialInnerCreateWithoutParentInput, AdversarialInnerUncheckedCreateWithoutParentInput>
+    connectOrCreate?: AdversarialInnerCreateOrConnectWithoutParentInput
+    connect?: AdversarialInnerWhereUniqueInput
+  }
+
+  export type AdversarialInnerUncheckedCreateNestedOneWithoutParentInput = {
+    create?: XOR<AdversarialInnerCreateWithoutParentInput, AdversarialInnerUncheckedCreateWithoutParentInput>
+    connectOrCreate?: AdversarialInnerCreateOrConnectWithoutParentInput
+    connect?: AdversarialInnerWhereUniqueInput
+  }
+
+  export type AdversarialResourceUpdateOneRequiredWithoutParentNestedInput = {
+    create?: XOR<AdversarialResourceCreateWithoutParentInput, AdversarialResourceUncheckedCreateWithoutParentInput>
+    connectOrCreate?: AdversarialResourceCreateOrConnectWithoutParentInput
+    upsert?: AdversarialResourceUpsertWithoutParentInput
+    connect?: AdversarialResourceWhereUniqueInput
+    update?: XOR<XOR<AdversarialResourceUpdateToOneWithWhereWithoutParentInput, AdversarialResourceUpdateWithoutParentInput>, AdversarialResourceUncheckedUpdateWithoutParentInput>
+  }
+
+  export type AdversarialInnerUpdateOneWithoutParentNestedInput = {
+    create?: XOR<AdversarialInnerCreateWithoutParentInput, AdversarialInnerUncheckedCreateWithoutParentInput>
+    connectOrCreate?: AdversarialInnerCreateOrConnectWithoutParentInput
+    upsert?: AdversarialInnerUpsertWithoutParentInput
+    disconnect?: AdversarialInnerWhereInput | boolean
+    delete?: AdversarialInnerWhereInput | boolean
+    connect?: AdversarialInnerWhereUniqueInput
+    update?: XOR<XOR<AdversarialInnerUpdateToOneWithWhereWithoutParentInput, AdversarialInnerUpdateWithoutParentInput>, AdversarialInnerUncheckedUpdateWithoutParentInput>
+  }
+
+  export type AdversarialInnerUncheckedUpdateOneWithoutParentNestedInput = {
+    create?: XOR<AdversarialInnerCreateWithoutParentInput, AdversarialInnerUncheckedCreateWithoutParentInput>
+    connectOrCreate?: AdversarialInnerCreateOrConnectWithoutParentInput
+    upsert?: AdversarialInnerUpsertWithoutParentInput
+    disconnect?: AdversarialInnerWhereInput | boolean
+    delete?: AdversarialInnerWhereInput | boolean
+    connect?: AdversarialInnerWhereUniqueInput
+    update?: XOR<XOR<AdversarialInnerUpdateToOneWithWhereWithoutParentInput, AdversarialInnerUpdateWithoutParentInput>, AdversarialInnerUncheckedUpdateWithoutParentInput>
+  }
+
+  export type AdversarialParentCreateNestedOneWithoutInnerInput = {
+    create?: XOR<AdversarialParentCreateWithoutInnerInput, AdversarialParentUncheckedCreateWithoutInnerInput>
+    connectOrCreate?: AdversarialParentCreateOrConnectWithoutInnerInput
+    connect?: AdversarialParentWhereUniqueInput
+  }
+
+  export type AdversarialParentUpdateOneRequiredWithoutInnerNestedInput = {
+    create?: XOR<AdversarialParentCreateWithoutInnerInput, AdversarialParentUncheckedCreateWithoutInnerInput>
+    connectOrCreate?: AdversarialParentCreateOrConnectWithoutInnerInput
+    upsert?: AdversarialParentUpsertWithoutInnerInput
+    connect?: AdversarialParentWhereUniqueInput
+    update?: XOR<XOR<AdversarialParentUpdateToOneWithWhereWithoutInnerInput, AdversarialParentUpdateWithoutInnerInput>, AdversarialParentUncheckedUpdateWithoutInnerInput>
+  }
+
   export type NestedStringFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[]
@@ -8178,6 +11075,29 @@ export namespace Prisma {
     data: AdversarialCategoryCreateManyResourceInput | AdversarialCategoryCreateManyResourceInput[]
   }
 
+  export type AdversarialParentCreateWithoutResourceInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    inner?: AdversarialInnerCreateNestedOneWithoutParentInput
+  }
+
+  export type AdversarialParentUncheckedCreateWithoutResourceInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    inner?: AdversarialInnerUncheckedCreateNestedOneWithoutParentInput
+  }
+
+  export type AdversarialParentCreateOrConnectWithoutResourceInput = {
+    where: AdversarialParentWhereUniqueInput
+    create: XOR<AdversarialParentCreateWithoutResourceInput, AdversarialParentUncheckedCreateWithoutResourceInput>
+  }
+
   export type AdversarialTagUpsertWithWhereUniqueWithoutResourceInput = {
     where: AdversarialTagWhereUniqueInput
     update: XOR<AdversarialTagUpdateWithoutResourceInput, AdversarialTagUncheckedUpdateWithoutResourceInput>
@@ -8229,6 +11149,35 @@ export namespace Prisma {
     resourceId?: StringFilter<"AdversarialCategory"> | string
   }
 
+  export type AdversarialParentUpsertWithoutResourceInput = {
+    update: XOR<AdversarialParentUpdateWithoutResourceInput, AdversarialParentUncheckedUpdateWithoutResourceInput>
+    create: XOR<AdversarialParentCreateWithoutResourceInput, AdversarialParentUncheckedCreateWithoutResourceInput>
+    where?: AdversarialParentWhereInput
+  }
+
+  export type AdversarialParentUpdateToOneWithWhereWithoutResourceInput = {
+    where?: AdversarialParentWhereInput
+    data: XOR<AdversarialParentUpdateWithoutResourceInput, AdversarialParentUncheckedUpdateWithoutResourceInput>
+  }
+
+  export type AdversarialParentUpdateWithoutResourceInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    inner?: AdversarialInnerUpdateOneWithoutParentNestedInput
+  }
+
+  export type AdversarialParentUncheckedUpdateWithoutResourceInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    inner?: AdversarialInnerUncheckedUpdateOneWithoutParentNestedInput
+  }
+
   export type AdversarialResourceCreateWithoutTagsInput = {
     id: string
     aBool: boolean
@@ -8240,6 +11189,7 @@ export namespace Prisma {
     scope?: string | null
     createdAt?: Date | string | null
     categories?: AdversarialCategoryCreateNestedManyWithoutResourceInput
+    parent?: AdversarialParentCreateNestedOneWithoutResourceInput
   }
 
   export type AdversarialResourceUncheckedCreateWithoutTagsInput = {
@@ -8253,6 +11203,7 @@ export namespace Prisma {
     scope?: string | null
     createdAt?: Date | string | null
     categories?: AdversarialCategoryUncheckedCreateNestedManyWithoutResourceInput
+    parent?: AdversarialParentUncheckedCreateNestedOneWithoutResourceInput
   }
 
   export type AdversarialResourceCreateOrConnectWithoutTagsInput = {
@@ -8282,6 +11233,7 @@ export namespace Prisma {
     scope?: NullableStringFieldUpdateOperationsInput | string | null
     createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     categories?: AdversarialCategoryUpdateManyWithoutResourceNestedInput
+    parent?: AdversarialParentUpdateOneWithoutResourceNestedInput
   }
 
   export type AdversarialResourceUncheckedUpdateWithoutTagsInput = {
@@ -8295,6 +11247,7 @@ export namespace Prisma {
     scope?: NullableStringFieldUpdateOperationsInput | string | null
     createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     categories?: AdversarialCategoryUncheckedUpdateManyWithoutResourceNestedInput
+    parent?: AdversarialParentUncheckedUpdateOneWithoutResourceNestedInput
   }
 
   export type AdversarialResourceCreateWithoutCategoriesInput = {
@@ -8308,6 +11261,7 @@ export namespace Prisma {
     scope?: string | null
     createdAt?: Date | string | null
     tags?: AdversarialTagCreateNestedManyWithoutResourceInput
+    parent?: AdversarialParentCreateNestedOneWithoutResourceInput
   }
 
   export type AdversarialResourceUncheckedCreateWithoutCategoriesInput = {
@@ -8321,6 +11275,7 @@ export namespace Prisma {
     scope?: string | null
     createdAt?: Date | string | null
     tags?: AdversarialTagUncheckedCreateNestedManyWithoutResourceInput
+    parent?: AdversarialParentUncheckedCreateNestedOneWithoutResourceInput
   }
 
   export type AdversarialResourceCreateOrConnectWithoutCategoriesInput = {
@@ -8371,6 +11326,7 @@ export namespace Prisma {
     scope?: NullableStringFieldUpdateOperationsInput | string | null
     createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     tags?: AdversarialTagUpdateManyWithoutResourceNestedInput
+    parent?: AdversarialParentUpdateOneWithoutResourceNestedInput
   }
 
   export type AdversarialResourceUncheckedUpdateWithoutCategoriesInput = {
@@ -8384,6 +11340,7 @@ export namespace Prisma {
     scope?: NullableStringFieldUpdateOperationsInput | string | null
     createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
     tags?: AdversarialTagUncheckedUpdateManyWithoutResourceNestedInput
+    parent?: AdversarialParentUncheckedUpdateOneWithoutResourceNestedInput
   }
 
   export type AdversarialSubCategoryUpsertWithWhereUniqueWithoutCategoryInput = {
@@ -8535,6 +11492,178 @@ export namespace Prisma {
     categoryId?: StringFieldUpdateOperationsInput | string
   }
 
+  export type AdversarialResourceCreateWithoutParentInput = {
+    id: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aDouble?: number | null
+    aOptionalString?: string | null
+    createdBy: string
+    scope?: string | null
+    createdAt?: Date | string | null
+    tags?: AdversarialTagCreateNestedManyWithoutResourceInput
+    categories?: AdversarialCategoryCreateNestedManyWithoutResourceInput
+  }
+
+  export type AdversarialResourceUncheckedCreateWithoutParentInput = {
+    id: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aDouble?: number | null
+    aOptionalString?: string | null
+    createdBy: string
+    scope?: string | null
+    createdAt?: Date | string | null
+    tags?: AdversarialTagUncheckedCreateNestedManyWithoutResourceInput
+    categories?: AdversarialCategoryUncheckedCreateNestedManyWithoutResourceInput
+  }
+
+  export type AdversarialResourceCreateOrConnectWithoutParentInput = {
+    where: AdversarialResourceWhereUniqueInput
+    create: XOR<AdversarialResourceCreateWithoutParentInput, AdversarialResourceUncheckedCreateWithoutParentInput>
+  }
+
+  export type AdversarialInnerCreateWithoutParentInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+  }
+
+  export type AdversarialInnerUncheckedCreateWithoutParentInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+  }
+
+  export type AdversarialInnerCreateOrConnectWithoutParentInput = {
+    where: AdversarialInnerWhereUniqueInput
+    create: XOR<AdversarialInnerCreateWithoutParentInput, AdversarialInnerUncheckedCreateWithoutParentInput>
+  }
+
+  export type AdversarialResourceUpsertWithoutParentInput = {
+    update: XOR<AdversarialResourceUpdateWithoutParentInput, AdversarialResourceUncheckedUpdateWithoutParentInput>
+    create: XOR<AdversarialResourceCreateWithoutParentInput, AdversarialResourceUncheckedCreateWithoutParentInput>
+    where?: AdversarialResourceWhereInput
+  }
+
+  export type AdversarialResourceUpdateToOneWithWhereWithoutParentInput = {
+    where?: AdversarialResourceWhereInput
+    data: XOR<AdversarialResourceUpdateWithoutParentInput, AdversarialResourceUncheckedUpdateWithoutParentInput>
+  }
+
+  export type AdversarialResourceUpdateWithoutParentInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aDouble?: NullableFloatFieldUpdateOperationsInput | number | null
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    createdBy?: StringFieldUpdateOperationsInput | string
+    scope?: NullableStringFieldUpdateOperationsInput | string | null
+    createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+    tags?: AdversarialTagUpdateManyWithoutResourceNestedInput
+    categories?: AdversarialCategoryUpdateManyWithoutResourceNestedInput
+  }
+
+  export type AdversarialResourceUncheckedUpdateWithoutParentInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aDouble?: NullableFloatFieldUpdateOperationsInput | number | null
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    createdBy?: StringFieldUpdateOperationsInput | string
+    scope?: NullableStringFieldUpdateOperationsInput | string | null
+    createdAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+    tags?: AdversarialTagUncheckedUpdateManyWithoutResourceNestedInput
+    categories?: AdversarialCategoryUncheckedUpdateManyWithoutResourceNestedInput
+  }
+
+  export type AdversarialInnerUpsertWithoutParentInput = {
+    update: XOR<AdversarialInnerUpdateWithoutParentInput, AdversarialInnerUncheckedUpdateWithoutParentInput>
+    create: XOR<AdversarialInnerCreateWithoutParentInput, AdversarialInnerUncheckedCreateWithoutParentInput>
+    where?: AdversarialInnerWhereInput
+  }
+
+  export type AdversarialInnerUpdateToOneWithWhereWithoutParentInput = {
+    where?: AdversarialInnerWhereInput
+    data: XOR<AdversarialInnerUpdateWithoutParentInput, AdversarialInnerUncheckedUpdateWithoutParentInput>
+  }
+
+  export type AdversarialInnerUpdateWithoutParentInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+  }
+
+  export type AdversarialInnerUncheckedUpdateWithoutParentInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+  }
+
+  export type AdversarialParentCreateWithoutInnerInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    resource: AdversarialResourceCreateNestedOneWithoutParentInput
+  }
+
+  export type AdversarialParentUncheckedCreateWithoutInnerInput = {
+    id?: string
+    aBool: boolean
+    aString: string
+    aNumber: number
+    aOptionalString?: string | null
+    resourceId: string
+  }
+
+  export type AdversarialParentCreateOrConnectWithoutInnerInput = {
+    where: AdversarialParentWhereUniqueInput
+    create: XOR<AdversarialParentCreateWithoutInnerInput, AdversarialParentUncheckedCreateWithoutInnerInput>
+  }
+
+  export type AdversarialParentUpsertWithoutInnerInput = {
+    update: XOR<AdversarialParentUpdateWithoutInnerInput, AdversarialParentUncheckedUpdateWithoutInnerInput>
+    create: XOR<AdversarialParentCreateWithoutInnerInput, AdversarialParentUncheckedCreateWithoutInnerInput>
+    where?: AdversarialParentWhereInput
+  }
+
+  export type AdversarialParentUpdateToOneWithWhereWithoutInnerInput = {
+    where?: AdversarialParentWhereInput
+    data: XOR<AdversarialParentUpdateWithoutInnerInput, AdversarialParentUncheckedUpdateWithoutInnerInput>
+  }
+
+  export type AdversarialParentUpdateWithoutInnerInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    resource?: AdversarialResourceUpdateOneRequiredWithoutParentNestedInput
+  }
+
+  export type AdversarialParentUncheckedUpdateWithoutInnerInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    aBool?: BoolFieldUpdateOperationsInput | boolean
+    aString?: StringFieldUpdateOperationsInput | string
+    aNumber?: IntFieldUpdateOperationsInput | number
+    aOptionalString?: NullableStringFieldUpdateOperationsInput | string | null
+    resourceId?: StringFieldUpdateOperationsInput | string
+  }
+
   export type AdversarialTagCreateManyResourceInput = {
     id?: string
     tagId: string