@crossauth/fastify 1.0.1 → 1.1.0

package/dist/lib/generated/prisma/models/Key.d.ts

@@ -0,0 +1,1308 @@
+import type * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../internal/prismaNamespace.ts";
+/**
+ * Model Key
+ *
+ */
+export type KeyModel = runtime.Types.Result.DefaultSelection<Prisma.$KeyPayload>;
+export type AggregateKey = {
+    _count: KeyCountAggregateOutputType | null;
+    _avg: KeyAvgAggregateOutputType | null;
+    _sum: KeySumAggregateOutputType | null;
+    _min: KeyMinAggregateOutputType | null;
+    _max: KeyMaxAggregateOutputType | null;
+};
+export type KeyAvgAggregateOutputType = {
+    id: number | null;
+    userid: number | null;
+};
+export type KeySumAggregateOutputType = {
+    id: number | null;
+    userid: number | null;
+};
+export type KeyMinAggregateOutputType = {
+    id: number | null;
+    value: string | null;
+    userid: number | null;
+    created: Date | null;
+    expires: Date | null;
+    lastactive: Date | null;
+    data: string | null;
+};
+export type KeyMaxAggregateOutputType = {
+    id: number | null;
+    value: string | null;
+    userid: number | null;
+    created: Date | null;
+    expires: Date | null;
+    lastactive: Date | null;
+    data: string | null;
+};
+export type KeyCountAggregateOutputType = {
+    id: number;
+    value: number;
+    userid: number;
+    created: number;
+    expires: number;
+    lastactive: number;
+    data: number;
+    _all: number;
+};
+export type KeyAvgAggregateInputType = {
+    id?: true;
+    userid?: true;
+};
+export type KeySumAggregateInputType = {
+    id?: true;
+    userid?: true;
+};
+export type KeyMinAggregateInputType = {
+    id?: true;
+    value?: true;
+    userid?: true;
+    created?: true;
+    expires?: true;
+    lastactive?: true;
+    data?: true;
+};
+export type KeyMaxAggregateInputType = {
+    id?: true;
+    value?: true;
+    userid?: true;
+    created?: true;
+    expires?: true;
+    lastactive?: true;
+    data?: true;
+};
+export type KeyCountAggregateInputType = {
+    id?: true;
+    value?: true;
+    userid?: true;
+    created?: true;
+    expires?: true;
+    lastactive?: true;
+    data?: true;
+    _all?: true;
+};
+export type KeyAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which Key to aggregate.
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Keys to fetch.
+     */
+    orderBy?: Prisma.KeyOrderByWithRelationInput | Prisma.KeyOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the start position
+     */
+    cursor?: Prisma.KeyWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Keys 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` Keys.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Count returned Keys
+    **/
+    _count?: true | KeyCountAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to average
+    **/
+    _avg?: KeyAvgAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to sum
+    **/
+    _sum?: KeySumAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the minimum value
+    **/
+    _min?: KeyMinAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the maximum value
+    **/
+    _max?: KeyMaxAggregateInputType;
+};
+export type GetKeyAggregateType<T extends KeyAggregateArgs> = {
+    [P in keyof T & keyof AggregateKey]: P extends '_count' | 'count' ? T[P] extends true ? number : Prisma.GetScalarType<T[P], AggregateKey[P]> : Prisma.GetScalarType<T[P], AggregateKey[P]>;
+};
+export type KeyGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: Prisma.KeyWhereInput;
+    orderBy?: Prisma.KeyOrderByWithAggregationInput | Prisma.KeyOrderByWithAggregationInput[];
+    by: Prisma.KeyScalarFieldEnum[] | Prisma.KeyScalarFieldEnum;
+    having?: Prisma.KeyScalarWhereWithAggregatesInput;
+    take?: number;
+    skip?: number;
+    _count?: KeyCountAggregateInputType | true;
+    _avg?: KeyAvgAggregateInputType;
+    _sum?: KeySumAggregateInputType;
+    _min?: KeyMinAggregateInputType;
+    _max?: KeyMaxAggregateInputType;
+};
+export type KeyGroupByOutputType = {
+    id: number;
+    value: string;
+    userid: number | null;
+    created: Date;
+    expires: Date;
+    lastactive: Date | null;
+    data: string | null;
+    _count: KeyCountAggregateOutputType | null;
+    _avg: KeyAvgAggregateOutputType | null;
+    _sum: KeySumAggregateOutputType | null;
+    _min: KeyMinAggregateOutputType | null;
+    _max: KeyMaxAggregateOutputType | null;
+};
+type GetKeyGroupByPayload<T extends KeyGroupByArgs> = Prisma.PrismaPromise<Array<Prisma.PickEnumerable<KeyGroupByOutputType, T['by']> & {
+    [P in ((keyof T) & (keyof KeyGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : Prisma.GetScalarType<T[P], KeyGroupByOutputType[P]> : Prisma.GetScalarType<T[P], KeyGroupByOutputType[P]>;
+}>>;
+export type KeyWhereInput = {
+    AND?: Prisma.KeyWhereInput | Prisma.KeyWhereInput[];
+    OR?: Prisma.KeyWhereInput[];
+    NOT?: Prisma.KeyWhereInput | Prisma.KeyWhereInput[];
+    id?: Prisma.IntFilter<"Key"> | number;
+    value?: Prisma.StringFilter<"Key"> | string;
+    userid?: Prisma.IntNullableFilter<"Key"> | number | null;
+    created?: Prisma.DateTimeFilter<"Key"> | Date | string;
+    expires?: Prisma.DateTimeFilter<"Key"> | Date | string;
+    lastactive?: Prisma.DateTimeNullableFilter<"Key"> | Date | string | null;
+    data?: Prisma.StringNullableFilter<"Key"> | string | null;
+    user?: Prisma.XOR<Prisma.UserNullableScalarRelationFilter, Prisma.UserWhereInput> | null;
+};
+export type KeyOrderByWithRelationInput = {
+    id?: Prisma.SortOrder;
+    value?: Prisma.SortOrder;
+    userid?: Prisma.SortOrderInput | Prisma.SortOrder;
+    created?: Prisma.SortOrder;
+    expires?: Prisma.SortOrder;
+    lastactive?: Prisma.SortOrderInput | Prisma.SortOrder;
+    data?: Prisma.SortOrderInput | Prisma.SortOrder;
+    user?: Prisma.UserOrderByWithRelationInput;
+};
+export type KeyWhereUniqueInput = Prisma.AtLeast<{
+    id?: number;
+    value?: string;
+    AND?: Prisma.KeyWhereInput | Prisma.KeyWhereInput[];
+    OR?: Prisma.KeyWhereInput[];
+    NOT?: Prisma.KeyWhereInput | Prisma.KeyWhereInput[];
+    userid?: Prisma.IntNullableFilter<"Key"> | number | null;
+    created?: Prisma.DateTimeFilter<"Key"> | Date | string;
+    expires?: Prisma.DateTimeFilter<"Key"> | Date | string;
+    lastactive?: Prisma.DateTimeNullableFilter<"Key"> | Date | string | null;
+    data?: Prisma.StringNullableFilter<"Key"> | string | null;
+    user?: Prisma.XOR<Prisma.UserNullableScalarRelationFilter, Prisma.UserWhereInput> | null;
+}, "id" | "id" | "value">;
+export type KeyOrderByWithAggregationInput = {
+    id?: Prisma.SortOrder;
+    value?: Prisma.SortOrder;
+    userid?: Prisma.SortOrderInput | Prisma.SortOrder;
+    created?: Prisma.SortOrder;
+    expires?: Prisma.SortOrder;
+    lastactive?: Prisma.SortOrderInput | Prisma.SortOrder;
+    data?: Prisma.SortOrderInput | Prisma.SortOrder;
+    _count?: Prisma.KeyCountOrderByAggregateInput;
+    _avg?: Prisma.KeyAvgOrderByAggregateInput;
+    _max?: Prisma.KeyMaxOrderByAggregateInput;
+    _min?: Prisma.KeyMinOrderByAggregateInput;
+    _sum?: Prisma.KeySumOrderByAggregateInput;
+};
+export type KeyScalarWhereWithAggregatesInput = {
+    AND?: Prisma.KeyScalarWhereWithAggregatesInput | Prisma.KeyScalarWhereWithAggregatesInput[];
+    OR?: Prisma.KeyScalarWhereWithAggregatesInput[];
+    NOT?: Prisma.KeyScalarWhereWithAggregatesInput | Prisma.KeyScalarWhereWithAggregatesInput[];
+    id?: Prisma.IntWithAggregatesFilter<"Key"> | number;
+    value?: Prisma.StringWithAggregatesFilter<"Key"> | string;
+    userid?: Prisma.IntNullableWithAggregatesFilter<"Key"> | number | null;
+    created?: Prisma.DateTimeWithAggregatesFilter<"Key"> | Date | string;
+    expires?: Prisma.DateTimeWithAggregatesFilter<"Key"> | Date | string;
+    lastactive?: Prisma.DateTimeNullableWithAggregatesFilter<"Key"> | Date | string | null;
+    data?: Prisma.StringNullableWithAggregatesFilter<"Key"> | string | null;
+};
+export type KeyCreateInput = {
+    value: string;
+    created: Date | string;
+    expires: Date | string;
+    lastactive?: Date | string | null;
+    data?: string | null;
+    user?: Prisma.UserCreateNestedOneWithoutSessionInput;
+};
+export type KeyUncheckedCreateInput = {
+    id?: number;
+    value: string;
+    userid?: number | null;
+    created: Date | string;
+    expires: Date | string;
+    lastactive?: Date | string | null;
+    data?: string | null;
+};
+export type KeyUpdateInput = {
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    user?: Prisma.UserUpdateOneWithoutSessionNestedInput;
+};
+export type KeyUncheckedUpdateInput = {
+    id?: Prisma.IntFieldUpdateOperationsInput | number;
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    userid?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+};
+export type KeyCreateManyInput = {
+    id?: number;
+    value: string;
+    userid?: number | null;
+    created: Date | string;
+    expires: Date | string;
+    lastactive?: Date | string | null;
+    data?: string | null;
+};
+export type KeyUpdateManyMutationInput = {
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+};
+export type KeyUncheckedUpdateManyInput = {
+    id?: Prisma.IntFieldUpdateOperationsInput | number;
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    userid?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+};
+export type KeyListRelationFilter = {
+    every?: Prisma.KeyWhereInput;
+    some?: Prisma.KeyWhereInput;
+    none?: Prisma.KeyWhereInput;
+};
+export type KeyOrderByRelationAggregateInput = {
+    _count?: Prisma.SortOrder;
+};
+export type KeyCountOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    value?: Prisma.SortOrder;
+    userid?: Prisma.SortOrder;
+    created?: Prisma.SortOrder;
+    expires?: Prisma.SortOrder;
+    lastactive?: Prisma.SortOrder;
+    data?: Prisma.SortOrder;
+};
+export type KeyAvgOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    userid?: Prisma.SortOrder;
+};
+export type KeyMaxOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    value?: Prisma.SortOrder;
+    userid?: Prisma.SortOrder;
+    created?: Prisma.SortOrder;
+    expires?: Prisma.SortOrder;
+    lastactive?: Prisma.SortOrder;
+    data?: Prisma.SortOrder;
+};
+export type KeyMinOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    value?: Prisma.SortOrder;
+    userid?: Prisma.SortOrder;
+    created?: Prisma.SortOrder;
+    expires?: Prisma.SortOrder;
+    lastactive?: Prisma.SortOrder;
+    data?: Prisma.SortOrder;
+};
+export type KeySumOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    userid?: Prisma.SortOrder;
+};
+export type KeyCreateNestedManyWithoutUserInput = {
+    create?: Prisma.XOR<Prisma.KeyCreateWithoutUserInput, Prisma.KeyUncheckedCreateWithoutUserInput> | Prisma.KeyCreateWithoutUserInput[] | Prisma.KeyUncheckedCreateWithoutUserInput[];
+    connectOrCreate?: Prisma.KeyCreateOrConnectWithoutUserInput | Prisma.KeyCreateOrConnectWithoutUserInput[];
+    createMany?: Prisma.KeyCreateManyUserInputEnvelope;
+    connect?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+};
+export type KeyUncheckedCreateNestedManyWithoutUserInput = {
+    create?: Prisma.XOR<Prisma.KeyCreateWithoutUserInput, Prisma.KeyUncheckedCreateWithoutUserInput> | Prisma.KeyCreateWithoutUserInput[] | Prisma.KeyUncheckedCreateWithoutUserInput[];
+    connectOrCreate?: Prisma.KeyCreateOrConnectWithoutUserInput | Prisma.KeyCreateOrConnectWithoutUserInput[];
+    createMany?: Prisma.KeyCreateManyUserInputEnvelope;
+    connect?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+};
+export type KeyUpdateManyWithoutUserNestedInput = {
+    create?: Prisma.XOR<Prisma.KeyCreateWithoutUserInput, Prisma.KeyUncheckedCreateWithoutUserInput> | Prisma.KeyCreateWithoutUserInput[] | Prisma.KeyUncheckedCreateWithoutUserInput[];
+    connectOrCreate?: Prisma.KeyCreateOrConnectWithoutUserInput | Prisma.KeyCreateOrConnectWithoutUserInput[];
+    upsert?: Prisma.KeyUpsertWithWhereUniqueWithoutUserInput | Prisma.KeyUpsertWithWhereUniqueWithoutUserInput[];
+    createMany?: Prisma.KeyCreateManyUserInputEnvelope;
+    set?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    disconnect?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    delete?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    connect?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    update?: Prisma.KeyUpdateWithWhereUniqueWithoutUserInput | Prisma.KeyUpdateWithWhereUniqueWithoutUserInput[];
+    updateMany?: Prisma.KeyUpdateManyWithWhereWithoutUserInput | Prisma.KeyUpdateManyWithWhereWithoutUserInput[];
+    deleteMany?: Prisma.KeyScalarWhereInput | Prisma.KeyScalarWhereInput[];
+};
+export type KeyUncheckedUpdateManyWithoutUserNestedInput = {
+    create?: Prisma.XOR<Prisma.KeyCreateWithoutUserInput, Prisma.KeyUncheckedCreateWithoutUserInput> | Prisma.KeyCreateWithoutUserInput[] | Prisma.KeyUncheckedCreateWithoutUserInput[];
+    connectOrCreate?: Prisma.KeyCreateOrConnectWithoutUserInput | Prisma.KeyCreateOrConnectWithoutUserInput[];
+    upsert?: Prisma.KeyUpsertWithWhereUniqueWithoutUserInput | Prisma.KeyUpsertWithWhereUniqueWithoutUserInput[];
+    createMany?: Prisma.KeyCreateManyUserInputEnvelope;
+    set?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    disconnect?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    delete?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    connect?: Prisma.KeyWhereUniqueInput | Prisma.KeyWhereUniqueInput[];
+    update?: Prisma.KeyUpdateWithWhereUniqueWithoutUserInput | Prisma.KeyUpdateWithWhereUniqueWithoutUserInput[];
+    updateMany?: Prisma.KeyUpdateManyWithWhereWithoutUserInput | Prisma.KeyUpdateManyWithWhereWithoutUserInput[];
+    deleteMany?: Prisma.KeyScalarWhereInput | Prisma.KeyScalarWhereInput[];
+};
+export type DateTimeFieldUpdateOperationsInput = {
+    set?: Date | string;
+};
+export type NullableDateTimeFieldUpdateOperationsInput = {
+    set?: Date | string | null;
+};
+export type NullableIntFieldUpdateOperationsInput = {
+    set?: number | null;
+    increment?: number;
+    decrement?: number;
+    multiply?: number;
+    divide?: number;
+};
+export type KeyCreateWithoutUserInput = {
+    value: string;
+    created: Date | string;
+    expires: Date | string;
+    lastactive?: Date | string | null;
+    data?: string | null;
+};
+export type KeyUncheckedCreateWithoutUserInput = {
+    id?: number;
+    value: string;
+    created: Date | string;
+    expires: Date | string;
+    lastactive?: Date | string | null;
+    data?: string | null;
+};
+export type KeyCreateOrConnectWithoutUserInput = {
+    where: Prisma.KeyWhereUniqueInput;
+    create: Prisma.XOR<Prisma.KeyCreateWithoutUserInput, Prisma.KeyUncheckedCreateWithoutUserInput>;
+};
+export type KeyCreateManyUserInputEnvelope = {
+    data: Prisma.KeyCreateManyUserInput | Prisma.KeyCreateManyUserInput[];
+};
+export type KeyUpsertWithWhereUniqueWithoutUserInput = {
+    where: Prisma.KeyWhereUniqueInput;
+    update: Prisma.XOR<Prisma.KeyUpdateWithoutUserInput, Prisma.KeyUncheckedUpdateWithoutUserInput>;
+    create: Prisma.XOR<Prisma.KeyCreateWithoutUserInput, Prisma.KeyUncheckedCreateWithoutUserInput>;
+};
+export type KeyUpdateWithWhereUniqueWithoutUserInput = {
+    where: Prisma.KeyWhereUniqueInput;
+    data: Prisma.XOR<Prisma.KeyUpdateWithoutUserInput, Prisma.KeyUncheckedUpdateWithoutUserInput>;
+};
+export type KeyUpdateManyWithWhereWithoutUserInput = {
+    where: Prisma.KeyScalarWhereInput;
+    data: Prisma.XOR<Prisma.KeyUpdateManyMutationInput, Prisma.KeyUncheckedUpdateManyWithoutUserInput>;
+};
+export type KeyScalarWhereInput = {
+    AND?: Prisma.KeyScalarWhereInput | Prisma.KeyScalarWhereInput[];
+    OR?: Prisma.KeyScalarWhereInput[];
+    NOT?: Prisma.KeyScalarWhereInput | Prisma.KeyScalarWhereInput[];
+    id?: Prisma.IntFilter<"Key"> | number;
+    value?: Prisma.StringFilter<"Key"> | string;
+    userid?: Prisma.IntNullableFilter<"Key"> | number | null;
+    created?: Prisma.DateTimeFilter<"Key"> | Date | string;
+    expires?: Prisma.DateTimeFilter<"Key"> | Date | string;
+    lastactive?: Prisma.DateTimeNullableFilter<"Key"> | Date | string | null;
+    data?: Prisma.StringNullableFilter<"Key"> | string | null;
+};
+export type KeyCreateManyUserInput = {
+    id?: number;
+    value: string;
+    created: Date | string;
+    expires: Date | string;
+    lastactive?: Date | string | null;
+    data?: string | null;
+};
+export type KeyUpdateWithoutUserInput = {
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+};
+export type KeyUncheckedUpdateWithoutUserInput = {
+    id?: Prisma.IntFieldUpdateOperationsInput | number;
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+};
+export type KeyUncheckedUpdateManyWithoutUserInput = {
+    id?: Prisma.IntFieldUpdateOperationsInput | number;
+    value?: Prisma.StringFieldUpdateOperationsInput | string;
+    created?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    lastactive?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null;
+    data?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+};
+export type KeySelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    value?: boolean;
+    userid?: boolean;
+    created?: boolean;
+    expires?: boolean;
+    lastactive?: boolean;
+    data?: boolean;
+    user?: boolean | Prisma.Key$userArgs<ExtArgs>;
+}, ExtArgs["result"]["key"]>;
+export type KeySelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    value?: boolean;
+    userid?: boolean;
+    created?: boolean;
+    expires?: boolean;
+    lastactive?: boolean;
+    data?: boolean;
+    user?: boolean | Prisma.Key$userArgs<ExtArgs>;
+}, ExtArgs["result"]["key"]>;
+export type KeySelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    value?: boolean;
+    userid?: boolean;
+    created?: boolean;
+    expires?: boolean;
+    lastactive?: boolean;
+    data?: boolean;
+    user?: boolean | Prisma.Key$userArgs<ExtArgs>;
+}, ExtArgs["result"]["key"]>;
+export type KeySelectScalar = {
+    id?: boolean;
+    value?: boolean;
+    userid?: boolean;
+    created?: boolean;
+    expires?: boolean;
+    lastactive?: boolean;
+    data?: boolean;
+};
+export type KeyOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "value" | "userid" | "created" | "expires" | "lastactive" | "data", ExtArgs["result"]["key"]>;
+export type KeyInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    user?: boolean | Prisma.Key$userArgs<ExtArgs>;
+};
+export type KeyIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    user?: boolean | Prisma.Key$userArgs<ExtArgs>;
+};
+export type KeyIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    user?: boolean | Prisma.Key$userArgs<ExtArgs>;
+};
+export type $KeyPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    name: "Key";
+    objects: {
+        user: Prisma.$UserPayload<ExtArgs> | null;
+    };
+    scalars: runtime.Types.Extensions.GetPayloadResult<{
+        id: number;
+        value: string;
+        userid: number | null;
+        created: Date;
+        expires: Date;
+        lastactive: Date | null;
+        data: string | null;
+    }, ExtArgs["result"]["key"]>;
+    composites: {};
+};
+export type KeyGetPayload<S extends boolean | null | undefined | KeyDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$KeyPayload, S>;
+export type KeyCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<KeyFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: KeyCountAggregateInputType | true;
+};
+export interface KeyDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: {
+        types: Prisma.TypeMap<ExtArgs>['model']['Key'];
+        meta: {
+            name: 'Key';
+        };
+    };
+    /**
+     * Find zero or one Key that matches the filter.
+     * @param {KeyFindUniqueArgs} args - Arguments to find a Key
+     * @example
+     * // Get one Key
+     * const key = await prisma.key.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends KeyFindUniqueArgs>(args: Prisma.SelectSubset<T, KeyFindUniqueArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find one Key that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {KeyFindUniqueOrThrowArgs} args - Arguments to find a Key
+     * @example
+     * // Get one Key
+     * const key = await prisma.key.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends KeyFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, KeyFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first Key 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 {KeyFindFirstArgs} args - Arguments to find a Key
+     * @example
+     * // Get one Key
+     * const key = await prisma.key.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends KeyFindFirstArgs>(args?: Prisma.SelectSubset<T, KeyFindFirstArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first Key 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 {KeyFindFirstOrThrowArgs} args - Arguments to find a Key
+     * @example
+     * // Get one Key
+     * const key = await prisma.key.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends KeyFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, KeyFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find zero or more Keys 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 {KeyFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all Keys
+     * const keys = await prisma.key.findMany()
+     *
+     * // Get first 10 Keys
+     * const keys = await prisma.key.findMany({ take: 10 })
+     *
+     * // Only select the `id`
+     * const keyWithIdOnly = await prisma.key.findMany({ select: { id: true } })
+     *
+     */
+    findMany<T extends KeyFindManyArgs>(args?: Prisma.SelectSubset<T, KeyFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
+    /**
+     * Create a Key.
+     * @param {KeyCreateArgs} args - Arguments to create a Key.
+     * @example
+     * // Create one Key
+     * const Key = await prisma.key.create({
+     *   data: {
+     *     // ... data to create a Key
+     *   }
+     * })
+     *
+     */
+    create<T extends KeyCreateArgs>(args: Prisma.SelectSubset<T, KeyCreateArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Create many Keys.
+     * @param {KeyCreateManyArgs} args - Arguments to create many Keys.
+     * @example
+     * // Create many Keys
+     * const key = await prisma.key.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     */
+    createMany<T extends KeyCreateManyArgs>(args?: Prisma.SelectSubset<T, KeyCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    /**
+     * Create many Keys and returns the data saved in the database.
+     * @param {KeyCreateManyAndReturnArgs} args - Arguments to create many Keys.
+     * @example
+     * // Create many Keys
+     * const key = await prisma.key.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Create many Keys and only return the `id`
+     * const keyWithIdOnly = await prisma.key.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 KeyCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, KeyCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Delete a Key.
+     * @param {KeyDeleteArgs} args - Arguments to delete one Key.
+     * @example
+     * // Delete one Key
+     * const Key = await prisma.key.delete({
+     *   where: {
+     *     // ... filter to delete one Key
+     *   }
+     * })
+     *
+     */
+    delete<T extends KeyDeleteArgs>(args: Prisma.SelectSubset<T, KeyDeleteArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Update one Key.
+     * @param {KeyUpdateArgs} args - Arguments to update one Key.
+     * @example
+     * // Update one Key
+     * const key = await prisma.key.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    update<T extends KeyUpdateArgs>(args: Prisma.SelectSubset<T, KeyUpdateArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Delete zero or more Keys.
+     * @param {KeyDeleteManyArgs} args - Arguments to filter Keys to delete.
+     * @example
+     * // Delete a few Keys
+     * const { count } = await prisma.key.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     *
+     */
+    deleteMany<T extends KeyDeleteManyArgs>(args?: Prisma.SelectSubset<T, KeyDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    /**
+     * Update zero or more Keys.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {KeyUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many Keys
+     * const key = await prisma.key.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    updateMany<T extends KeyUpdateManyArgs>(args: Prisma.SelectSubset<T, KeyUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    /**
+     * Update zero or more Keys and returns the data updated in the database.
+     * @param {KeyUpdateManyAndReturnArgs} args - Arguments to update many Keys.
+     * @example
+     * // Update many Keys
+     * const key = await prisma.key.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Update zero or more Keys and only return the `id`
+     * const keyWithIdOnly = await prisma.key.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 KeyUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, KeyUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Create or update one Key.
+     * @param {KeyUpsertArgs} args - Arguments to update or create a Key.
+     * @example
+     * // Update or create a Key
+     * const key = await prisma.key.upsert({
+     *   create: {
+     *     // ... data to create a Key
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the Key we want to update
+     *   }
+     * })
+     */
+    upsert<T extends KeyUpsertArgs>(args: Prisma.SelectSubset<T, KeyUpsertArgs<ExtArgs>>): Prisma.Prisma__KeyClient<runtime.Types.Result.GetResult<Prisma.$KeyPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Count the number of Keys.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {KeyCountArgs} args - Arguments to filter Keys to count.
+     * @example
+     * // Count the number of Keys
+     * const count = await prisma.key.count({
+     *   where: {
+     *     // ... the filter for the Keys we want to count
+     *   }
+     * })
+    **/
+    count<T extends KeyCountArgs>(args?: Prisma.Subset<T, KeyCountArgs>): Prisma.PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : Prisma.GetScalarType<T['select'], KeyCountAggregateOutputType> : number>;
+    /**
+     * Allows you to perform aggregations operations on a Key.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {KeyAggregateArgs} 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 KeyAggregateArgs>(args: Prisma.Subset<T, KeyAggregateArgs>): Prisma.PrismaPromise<GetKeyAggregateType<T>>;
+    /**
+     * Group by Key.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {KeyGroupByArgs} 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 KeyGroupByArgs, HasSelectOrTake extends Prisma.Or<Prisma.Extends<'skip', Prisma.Keys<T>>, Prisma.Extends<'take', Prisma.Keys<T>>>, OrderByArg extends Prisma.True extends HasSelectOrTake ? {
+        orderBy: KeyGroupByArgs['orderBy'];
+    } : {
+        orderBy?: KeyGroupByArgs['orderBy'];
+    }, OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>, ByFields extends Prisma.MaybeTupleToUnion<T['by']>, ByValid extends Prisma.Has<ByFields, OrderFields>, HavingFields extends Prisma.GetHavingFields<T['having']>, HavingValid extends Prisma.Has<ByFields, HavingFields>, ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False, InputErrors extends ByEmpty extends Prisma.True ? `Error: "by" must not be empty.` : HavingValid extends Prisma.False ? {
+        [P in HavingFields]: P extends ByFields ? never : P extends string ? `Error: Field "${P}" used in "having" needs to be provided in "by".` : [
+            Error,
+            'Field ',
+            P,
+            ` in "having" needs to be provided in "by"`
+        ];
+    }[HavingFields] : 'take' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields] : 'Error: If you provide "take", you also need to provide "orderBy"' : 'skip' extends Prisma.Keys<T> ? 'orderBy' extends Prisma.Keys<T> ? ByValid extends Prisma.True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields] : 'Error: If you provide "skip", you also need to provide "orderBy"' : ByValid extends Prisma.True ? {} : {
+        [P in OrderFields]: P extends ByFields ? never : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`;
+    }[OrderFields]>(args: Prisma.SubsetIntersection<T, KeyGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetKeyGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>;
+    /**
+     * Fields of the Key model
+     */
+    readonly fields: KeyFieldRefs;
+}
+/**
+ * The delegate class that acts as a "Promise-like" for Key.
+ * 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__KeyClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise";
+    user<T extends Prisma.Key$userArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Key$userArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>;
+}
+/**
+ * Fields of the Key model
+ */
+export interface KeyFieldRefs {
+    readonly id: Prisma.FieldRef<"Key", 'Int'>;
+    readonly value: Prisma.FieldRef<"Key", 'String'>;
+    readonly userid: Prisma.FieldRef<"Key", 'Int'>;
+    readonly created: Prisma.FieldRef<"Key", 'DateTime'>;
+    readonly expires: Prisma.FieldRef<"Key", 'DateTime'>;
+    readonly lastactive: Prisma.FieldRef<"Key", 'DateTime'>;
+    readonly data: Prisma.FieldRef<"Key", 'String'>;
+}
+/**
+ * Key findUnique
+ */
+export type KeyFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * Filter, which Key to fetch.
+     */
+    where: Prisma.KeyWhereUniqueInput;
+};
+/**
+ * Key findUniqueOrThrow
+ */
+export type KeyFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * Filter, which Key to fetch.
+     */
+    where: Prisma.KeyWhereUniqueInput;
+};
+/**
+ * Key findFirst
+ */
+export type KeyFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * Filter, which Key to fetch.
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Keys to fetch.
+     */
+    orderBy?: Prisma.KeyOrderByWithRelationInput | Prisma.KeyOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for Keys.
+     */
+    cursor?: Prisma.KeyWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Keys 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` Keys.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of Keys.
+     */
+    distinct?: Prisma.KeyScalarFieldEnum | Prisma.KeyScalarFieldEnum[];
+};
+/**
+ * Key findFirstOrThrow
+ */
+export type KeyFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * Filter, which Key to fetch.
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Keys to fetch.
+     */
+    orderBy?: Prisma.KeyOrderByWithRelationInput | Prisma.KeyOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for Keys.
+     */
+    cursor?: Prisma.KeyWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Keys 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` Keys.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of Keys.
+     */
+    distinct?: Prisma.KeyScalarFieldEnum | Prisma.KeyScalarFieldEnum[];
+};
+/**
+ * Key findMany
+ */
+export type KeyFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * Filter, which Keys to fetch.
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of Keys to fetch.
+     */
+    orderBy?: Prisma.KeyOrderByWithRelationInput | Prisma.KeyOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for listing Keys.
+     */
+    cursor?: Prisma.KeyWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` Keys 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` Keys.
+     */
+    skip?: number;
+    distinct?: Prisma.KeyScalarFieldEnum | Prisma.KeyScalarFieldEnum[];
+};
+/**
+ * Key create
+ */
+export type KeyCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * The data needed to create a Key.
+     */
+    data: Prisma.XOR<Prisma.KeyCreateInput, Prisma.KeyUncheckedCreateInput>;
+};
+/**
+ * Key createMany
+ */
+export type KeyCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many Keys.
+     */
+    data: Prisma.KeyCreateManyInput | Prisma.KeyCreateManyInput[];
+};
+/**
+ * Key createManyAndReturn
+ */
+export type KeyCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelectCreateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * The data used to create many Keys.
+     */
+    data: Prisma.KeyCreateManyInput | Prisma.KeyCreateManyInput[];
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyIncludeCreateManyAndReturn<ExtArgs> | null;
+};
+/**
+ * Key update
+ */
+export type KeyUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * The data needed to update a Key.
+     */
+    data: Prisma.XOR<Prisma.KeyUpdateInput, Prisma.KeyUncheckedUpdateInput>;
+    /**
+     * Choose, which Key to update.
+     */
+    where: Prisma.KeyWhereUniqueInput;
+};
+/**
+ * Key updateMany
+ */
+export type KeyUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to update Keys.
+     */
+    data: Prisma.XOR<Prisma.KeyUpdateManyMutationInput, Prisma.KeyUncheckedUpdateManyInput>;
+    /**
+     * Filter which Keys to update
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * Limit how many Keys to update.
+     */
+    limit?: number;
+};
+/**
+ * Key updateManyAndReturn
+ */
+export type KeyUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelectUpdateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * The data used to update Keys.
+     */
+    data: Prisma.XOR<Prisma.KeyUpdateManyMutationInput, Prisma.KeyUncheckedUpdateManyInput>;
+    /**
+     * Filter which Keys to update
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * Limit how many Keys to update.
+     */
+    limit?: number;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyIncludeUpdateManyAndReturn<ExtArgs> | null;
+};
+/**
+ * Key upsert
+ */
+export type KeyUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * The filter to search for the Key to update in case it exists.
+     */
+    where: Prisma.KeyWhereUniqueInput;
+    /**
+     * In case the Key found by the `where` argument doesn't exist, create a new Key with this data.
+     */
+    create: Prisma.XOR<Prisma.KeyCreateInput, Prisma.KeyUncheckedCreateInput>;
+    /**
+     * In case the Key was found with the provided `where` argument, update it with this data.
+     */
+    update: Prisma.XOR<Prisma.KeyUpdateInput, Prisma.KeyUncheckedUpdateInput>;
+};
+/**
+ * Key delete
+ */
+export type KeyDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+    /**
+     * Filter which Key to delete.
+     */
+    where: Prisma.KeyWhereUniqueInput;
+};
+/**
+ * Key deleteMany
+ */
+export type KeyDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which Keys to delete
+     */
+    where?: Prisma.KeyWhereInput;
+    /**
+     * Limit how many Keys to delete.
+     */
+    limit?: number;
+};
+/**
+ * Key.user
+ */
+export type Key$userArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the User
+     */
+    select?: Prisma.UserSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the User
+     */
+    omit?: Prisma.UserOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.UserInclude<ExtArgs> | null;
+    where?: Prisma.UserWhereInput;
+};
+/**
+ * Key without action
+ */
+export type KeyDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the Key
+     */
+    select?: Prisma.KeySelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the Key
+     */
+    omit?: Prisma.KeyOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.KeyInclude<ExtArgs> | null;
+};
+export {};