initial commit

node_modules/prisma/prisma-client/README.md

@@ -0,0 +1,27 @@
+# Prisma Client · [![npm version](https://img.shields.io/npm/v/@prisma/client.svg?style=flat)](https://www.npmjs.com/package/@prisma/client) [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/prisma/prisma/blob/main/CONTRIBUTING.md) [![GitHub license](https://img.shields.io/badge/license-Apache%202-blue)](https://github.com/prisma/prisma/blob/main/LICENSE) [![Slack](https://img.shields.io/badge/chat-on%20slack-blue.svg)](https://slack.prisma.io/)
+
+Prisma Client JS is an **auto-generated query builder** that enables **type-safe** database access and **reduces boilerplate**. You can use it as an alternative to traditional ORMs such as Sequelize, TypeORM or SQL query builders like knex.js.
+
+It is part of the [Prisma](https://www.prisma.io/) ecosystem. Prisma provides database tools for data access, declarative data modeling, schema migrations and visual data management. Learn more in the main [`prisma`](https://github.com/prisma/prisma/) repository or read the [documentation](https://www.prisma.io/docs/).
+
+## Getting started
+
+Follow one of these guides to get started with Prisma Client JS:
+
+- [Quickstart](https://www.prisma.io/docs/getting-started/quickstart) (5 min)
+- [Set up a new project with Prisma (SQL migrations)](https://www.prisma.io/docs/getting-started/setup-prisma/start-from-scratch-sql) (15 min)
+- [Set up a new project with Prisma (Prisma Migrate)](https://www.prisma.io/docs/getting-started/setup-prisma/start-from-scratch-prisma-migrate) (15 min)
+- [Add Prisma to an existing project](https://www.prisma.io/docs/getting-started/setup-prisma/add-to-existing-project) (15 min)
+
+Alternatively you can explore the ready-to-run [examples](https://github.com/prisma/prisma-examples/) (REST, GraphQL, gRPC, plain JavaScript and TypeScript demos, ...) or watch the [demo videos](https://www.youtube.com/watch?v=0RhtQgIs-TE&list=PLn2e1F9Rfr6k9PnR_figWOcSHgc_erDr5&index=1) (1-2 min per video).
+
+## Contributing
+
+Refer to our [contribution guidelines](https://github.com/prisma/prisma/blob/main/CONTRIBUTING.md) and [Code of Conduct for contributors](https://github.com/prisma/prisma/blob/main/CODE_OF_CONDUCT.md).
+
+## Build Status
+
+- Prisma Tests Status:  
+  [![Build status](https://badge.buildkite.com/590e1981074b70961362481ad8319a831b44a38c5d468d6408.svg?branch=master)](https://buildkite.com/prisma/prisma2-test)
+- Ecosystem Tests Status:  
+  [![Actions Status](https://github.com/prisma/ecosystem-tests/workflows/test/badge.svg)](https://github.com/prisma/ecosystem-tests/actions)

node_modules/prisma/prisma-client/edge.d.ts

@@ -0,0 +1 @@
+export * from '.prisma/client'

node_modules/prisma/prisma-client/edge.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('.prisma/client/edge'),
+}

node_modules/prisma/prisma-client/index-browser.js

@@ -0,0 +1,3 @@
+const prisma = require('.prisma/client/index-browser')
+
+module.exports = prisma

node_modules/prisma/prisma-client/index.d.ts

@@ -0,0 +1 @@
+export * from '.prisma/client'

node_modules/prisma/prisma-client/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('.prisma/client/index'),
+}

node_modules/prisma/prisma-client/runtime/index-browser.d.ts

@@ -0,0 +1,323 @@
+declare class AnyNull extends NullTypesEnumValue {
+}
+
+declare class DbNull extends NullTypesEnumValue {
+}
+
+export declare namespace Decimal {
+    export type Constructor = typeof Decimal;
+    export type Instance = Decimal;
+    export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+    export type Modulo = Rounding | 9;
+    export type Value = string | number | Decimal;
+
+    // http://mikemcl.github.io/decimal.js/#constructor-properties
+    export interface Config {
+        precision?: number;
+        rounding?: Rounding;
+        toExpNeg?: number;
+        toExpPos?: number;
+        minE?: number;
+        maxE?: number;
+        crypto?: boolean;
+        modulo?: Modulo;
+        defaults?: boolean;
+    }
+}
+
+export declare class Decimal {
+    readonly d: number[];
+    readonly e: number;
+    readonly s: number;
+    private readonly toStringTag: string;
+
+    constructor(n: Decimal.Value);
+
+    absoluteValue(): Decimal;
+    abs(): Decimal;
+
+    ceil(): Decimal;
+
+    clampedTo(min: Decimal.Value, max: Decimal.Value): Decimal;
+    clamp(min: Decimal.Value, max: Decimal.Value): Decimal;
+
+    comparedTo(n: Decimal.Value): number;
+    cmp(n: Decimal.Value): number;
+
+    cosine(): Decimal;
+    cos(): Decimal;
+
+    cubeRoot(): Decimal;
+    cbrt(): Decimal;
+
+    decimalPlaces(): number;
+    dp(): number;
+
+    dividedBy(n: Decimal.Value): Decimal;
+    div(n: Decimal.Value): Decimal;
+
+    dividedToIntegerBy(n: Decimal.Value): Decimal;
+    divToInt(n: Decimal.Value): Decimal;
+
+    equals(n: Decimal.Value): boolean;
+    eq(n: Decimal.Value): boolean;
+
+    floor(): Decimal;
+
+    greaterThan(n: Decimal.Value): boolean;
+    gt(n: Decimal.Value): boolean;
+
+    greaterThanOrEqualTo(n: Decimal.Value): boolean;
+    gte(n: Decimal.Value): boolean;
+
+    hyperbolicCosine(): Decimal;
+    cosh(): Decimal;
+
+    hyperbolicSine(): Decimal;
+    sinh(): Decimal;
+
+    hyperbolicTangent(): Decimal;
+    tanh(): Decimal;
+
+    inverseCosine(): Decimal;
+    acos(): Decimal;
+
+    inverseHyperbolicCosine(): Decimal;
+    acosh(): Decimal;
+
+    inverseHyperbolicSine(): Decimal;
+    asinh(): Decimal;
+
+    inverseHyperbolicTangent(): Decimal;
+    atanh(): Decimal;
+
+    inverseSine(): Decimal;
+    asin(): Decimal;
+
+    inverseTangent(): Decimal;
+    atan(): Decimal;
+
+    isFinite(): boolean;
+
+    isInteger(): boolean;
+    isInt(): boolean;
+
+    isNaN(): boolean;
+
+    isNegative(): boolean;
+    isNeg(): boolean;
+
+    isPositive(): boolean;
+    isPos(): boolean;
+
+    isZero(): boolean;
+
+    lessThan(n: Decimal.Value): boolean;
+    lt(n: Decimal.Value): boolean;
+
+    lessThanOrEqualTo(n: Decimal.Value): boolean;
+    lte(n: Decimal.Value): boolean;
+
+    logarithm(n?: Decimal.Value): Decimal;
+    log(n?: Decimal.Value): Decimal;
+
+    minus(n: Decimal.Value): Decimal;
+    sub(n: Decimal.Value): Decimal;
+
+    modulo(n: Decimal.Value): Decimal;
+    mod(n: Decimal.Value): Decimal;
+
+    naturalExponential(): Decimal;
+    exp(): Decimal;
+
+    naturalLogarithm(): Decimal;
+    ln(): Decimal;
+
+    negated(): Decimal;
+    neg(): Decimal;
+
+    plus(n: Decimal.Value): Decimal;
+    add(n: Decimal.Value): Decimal;
+
+    precision(includeZeros?: boolean): number;
+    sd(includeZeros?: boolean): number;
+
+    round(): Decimal;
+
+    sine() : Decimal;
+    sin() : Decimal;
+
+    squareRoot(): Decimal;
+    sqrt(): Decimal;
+
+    tangent() : Decimal;
+    tan() : Decimal;
+
+    times(n: Decimal.Value): Decimal;
+    mul(n: Decimal.Value) : Decimal;
+
+    toBinary(significantDigits?: number): string;
+    toBinary(significantDigits: number, rounding: Decimal.Rounding): string;
+
+    toDecimalPlaces(decimalPlaces?: number): Decimal;
+    toDecimalPlaces(decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+    toDP(decimalPlaces?: number): Decimal;
+    toDP(decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
+
+    toExponential(decimalPlaces?: number): string;
+    toExponential(decimalPlaces: number, rounding: Decimal.Rounding): string;
+
+    toFixed(decimalPlaces?: number): string;
+    toFixed(decimalPlaces: number, rounding: Decimal.Rounding): string;
+
+    toFraction(max_denominator?: Decimal.Value): Decimal[];
+
+    toHexadecimal(significantDigits?: number): string;
+    toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): string;
+    toHex(significantDigits?: number): string;
+    toHex(significantDigits: number, rounding?: Decimal.Rounding): string;
+
+    toJSON(): string;
+
+    toNearest(n: Decimal.Value, rounding?: Decimal.Rounding): Decimal;
+
+    toNumber(): number;
+
+    toOctal(significantDigits?: number): string;
+    toOctal(significantDigits: number, rounding: Decimal.Rounding): string;
+
+    toPower(n: Decimal.Value): Decimal;
+    pow(n: Decimal.Value): Decimal;
+
+    toPrecision(significantDigits?: number): string;
+    toPrecision(significantDigits: number, rounding: Decimal.Rounding): string;
+
+    toSignificantDigits(significantDigits?: number): Decimal;
+    toSignificantDigits(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+    toSD(significantDigits?: number): Decimal;
+    toSD(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+
+    toString(): string;
+
+    truncated(): Decimal;
+    trunc(): Decimal;
+
+    valueOf(): string;
+
+    static abs(n: Decimal.Value): Decimal;
+    static acos(n: Decimal.Value): Decimal;
+    static acosh(n: Decimal.Value): Decimal;
+    static add(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static asin(n: Decimal.Value): Decimal;
+    static asinh(n: Decimal.Value): Decimal;
+    static atan(n: Decimal.Value): Decimal;
+    static atanh(n: Decimal.Value): Decimal;
+    static atan2(y: Decimal.Value, x: Decimal.Value): Decimal;
+    static cbrt(n: Decimal.Value): Decimal;
+    static ceil(n: Decimal.Value): Decimal;
+    static clamp(n: Decimal.Value, min: Decimal.Value, max: Decimal.Value): Decimal;
+    static clone(object?: Decimal.Config): Decimal.Constructor;
+    static config(object: Decimal.Config): Decimal.Constructor;
+    static cos(n: Decimal.Value): Decimal;
+    static cosh(n: Decimal.Value): Decimal;
+    static div(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static exp(n: Decimal.Value): Decimal;
+    static floor(n: Decimal.Value): Decimal;
+    static hypot(...n: Decimal.Value[]): Decimal;
+    static isDecimal(object: any): object is Decimal;
+    static ln(n: Decimal.Value): Decimal;
+    static log(n: Decimal.Value, base?: Decimal.Value): Decimal;
+    static log2(n: Decimal.Value): Decimal;
+    static log10(n: Decimal.Value): Decimal;
+    static max(...n: Decimal.Value[]): Decimal;
+    static min(...n: Decimal.Value[]): Decimal;
+    static mod(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static mul(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static noConflict(): Decimal.Constructor;   // Browser only
+    static pow(base: Decimal.Value, exponent: Decimal.Value): Decimal;
+    static random(significantDigits?: number): Decimal;
+    static round(n: Decimal.Value): Decimal;
+    static set(object: Decimal.Config): Decimal.Constructor;
+    static sign(n: Decimal.Value): number;
+    static sin(n: Decimal.Value): Decimal;
+    static sinh(n: Decimal.Value): Decimal;
+    static sqrt(n: Decimal.Value): Decimal;
+    static sub(x: Decimal.Value, y: Decimal.Value): Decimal;
+    static sum(...n: Decimal.Value[]): Decimal;
+    static tan(n: Decimal.Value): Decimal;
+    static tanh(n: Decimal.Value): Decimal;
+    static trunc(n: Decimal.Value): Decimal;
+
+    static readonly default?: Decimal.Constructor;
+    static readonly Decimal?: Decimal.Constructor;
+
+    static readonly precision: number;
+    static readonly rounding: Decimal.Rounding;
+    static readonly toExpNeg: number;
+    static readonly toExpPos: number;
+    static readonly minE: number;
+    static readonly maxE: number;
+    static readonly crypto: boolean;
+    static readonly modulo: Decimal.Modulo;
+
+    static readonly ROUND_UP: 0;
+    static readonly ROUND_DOWN: 1;
+    static readonly ROUND_CEIL: 2;
+    static readonly ROUND_FLOOR: 3;
+    static readonly ROUND_HALF_UP: 4;
+    static readonly ROUND_HALF_DOWN: 5;
+    static readonly ROUND_HALF_EVEN: 6;
+    static readonly ROUND_HALF_CEIL: 7;
+    static readonly ROUND_HALF_FLOOR: 8;
+    static readonly EUCLID: 9;
+}
+
+declare class JsonNull extends NullTypesEnumValue {
+}
+
+/**
+ * Generates more strict variant of an enum which, unlike regular enum,
+ * throws on non-existing property access. This can be useful in following situations:
+ * - we have an API, that accepts both `undefined` and `SomeEnumType` as an input
+ * - enum values are generated dynamically from DMMF.
+ *
+ * In that case, if using normal enums and no compile-time typechecking, using non-existing property
+ * will result in `undefined` value being used, which will be accepted. Using strict enum
+ * in this case will help to have a runtime exception, telling you that you are probably doing something wrong.
+ *
+ * Note: if you need to check for existence of a value in the enum you can still use either
+ * `in` operator or `hasOwnProperty` function.
+ *
+ * @param definition
+ * @returns
+ */
+export declare function makeStrictEnum<T extends Record<PropertyKey, string | number>>(definition: T): T;
+
+declare class NullTypesEnumValue extends ObjectEnumValue {
+    _getNamespace(): string;
+}
+
+/**
+ * Base class for unique values of object-valued enums.
+ */
+declare abstract class ObjectEnumValue {
+    constructor(arg?: symbol);
+    abstract _getNamespace(): string;
+    _getName(): string;
+    toString(): string;
+}
+
+export declare const objectEnumValues: {
+    classes: {
+        DbNull: typeof DbNull;
+        JsonNull: typeof JsonNull;
+        AnyNull: typeof AnyNull;
+    };
+    instances: {
+        DbNull: DbNull;
+        JsonNull: JsonNull;
+        AnyNull: AnyNull;
+    };
+};
+
+export { }

node_modules/prisma/prisma-client/scripts/colors.js

@@ -0,0 +1,176 @@
+'use strict'
+
+const isObject = (val) => val !== null && typeof val === 'object' && !Array.isArray(val)
+
+// this is a modified version of https://github.com/chalk/ansi-regex (MIT License)
+const ANSI_REGEX =
+  /* eslint-disable-next-line no-control-regex */
+  /[\u001b\u009b][[\]#;?()]*(?:(?:(?:[^\W_]*;?[^\W_]*)\u0007)|(?:(?:[0-9]{1,4}(;[0-9]{0,4})*)?[~0-9=<>cf-nqrtyA-PRZ]))/g
+
+const create = () => {
+  const colors = { enabled: true, visible: true, styles: {}, keys: {} }
+
+  if ('FORCE_COLOR' in process.env) {
+    colors.enabled = process.env.FORCE_COLOR !== '0'
+  }
+
+  const ansi = (style) => {
+    let open = (style.open = `\u001b[${style.codes[0]}m`)
+    let close = (style.close = `\u001b[${style.codes[1]}m`)
+    let regex = (style.regex = new RegExp(`\\u001b\\[${style.codes[1]}m`, 'g'))
+    style.wrap = (input, newline) => {
+      if (input.includes(close)) input = input.replace(regex, close + open)
+      let output = open + input + close
+      // see https://github.com/chalk/chalk/pull/92, thanks to the
+      // chalk contributors for this fix. However, we've confirmed that
+      // this issue is also present in Windows terminals
+      return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output
+    }
+    return style
+  }
+
+  const wrap = (style, input, newline) => {
+    return typeof style === 'function' ? style(input) : style.wrap(input, newline)
+  }
+
+  const style = (input, stack) => {
+    if (input === '' || input == null) return ''
+    if (colors.enabled === false) return input
+    if (colors.visible === false) return ''
+    let str = '' + input
+    let nl = str.includes('\n')
+    let n = stack.length
+    if (n > 0 && stack.includes('unstyle')) {
+      stack = [...new Set(['unstyle', ...stack])].reverse()
+    }
+    while (n-- > 0) str = wrap(colors.styles[stack[n]], str, nl)
+    return str
+  }
+
+  const define = (name, codes, type) => {
+    colors.styles[name] = ansi({ name, codes })
+    let keys = colors.keys[type] || (colors.keys[type] = [])
+    keys.push(name)
+
+    Reflect.defineProperty(colors, name, {
+      configurable: true,
+      enumerable: true,
+      set(value) {
+        colors.alias(name, value)
+      },
+      get() {
+        let color = (input) => style(input, color.stack)
+        Reflect.setPrototypeOf(color, colors)
+        color.stack = this.stack ? this.stack.concat(name) : [name]
+        return color
+      },
+    })
+  }
+
+  define('reset', [0, 0], 'modifier')
+  define('bold', [1, 22], 'modifier')
+  define('dim', [2, 22], 'modifier')
+  define('italic', [3, 23], 'modifier')
+  define('underline', [4, 24], 'modifier')
+  define('inverse', [7, 27], 'modifier')
+  define('hidden', [8, 28], 'modifier')
+  define('strikethrough', [9, 29], 'modifier')
+
+  define('black', [30, 39], 'color')
+  define('red', [31, 39], 'color')
+  define('green', [32, 39], 'color')
+  define('yellow', [33, 39], 'color')
+  define('blue', [34, 39], 'color')
+  define('magenta', [35, 39], 'color')
+  define('cyan', [36, 39], 'color')
+  define('white', [37, 39], 'color')
+  define('gray', [90, 39], 'color')
+  define('grey', [90, 39], 'color')
+
+  define('bgBlack', [40, 49], 'bg')
+  define('bgRed', [41, 49], 'bg')
+  define('bgGreen', [42, 49], 'bg')
+  define('bgYellow', [43, 49], 'bg')
+  define('bgBlue', [44, 49], 'bg')
+  define('bgMagenta', [45, 49], 'bg')
+  define('bgCyan', [46, 49], 'bg')
+  define('bgWhite', [47, 49], 'bg')
+
+  define('blackBright', [90, 39], 'bright')
+  define('redBright', [91, 39], 'bright')
+  define('greenBright', [92, 39], 'bright')
+  define('yellowBright', [93, 39], 'bright')
+  define('blueBright', [94, 39], 'bright')
+  define('magentaBright', [95, 39], 'bright')
+  define('cyanBright', [96, 39], 'bright')
+  define('whiteBright', [97, 39], 'bright')
+
+  define('bgBlackBright', [100, 49], 'bgBright')
+  define('bgRedBright', [101, 49], 'bgBright')
+  define('bgGreenBright', [102, 49], 'bgBright')
+  define('bgYellowBright', [103, 49], 'bgBright')
+  define('bgBlueBright', [104, 49], 'bgBright')
+  define('bgMagentaBright', [105, 49], 'bgBright')
+  define('bgCyanBright', [106, 49], 'bgBright')
+  define('bgWhiteBright', [107, 49], 'bgBright')
+
+  colors.ansiRegex = ANSI_REGEX
+  colors.hasColor = colors.hasAnsi = (str) => {
+    colors.ansiRegex.lastIndex = 0
+    return typeof str === 'string' && str !== '' && colors.ansiRegex.test(str)
+  }
+
+  colors.alias = (name, color) => {
+    let fn = typeof color === 'string' ? colors[color] : color
+
+    if (typeof fn !== 'function') {
+      throw new TypeError('Expected alias to be the name of an existing color (string) or a function')
+    }
+
+    if (!fn.stack) {
+      Reflect.defineProperty(fn, 'name', { value: name })
+      colors.styles[name] = fn
+      fn.stack = [name]
+    }
+
+    Reflect.defineProperty(colors, name, {
+      configurable: true,
+      enumerable: true,
+      set(value) {
+        colors.alias(name, value)
+      },
+      get() {
+        let color = (input) => style(input, color.stack)
+        Reflect.setPrototypeOf(color, colors)
+        color.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack
+        return color
+      },
+    })
+  }
+
+  colors.theme = (custom) => {
+    if (!isObject(custom)) throw new TypeError('Expected theme to be an object')
+    for (let name of Object.keys(custom)) {
+      colors.alias(name, custom[name])
+    }
+    return colors
+  }
+
+  colors.alias('unstyle', (str) => {
+    if (typeof str === 'string' && str !== '') {
+      colors.ansiRegex.lastIndex = 0
+      return str.replace(colors.ansiRegex, '')
+    }
+    return ''
+  })
+
+  colors.alias('noop', (str) => str)
+  colors.none = colors.clear = colors.noop
+
+  colors.stripColor = colors.unstyle
+  colors.define = define
+  return colors
+}
+
+module.exports = create()
+module.exports.create = create

node_modules/prisma/prisma-client/scripts/default-deno-edge.ts

@@ -0,0 +1,10 @@
+class PrismaClient {
+  constructor() {
+    throw new Error(
+      `@prisma/client/deno/edge did not initialize yet. Please run "prisma generate --data-proxy" and try to import it again.
+In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues`,
+    )
+  }
+}
+
+export { PrismaClient }

node_modules/prisma/prisma-client/scripts/default-edge.js

@@ -0,0 +1,12 @@
+class PrismaClient {
+  constructor() {
+    throw new Error(
+      `@prisma/client/edge did not initialize yet. Please run "prisma generate --data-proxy" and try to import it again.
+In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues`,
+    )
+  }
+}
+
+module.exports = {
+  PrismaClient,
+}

node_modules/prisma/prisma-client/scripts/default-index-browser.js

@@ -0,0 +1,12 @@
+class PrismaClient {
+  constructor() {
+    throw new Error(
+      `@prisma/client did not initialize yet. Please run "prisma generate" and try to import it again.
+In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues/new`,
+    )
+  }
+}
+
+module.exports = {
+  PrismaClient,
+}

node_modules/prisma/prisma-client/scripts/default-index.d.ts

@@ -0,0 +1,73 @@
+/* eslint-disable prettier/prettier */
+
+import runtime from '@prisma/client/runtime'
+
+/**
+ * ##  Prisma Client ʲˢ
+ *
+ * Type-safe database client for TypeScript & Node.js
+ * @example
+ * ```
+ * const prisma = new Prisma()
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ *
+ *
+ * Read more in our [docs](https://github.com/prisma/prisma/blob/main/docs/prisma-client-js/api.md).
+ */
+export declare const PrismaClient: any
+/**
+ * ##  Prisma Client ʲˢ
+ *
+ * Type-safe database client for TypeScript & Node.js
+ * @example
+ * ```
+ * const prisma = new Prisma()
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ *
+ *
+ * Read more in our [docs](https://github.com/prisma/prisma/blob/main/docs/prisma-client-js/api.md).
+ */
+export declare type PrismaClient = any
+
+export declare type PrismaClientExtends<ExtArgs extends runtime.Types.Extensions.Args = runtime.Types.Extensions.DefaultArgs> = {
+  $extends: { extArgs: ExtArgs } & (<
+    R extends runtime.Types.Extensions.Args['result'] = {},
+    M extends runtime.Types.Extensions.Args['model'] = {},
+    Q extends runtime.Types.Extensions.Args['query'] = {},
+    C extends runtime.Types.Extensions.Args['client'] = {},
+    Args extends runtime.Types.Extensions.Args = { result: R; model: M; query: Q; client: C }
+  >(args: ((client: PrismaClientExtends<ExtArgs>) => { $extends: { extArgs: Args } }) | {
+    result?: R; model?: M; query?: Q; client?: C
+  }) => PrismaClientExtends<runtime.Types.Utils.PatchDeep<Args, ExtArgs>>)
+}
+
+export declare const dmmf: any
+export declare type dmmf = any
+
+/**
+ * Get the type of the value, that the Promise holds.
+ */
+export declare type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T
+
+/**
+ * Get the return type of a function which returns a Promise.
+ */
+export declare type PromiseReturnType<T extends (...args: any) => Promise<any>> = PromiseType<ReturnType<T>>
+
+export namespace Prisma {
+  export type TransactionClient = any
+
+  export function defineExtension<
+    R extends runtime.Types.Extensions.Args['result'] = {},
+    M extends runtime.Types.Extensions.Args['model'] = {},
+    Q extends runtime.Types.Extensions.Args['query'] = {},
+    C extends runtime.Types.Extensions.Args['client'] = {},
+    Args extends runtime.Types.Extensions.Args = { result: R; model: M; query: Q; client: C }
+  >(args: ((client: PrismaClientExtends) => { $extends: { extArgs: Args } }) | {
+    result?: R; model?: M; query?: Q; client?: C
+  }): (client: any) => PrismaClientExtends<Args>
+}

node_modules/prisma/prisma-client/scripts/default-index.js

@@ -0,0 +1,23 @@
+class PrismaClient {
+  constructor() {
+    throw new Error(
+      `@prisma/client did not initialize yet. Please run "prisma generate" and try to import it again.
+In case this error is unexpected for you, please report it in https://github.com/prisma/prisma/issues`,
+    )
+  }
+}
+
+function defineExtension(ext) {
+  if (typeof ext === 'function') {
+    return ext
+  }
+
+  return (client) => client.$extends(ext)
+}
+
+module.exports = {
+  PrismaClient,
+  Prisma: {
+    defineExtension,
+  },
+}

node_modules/prisma/prisma-client/scripts/get-packed-client.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+const path = require('path')
+const { getPackedPackage } = require('@prisma/internals')
+
+async function main() {
+  const target = path.join(process.cwd(), './node_modules/@prisma/client')
+  await getPackedPackage('@prisma/client', target, path.join(__dirname, '../'))
+  console.log(`Saving packed client to ${target}`)
+}
+
+void main()

node_modules/prisma/prisma-client/scripts/mock-fs.js

@@ -0,0 +1,14 @@
+const { patchFs } = require('fs-monkey')
+const fs = require('fs')
+
+module.exports = function mockFs(fileMap) {
+  const originalFsRead = fs.readFileSync
+
+  const myFs = {
+    readFileSync: (fileName, ...args) => {
+      return fileMap[fileName] || originalFsRead.call(fs, fileName, ...args)
+    },
+  }
+
+  patchFs(myFs)
+}

node_modules/prisma/prisma-client/scripts/postinstall.d.ts

@@ -0,0 +1,5 @@
+export function getPostInstallTrigger(): string
+export const UNABLE_TO_FIND_POSTINSTALL_TRIGGER__EMPTY_STRING
+export const UNABLE_TO_FIND_POSTINSTALL_TRIGGER__ENVAR_MISSING
+export const UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_PARSE_ERROR
+export const UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR

node_modules/prisma/prisma-client/scripts/postinstall.js

@@ -0,0 +1,405 @@
+// @ts-check
+const childProcess = require('child_process')
+const { promisify } = require('util')
+const fs = require('fs')
+const path = require('path')
+const c = require('./colors')
+
+const exec = promisify(childProcess.exec)
+const copyFile = promisify(fs.copyFile)
+const mkdir = promisify(fs.mkdir)
+const stat = promisify(fs.stat)
+
+function debug(message, ...optionalParams) {
+  if (process.env.DEBUG && process.env.DEBUG === 'prisma:postinstall') {
+    console.log(message, ...optionalParams)
+  }
+}
+/**
+ * Adds `package.json` to the end of a path if it doesn't already exist'
+ * @param {string} pth
+ */
+function addPackageJSON(pth) {
+  if (pth.endsWith('package.json')) return pth
+  return path.join(pth, 'package.json')
+}
+
+/**
+ * Looks up for a `package.json` which is not `@prisma/cli` or `prisma` and returns the directory of the package
+ * @param {string} startPath - Path to Start At
+ * @param {number} limit - Find Up limit
+ * @returns {string | null}
+ */
+function findPackageRoot(startPath, limit = 10) {
+  if (!startPath || !fs.existsSync(startPath)) return null
+  let currentPath = startPath
+  // Limit traversal
+  for (let i = 0; i < limit; i++) {
+    const pkgPath = addPackageJSON(currentPath)
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = require(pkgPath)
+        if (pkg.name && !['@prisma/cli', 'prisma'].includes(pkg.name)) {
+          return pkgPath.replace('package.json', '')
+        }
+      } catch {} // eslint-disable-line no-empty
+    }
+    currentPath = path.join(currentPath, '../')
+  }
+  return null
+}
+
+/**
+ * The `postinstall` hook of client sets up the ground and env vars for the `prisma generate` command,
+ * and runs it, showing a warning if the schema is not found.
+ * - initializes the ./node_modules/.prisma/client folder with the default index(-browser).js/index.d.ts,
+ *   which define a `PrismaClient` class stub that throws an error if instantiated before the `prisma generate`
+ *   command is successfully executed.
+ * - sets the path of the root of the project (TODO: to verify) to the `process.env.PRISMA_GENERATE_IN_POSTINSTALL`
+ *   variable, or `'true'` if the project root cannot be found.
+ * - runs `prisma generate`, passing through additional information about the command that triggered the generation,
+ *   which is useful for debugging/telemetry. It tries to use the local `prisma` package if it is installed, otherwise it
+ *   falls back to the global `prisma` package. If neither options are available, it warns the user to install `prisma` first.
+ */
+async function main() {
+  if (process.env.INIT_CWD) {
+    process.chdir(process.env.INIT_CWD) // necessary, because npm chooses __dirname as process.cwd()
+    // in the postinstall hook
+  }
+
+  await createDefaultGeneratedThrowFiles()
+
+  // TODO: consider using the `which` package
+  const localPath = getLocalPackagePath()
+
+  // Only execute if !localpath
+  const installedGlobally = localPath ? undefined : await isInstalledGlobally()
+
+  // this is needed, so we can find the correct schemas in yarn workspace projects
+  const root = findPackageRoot(localPath)
+
+  process.env.PRISMA_GENERATE_IN_POSTINSTALL = root ? root : 'true'
+
+  debug({
+    localPath,
+    installedGlobally,
+    init_cwd: process.env.INIT_CWD,
+    PRISMA_GENERATE_IN_POSTINSTALL: process.env.PRISMA_GENERATE_IN_POSTINSTALL,
+  })
+  try {
+    if (localPath) {
+      await run('node', [localPath, 'generate', '--postinstall', doubleQuote(getPostInstallTrigger())])
+      return
+    }
+    if (installedGlobally) {
+      await run('prisma', ['generate', '--postinstall', doubleQuote(getPostInstallTrigger())])
+      return
+    }
+  } catch (e) {
+    // if exit code = 1 do not print
+    if (e && e !== 1) {
+      console.error(e)
+    }
+    debug(e)
+  }
+
+  if (!localPath && !installedGlobally) {
+    console.error(
+      `${c.yellow(
+        'warning',
+      )} In order to use "@prisma/client", please install Prisma CLI. You can install it with "npm add -D prisma".`,
+    )
+  }
+}
+
+function getLocalPackagePath() {
+  try {
+    const packagePath = require.resolve('prisma/package.json')
+    if (packagePath) {
+      return require.resolve('prisma')
+    }
+  } catch (e) {} // eslint-disable-line no-empty
+
+  // TODO: consider removing this
+  try {
+    const packagePath = require.resolve('@prisma/cli/package.json')
+    if (packagePath) {
+      return require.resolve('@prisma/cli')
+    }
+  } catch (e) {} // eslint-disable-line no-empty
+
+  return null
+}
+
+async function isInstalledGlobally() {
+  try {
+    const result = await exec('prisma -v')
+    if (result.stdout.includes('@prisma/client')) {
+      return true
+    } else {
+      console.error(`${c.yellow('warning')} You still have the ${c.bold('prisma')} cli (Prisma 1) installed globally.
+Please uninstall it with either ${c.green('npm remove -g prisma')} or ${c.green('yarn global remove prisma')}.`)
+    }
+  } catch (e) {
+    return false
+  }
+}
+
+if (!process.env.PRISMA_SKIP_POSTINSTALL_GENERATE) {
+  main()
+    .catch((e) => {
+      if (e.stderr) {
+        if (e.stderr.includes(`Can't find schema.prisma`)) {
+          console.error(
+            `${c.yellow('warning')} @prisma/client needs a ${c.bold('schema.prisma')} to function, but couldn't find it.
+        Please either create one manually or use ${c.bold('prisma init')}.
+        Once you created it, run ${c.bold('prisma generate')}.
+        To keep Prisma related things separate, we recommend creating it in a subfolder called ${c.underline(
+          './prisma',
+        )} like so: ${c.underline('./prisma/schema.prisma')}\n`,
+          )
+        } else {
+          console.error(e.stderr)
+        }
+      } else {
+        console.error(e)
+      }
+      process.exit(0)
+    })
+    .finally(() => {
+      debug(`postinstall trigger: ${getPostInstallTrigger()}`)
+    })
+}
+
+function run(cmd, params, cwd = process.cwd()) {
+  const child = childProcess.spawn(cmd, params, {
+    stdio: ['pipe', 'inherit', 'inherit'],
+    cwd,
+  })
+
+  return new Promise((resolve, reject) => {
+    child.on('close', () => {
+      resolve()
+    })
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve()
+      } else {
+        reject(code)
+      }
+    })
+    child.on('error', () => {
+      reject()
+    })
+  })
+}
+
+/**
+ * Copies our default "throw" files into the default generation folder. These
+ * files are dummy and informative because they just throw an error to let the
+ * user know that they have forgotten to run `prisma generate` or that they
+ * don't have a a schema file yet. We only add these files at the default
+ * location `node_modules/.prisma/client`.
+ */
+async function createDefaultGeneratedThrowFiles() {
+  try {
+    const dotPrismaClientDir = path.join(__dirname, '../../../.prisma/client')
+    const defaultNodeIndexPath = path.join(dotPrismaClientDir, 'index.js')
+    const defaultNodeIndexDtsPath = path.join(dotPrismaClientDir, 'index.d.ts')
+    const defaultBrowserIndexPath = path.join(dotPrismaClientDir, 'index-browser.js')
+    const defaultEdgeIndexPath = path.join(dotPrismaClientDir, 'edge.js')
+    const defaultEdgeIndexDtsPath = path.join(dotPrismaClientDir, 'edge.d.ts')
+    const defaultDenoClientDir = path.join(dotPrismaClientDir, 'deno')
+    const defaultDenoEdgeIndexPath = path.join(defaultDenoClientDir, 'edge.ts')
+    await makeDir(dotPrismaClientDir)
+    await makeDir(defaultDenoClientDir)
+
+    if (!fs.existsSync(defaultNodeIndexPath)) {
+      await copyFile(path.join(__dirname, 'default-index.js'), defaultNodeIndexPath)
+    }
+
+    if (!fs.existsSync(defaultBrowserIndexPath)) {
+      await copyFile(path.join(__dirname, 'default-index-browser.js'), defaultBrowserIndexPath)
+    }
+
+    if (!fs.existsSync(defaultNodeIndexDtsPath)) {
+      await copyFile(path.join(__dirname, 'default-index.d.ts'), defaultNodeIndexDtsPath)
+    }
+
+    if (!fs.existsSync(defaultEdgeIndexPath)) {
+      await copyFile(path.join(__dirname, 'default-edge.js'), defaultEdgeIndexPath)
+    }
+
+    if (!fs.existsSync(defaultEdgeIndexDtsPath)) {
+      await copyFile(path.join(__dirname, 'default-index.d.ts'), defaultEdgeIndexDtsPath)
+    }
+
+    if (!fs.existsSync(defaultDenoEdgeIndexPath)) {
+      await copyFile(path.join(__dirname, 'default-deno-edge.ts'), defaultDenoEdgeIndexPath)
+    }
+  } catch (e) {
+    console.error(e)
+  }
+}
+
+// TODO: can this be replaced some utility eg. mkdir
+function makeDir(input) {
+  const make = async (pth) => {
+    try {
+      await mkdir(pth)
+
+      return pth
+    } catch (error) {
+      if (error.code === 'EPERM') {
+        throw error
+      }
+
+      if (error.code === 'ENOENT') {
+        if (path.dirname(pth) === pth) {
+          throw new Error(`operation not permitted, mkdir '${pth}'`)
+        }
+
+        if (error.message.includes('null bytes')) {
+          throw error
+        }
+
+        await make(path.dirname(pth))
+
+        return make(pth)
+      }
+
+      try {
+        const stats = await stat(pth)
+        if (!stats.isDirectory()) {
+          throw new Error('The path is not a directory')
+        }
+      } catch (_) {
+        throw error
+      }
+
+      return pth
+    }
+  }
+
+  return make(path.resolve(input))
+}
+
+/**
+ * Get the command that triggered this postinstall script being run. If there is
+ * an error while attempting to get this value then the string constant
+ * 'ERROR_WHILE_FINDING_POSTINSTALL_TRIGGER' is returned.
+ * This information is just necessary for telemetry.
+ * This is passed to `prisma generate` as a string like `--postinstall value`.
+ */
+function getPostInstallTrigger() {
+  /*
+  npm_config_argv` is not officially documented so here are our research notes 
+
+  `npm_config_argv` is available to the postinstall script when the containing package has been installed by npm into some project.
+
+  An example of its value:
+
+  ```
+  npm_config_argv: '{"remain":["../test"],"cooked":["add","../test"],"original":["add","../test"]}',
+  ```
+
+  We are interesting in the data contained in the "original" field.
+
+  Trivia/Note: `npm_config_argv` is not available when running e.g. `npm install` on the containing package itself (e.g. when working on it)
+
+  Yarn mimics this data and environment variable. Here is an example following `yarn add` for the same package:
+
+  ```
+  npm_config_argv: '{"remain":[],"cooked":["add"],"original":["add","../test"]}'
+  ```
+
+  Other package managers like `pnpm` have not been tested.
+  */
+
+  const maybe_npm_config_argv_string = process.env.npm_config_argv
+
+  if (maybe_npm_config_argv_string === undefined) {
+    return UNABLE_TO_FIND_POSTINSTALL_TRIGGER__ENVAR_MISSING
+  }
+
+  let npm_config_argv
+  try {
+    npm_config_argv = JSON.parse(maybe_npm_config_argv_string)
+  } catch (e) {
+    return `${UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_PARSE_ERROR}: ${maybe_npm_config_argv_string}`
+  }
+
+  if (typeof npm_config_argv !== 'object' || npm_config_argv === null) {
+    return `${UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR}: ${maybe_npm_config_argv_string}`
+  }
+
+  const npm_config_argv_original_arr = npm_config_argv.original
+
+  if (!Array.isArray(npm_config_argv_original_arr)) {
+    return `${UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR}: ${maybe_npm_config_argv_string}`
+  }
+
+  const npm_config_argv_original = npm_config_argv_original_arr.filter((arg) => arg !== '').join(' ')
+
+  const command =
+    npm_config_argv_original === ''
+      ? getPackageManagerName()
+      : [getPackageManagerName(), npm_config_argv_original].join(' ')
+
+  return command
+}
+
+/**
+ * Wrap double quotes around the given string.
+ */
+function doubleQuote(x) {
+  return `"${x}"`
+}
+
+/**
+ * Get the package manager name currently being used. If parsing fails, then the following pattern is returned:
+ * UNKNOWN_NPM_CONFIG_USER_AGENT(<string received>).
+ */
+function getPackageManagerName() {
+  const userAgent = process.env.npm_config_user_agent
+  if (!userAgent) return 'MISSING_NPM_CONFIG_USER_AGENT'
+
+  const name = parsePackageManagerName(userAgent)
+  if (!name) return `UNKNOWN_NPM_CONFIG_USER_AGENT(${userAgent})`
+
+  return name
+}
+
+/**
+ * Parse package manager name from useragent. If parsing fails, `null` is returned.
+ */
+function parsePackageManagerName(userAgent) {
+  let packageManager = null
+
+  // example: 'yarn/1.22.4 npm/? node/v13.11.0 darwin x64'
+  // References:
+  // - https://pnpm.io/only-allow-pnpm
+  // - https://github.com/cameronhunter/npm-config-user-agent-parser
+  if (userAgent) {
+    const matchResult = userAgent.match(/^([^/]+)\/.+/)
+    if (matchResult) {
+      packageManager = matchResult[1].trim()
+    }
+  }
+
+  return packageManager
+}
+
+// prettier-ignore
+const UNABLE_TO_FIND_POSTINSTALL_TRIGGER__ENVAR_MISSING = 'UNABLE_TO_FIND_POSTINSTALL_TRIGGER__ENVAR_MISSING'
+// prettier-ignore
+const UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_PARSE_ERROR = 'UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_PARSE_ERROR'
+// prettier-ignore
+const UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR = 'UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR'
+
+// expose for testing
+
+exports.UNABLE_TO_FIND_POSTINSTALL_TRIGGER__ENVAR_MISSING = UNABLE_TO_FIND_POSTINSTALL_TRIGGER__ENVAR_MISSING
+exports.UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_PARSE_ERROR = UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_PARSE_ERROR
+exports.UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR = UNABLE_TO_FIND_POSTINSTALL_TRIGGER_JSON_SCHEMA_ERROR
+exports.getPostInstallTrigger = getPostInstallTrigger