@wardby/cli 0.2.1 → 0.3.0

package/dist/generated/prisma/models/RegistryFetch.d.ts

@@ -0,0 +1,1428 @@
+import type * as runtime from "@prisma/client/runtime/client";
+import type * as $Enums from "../enums.js";
+import type * as Prisma from "../internal/prismaNamespace.js";
+/**
+ * Model RegistryFetch
+ * Audit ledger of every package fetch the registry proxy served or refused
+ * for a run.
+ */
+export type RegistryFetchModel = runtime.Types.Result.DefaultSelection<Prisma.$RegistryFetchPayload>;
+export type AggregateRegistryFetch = {
+    _count: RegistryFetchCountAggregateOutputType | null;
+    _avg: RegistryFetchAvgAggregateOutputType | null;
+    _sum: RegistryFetchSumAggregateOutputType | null;
+    _min: RegistryFetchMinAggregateOutputType | null;
+    _max: RegistryFetchMaxAggregateOutputType | null;
+};
+export type RegistryFetchAvgAggregateOutputType = {
+    sizeBytes: number | null;
+};
+export type RegistryFetchSumAggregateOutputType = {
+    sizeBytes: number | null;
+};
+export type RegistryFetchMinAggregateOutputType = {
+    id: string | null;
+    runId: string | null;
+    ecosystem: string | null;
+    name: string | null;
+    version: string | null;
+    filename: string | null;
+    integrity: string | null;
+    sizeBytes: number | null;
+    outcome: $Enums.RegistryFetchOutcome | null;
+    reason: string | null;
+    createdAt: Date | null;
+};
+export type RegistryFetchMaxAggregateOutputType = {
+    id: string | null;
+    runId: string | null;
+    ecosystem: string | null;
+    name: string | null;
+    version: string | null;
+    filename: string | null;
+    integrity: string | null;
+    sizeBytes: number | null;
+    outcome: $Enums.RegistryFetchOutcome | null;
+    reason: string | null;
+    createdAt: Date | null;
+};
+export type RegistryFetchCountAggregateOutputType = {
+    id: number;
+    runId: number;
+    ecosystem: number;
+    name: number;
+    version: number;
+    filename: number;
+    integrity: number;
+    sizeBytes: number;
+    outcome: number;
+    reason: number;
+    createdAt: number;
+    _all: number;
+};
+export type RegistryFetchAvgAggregateInputType = {
+    sizeBytes?: true;
+};
+export type RegistryFetchSumAggregateInputType = {
+    sizeBytes?: true;
+};
+export type RegistryFetchMinAggregateInputType = {
+    id?: true;
+    runId?: true;
+    ecosystem?: true;
+    name?: true;
+    version?: true;
+    filename?: true;
+    integrity?: true;
+    sizeBytes?: true;
+    outcome?: true;
+    reason?: true;
+    createdAt?: true;
+};
+export type RegistryFetchMaxAggregateInputType = {
+    id?: true;
+    runId?: true;
+    ecosystem?: true;
+    name?: true;
+    version?: true;
+    filename?: true;
+    integrity?: true;
+    sizeBytes?: true;
+    outcome?: true;
+    reason?: true;
+    createdAt?: true;
+};
+export type RegistryFetchCountAggregateInputType = {
+    id?: true;
+    runId?: true;
+    ecosystem?: true;
+    name?: true;
+    version?: true;
+    filename?: true;
+    integrity?: true;
+    sizeBytes?: true;
+    outcome?: true;
+    reason?: true;
+    createdAt?: true;
+    _all?: true;
+};
+export type RegistryFetchAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which RegistryFetch to aggregate.
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of RegistryFetches to fetch.
+     */
+    orderBy?: Prisma.RegistryFetchOrderByWithRelationInput | Prisma.RegistryFetchOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the start position
+     */
+    cursor?: Prisma.RegistryFetchWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` RegistryFetches 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` RegistryFetches.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Count returned RegistryFetches
+    **/
+    _count?: true | RegistryFetchCountAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to average
+    **/
+    _avg?: RegistryFetchAvgAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to sum
+    **/
+    _sum?: RegistryFetchSumAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the minimum value
+    **/
+    _min?: RegistryFetchMinAggregateInputType;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     *
+     * Select which fields to find the maximum value
+    **/
+    _max?: RegistryFetchMaxAggregateInputType;
+};
+export type GetRegistryFetchAggregateType<T extends RegistryFetchAggregateArgs> = {
+    [P in keyof T & keyof AggregateRegistryFetch]: P extends '_count' | 'count' ? T[P] extends true ? number : Prisma.GetScalarType<T[P], AggregateRegistryFetch[P]> : Prisma.GetScalarType<T[P], AggregateRegistryFetch[P]>;
+};
+export type RegistryFetchGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    where?: Prisma.RegistryFetchWhereInput;
+    orderBy?: Prisma.RegistryFetchOrderByWithAggregationInput | Prisma.RegistryFetchOrderByWithAggregationInput[];
+    by: Prisma.RegistryFetchScalarFieldEnum[] | Prisma.RegistryFetchScalarFieldEnum;
+    having?: Prisma.RegistryFetchScalarWhereWithAggregatesInput;
+    take?: number;
+    skip?: number;
+    _count?: RegistryFetchCountAggregateInputType | true;
+    _avg?: RegistryFetchAvgAggregateInputType;
+    _sum?: RegistryFetchSumAggregateInputType;
+    _min?: RegistryFetchMinAggregateInputType;
+    _max?: RegistryFetchMaxAggregateInputType;
+};
+export type RegistryFetchGroupByOutputType = {
+    id: string;
+    runId: string;
+    ecosystem: string;
+    name: string;
+    version: string | null;
+    filename: string | null;
+    integrity: string | null;
+    sizeBytes: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason: string | null;
+    createdAt: Date;
+    _count: RegistryFetchCountAggregateOutputType | null;
+    _avg: RegistryFetchAvgAggregateOutputType | null;
+    _sum: RegistryFetchSumAggregateOutputType | null;
+    _min: RegistryFetchMinAggregateOutputType | null;
+    _max: RegistryFetchMaxAggregateOutputType | null;
+};
+export type GetRegistryFetchGroupByPayload<T extends RegistryFetchGroupByArgs> = Prisma.PrismaPromise<Array<Prisma.PickEnumerable<RegistryFetchGroupByOutputType, T['by']> & {
+    [P in ((keyof T) & (keyof RegistryFetchGroupByOutputType))]: P extends '_count' ? T[P] extends boolean ? number : Prisma.GetScalarType<T[P], RegistryFetchGroupByOutputType[P]> : Prisma.GetScalarType<T[P], RegistryFetchGroupByOutputType[P]>;
+}>>;
+export type RegistryFetchWhereInput = {
+    AND?: Prisma.RegistryFetchWhereInput | Prisma.RegistryFetchWhereInput[];
+    OR?: Prisma.RegistryFetchWhereInput[];
+    NOT?: Prisma.RegistryFetchWhereInput | Prisma.RegistryFetchWhereInput[];
+    id?: Prisma.StringFilter<"RegistryFetch"> | string;
+    runId?: Prisma.StringFilter<"RegistryFetch"> | string;
+    ecosystem?: Prisma.StringFilter<"RegistryFetch"> | string;
+    name?: Prisma.StringFilter<"RegistryFetch"> | string;
+    version?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    filename?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    integrity?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    sizeBytes?: Prisma.IntNullableFilter<"RegistryFetch"> | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFilter<"RegistryFetch"> | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    createdAt?: Prisma.DateTimeFilter<"RegistryFetch"> | Date | string;
+    run?: Prisma.XOR<Prisma.CodingRunScalarRelationFilter, Prisma.CodingRunWhereInput>;
+};
+export type RegistryFetchOrderByWithRelationInput = {
+    id?: Prisma.SortOrder;
+    runId?: Prisma.SortOrder;
+    ecosystem?: Prisma.SortOrder;
+    name?: Prisma.SortOrder;
+    version?: Prisma.SortOrderInput | Prisma.SortOrder;
+    filename?: Prisma.SortOrderInput | Prisma.SortOrder;
+    integrity?: Prisma.SortOrderInput | Prisma.SortOrder;
+    sizeBytes?: Prisma.SortOrderInput | Prisma.SortOrder;
+    outcome?: Prisma.SortOrder;
+    reason?: Prisma.SortOrderInput | Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    run?: Prisma.CodingRunOrderByWithRelationInput;
+};
+export type RegistryFetchWhereUniqueInput = Prisma.AtLeast<{
+    id?: string;
+    AND?: Prisma.RegistryFetchWhereInput | Prisma.RegistryFetchWhereInput[];
+    OR?: Prisma.RegistryFetchWhereInput[];
+    NOT?: Prisma.RegistryFetchWhereInput | Prisma.RegistryFetchWhereInput[];
+    runId?: Prisma.StringFilter<"RegistryFetch"> | string;
+    ecosystem?: Prisma.StringFilter<"RegistryFetch"> | string;
+    name?: Prisma.StringFilter<"RegistryFetch"> | string;
+    version?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    filename?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    integrity?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    sizeBytes?: Prisma.IntNullableFilter<"RegistryFetch"> | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFilter<"RegistryFetch"> | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    createdAt?: Prisma.DateTimeFilter<"RegistryFetch"> | Date | string;
+    run?: Prisma.XOR<Prisma.CodingRunScalarRelationFilter, Prisma.CodingRunWhereInput>;
+}, "id">;
+export type RegistryFetchOrderByWithAggregationInput = {
+    id?: Prisma.SortOrder;
+    runId?: Prisma.SortOrder;
+    ecosystem?: Prisma.SortOrder;
+    name?: Prisma.SortOrder;
+    version?: Prisma.SortOrderInput | Prisma.SortOrder;
+    filename?: Prisma.SortOrderInput | Prisma.SortOrder;
+    integrity?: Prisma.SortOrderInput | Prisma.SortOrder;
+    sizeBytes?: Prisma.SortOrderInput | Prisma.SortOrder;
+    outcome?: Prisma.SortOrder;
+    reason?: Prisma.SortOrderInput | Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+    _count?: Prisma.RegistryFetchCountOrderByAggregateInput;
+    _avg?: Prisma.RegistryFetchAvgOrderByAggregateInput;
+    _max?: Prisma.RegistryFetchMaxOrderByAggregateInput;
+    _min?: Prisma.RegistryFetchMinOrderByAggregateInput;
+    _sum?: Prisma.RegistryFetchSumOrderByAggregateInput;
+};
+export type RegistryFetchScalarWhereWithAggregatesInput = {
+    AND?: Prisma.RegistryFetchScalarWhereWithAggregatesInput | Prisma.RegistryFetchScalarWhereWithAggregatesInput[];
+    OR?: Prisma.RegistryFetchScalarWhereWithAggregatesInput[];
+    NOT?: Prisma.RegistryFetchScalarWhereWithAggregatesInput | Prisma.RegistryFetchScalarWhereWithAggregatesInput[];
+    id?: Prisma.StringWithAggregatesFilter<"RegistryFetch"> | string;
+    runId?: Prisma.StringWithAggregatesFilter<"RegistryFetch"> | string;
+    ecosystem?: Prisma.StringWithAggregatesFilter<"RegistryFetch"> | string;
+    name?: Prisma.StringWithAggregatesFilter<"RegistryFetch"> | string;
+    version?: Prisma.StringNullableWithAggregatesFilter<"RegistryFetch"> | string | null;
+    filename?: Prisma.StringNullableWithAggregatesFilter<"RegistryFetch"> | string | null;
+    integrity?: Prisma.StringNullableWithAggregatesFilter<"RegistryFetch"> | string | null;
+    sizeBytes?: Prisma.IntNullableWithAggregatesFilter<"RegistryFetch"> | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeWithAggregatesFilter<"RegistryFetch"> | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.StringNullableWithAggregatesFilter<"RegistryFetch"> | string | null;
+    createdAt?: Prisma.DateTimeWithAggregatesFilter<"RegistryFetch"> | Date | string;
+};
+export type RegistryFetchCreateInput = {
+    id?: string;
+    ecosystem: string;
+    name: string;
+    version?: string | null;
+    filename?: string | null;
+    integrity?: string | null;
+    sizeBytes?: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason?: string | null;
+    createdAt?: Date | string;
+    run: Prisma.CodingRunCreateNestedOneWithoutRegistryFetchesInput;
+};
+export type RegistryFetchUncheckedCreateInput = {
+    id?: string;
+    runId: string;
+    ecosystem: string;
+    name: string;
+    version?: string | null;
+    filename?: string | null;
+    integrity?: string | null;
+    sizeBytes?: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason?: string | null;
+    createdAt?: Date | string;
+};
+export type RegistryFetchUpdateInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+    run?: Prisma.CodingRunUpdateOneRequiredWithoutRegistryFetchesNestedInput;
+};
+export type RegistryFetchUncheckedUpdateInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    runId?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type RegistryFetchCreateManyInput = {
+    id?: string;
+    runId: string;
+    ecosystem: string;
+    name: string;
+    version?: string | null;
+    filename?: string | null;
+    integrity?: string | null;
+    sizeBytes?: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason?: string | null;
+    createdAt?: Date | string;
+};
+export type RegistryFetchUpdateManyMutationInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type RegistryFetchUncheckedUpdateManyInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    runId?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type RegistryFetchListRelationFilter = {
+    every?: Prisma.RegistryFetchWhereInput;
+    some?: Prisma.RegistryFetchWhereInput;
+    none?: Prisma.RegistryFetchWhereInput;
+};
+export type RegistryFetchOrderByRelationAggregateInput = {
+    _count?: Prisma.SortOrder;
+};
+export type RegistryFetchCountOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    runId?: Prisma.SortOrder;
+    ecosystem?: Prisma.SortOrder;
+    name?: Prisma.SortOrder;
+    version?: Prisma.SortOrder;
+    filename?: Prisma.SortOrder;
+    integrity?: Prisma.SortOrder;
+    sizeBytes?: Prisma.SortOrder;
+    outcome?: Prisma.SortOrder;
+    reason?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+};
+export type RegistryFetchAvgOrderByAggregateInput = {
+    sizeBytes?: Prisma.SortOrder;
+};
+export type RegistryFetchMaxOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    runId?: Prisma.SortOrder;
+    ecosystem?: Prisma.SortOrder;
+    name?: Prisma.SortOrder;
+    version?: Prisma.SortOrder;
+    filename?: Prisma.SortOrder;
+    integrity?: Prisma.SortOrder;
+    sizeBytes?: Prisma.SortOrder;
+    outcome?: Prisma.SortOrder;
+    reason?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+};
+export type RegistryFetchMinOrderByAggregateInput = {
+    id?: Prisma.SortOrder;
+    runId?: Prisma.SortOrder;
+    ecosystem?: Prisma.SortOrder;
+    name?: Prisma.SortOrder;
+    version?: Prisma.SortOrder;
+    filename?: Prisma.SortOrder;
+    integrity?: Prisma.SortOrder;
+    sizeBytes?: Prisma.SortOrder;
+    outcome?: Prisma.SortOrder;
+    reason?: Prisma.SortOrder;
+    createdAt?: Prisma.SortOrder;
+};
+export type RegistryFetchSumOrderByAggregateInput = {
+    sizeBytes?: Prisma.SortOrder;
+};
+export type RegistryFetchCreateNestedManyWithoutRunInput = {
+    create?: Prisma.XOR<Prisma.RegistryFetchCreateWithoutRunInput, Prisma.RegistryFetchUncheckedCreateWithoutRunInput> | Prisma.RegistryFetchCreateWithoutRunInput[] | Prisma.RegistryFetchUncheckedCreateWithoutRunInput[];
+    connectOrCreate?: Prisma.RegistryFetchCreateOrConnectWithoutRunInput | Prisma.RegistryFetchCreateOrConnectWithoutRunInput[];
+    createMany?: Prisma.RegistryFetchCreateManyRunInputEnvelope;
+    connect?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+};
+export type RegistryFetchUncheckedCreateNestedManyWithoutRunInput = {
+    create?: Prisma.XOR<Prisma.RegistryFetchCreateWithoutRunInput, Prisma.RegistryFetchUncheckedCreateWithoutRunInput> | Prisma.RegistryFetchCreateWithoutRunInput[] | Prisma.RegistryFetchUncheckedCreateWithoutRunInput[];
+    connectOrCreate?: Prisma.RegistryFetchCreateOrConnectWithoutRunInput | Prisma.RegistryFetchCreateOrConnectWithoutRunInput[];
+    createMany?: Prisma.RegistryFetchCreateManyRunInputEnvelope;
+    connect?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+};
+export type RegistryFetchUpdateManyWithoutRunNestedInput = {
+    create?: Prisma.XOR<Prisma.RegistryFetchCreateWithoutRunInput, Prisma.RegistryFetchUncheckedCreateWithoutRunInput> | Prisma.RegistryFetchCreateWithoutRunInput[] | Prisma.RegistryFetchUncheckedCreateWithoutRunInput[];
+    connectOrCreate?: Prisma.RegistryFetchCreateOrConnectWithoutRunInput | Prisma.RegistryFetchCreateOrConnectWithoutRunInput[];
+    upsert?: Prisma.RegistryFetchUpsertWithWhereUniqueWithoutRunInput | Prisma.RegistryFetchUpsertWithWhereUniqueWithoutRunInput[];
+    createMany?: Prisma.RegistryFetchCreateManyRunInputEnvelope;
+    set?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    disconnect?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    delete?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    connect?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    update?: Prisma.RegistryFetchUpdateWithWhereUniqueWithoutRunInput | Prisma.RegistryFetchUpdateWithWhereUniqueWithoutRunInput[];
+    updateMany?: Prisma.RegistryFetchUpdateManyWithWhereWithoutRunInput | Prisma.RegistryFetchUpdateManyWithWhereWithoutRunInput[];
+    deleteMany?: Prisma.RegistryFetchScalarWhereInput | Prisma.RegistryFetchScalarWhereInput[];
+};
+export type RegistryFetchUncheckedUpdateManyWithoutRunNestedInput = {
+    create?: Prisma.XOR<Prisma.RegistryFetchCreateWithoutRunInput, Prisma.RegistryFetchUncheckedCreateWithoutRunInput> | Prisma.RegistryFetchCreateWithoutRunInput[] | Prisma.RegistryFetchUncheckedCreateWithoutRunInput[];
+    connectOrCreate?: Prisma.RegistryFetchCreateOrConnectWithoutRunInput | Prisma.RegistryFetchCreateOrConnectWithoutRunInput[];
+    upsert?: Prisma.RegistryFetchUpsertWithWhereUniqueWithoutRunInput | Prisma.RegistryFetchUpsertWithWhereUniqueWithoutRunInput[];
+    createMany?: Prisma.RegistryFetchCreateManyRunInputEnvelope;
+    set?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    disconnect?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    delete?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    connect?: Prisma.RegistryFetchWhereUniqueInput | Prisma.RegistryFetchWhereUniqueInput[];
+    update?: Prisma.RegistryFetchUpdateWithWhereUniqueWithoutRunInput | Prisma.RegistryFetchUpdateWithWhereUniqueWithoutRunInput[];
+    updateMany?: Prisma.RegistryFetchUpdateManyWithWhereWithoutRunInput | Prisma.RegistryFetchUpdateManyWithWhereWithoutRunInput[];
+    deleteMany?: Prisma.RegistryFetchScalarWhereInput | Prisma.RegistryFetchScalarWhereInput[];
+};
+export type EnumRegistryFetchOutcomeFieldUpdateOperationsInput = {
+    set?: $Enums.RegistryFetchOutcome;
+};
+export type RegistryFetchCreateWithoutRunInput = {
+    id?: string;
+    ecosystem: string;
+    name: string;
+    version?: string | null;
+    filename?: string | null;
+    integrity?: string | null;
+    sizeBytes?: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason?: string | null;
+    createdAt?: Date | string;
+};
+export type RegistryFetchUncheckedCreateWithoutRunInput = {
+    id?: string;
+    ecosystem: string;
+    name: string;
+    version?: string | null;
+    filename?: string | null;
+    integrity?: string | null;
+    sizeBytes?: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason?: string | null;
+    createdAt?: Date | string;
+};
+export type RegistryFetchCreateOrConnectWithoutRunInput = {
+    where: Prisma.RegistryFetchWhereUniqueInput;
+    create: Prisma.XOR<Prisma.RegistryFetchCreateWithoutRunInput, Prisma.RegistryFetchUncheckedCreateWithoutRunInput>;
+};
+export type RegistryFetchCreateManyRunInputEnvelope = {
+    data: Prisma.RegistryFetchCreateManyRunInput | Prisma.RegistryFetchCreateManyRunInput[];
+    skipDuplicates?: boolean;
+};
+export type RegistryFetchUpsertWithWhereUniqueWithoutRunInput = {
+    where: Prisma.RegistryFetchWhereUniqueInput;
+    update: Prisma.XOR<Prisma.RegistryFetchUpdateWithoutRunInput, Prisma.RegistryFetchUncheckedUpdateWithoutRunInput>;
+    create: Prisma.XOR<Prisma.RegistryFetchCreateWithoutRunInput, Prisma.RegistryFetchUncheckedCreateWithoutRunInput>;
+};
+export type RegistryFetchUpdateWithWhereUniqueWithoutRunInput = {
+    where: Prisma.RegistryFetchWhereUniqueInput;
+    data: Prisma.XOR<Prisma.RegistryFetchUpdateWithoutRunInput, Prisma.RegistryFetchUncheckedUpdateWithoutRunInput>;
+};
+export type RegistryFetchUpdateManyWithWhereWithoutRunInput = {
+    where: Prisma.RegistryFetchScalarWhereInput;
+    data: Prisma.XOR<Prisma.RegistryFetchUpdateManyMutationInput, Prisma.RegistryFetchUncheckedUpdateManyWithoutRunInput>;
+};
+export type RegistryFetchScalarWhereInput = {
+    AND?: Prisma.RegistryFetchScalarWhereInput | Prisma.RegistryFetchScalarWhereInput[];
+    OR?: Prisma.RegistryFetchScalarWhereInput[];
+    NOT?: Prisma.RegistryFetchScalarWhereInput | Prisma.RegistryFetchScalarWhereInput[];
+    id?: Prisma.StringFilter<"RegistryFetch"> | string;
+    runId?: Prisma.StringFilter<"RegistryFetch"> | string;
+    ecosystem?: Prisma.StringFilter<"RegistryFetch"> | string;
+    name?: Prisma.StringFilter<"RegistryFetch"> | string;
+    version?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    filename?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    integrity?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    sizeBytes?: Prisma.IntNullableFilter<"RegistryFetch"> | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFilter<"RegistryFetch"> | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.StringNullableFilter<"RegistryFetch"> | string | null;
+    createdAt?: Prisma.DateTimeFilter<"RegistryFetch"> | Date | string;
+};
+export type RegistryFetchCreateManyRunInput = {
+    id?: string;
+    ecosystem: string;
+    name: string;
+    version?: string | null;
+    filename?: string | null;
+    integrity?: string | null;
+    sizeBytes?: number | null;
+    outcome: $Enums.RegistryFetchOutcome;
+    reason?: string | null;
+    createdAt?: Date | string;
+};
+export type RegistryFetchUpdateWithoutRunInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type RegistryFetchUncheckedUpdateWithoutRunInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type RegistryFetchUncheckedUpdateManyWithoutRunInput = {
+    id?: Prisma.StringFieldUpdateOperationsInput | string;
+    ecosystem?: Prisma.StringFieldUpdateOperationsInput | string;
+    name?: Prisma.StringFieldUpdateOperationsInput | string;
+    version?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    filename?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    integrity?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    sizeBytes?: Prisma.NullableIntFieldUpdateOperationsInput | number | null;
+    outcome?: Prisma.EnumRegistryFetchOutcomeFieldUpdateOperationsInput | $Enums.RegistryFetchOutcome;
+    reason?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
+    createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
+};
+export type RegistryFetchSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    runId?: boolean;
+    ecosystem?: boolean;
+    name?: boolean;
+    version?: boolean;
+    filename?: boolean;
+    integrity?: boolean;
+    sizeBytes?: boolean;
+    outcome?: boolean;
+    reason?: boolean;
+    createdAt?: boolean;
+    run?: boolean | Prisma.CodingRunDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["registryFetch"]>;
+export type RegistryFetchSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    runId?: boolean;
+    ecosystem?: boolean;
+    name?: boolean;
+    version?: boolean;
+    filename?: boolean;
+    integrity?: boolean;
+    sizeBytes?: boolean;
+    outcome?: boolean;
+    reason?: boolean;
+    createdAt?: boolean;
+    run?: boolean | Prisma.CodingRunDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["registryFetch"]>;
+export type RegistryFetchSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+    id?: boolean;
+    runId?: boolean;
+    ecosystem?: boolean;
+    name?: boolean;
+    version?: boolean;
+    filename?: boolean;
+    integrity?: boolean;
+    sizeBytes?: boolean;
+    outcome?: boolean;
+    reason?: boolean;
+    createdAt?: boolean;
+    run?: boolean | Prisma.CodingRunDefaultArgs<ExtArgs>;
+}, ExtArgs["result"]["registryFetch"]>;
+export type RegistryFetchSelectScalar = {
+    id?: boolean;
+    runId?: boolean;
+    ecosystem?: boolean;
+    name?: boolean;
+    version?: boolean;
+    filename?: boolean;
+    integrity?: boolean;
+    sizeBytes?: boolean;
+    outcome?: boolean;
+    reason?: boolean;
+    createdAt?: boolean;
+};
+export type RegistryFetchOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "runId" | "ecosystem" | "name" | "version" | "filename" | "integrity" | "sizeBytes" | "outcome" | "reason" | "createdAt", ExtArgs["result"]["registryFetch"]>;
+export type RegistryFetchInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    run?: boolean | Prisma.CodingRunDefaultArgs<ExtArgs>;
+};
+export type RegistryFetchIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    run?: boolean | Prisma.CodingRunDefaultArgs<ExtArgs>;
+};
+export type RegistryFetchIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    run?: boolean | Prisma.CodingRunDefaultArgs<ExtArgs>;
+};
+export type $RegistryFetchPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    name: "RegistryFetch";
+    objects: {
+        run: Prisma.$CodingRunPayload<ExtArgs>;
+    };
+    scalars: runtime.Types.Extensions.GetPayloadResult<{
+        id: string;
+        runId: string;
+        ecosystem: string;
+        name: string;
+        version: string | null;
+        filename: string | null;
+        integrity: string | null;
+        sizeBytes: number | null;
+        outcome: $Enums.RegistryFetchOutcome;
+        reason: string | null;
+        createdAt: Date;
+    }, ExtArgs["result"]["registryFetch"]>;
+    composites: {};
+};
+export type RegistryFetchGetPayload<S extends boolean | null | undefined | RegistryFetchDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload, S>;
+export type RegistryFetchCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = Omit<RegistryFetchFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: RegistryFetchCountAggregateInputType | true;
+};
+export interface RegistryFetchDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: {
+        types: Prisma.TypeMap<ExtArgs>['model']['RegistryFetch'];
+        meta: {
+            name: 'RegistryFetch';
+        };
+    };
+    /**
+     * Find zero or one RegistryFetch that matches the filter.
+     * @param {RegistryFetchFindUniqueArgs} args - Arguments to find a RegistryFetch
+     * @example
+     * // Get one RegistryFetch
+     * const registryFetch = await prisma.registryFetch.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends RegistryFetchFindUniqueArgs>(args: Prisma.SelectSubset<T, RegistryFetchFindUniqueArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find one RegistryFetch that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {RegistryFetchFindUniqueOrThrowArgs} args - Arguments to find a RegistryFetch
+     * @example
+     * // Get one RegistryFetch
+     * const registryFetch = await prisma.registryFetch.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends RegistryFetchFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, RegistryFetchFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first RegistryFetch 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 {RegistryFetchFindFirstArgs} args - Arguments to find a RegistryFetch
+     * @example
+     * // Get one RegistryFetch
+     * const registryFetch = await prisma.registryFetch.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends RegistryFetchFindFirstArgs>(args?: Prisma.SelectSubset<T, RegistryFetchFindFirstArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find the first RegistryFetch 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 {RegistryFetchFindFirstOrThrowArgs} args - Arguments to find a RegistryFetch
+     * @example
+     * // Get one RegistryFetch
+     * const registryFetch = await prisma.registryFetch.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends RegistryFetchFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, RegistryFetchFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Find zero or more RegistryFetches 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 {RegistryFetchFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all RegistryFetches
+     * const registryFetches = await prisma.registryFetch.findMany()
+     *
+     * // Get first 10 RegistryFetches
+     * const registryFetches = await prisma.registryFetch.findMany({ take: 10 })
+     *
+     * // Only select the `id`
+     * const registryFetchWithIdOnly = await prisma.registryFetch.findMany({ select: { id: true } })
+     *
+     */
+    findMany<T extends RegistryFetchFindManyArgs>(args?: Prisma.SelectSubset<T, RegistryFetchFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>;
+    /**
+     * Create a RegistryFetch.
+     * @param {RegistryFetchCreateArgs} args - Arguments to create a RegistryFetch.
+     * @example
+     * // Create one RegistryFetch
+     * const RegistryFetch = await prisma.registryFetch.create({
+     *   data: {
+     *     // ... data to create a RegistryFetch
+     *   }
+     * })
+     *
+     */
+    create<T extends RegistryFetchCreateArgs>(args: Prisma.SelectSubset<T, RegistryFetchCreateArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Create many RegistryFetches.
+     * @param {RegistryFetchCreateManyArgs} args - Arguments to create many RegistryFetches.
+     * @example
+     * // Create many RegistryFetches
+     * const registryFetch = await prisma.registryFetch.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     */
+    createMany<T extends RegistryFetchCreateManyArgs>(args?: Prisma.SelectSubset<T, RegistryFetchCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    /**
+     * Create many RegistryFetches and returns the data saved in the database.
+     * @param {RegistryFetchCreateManyAndReturnArgs} args - Arguments to create many RegistryFetches.
+     * @example
+     * // Create many RegistryFetches
+     * const registryFetch = await prisma.registryFetch.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Create many RegistryFetches and only return the `id`
+     * const registryFetchWithIdOnly = await prisma.registryFetch.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 RegistryFetchCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, RegistryFetchCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Delete a RegistryFetch.
+     * @param {RegistryFetchDeleteArgs} args - Arguments to delete one RegistryFetch.
+     * @example
+     * // Delete one RegistryFetch
+     * const RegistryFetch = await prisma.registryFetch.delete({
+     *   where: {
+     *     // ... filter to delete one RegistryFetch
+     *   }
+     * })
+     *
+     */
+    delete<T extends RegistryFetchDeleteArgs>(args: Prisma.SelectSubset<T, RegistryFetchDeleteArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Update one RegistryFetch.
+     * @param {RegistryFetchUpdateArgs} args - Arguments to update one RegistryFetch.
+     * @example
+     * // Update one RegistryFetch
+     * const registryFetch = await prisma.registryFetch.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    update<T extends RegistryFetchUpdateArgs>(args: Prisma.SelectSubset<T, RegistryFetchUpdateArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Delete zero or more RegistryFetches.
+     * @param {RegistryFetchDeleteManyArgs} args - Arguments to filter RegistryFetches to delete.
+     * @example
+     * // Delete a few RegistryFetches
+     * const { count } = await prisma.registryFetch.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     *
+     */
+    deleteMany<T extends RegistryFetchDeleteManyArgs>(args?: Prisma.SelectSubset<T, RegistryFetchDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    /**
+     * Update zero or more RegistryFetches.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RegistryFetchUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many RegistryFetches
+     * const registryFetch = await prisma.registryFetch.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     *
+     */
+    updateMany<T extends RegistryFetchUpdateManyArgs>(args: Prisma.SelectSubset<T, RegistryFetchUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    /**
+     * Update zero or more RegistryFetches and returns the data updated in the database.
+     * @param {RegistryFetchUpdateManyAndReturnArgs} args - Arguments to update many RegistryFetches.
+     * @example
+     * // Update many RegistryFetches
+     * const registryFetch = await prisma.registryFetch.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *
+     * // Update zero or more RegistryFetches and only return the `id`
+     * const registryFetchWithIdOnly = await prisma.registryFetch.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 RegistryFetchUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, RegistryFetchUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>;
+    /**
+     * Create or update one RegistryFetch.
+     * @param {RegistryFetchUpsertArgs} args - Arguments to update or create a RegistryFetch.
+     * @example
+     * // Update or create a RegistryFetch
+     * const registryFetch = await prisma.registryFetch.upsert({
+     *   create: {
+     *     // ... data to create a RegistryFetch
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the RegistryFetch we want to update
+     *   }
+     * })
+     */
+    upsert<T extends RegistryFetchUpsertArgs>(args: Prisma.SelectSubset<T, RegistryFetchUpsertArgs<ExtArgs>>): Prisma.Prisma__RegistryFetchClient<runtime.Types.Result.GetResult<Prisma.$RegistryFetchPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>;
+    /**
+     * Count the number of RegistryFetches.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RegistryFetchCountArgs} args - Arguments to filter RegistryFetches to count.
+     * @example
+     * // Count the number of RegistryFetches
+     * const count = await prisma.registryFetch.count({
+     *   where: {
+     *     // ... the filter for the RegistryFetches we want to count
+     *   }
+     * })
+    **/
+    count<T extends RegistryFetchCountArgs>(args?: Prisma.Subset<T, RegistryFetchCountArgs>): Prisma.PrismaPromise<T extends runtime.Types.Utils.Record<'select', any> ? T['select'] extends true ? number : Prisma.GetScalarType<T['select'], RegistryFetchCountAggregateOutputType> : number>;
+    /**
+     * Allows you to perform aggregations operations on a RegistryFetch.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RegistryFetchAggregateArgs} 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 RegistryFetchAggregateArgs>(args: Prisma.Subset<T, RegistryFetchAggregateArgs>): Prisma.PrismaPromise<GetRegistryFetchAggregateType<T>>;
+    /**
+     * Group by RegistryFetch.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {RegistryFetchGroupByArgs} 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 RegistryFetchGroupByArgs, HasSelectOrTake extends Prisma.Or<Prisma.Extends<'skip', Prisma.Keys<T>>, Prisma.Extends<'take', Prisma.Keys<T>>>, OrderByArg extends Prisma.True extends HasSelectOrTake ? {
+        orderBy: RegistryFetchGroupByArgs['orderBy'];
+    } : {
+        orderBy?: RegistryFetchGroupByArgs['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, RegistryFetchGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetRegistryFetchGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>;
+    /**
+     * Fields of the RegistryFetch model
+     */
+    readonly fields: RegistryFetchFieldRefs;
+}
+/**
+ * The delegate class that acts as a "Promise-like" for RegistryFetch.
+ * 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__RegistryFetchClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise";
+    run<T extends Prisma.CodingRunDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.CodingRunDefaultArgs<ExtArgs>>): Prisma.Prisma__CodingRunClient<runtime.Types.Result.GetResult<Prisma.$CodingRunPayload<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 RegistryFetch model
+ */
+export interface RegistryFetchFieldRefs {
+    readonly id: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly runId: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly ecosystem: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly name: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly version: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly filename: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly integrity: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly sizeBytes: Prisma.FieldRef<"RegistryFetch", 'Int'>;
+    readonly outcome: Prisma.FieldRef<"RegistryFetch", 'RegistryFetchOutcome'>;
+    readonly reason: Prisma.FieldRef<"RegistryFetch", 'String'>;
+    readonly createdAt: Prisma.FieldRef<"RegistryFetch", 'DateTime'>;
+}
+/**
+ * RegistryFetch findUnique
+ */
+export type RegistryFetchFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * Filter, which RegistryFetch to fetch.
+     */
+    where: Prisma.RegistryFetchWhereUniqueInput;
+};
+/**
+ * RegistryFetch findUniqueOrThrow
+ */
+export type RegistryFetchFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * Filter, which RegistryFetch to fetch.
+     */
+    where: Prisma.RegistryFetchWhereUniqueInput;
+};
+/**
+ * RegistryFetch findFirst
+ */
+export type RegistryFetchFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * Filter, which RegistryFetch to fetch.
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of RegistryFetches to fetch.
+     */
+    orderBy?: Prisma.RegistryFetchOrderByWithRelationInput | Prisma.RegistryFetchOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for RegistryFetches.
+     */
+    cursor?: Prisma.RegistryFetchWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` RegistryFetches 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` RegistryFetches.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of RegistryFetches.
+     */
+    distinct?: Prisma.RegistryFetchScalarFieldEnum | Prisma.RegistryFetchScalarFieldEnum[];
+};
+/**
+ * RegistryFetch findFirstOrThrow
+ */
+export type RegistryFetchFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * Filter, which RegistryFetch to fetch.
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of RegistryFetches to fetch.
+     */
+    orderBy?: Prisma.RegistryFetchOrderByWithRelationInput | Prisma.RegistryFetchOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for searching for RegistryFetches.
+     */
+    cursor?: Prisma.RegistryFetchWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` RegistryFetches 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` RegistryFetches.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of RegistryFetches.
+     */
+    distinct?: Prisma.RegistryFetchScalarFieldEnum | Prisma.RegistryFetchScalarFieldEnum[];
+};
+/**
+ * RegistryFetch findMany
+ */
+export type RegistryFetchFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * Filter, which RegistryFetches to fetch.
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     *
+     * Determine the order of RegistryFetches to fetch.
+     */
+    orderBy?: Prisma.RegistryFetchOrderByWithRelationInput | Prisma.RegistryFetchOrderByWithRelationInput[];
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     *
+     * Sets the position for listing RegistryFetches.
+     */
+    cursor?: Prisma.RegistryFetchWhereUniqueInput;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     *
+     * Take `±n` RegistryFetches 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` RegistryFetches.
+     */
+    skip?: number;
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     *
+     * Filter by unique combinations of RegistryFetches.
+     */
+    distinct?: Prisma.RegistryFetchScalarFieldEnum | Prisma.RegistryFetchScalarFieldEnum[];
+};
+/**
+ * RegistryFetch create
+ */
+export type RegistryFetchCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * The data needed to create a RegistryFetch.
+     */
+    data: Prisma.XOR<Prisma.RegistryFetchCreateInput, Prisma.RegistryFetchUncheckedCreateInput>;
+};
+/**
+ * RegistryFetch createMany
+ */
+export type RegistryFetchCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many RegistryFetches.
+     */
+    data: Prisma.RegistryFetchCreateManyInput | Prisma.RegistryFetchCreateManyInput[];
+    skipDuplicates?: boolean;
+};
+/**
+ * RegistryFetch createManyAndReturn
+ */
+export type RegistryFetchCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelectCreateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * The data used to create many RegistryFetches.
+     */
+    data: Prisma.RegistryFetchCreateManyInput | Prisma.RegistryFetchCreateManyInput[];
+    skipDuplicates?: boolean;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchIncludeCreateManyAndReturn<ExtArgs> | null;
+};
+/**
+ * RegistryFetch update
+ */
+export type RegistryFetchUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * The data needed to update a RegistryFetch.
+     */
+    data: Prisma.XOR<Prisma.RegistryFetchUpdateInput, Prisma.RegistryFetchUncheckedUpdateInput>;
+    /**
+     * Choose, which RegistryFetch to update.
+     */
+    where: Prisma.RegistryFetchWhereUniqueInput;
+};
+/**
+ * RegistryFetch updateMany
+ */
+export type RegistryFetchUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * The data used to update RegistryFetches.
+     */
+    data: Prisma.XOR<Prisma.RegistryFetchUpdateManyMutationInput, Prisma.RegistryFetchUncheckedUpdateManyInput>;
+    /**
+     * Filter which RegistryFetches to update
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * Limit how many RegistryFetches to update.
+     */
+    limit?: number;
+};
+/**
+ * RegistryFetch updateManyAndReturn
+ */
+export type RegistryFetchUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelectUpdateManyAndReturn<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * The data used to update RegistryFetches.
+     */
+    data: Prisma.XOR<Prisma.RegistryFetchUpdateManyMutationInput, Prisma.RegistryFetchUncheckedUpdateManyInput>;
+    /**
+     * Filter which RegistryFetches to update
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * Limit how many RegistryFetches to update.
+     */
+    limit?: number;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchIncludeUpdateManyAndReturn<ExtArgs> | null;
+};
+/**
+ * RegistryFetch upsert
+ */
+export type RegistryFetchUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * The filter to search for the RegistryFetch to update in case it exists.
+     */
+    where: Prisma.RegistryFetchWhereUniqueInput;
+    /**
+     * In case the RegistryFetch found by the `where` argument doesn't exist, create a new RegistryFetch with this data.
+     */
+    create: Prisma.XOR<Prisma.RegistryFetchCreateInput, Prisma.RegistryFetchUncheckedCreateInput>;
+    /**
+     * In case the RegistryFetch was found with the provided `where` argument, update it with this data.
+     */
+    update: Prisma.XOR<Prisma.RegistryFetchUpdateInput, Prisma.RegistryFetchUncheckedUpdateInput>;
+};
+/**
+ * RegistryFetch delete
+ */
+export type RegistryFetchDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+    /**
+     * Filter which RegistryFetch to delete.
+     */
+    where: Prisma.RegistryFetchWhereUniqueInput;
+};
+/**
+ * RegistryFetch deleteMany
+ */
+export type RegistryFetchDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Filter which RegistryFetches to delete
+     */
+    where?: Prisma.RegistryFetchWhereInput;
+    /**
+     * Limit how many RegistryFetches to delete.
+     */
+    limit?: number;
+};
+/**
+ * RegistryFetch without action
+ */
+export type RegistryFetchDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the RegistryFetch
+     */
+    select?: Prisma.RegistryFetchSelect<ExtArgs> | null;
+    /**
+     * Omit specific fields from the RegistryFetch
+     */
+    omit?: Prisma.RegistryFetchOmit<ExtArgs> | null;
+    /**
+     * Choose, which related nodes to fetch as well
+     */
+    include?: Prisma.RegistryFetchInclude<ExtArgs> | null;
+};