Rename pipeline schema (#184)

front/src/generated/graphql.tsx

@@ -993,20 +993,15 @@ export type Pipeline = {
   icon: Scalars['String'];
   id: Scalars['ID'];
   name: Scalars['String'];
-  pipelineAssociations?: Maybe<Array<PipelineAssociation>>;
+  pipelineProgresses?: Maybe<Array<PipelineProgress>>;
   pipelineStages?: Maybe<Array<PipelineStage>>;
   updatedAt: Scalars['DateTime'];
 };
 
-export enum PipelineAssociableType {
+export type PipelineProgress = {
-  Company = 'Company',
+  __typename?: 'PipelineProgress';
-  Person = 'Person'
-}
-
-export type PipelineAssociation = {
-  __typename?: 'PipelineAssociation';
   associableId: Scalars['String'];
-  associableType: PipelineAssociableType;
+  associableType: PipelineProgressableType;
   createdAt: Scalars['DateTime'];
   deletedAt?: Maybe<Scalars['DateTime']>;
   id: Scalars['ID'];
@@ -1017,6 +1012,11 @@ export type PipelineAssociation = {
   updatedAt: Scalars['DateTime'];
 };
 
+export enum PipelineProgressableType {
+  Company = 'Company',
+  Person = 'Person'
+}
+
 export type PipelineStage = {
   __typename?: 'PipelineStage';
   color: Scalars['String'];
@@ -1025,8 +1025,8 @@ export type PipelineStage = {
   id: Scalars['ID'];
   name: Scalars['String'];
   pipeline: Pipeline;
-  pipelineAssociations?: Maybe<Array<PipelineAssociation>>;
   pipelineId: Scalars['String'];
+  pipelineProgresses?: Maybe<Array<PipelineProgress>>;
   type: Scalars['String'];
   updatedAt: Scalars['DateTime'];
 };

server/src/api/@generated/pipeline-progress/aggregate-pipeline-progress.output.ts

@@ -0,0 +1,17 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { PipelineProgressCountAggregate } from './pipeline-progress-count-aggregate.output';
+import { PipelineProgressMinAggregate } from './pipeline-progress-min-aggregate.output';
+import { PipelineProgressMaxAggregate } from './pipeline-progress-max-aggregate.output';
+
+@ObjectType()
+export class AggregatePipelineProgress {
+  @Field(() => PipelineProgressCountAggregate, { nullable: true })
+  _count?: PipelineProgressCountAggregate;
+
+  @Field(() => PipelineProgressMinAggregate, { nullable: true })
+  _min?: PipelineProgressMinAggregate;
+
+  @Field(() => PipelineProgressMaxAggregate, { nullable: true })
+  _max?: PipelineProgressMaxAggregate;
+}

server/src/api/@generated/pipeline-progress/create-many-pipeline-progress.args.ts

@@ -0,0 +1,14 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressCreateManyInput } from './pipeline-progress-create-many.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class CreateManyPipelineProgressArgs {
+  @Field(() => [PipelineProgressCreateManyInput], { nullable: false })
+  @Type(() => PipelineProgressCreateManyInput)
+  data!: Array<PipelineProgressCreateManyInput>;
+
+  @Field(() => Boolean, { nullable: true })
+  skipDuplicates?: boolean;
+}

server/src/api/@generated/pipeline-progress/create-one-pipeline-progress.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressCreateInput } from './pipeline-progress-create.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class CreateOnePipelineProgressArgs {
+  @Field(() => PipelineProgressCreateInput, { nullable: false })
+  @Type(() => PipelineProgressCreateInput)
+  data!: PipelineProgressCreateInput;
+}

server/src/api/@generated/pipeline-progress/delete-many-pipeline-progress.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class DeleteManyPipelineProgressArgs {
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  @Type(() => PipelineProgressWhereInput)
+  where?: PipelineProgressWhereInput;
+}

server/src/api/@generated/pipeline-progress/delete-one-pipeline-progress.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class DeleteOnePipelineProgressArgs {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+}

server/src/api/@generated/pipeline-progress/find-first-pipeline-progress-or-throw.args.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressOrderByWithRelationInput } from './pipeline-progress-order-by-with-relation.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { PipelineProgressScalarFieldEnum } from './pipeline-progress-scalar-field.enum';
+
+@ArgsType()
+export class FindFirstPipelineProgressOrThrowArgs {
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  @Type(() => PipelineProgressWhereInput)
+  where?: PipelineProgressWhereInput;
+
+  @Field(() => [PipelineProgressOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<PipelineProgressOrderByWithRelationInput>;
+
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: true })
+  cursor?: PipelineProgressWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [PipelineProgressScalarFieldEnum], { nullable: true })
+  distinct?: Array<keyof typeof PipelineProgressScalarFieldEnum>;
+}

server/src/api/@generated/pipeline-progress/find-first-pipeline-progress.args.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressOrderByWithRelationInput } from './pipeline-progress-order-by-with-relation.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { PipelineProgressScalarFieldEnum } from './pipeline-progress-scalar-field.enum';
+
+@ArgsType()
+export class FindFirstPipelineProgressArgs {
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  @Type(() => PipelineProgressWhereInput)
+  where?: PipelineProgressWhereInput;
+
+  @Field(() => [PipelineProgressOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<PipelineProgressOrderByWithRelationInput>;
+
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: true })
+  cursor?: PipelineProgressWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [PipelineProgressScalarFieldEnum], { nullable: true })
+  distinct?: Array<keyof typeof PipelineProgressScalarFieldEnum>;
+}

server/src/api/@generated/pipeline-progress/find-many-pipeline-progress.args.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressOrderByWithRelationInput } from './pipeline-progress-order-by-with-relation.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Int } from '@nestjs/graphql';
+import { PipelineProgressScalarFieldEnum } from './pipeline-progress-scalar-field.enum';
+
+@ArgsType()
+export class FindManyPipelineProgressArgs {
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  @Type(() => PipelineProgressWhereInput)
+  where?: PipelineProgressWhereInput;
+
+  @Field(() => [PipelineProgressOrderByWithRelationInput], { nullable: true })
+  orderBy?: Array<PipelineProgressOrderByWithRelationInput>;
+
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: true })
+  cursor?: PipelineProgressWhereUniqueInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [PipelineProgressScalarFieldEnum], { nullable: true })
+  distinct?: Array<keyof typeof PipelineProgressScalarFieldEnum>;
+}

server/src/api/@generated/pipeline-progress/find-unique-pipeline-progress-or-throw.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class FindUniquePipelineProgressOrThrowArgs {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+}

server/src/api/@generated/pipeline-progress/find-unique-pipeline-progress.args.ts

@@ -0,0 +1,11 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+
+@ArgsType()
+export class FindUniquePipelineProgressArgs {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-count-aggregate.input.ts

@@ -0,0 +1,32 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineProgressCountAggregateInput {
+  @Field(() => Boolean, { nullable: true })
+  id?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  createdAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  updatedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  deletedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  pipelineId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  pipelineStageId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  associableType?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  associableId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  _all?: true;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-count-aggregate.output.ts

@@ -0,0 +1,33 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { Int } from '@nestjs/graphql';
+
+@ObjectType()
+export class PipelineProgressCountAggregate {
+  @Field(() => Int, { nullable: false })
+  id!: number;
+
+  @Field(() => Int, { nullable: false })
+  createdAt!: number;
+
+  @Field(() => Int, { nullable: false })
+  updatedAt!: number;
+
+  @Field(() => Int, { nullable: false })
+  deletedAt!: number;
+
+  @Field(() => Int, { nullable: false })
+  pipelineId!: number;
+
+  @Field(() => Int, { nullable: false })
+  pipelineStageId!: number;
+
+  @Field(() => Int, { nullable: false })
+  associableType!: number;
+
+  @Field(() => Int, { nullable: false })
+  associableId!: number;
+
+  @Field(() => Int, { nullable: false })
+  _all!: number;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-count-order-by-aggregate.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class PipelineProgressCountOrderByAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineStageId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableType?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableId?: keyof typeof SortOrder;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-many-pipeline-input-envelope.input.ts

@@ -0,0 +1,14 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateManyPipelineInput } from './pipeline-progress-create-many-pipeline.input';
+import { Type } from 'class-transformer';
+
+@InputType()
+export class PipelineProgressCreateManyPipelineInputEnvelope {
+  @Field(() => [PipelineProgressCreateManyPipelineInput], { nullable: false })
+  @Type(() => PipelineProgressCreateManyPipelineInput)
+  data!: Array<PipelineProgressCreateManyPipelineInput>;
+
+  @Field(() => Boolean, { nullable: true })
+  skipDuplicates?: boolean;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-many-pipeline-stage-input-envelope.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateManyPipelineStageInput } from './pipeline-progress-create-many-pipeline-stage.input';
+import { Type } from 'class-transformer';
+
+@InputType()
+export class PipelineProgressCreateManyPipelineStageInputEnvelope {
+  @Field(() => [PipelineProgressCreateManyPipelineStageInput], {
+    nullable: false,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineStageInput)
+  data!: Array<PipelineProgressCreateManyPipelineStageInput>;
+
+  @Field(() => Boolean, { nullable: true })
+  skipDuplicates?: boolean;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-many-pipeline-stage.input.ts

@@ -0,0 +1,27 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@InputType()
+export class PipelineProgressCreateManyPipelineStageInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-many-pipeline.input.ts

@@ -0,0 +1,27 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@InputType()
+export class PipelineProgressCreateManyPipelineInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineStageId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-many.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@InputType()
+export class PipelineProgressCreateManyInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @Field(() => String, { nullable: false })
+  pipelineStageId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-nested-many-without-pipeline-stage.input.ts

@@ -0,0 +1,32 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineStageInput } from './pipeline-progress-create-without-pipeline-stage.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineStageInput } from './pipeline-progress-create-or-connect-without-pipeline-stage.input';
+import { PipelineProgressCreateManyPipelineStageInputEnvelope } from './pipeline-progress-create-many-pipeline-stage-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+
+@InputType()
+export class PipelineProgressCreateNestedManyWithoutPipelineStageInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateWithoutPipelineStageInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineStageInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineStageInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineStageInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineStageInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineStageInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-nested-many-without-pipeline.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineInput } from './pipeline-progress-create-without-pipeline.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineInput } from './pipeline-progress-create-or-connect-without-pipeline.input';
+import { PipelineProgressCreateManyPipelineInputEnvelope } from './pipeline-progress-create-many-pipeline-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+
+@InputType()
+export class PipelineProgressCreateNestedManyWithoutPipelineInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineInput], { nullable: true })
+  @Type(() => PipelineProgressCreateWithoutPipelineInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-or-connect-without-pipeline-stage.input.ts

@@ -0,0 +1,18 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateWithoutPipelineStageInput } from './pipeline-progress-create-without-pipeline-stage.input';
+
+@InputType()
+export class PipelineProgressCreateOrConnectWithoutPipelineStageInput {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressCreateWithoutPipelineStageInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineProgressCreateWithoutPipelineStageInput)
+  create!: PipelineProgressCreateWithoutPipelineStageInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-or-connect-without-pipeline.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateWithoutPipelineInput } from './pipeline-progress-create-without-pipeline.input';
+
+@InputType()
+export class PipelineProgressCreateOrConnectWithoutPipelineInput {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressCreateWithoutPipelineInput, { nullable: false })
+  @Type(() => PipelineProgressCreateWithoutPipelineInput)
+  create!: PipelineProgressCreateWithoutPipelineInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-without-pipeline-stage.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+import { PipelineCreateNestedOneWithoutPipelineProgressesInput } from '../pipeline/pipeline-create-nested-one-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineProgressCreateWithoutPipelineStageInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+
+  @Field(() => PipelineCreateNestedOneWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  pipeline!: PipelineCreateNestedOneWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create-without-pipeline.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+import { PipelineStageCreateNestedOneWithoutPipelineProgressesInput } from '../pipeline-stage/pipeline-stage-create-nested-one-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineProgressCreateWithoutPipelineInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+
+  @Field(() => PipelineStageCreateNestedOneWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  pipelineStage!: PipelineStageCreateNestedOneWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-create.input.ts

@@ -0,0 +1,36 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+import { PipelineCreateNestedOneWithoutPipelineProgressesInput } from '../pipeline/pipeline-create-nested-one-without-pipeline-progresses.input';
+import { PipelineStageCreateNestedOneWithoutPipelineProgressesInput } from '../pipeline-stage/pipeline-stage-create-nested-one-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineProgressCreateInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+
+  @Field(() => PipelineCreateNestedOneWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  pipeline!: PipelineCreateNestedOneWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageCreateNestedOneWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  pipelineStage!: PipelineStageCreateNestedOneWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-group-by.args.ts

@@ -0,0 +1,46 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressOrderByWithAggregationInput } from './pipeline-progress-order-by-with-aggregation.input';
+import { PipelineProgressScalarFieldEnum } from './pipeline-progress-scalar-field.enum';
+import { PipelineProgressScalarWhereWithAggregatesInput } from './pipeline-progress-scalar-where-with-aggregates.input';
+import { Int } from '@nestjs/graphql';
+import { PipelineProgressCountAggregateInput } from './pipeline-progress-count-aggregate.input';
+import { PipelineProgressMinAggregateInput } from './pipeline-progress-min-aggregate.input';
+import { PipelineProgressMaxAggregateInput } from './pipeline-progress-max-aggregate.input';
+
+@ArgsType()
+export class PipelineProgressGroupByArgs {
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  @Type(() => PipelineProgressWhereInput)
+  where?: PipelineProgressWhereInput;
+
+  @Field(() => [PipelineProgressOrderByWithAggregationInput], {
+    nullable: true,
+  })
+  orderBy?: Array<PipelineProgressOrderByWithAggregationInput>;
+
+  @Field(() => [PipelineProgressScalarFieldEnum], { nullable: false })
+  by!: Array<keyof typeof PipelineProgressScalarFieldEnum>;
+
+  @Field(() => PipelineProgressScalarWhereWithAggregatesInput, {
+    nullable: true,
+  })
+  having?: PipelineProgressScalarWhereWithAggregatesInput;
+
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => PipelineProgressCountAggregateInput, { nullable: true })
+  _count?: PipelineProgressCountAggregateInput;
+
+  @Field(() => PipelineProgressMinAggregateInput, { nullable: true })
+  _min?: PipelineProgressMinAggregateInput;
+
+  @Field(() => PipelineProgressMaxAggregateInput, { nullable: true })
+  _max?: PipelineProgressMaxAggregateInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-group-by.output.ts

@@ -0,0 +1,42 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+import { PipelineProgressCountAggregate } from './pipeline-progress-count-aggregate.output';
+import { PipelineProgressMinAggregate } from './pipeline-progress-min-aggregate.output';
+import { PipelineProgressMaxAggregate } from './pipeline-progress-max-aggregate.output';
+
+@ObjectType()
+export class PipelineProgressGroupBy {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: false })
+  createdAt!: Date | string;
+
+  @Field(() => Date, { nullable: false })
+  updatedAt!: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @Field(() => String, { nullable: false })
+  pipelineStageId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+
+  @Field(() => PipelineProgressCountAggregate, { nullable: true })
+  _count?: PipelineProgressCountAggregate;
+
+  @Field(() => PipelineProgressMinAggregate, { nullable: true })
+  _min?: PipelineProgressMinAggregate;
+
+  @Field(() => PipelineProgressMaxAggregate, { nullable: true })
+  _max?: PipelineProgressMaxAggregate;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-list-relation-filter.input.ts

@@ -0,0 +1,15 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+
+@InputType()
+export class PipelineProgressListRelationFilter {
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  every?: PipelineProgressWhereInput;
+
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  some?: PipelineProgressWhereInput;
+
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  none?: PipelineProgressWhereInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-max-aggregate.input.ts

@@ -0,0 +1,29 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineProgressMaxAggregateInput {
+  @Field(() => Boolean, { nullable: true })
+  id?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  createdAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  updatedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  deletedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  pipelineId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  pipelineStageId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  associableType?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  associableId?: true;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-max-aggregate.output.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@ObjectType()
+export class PipelineProgressMaxAggregate {
+  @Field(() => String, { nullable: true })
+  id?: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: true })
+  pipelineId?: string;
+
+  @Field(() => String, { nullable: true })
+  pipelineStageId?: string;
+
+  @Field(() => PipelineProgressableType, { nullable: true })
+  associableType?: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: true })
+  associableId?: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-max-order-by-aggregate.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class PipelineProgressMaxOrderByAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineStageId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableType?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableId?: keyof typeof SortOrder;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-min-aggregate.input.ts

@@ -0,0 +1,29 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineProgressMinAggregateInput {
+  @Field(() => Boolean, { nullable: true })
+  id?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  createdAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  updatedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  deletedAt?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  pipelineId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  pipelineStageId?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  associableType?: true;
+
+  @Field(() => Boolean, { nullable: true })
+  associableId?: true;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-min-aggregate.output.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@ObjectType()
+export class PipelineProgressMinAggregate {
+  @Field(() => String, { nullable: true })
+  id?: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: true })
+  pipelineId?: string;
+
+  @Field(() => String, { nullable: true })
+  pipelineStageId?: string;
+
+  @Field(() => PipelineProgressableType, { nullable: true })
+  associableType?: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: true })
+  associableId?: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-min-order-by-aggregate.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class PipelineProgressMinOrderByAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineStageId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableType?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableId?: keyof typeof SortOrder;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-order-by-relation-aggregate.input.ts

@@ -0,0 +1,9 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+
+@InputType()
+export class PipelineProgressOrderByRelationAggregateInput {
+  @Field(() => SortOrder, { nullable: true })
+  _count?: keyof typeof SortOrder;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-order-by-with-aggregation.input.ts

@@ -0,0 +1,42 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+import { PipelineProgressCountOrderByAggregateInput } from './pipeline-progress-count-order-by-aggregate.input';
+import { PipelineProgressMaxOrderByAggregateInput } from './pipeline-progress-max-order-by-aggregate.input';
+import { PipelineProgressMinOrderByAggregateInput } from './pipeline-progress-min-order-by-aggregate.input';
+
+@InputType()
+export class PipelineProgressOrderByWithAggregationInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineStageId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableType?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableId?: keyof typeof SortOrder;
+
+  @Field(() => PipelineProgressCountOrderByAggregateInput, { nullable: true })
+  _count?: PipelineProgressCountOrderByAggregateInput;
+
+  @Field(() => PipelineProgressMaxOrderByAggregateInput, { nullable: true })
+  _max?: PipelineProgressMaxOrderByAggregateInput;
+
+  @Field(() => PipelineProgressMinOrderByAggregateInput, { nullable: true })
+  _min?: PipelineProgressMinOrderByAggregateInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-order-by-with-relation.input.ts

@@ -0,0 +1,38 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { SortOrder } from '../prisma/sort-order.enum';
+import { PipelineOrderByWithRelationInput } from '../pipeline/pipeline-order-by-with-relation.input';
+import { PipelineStageOrderByWithRelationInput } from '../pipeline-stage/pipeline-stage-order-by-with-relation.input';
+
+@InputType()
+export class PipelineProgressOrderByWithRelationInput {
+  @Field(() => SortOrder, { nullable: true })
+  id?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  createdAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  updatedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  deletedAt?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  pipelineStageId?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableType?: keyof typeof SortOrder;
+
+  @Field(() => SortOrder, { nullable: true })
+  associableId?: keyof typeof SortOrder;
+
+  @Field(() => PipelineOrderByWithRelationInput, { nullable: true })
+  pipeline?: PipelineOrderByWithRelationInput;
+
+  @Field(() => PipelineStageOrderByWithRelationInput, { nullable: true })
+  pipelineStage?: PipelineStageOrderByWithRelationInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-scalar-field.enum.ts

@@ -0,0 +1,17 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+export enum PipelineProgressScalarFieldEnum {
+  id = 'id',
+  createdAt = 'createdAt',
+  updatedAt = 'updatedAt',
+  deletedAt = 'deletedAt',
+  pipelineId = 'pipelineId',
+  pipelineStageId = 'pipelineStageId',
+  associableType = 'associableType',
+  associableId = 'associableId',
+}
+
+registerEnumType(PipelineProgressScalarFieldEnum, {
+  name: 'PipelineProgressScalarFieldEnum',
+  description: undefined,
+});

server/src/api/@generated/pipeline-progress/pipeline-progress-scalar-where-with-aggregates.input.ts

@@ -0,0 +1,50 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringWithAggregatesFilter } from '../prisma/string-with-aggregates-filter.input';
+import { DateTimeWithAggregatesFilter } from '../prisma/date-time-with-aggregates-filter.input';
+import { DateTimeNullableWithAggregatesFilter } from '../prisma/date-time-nullable-with-aggregates-filter.input';
+import { EnumPipelineProgressableTypeWithAggregatesFilter } from '../prisma/enum-pipeline-progressable-type-with-aggregates-filter.input';
+
+@InputType()
+export class PipelineProgressScalarWhereWithAggregatesInput {
+  @Field(() => [PipelineProgressScalarWhereWithAggregatesInput], {
+    nullable: true,
+  })
+  AND?: Array<PipelineProgressScalarWhereWithAggregatesInput>;
+
+  @Field(() => [PipelineProgressScalarWhereWithAggregatesInput], {
+    nullable: true,
+  })
+  OR?: Array<PipelineProgressScalarWhereWithAggregatesInput>;
+
+  @Field(() => [PipelineProgressScalarWhereWithAggregatesInput], {
+    nullable: true,
+  })
+  NOT?: Array<PipelineProgressScalarWhereWithAggregatesInput>;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  id?: StringWithAggregatesFilter;
+
+  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
+  createdAt?: DateTimeWithAggregatesFilter;
+
+  @Field(() => DateTimeWithAggregatesFilter, { nullable: true })
+  updatedAt?: DateTimeWithAggregatesFilter;
+
+  @Field(() => DateTimeNullableWithAggregatesFilter, { nullable: true })
+  deletedAt?: DateTimeNullableWithAggregatesFilter;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  pipelineId?: StringWithAggregatesFilter;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  pipelineStageId?: StringWithAggregatesFilter;
+
+  @Field(() => EnumPipelineProgressableTypeWithAggregatesFilter, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeWithAggregatesFilter;
+
+  @Field(() => StringWithAggregatesFilter, { nullable: true })
+  associableId?: StringWithAggregatesFilter;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-scalar-where.input.ts

@@ -0,0 +1,42 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFilter } from '../prisma/string-filter.input';
+import { DateTimeFilter } from '../prisma/date-time-filter.input';
+import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
+import { EnumPipelineProgressableTypeFilter } from '../prisma/enum-pipeline-progressable-type-filter.input';
+
+@InputType()
+export class PipelineProgressScalarWhereInput {
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  AND?: Array<PipelineProgressScalarWhereInput>;
+
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  OR?: Array<PipelineProgressScalarWhereInput>;
+
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  NOT?: Array<PipelineProgressScalarWhereInput>;
+
+  @Field(() => StringFilter, { nullable: true })
+  id?: StringFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  createdAt?: DateTimeFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  updatedAt?: DateTimeFilter;
+
+  @Field(() => DateTimeNullableFilter, { nullable: true })
+  deletedAt?: DateTimeNullableFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  pipelineId?: StringFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  pipelineStageId?: StringFilter;
+
+  @Field(() => EnumPipelineProgressableTypeFilter, { nullable: true })
+  associableType?: EnumPipelineProgressableTypeFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  associableId?: StringFilter;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-create-nested-many-without-pipeline-stage.input.ts

@@ -0,0 +1,32 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineStageInput } from './pipeline-progress-create-without-pipeline-stage.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineStageInput } from './pipeline-progress-create-or-connect-without-pipeline-stage.input';
+import { PipelineProgressCreateManyPipelineStageInputEnvelope } from './pipeline-progress-create-many-pipeline-stage-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+
+@InputType()
+export class PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateWithoutPipelineStageInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineStageInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineStageInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineStageInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineStageInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineStageInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-create-nested-many-without-pipeline.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineInput } from './pipeline-progress-create-without-pipeline.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineInput } from './pipeline-progress-create-or-connect-without-pipeline.input';
+import { PipelineProgressCreateManyPipelineInputEnvelope } from './pipeline-progress-create-many-pipeline-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+
+@InputType()
+export class PipelineProgressUncheckedCreateNestedManyWithoutPipelineInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineInput], { nullable: true })
+  @Type(() => PipelineProgressCreateWithoutPipelineInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-create-without-pipeline-stage.input.ts

@@ -0,0 +1,27 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@InputType()
+export class PipelineProgressUncheckedCreateWithoutPipelineStageInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-create-without-pipeline.input.ts

@@ -0,0 +1,27 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@InputType()
+export class PipelineProgressUncheckedCreateWithoutPipelineInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineStageId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-create.input.ts

@@ -0,0 +1,30 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+
+@InputType()
+export class PipelineProgressUncheckedCreateInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @Field(() => String, { nullable: false })
+  pipelineStageId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update-many-without-pipeline-nested.input.ts

@@ -0,0 +1,68 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineInput } from './pipeline-progress-create-without-pipeline.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineInput } from './pipeline-progress-create-or-connect-without-pipeline.input';
+import { PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput } from './pipeline-progress-upsert-with-where-unique-without-pipeline.input';
+import { PipelineProgressCreateManyPipelineInputEnvelope } from './pipeline-progress-create-many-pipeline-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput } from './pipeline-progress-update-with-where-unique-without-pipeline.input';
+import { PipelineProgressUpdateManyWithWhereWithoutPipelineInput } from './pipeline-progress-update-many-with-where-without-pipeline.input';
+import { PipelineProgressScalarWhereInput } from './pipeline-progress-scalar-where.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateManyWithoutPipelineNestedInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineInput], { nullable: true })
+  @Type(() => PipelineProgressCreateWithoutPipelineInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput)
+  upsert?: Array<PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  set?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  disconnect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  delete?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput)
+  update?: Array<PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressUpdateManyWithWhereWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpdateManyWithWhereWithoutPipelineInput)
+  updateMany?: Array<PipelineProgressUpdateManyWithWhereWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  @Type(() => PipelineProgressScalarWhereInput)
+  deleteMany?: Array<PipelineProgressScalarWhereInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update-many-without-pipeline-progresses.input.ts

@@ -0,0 +1,32 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateManyWithoutPipelineProgressesInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineStageId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update-many-without-pipeline-stage-nested.input.ts

@@ -0,0 +1,72 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineStageInput } from './pipeline-progress-create-without-pipeline-stage.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineStageInput } from './pipeline-progress-create-or-connect-without-pipeline-stage.input';
+import { PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput } from './pipeline-progress-upsert-with-where-unique-without-pipeline-stage.input';
+import { PipelineProgressCreateManyPipelineStageInputEnvelope } from './pipeline-progress-create-many-pipeline-stage-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput } from './pipeline-progress-update-with-where-unique-without-pipeline-stage.input';
+import { PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput } from './pipeline-progress-update-many-with-where-without-pipeline-stage.input';
+import { PipelineProgressScalarWhereInput } from './pipeline-progress-scalar-where.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateWithoutPipelineStageInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineStageInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineStageInput>;
+
+  @Field(
+    () => [PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput],
+    { nullable: true },
+  )
+  @Type(() => PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput)
+  upsert?: Array<PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineStageInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineStageInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineStageInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  set?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  disconnect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  delete?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(
+    () => [PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput],
+    { nullable: true },
+  )
+  @Type(() => PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput)
+  update?: Array<PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput)
+  updateMany?: Array<PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  @Type(() => PipelineProgressScalarWhereInput)
+  deleteMany?: Array<PipelineProgressScalarWhereInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update-many.input.ts

@@ -0,0 +1,35 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateManyInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineStageId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update-without-pipeline-stage.input.ts

@@ -0,0 +1,32 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateWithoutPipelineStageInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update-without-pipeline.input.ts

@@ -0,0 +1,32 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateWithoutPipelineInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineStageId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-unchecked-update.input.ts

@@ -0,0 +1,35 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+
+@InputType()
+export class PipelineProgressUncheckedUpdateInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineStageId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-many-mutation.input.ts

@@ -0,0 +1,29 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+
+@InputType()
+export class PipelineProgressUpdateManyMutationInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-many-with-where-without-pipeline-stage.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressScalarWhereInput } from './pipeline-progress-scalar-where.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressUpdateManyMutationInput } from './pipeline-progress-update-many-mutation.input';
+
+@InputType()
+export class PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput {
+  @Field(() => PipelineProgressScalarWhereInput, { nullable: false })
+  @Type(() => PipelineProgressScalarWhereInput)
+  where!: PipelineProgressScalarWhereInput;
+
+  @Field(() => PipelineProgressUpdateManyMutationInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateManyMutationInput)
+  data!: PipelineProgressUpdateManyMutationInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-many-with-where-without-pipeline.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressScalarWhereInput } from './pipeline-progress-scalar-where.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressUpdateManyMutationInput } from './pipeline-progress-update-many-mutation.input';
+
+@InputType()
+export class PipelineProgressUpdateManyWithWhereWithoutPipelineInput {
+  @Field(() => PipelineProgressScalarWhereInput, { nullable: false })
+  @Type(() => PipelineProgressScalarWhereInput)
+  where!: PipelineProgressScalarWhereInput;
+
+  @Field(() => PipelineProgressUpdateManyMutationInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateManyMutationInput)
+  data!: PipelineProgressUpdateManyMutationInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-many-without-pipeline-nested.input.ts

@@ -0,0 +1,68 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineInput } from './pipeline-progress-create-without-pipeline.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineInput } from './pipeline-progress-create-or-connect-without-pipeline.input';
+import { PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput } from './pipeline-progress-upsert-with-where-unique-without-pipeline.input';
+import { PipelineProgressCreateManyPipelineInputEnvelope } from './pipeline-progress-create-many-pipeline-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput } from './pipeline-progress-update-with-where-unique-without-pipeline.input';
+import { PipelineProgressUpdateManyWithWhereWithoutPipelineInput } from './pipeline-progress-update-many-with-where-without-pipeline.input';
+import { PipelineProgressScalarWhereInput } from './pipeline-progress-scalar-where.input';
+
+@InputType()
+export class PipelineProgressUpdateManyWithoutPipelineNestedInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineInput], { nullable: true })
+  @Type(() => PipelineProgressCreateWithoutPipelineInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput)
+  upsert?: Array<PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  set?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  disconnect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  delete?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput)
+  update?: Array<PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressUpdateManyWithWhereWithoutPipelineInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpdateManyWithWhereWithoutPipelineInput)
+  updateMany?: Array<PipelineProgressUpdateManyWithWhereWithoutPipelineInput>;
+
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  @Type(() => PipelineProgressScalarWhereInput)
+  deleteMany?: Array<PipelineProgressScalarWhereInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-many-without-pipeline-stage-nested.input.ts

@@ -0,0 +1,72 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressCreateWithoutPipelineStageInput } from './pipeline-progress-create-without-pipeline-stage.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateOrConnectWithoutPipelineStageInput } from './pipeline-progress-create-or-connect-without-pipeline-stage.input';
+import { PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput } from './pipeline-progress-upsert-with-where-unique-without-pipeline-stage.input';
+import { PipelineProgressCreateManyPipelineStageInputEnvelope } from './pipeline-progress-create-many-pipeline-stage-input-envelope.input';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput } from './pipeline-progress-update-with-where-unique-without-pipeline-stage.input';
+import { PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput } from './pipeline-progress-update-many-with-where-without-pipeline-stage.input';
+import { PipelineProgressScalarWhereInput } from './pipeline-progress-scalar-where.input';
+
+@InputType()
+export class PipelineProgressUpdateManyWithoutPipelineStageNestedInput {
+  @Field(() => [PipelineProgressCreateWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateWithoutPipelineStageInput)
+  create?: Array<PipelineProgressCreateWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressCreateOrConnectWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateOrConnectWithoutPipelineStageInput)
+  connectOrCreate?: Array<PipelineProgressCreateOrConnectWithoutPipelineStageInput>;
+
+  @Field(
+    () => [PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput],
+    { nullable: true },
+  )
+  @Type(() => PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput)
+  upsert?: Array<PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput>;
+
+  @Field(() => PipelineProgressCreateManyPipelineStageInputEnvelope, {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressCreateManyPipelineStageInputEnvelope)
+  createMany?: PipelineProgressCreateManyPipelineStageInputEnvelope;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  set?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  disconnect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  delete?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(() => [PipelineProgressWhereUniqueInput], { nullable: true })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  connect?: Array<PipelineProgressWhereUniqueInput>;
+
+  @Field(
+    () => [PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput],
+    { nullable: true },
+  )
+  @Type(() => PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput)
+  update?: Array<PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput], {
+    nullable: true,
+  })
+  @Type(() => PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput)
+  updateMany?: Array<PipelineProgressUpdateManyWithWhereWithoutPipelineStageInput>;
+
+  @Field(() => [PipelineProgressScalarWhereInput], { nullable: true })
+  @Type(() => PipelineProgressScalarWhereInput)
+  deleteMany?: Array<PipelineProgressScalarWhereInput>;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-with-where-unique-without-pipeline-stage.input.ts

@@ -0,0 +1,18 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressUpdateWithoutPipelineStageInput } from './pipeline-progress-update-without-pipeline-stage.input';
+
+@InputType()
+export class PipelineProgressUpdateWithWhereUniqueWithoutPipelineStageInput {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressUpdateWithoutPipelineStageInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineProgressUpdateWithoutPipelineStageInput)
+  data!: PipelineProgressUpdateWithoutPipelineStageInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-with-where-unique-without-pipeline.input.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressUpdateWithoutPipelineInput } from './pipeline-progress-update-without-pipeline.input';
+
+@InputType()
+export class PipelineProgressUpdateWithWhereUniqueWithoutPipelineInput {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressUpdateWithoutPipelineInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateWithoutPipelineInput)
+  data!: PipelineProgressUpdateWithoutPipelineInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-without-pipeline-stage.input.ts

@@ -0,0 +1,35 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+import { PipelineUpdateOneRequiredWithoutPipelineProgressesNestedInput } from '../pipeline/pipeline-update-one-required-without-pipeline-progresses-nested.input';
+
+@InputType()
+export class PipelineProgressUpdateWithoutPipelineStageInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => PipelineUpdateOneRequiredWithoutPipelineProgressesNestedInput, {
+    nullable: true,
+  })
+  pipeline?: PipelineUpdateOneRequiredWithoutPipelineProgressesNestedInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update-without-pipeline.input.ts

@@ -0,0 +1,36 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+import { PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput } from '../pipeline-stage/pipeline-stage-update-one-required-without-pipeline-progresses-nested.input';
+
+@InputType()
+export class PipelineProgressUpdateWithoutPipelineInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+
+  @Field(
+    () => PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput,
+    { nullable: true },
+  )
+  pipelineStage?: PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-update.input.ts

@@ -0,0 +1,42 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { EnumPipelineProgressableTypeFieldUpdateOperationsInput } from '../prisma/enum-pipeline-progressable-type-field-update-operations.input';
+import { PipelineUpdateOneRequiredWithoutPipelineProgressesNestedInput } from '../pipeline/pipeline-update-one-required-without-pipeline-progresses-nested.input';
+import { PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput } from '../pipeline-stage/pipeline-stage-update-one-required-without-pipeline-progresses-nested.input';
+
+@InputType()
+export class PipelineProgressUpdateInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => EnumPipelineProgressableTypeFieldUpdateOperationsInput, {
+    nullable: true,
+  })
+  associableType?: EnumPipelineProgressableTypeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  associableId?: StringFieldUpdateOperationsInput;
+
+  @Field(() => PipelineUpdateOneRequiredWithoutPipelineProgressesNestedInput, {
+    nullable: true,
+  })
+  pipeline?: PipelineUpdateOneRequiredWithoutPipelineProgressesNestedInput;
+
+  @Field(
+    () => PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput,
+    { nullable: true },
+  )
+  pipelineStage?: PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-upsert-with-where-unique-without-pipeline-stage.input.ts

@@ -0,0 +1,25 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressUpdateWithoutPipelineStageInput } from './pipeline-progress-update-without-pipeline-stage.input';
+import { PipelineProgressCreateWithoutPipelineStageInput } from './pipeline-progress-create-without-pipeline-stage.input';
+
+@InputType()
+export class PipelineProgressUpsertWithWhereUniqueWithoutPipelineStageInput {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressUpdateWithoutPipelineStageInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineProgressUpdateWithoutPipelineStageInput)
+  update!: PipelineProgressUpdateWithoutPipelineStageInput;
+
+  @Field(() => PipelineProgressCreateWithoutPipelineStageInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineProgressCreateWithoutPipelineStageInput)
+  create!: PipelineProgressCreateWithoutPipelineStageInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-upsert-with-where-unique-without-pipeline.input.ts

@@ -0,0 +1,21 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressUpdateWithoutPipelineInput } from './pipeline-progress-update-without-pipeline.input';
+import { PipelineProgressCreateWithoutPipelineInput } from './pipeline-progress-create-without-pipeline.input';
+
+@InputType()
+export class PipelineProgressUpsertWithWhereUniqueWithoutPipelineInput {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressUpdateWithoutPipelineInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateWithoutPipelineInput)
+  update!: PipelineProgressUpdateWithoutPipelineInput;
+
+  @Field(() => PipelineProgressCreateWithoutPipelineInput, { nullable: false })
+  @Type(() => PipelineProgressCreateWithoutPipelineInput)
+  create!: PipelineProgressCreateWithoutPipelineInput;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-where-unique.input.ts

@@ -0,0 +1,8 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineProgressWhereUniqueInput {
+  @Field(() => String, { nullable: true })
+  id?: string;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress-where.input.ts

@@ -0,0 +1,50 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFilter } from '../prisma/string-filter.input';
+import { DateTimeFilter } from '../prisma/date-time-filter.input';
+import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
+import { EnumPipelineProgressableTypeFilter } from '../prisma/enum-pipeline-progressable-type-filter.input';
+import { PipelineRelationFilter } from '../pipeline/pipeline-relation-filter.input';
+import { PipelineStageRelationFilter } from '../pipeline-stage/pipeline-stage-relation-filter.input';
+
+@InputType()
+export class PipelineProgressWhereInput {
+  @Field(() => [PipelineProgressWhereInput], { nullable: true })
+  AND?: Array<PipelineProgressWhereInput>;
+
+  @Field(() => [PipelineProgressWhereInput], { nullable: true })
+  OR?: Array<PipelineProgressWhereInput>;
+
+  @Field(() => [PipelineProgressWhereInput], { nullable: true })
+  NOT?: Array<PipelineProgressWhereInput>;
+
+  @Field(() => StringFilter, { nullable: true })
+  id?: StringFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  createdAt?: DateTimeFilter;
+
+  @Field(() => DateTimeFilter, { nullable: true })
+  updatedAt?: DateTimeFilter;
+
+  @Field(() => DateTimeNullableFilter, { nullable: true })
+  deletedAt?: DateTimeNullableFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  pipelineId?: StringFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  pipelineStageId?: StringFilter;
+
+  @Field(() => EnumPipelineProgressableTypeFilter, { nullable: true })
+  associableType?: EnumPipelineProgressableTypeFilter;
+
+  @Field(() => StringFilter, { nullable: true })
+  associableId?: StringFilter;
+
+  @Field(() => PipelineRelationFilter, { nullable: true })
+  pipeline?: PipelineRelationFilter;
+
+  @Field(() => PipelineStageRelationFilter, { nullable: true })
+  pipelineStage?: PipelineStageRelationFilter;
+}

server/src/api/@generated/pipeline-progress/pipeline-progress.model.ts

@@ -0,0 +1,39 @@
+import { Field } from '@nestjs/graphql';
+import { ObjectType } from '@nestjs/graphql';
+import { ID } from '@nestjs/graphql';
+import { PipelineProgressableType } from '../prisma/pipeline-progressable-type.enum';
+import { Pipeline } from '../pipeline/pipeline.model';
+import { PipelineStage } from '../pipeline-stage/pipeline-stage.model';
+
+@ObjectType()
+export class PipelineProgress {
+  @Field(() => ID, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: false })
+  createdAt!: Date;
+
+  @Field(() => Date, { nullable: false })
+  updatedAt!: Date;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt!: Date | null;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @Field(() => String, { nullable: false })
+  pipelineStageId!: string;
+
+  @Field(() => PipelineProgressableType, { nullable: false })
+  associableType!: keyof typeof PipelineProgressableType;
+
+  @Field(() => String, { nullable: false })
+  associableId!: string;
+
+  @Field(() => Pipeline, { nullable: false })
+  pipeline?: Pipeline;
+
+  @Field(() => PipelineStage, { nullable: false })
+  pipelineStage?: PipelineStage;
+}

server/src/api/@generated/pipeline-progress/update-many-pipeline-progress.args.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressUpdateManyMutationInput } from './pipeline-progress-update-many-mutation.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressWhereInput } from './pipeline-progress-where.input';
+
+@ArgsType()
+export class UpdateManyPipelineProgressArgs {
+  @Field(() => PipelineProgressUpdateManyMutationInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateManyMutationInput)
+  data!: PipelineProgressUpdateManyMutationInput;
+
+  @Field(() => PipelineProgressWhereInput, { nullable: true })
+  @Type(() => PipelineProgressWhereInput)
+  where?: PipelineProgressWhereInput;
+}

server/src/api/@generated/pipeline-progress/update-one-pipeline-progress.args.ts

@@ -0,0 +1,16 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressUpdateInput } from './pipeline-progress-update.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+
+@ArgsType()
+export class UpdateOnePipelineProgressArgs {
+  @Field(() => PipelineProgressUpdateInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateInput)
+  data!: PipelineProgressUpdateInput;
+
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+}

server/src/api/@generated/pipeline-progress/upsert-one-pipeline-progress.args.ts

@@ -0,0 +1,21 @@
+import { Field } from '@nestjs/graphql';
+import { ArgsType } from '@nestjs/graphql';
+import { PipelineProgressWhereUniqueInput } from './pipeline-progress-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineProgressCreateInput } from './pipeline-progress-create.input';
+import { PipelineProgressUpdateInput } from './pipeline-progress-update.input';
+
+@ArgsType()
+export class UpsertOnePipelineProgressArgs {
+  @Field(() => PipelineProgressWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineProgressWhereUniqueInput)
+  where!: PipelineProgressWhereUniqueInput;
+
+  @Field(() => PipelineProgressCreateInput, { nullable: false })
+  @Type(() => PipelineProgressCreateInput)
+  create!: PipelineProgressCreateInput;
+
+  @Field(() => PipelineProgressUpdateInput, { nullable: false })
+  @Type(() => PipelineProgressUpdateInput)
+  update!: PipelineProgressUpdateInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-count.output.ts

@@ -5,5 +5,5 @@ import { Int } from '@nestjs/graphql';
 @ObjectType()
 export class PipelineStageCount {
   @Field(() => Int, { nullable: false })
-  pipelineAssociations?: number;
+  pipelineProgresses?: number;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-create-nested-one-without-pipeline-progresses.input.ts

@@ -0,0 +1,25 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineStageCreateWithoutPipelineProgressesInput } from './pipeline-stage-create-without-pipeline-progresses.input';
+import { Type } from 'class-transformer';
+import { PipelineStageCreateOrConnectWithoutPipelineProgressesInput } from './pipeline-stage-create-or-connect-without-pipeline-progresses.input';
+import { PipelineStageWhereUniqueInput } from './pipeline-stage-where-unique.input';
+
+@InputType()
+export class PipelineStageCreateNestedOneWithoutPipelineProgressesInput {
+  @Field(() => PipelineStageCreateWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineStageCreateWithoutPipelineProgressesInput)
+  create?: PipelineStageCreateWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageCreateOrConnectWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineStageCreateOrConnectWithoutPipelineProgressesInput)
+  connectOrCreate?: PipelineStageCreateOrConnectWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageWhereUniqueInput, { nullable: true })
+  @Type(() => PipelineStageWhereUniqueInput)
+  connect?: PipelineStageWhereUniqueInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-create-or-connect-without-pipeline-progresses.input.ts

@@ -0,0 +1,18 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineStageWhereUniqueInput } from './pipeline-stage-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineStageCreateWithoutPipelineProgressesInput } from './pipeline-stage-create-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineStageCreateOrConnectWithoutPipelineProgressesInput {
+  @Field(() => PipelineStageWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineStageWhereUniqueInput)
+  where!: PipelineStageWhereUniqueInput;
+
+  @Field(() => PipelineStageCreateWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineStageCreateWithoutPipelineProgressesInput)
+  create!: PipelineStageCreateWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-create-without-pipeline-progresses.input.ts

@@ -0,0 +1,37 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineCreateNestedOneWithoutPipelineStagesInput } from '../pipeline/pipeline-create-nested-one-without-pipeline-stages.input';
+import { WorkspaceCreateNestedOneWithoutPipelineStagesInput } from '../workspace/workspace-create-nested-one-without-pipeline-stages.input';
+import { HideField } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineStageCreateWithoutPipelineProgressesInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  name!: string;
+
+  @Field(() => String, { nullable: false })
+  type!: string;
+
+  @Field(() => String, { nullable: false })
+  color!: string;
+
+  @Field(() => PipelineCreateNestedOneWithoutPipelineStagesInput, {
+    nullable: false,
+  })
+  pipeline!: PipelineCreateNestedOneWithoutPipelineStagesInput;
+
+  @HideField()
+  workspace!: WorkspaceCreateNestedOneWithoutPipelineStagesInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-create-without-pipeline.input.ts

@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { PipelineAssociationCreateNestedManyWithoutPipelineStageInput } from '../pipeline-association/pipeline-association-create-nested-many-without-pipeline-stage.input';
+import { PipelineProgressCreateNestedManyWithoutPipelineStageInput } from '../pipeline-progress/pipeline-progress-create-nested-many-without-pipeline-stage.input';
 import { WorkspaceCreateNestedOneWithoutPipelineStagesInput } from '../workspace/workspace-create-nested-one-without-pipeline-stages.input';
 import { HideField } from '@nestjs/graphql';
 
@@ -27,10 +27,10 @@ export class PipelineStageCreateWithoutPipelineInput {
   @Field(() => String, { nullable: false })
   color!: string;
 
-  @Field(() => PipelineAssociationCreateNestedManyWithoutPipelineStageInput, {
+  @Field(() => PipelineProgressCreateNestedManyWithoutPipelineStageInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationCreateNestedManyWithoutPipelineStageInput;
+  pipelineProgresses?: PipelineProgressCreateNestedManyWithoutPipelineStageInput;
 
   @HideField()
   workspace!: WorkspaceCreateNestedOneWithoutPipelineStagesInput;

server/src/api/@generated/pipeline-stage/pipeline-stage-create-without-workspace.input.ts

@@ -1,7 +1,7 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { PipelineCreateNestedOneWithoutPipelineStagesInput } from '../pipeline/pipeline-create-nested-one-without-pipeline-stages.input';
-import { PipelineAssociationCreateNestedManyWithoutPipelineStageInput } from '../pipeline-association/pipeline-association-create-nested-many-without-pipeline-stage.input';
+import { PipelineProgressCreateNestedManyWithoutPipelineStageInput } from '../pipeline-progress/pipeline-progress-create-nested-many-without-pipeline-stage.input';
 
 @InputType()
 export class PipelineStageCreateWithoutWorkspaceInput {
@@ -31,8 +31,8 @@ export class PipelineStageCreateWithoutWorkspaceInput {
   })
   pipeline!: PipelineCreateNestedOneWithoutPipelineStagesInput;
 
-  @Field(() => PipelineAssociationCreateNestedManyWithoutPipelineStageInput, {
+  @Field(() => PipelineProgressCreateNestedManyWithoutPipelineStageInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationCreateNestedManyWithoutPipelineStageInput;
+  pipelineProgresses?: PipelineProgressCreateNestedManyWithoutPipelineStageInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-create.input.ts

@@ -1,7 +1,7 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { PipelineCreateNestedOneWithoutPipelineStagesInput } from '../pipeline/pipeline-create-nested-one-without-pipeline-stages.input';
-import { PipelineAssociationCreateNestedManyWithoutPipelineStageInput } from '../pipeline-association/pipeline-association-create-nested-many-without-pipeline-stage.input';
+import { PipelineProgressCreateNestedManyWithoutPipelineStageInput } from '../pipeline-progress/pipeline-progress-create-nested-many-without-pipeline-stage.input';
 import { WorkspaceCreateNestedOneWithoutPipelineStagesInput } from '../workspace/workspace-create-nested-one-without-pipeline-stages.input';
 import { HideField } from '@nestjs/graphql';
 
@@ -33,10 +33,10 @@ export class PipelineStageCreateInput {
   })
   pipeline!: PipelineCreateNestedOneWithoutPipelineStagesInput;
 
-  @Field(() => PipelineAssociationCreateNestedManyWithoutPipelineStageInput, {
+  @Field(() => PipelineProgressCreateNestedManyWithoutPipelineStageInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationCreateNestedManyWithoutPipelineStageInput;
+  pipelineProgresses?: PipelineProgressCreateNestedManyWithoutPipelineStageInput;
 
   @HideField()
   workspace!: WorkspaceCreateNestedOneWithoutPipelineStagesInput;

server/src/api/@generated/pipeline-stage/pipeline-stage-order-by-with-relation.input.ts

@@ -3,7 +3,7 @@ import { InputType } from '@nestjs/graphql';
 import { SortOrder } from '../prisma/sort-order.enum';
 import { HideField } from '@nestjs/graphql';
 import { PipelineOrderByWithRelationInput } from '../pipeline/pipeline-order-by-with-relation.input';
-import { PipelineAssociationOrderByRelationAggregateInput } from '../pipeline-association/pipeline-association-order-by-relation-aggregate.input';
+import { PipelineProgressOrderByRelationAggregateInput } from '../pipeline-progress/pipeline-progress-order-by-relation-aggregate.input';
 import { WorkspaceOrderByWithRelationInput } from '../workspace/workspace-order-by-with-relation.input';
 
 @InputType()
@@ -38,10 +38,10 @@ export class PipelineStageOrderByWithRelationInput {
   @Field(() => PipelineOrderByWithRelationInput, { nullable: true })
   pipeline?: PipelineOrderByWithRelationInput;
 
-  @Field(() => PipelineAssociationOrderByRelationAggregateInput, {
+  @Field(() => PipelineProgressOrderByRelationAggregateInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationOrderByRelationAggregateInput;
+  pipelineProgresses?: PipelineProgressOrderByRelationAggregateInput;
 
   @HideField()
   workspace?: WorkspaceOrderByWithRelationInput;

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-create-without-pipeline-progresses.input.ts

@@ -0,0 +1,33 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { HideField } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineStageUncheckedCreateWithoutPipelineProgressesInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  name!: string;
+
+  @Field(() => String, { nullable: false })
+  type!: string;
+
+  @Field(() => String, { nullable: false })
+  color!: string;
+
+  @Field(() => String, { nullable: false })
+  pipelineId!: string;
+
+  @HideField()
+  workspaceId!: string;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-create-without-pipeline.input.ts

@@ -1,7 +1,7 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { HideField } from '@nestjs/graphql';
-import { PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput } from '../pipeline-association/pipeline-association-unchecked-create-nested-many-without-pipeline-stage.input';
+import { PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput } from '../pipeline-progress/pipeline-progress-unchecked-create-nested-many-without-pipeline-stage.input';
 
 @InputType()
 export class PipelineStageUncheckedCreateWithoutPipelineInput {
@@ -30,8 +30,8 @@ export class PipelineStageUncheckedCreateWithoutPipelineInput {
   workspaceId!: string;
 
   @Field(
-    () => PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput,
+    () => PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput,
     { nullable: true },
   )
-  pipelineAssociations?: PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput;
+  pipelineProgresses?: PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-create-without-workspace.input.ts

@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput } from '../pipeline-association/pipeline-association-unchecked-create-nested-many-without-pipeline-stage.input';
+import { PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput } from '../pipeline-progress/pipeline-progress-unchecked-create-nested-many-without-pipeline-stage.input';
 
 @InputType()
 export class PipelineStageUncheckedCreateWithoutWorkspaceInput {
@@ -29,8 +29,8 @@ export class PipelineStageUncheckedCreateWithoutWorkspaceInput {
   pipelineId!: string;
 
   @Field(
-    () => PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput,
+    () => PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput,
     { nullable: true },
   )
-  pipelineAssociations?: PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput;
+  pipelineProgresses?: PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-create.input.ts

@@ -1,7 +1,7 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
 import { HideField } from '@nestjs/graphql';
-import { PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput } from '../pipeline-association/pipeline-association-unchecked-create-nested-many-without-pipeline-stage.input';
+import { PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput } from '../pipeline-progress/pipeline-progress-unchecked-create-nested-many-without-pipeline-stage.input';
 
 @InputType()
 export class PipelineStageUncheckedCreateInput {
@@ -33,8 +33,8 @@ export class PipelineStageUncheckedCreateInput {
   workspaceId!: string;
 
   @Field(
-    () => PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput,
+    () => PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput,
     { nullable: true },
   )
-  pipelineAssociations?: PipelineAssociationUncheckedCreateNestedManyWithoutPipelineStageInput;
+  pipelineProgresses?: PipelineProgressUncheckedCreateNestedManyWithoutPipelineStageInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-update-without-pipeline-progresses.input.ts

@@ -0,0 +1,36 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { HideField } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineStageUncheckedUpdateWithoutPipelineProgressesInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  name?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  type?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  color?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  pipelineId?: StringFieldUpdateOperationsInput;
+
+  @HideField()
+  workspaceId?: StringFieldUpdateOperationsInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-update-without-pipeline.input.ts

@@ -4,7 +4,7 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
 import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
 import { HideField } from '@nestjs/graphql';
-import { PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-association/pipeline-association-unchecked-update-many-without-pipeline-stage-nested.input';
+import { PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-progress/pipeline-progress-unchecked-update-many-without-pipeline-stage-nested.input';
 
 @InputType()
 export class PipelineStageUncheckedUpdateWithoutPipelineInput {
@@ -33,8 +33,8 @@ export class PipelineStageUncheckedUpdateWithoutPipelineInput {
   workspaceId?: StringFieldUpdateOperationsInput;
 
   @Field(
-    () => PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput,
+    () => PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput,
     { nullable: true },
   )
-  pipelineAssociations?: PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput;
+  pipelineProgresses?: PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-update-without-workspace.input.ts

@@ -3,7 +3,7 @@ import { InputType } from '@nestjs/graphql';
 import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
 import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
 import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
-import { PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-association/pipeline-association-unchecked-update-many-without-pipeline-stage-nested.input';
+import { PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-progress/pipeline-progress-unchecked-update-many-without-pipeline-stage-nested.input';
 
 @InputType()
 export class PipelineStageUncheckedUpdateWithoutWorkspaceInput {
@@ -32,8 +32,8 @@ export class PipelineStageUncheckedUpdateWithoutWorkspaceInput {
   pipelineId?: StringFieldUpdateOperationsInput;
 
   @Field(
-    () => PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput,
+    () => PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput,
     { nullable: true },
   )
-  pipelineAssociations?: PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput;
+  pipelineProgresses?: PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-unchecked-update.input.ts

@@ -4,7 +4,7 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
 import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
 import { HideField } from '@nestjs/graphql';
-import { PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-association/pipeline-association-unchecked-update-many-without-pipeline-stage-nested.input';
+import { PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-progress/pipeline-progress-unchecked-update-many-without-pipeline-stage-nested.input';
 
 @InputType()
 export class PipelineStageUncheckedUpdateInput {
@@ -36,8 +36,8 @@ export class PipelineStageUncheckedUpdateInput {
   workspaceId?: StringFieldUpdateOperationsInput;
 
   @Field(
-    () => PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput,
+    () => PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput,
     { nullable: true },
   )
-  pipelineAssociations?: PipelineAssociationUncheckedUpdateManyWithoutPipelineStageNestedInput;
+  pipelineProgresses?: PipelineProgressUncheckedUpdateManyWithoutPipelineStageNestedInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-update-one-required-without-pipeline-progresses-nested.input.ts

@@ -0,0 +1,39 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineStageCreateWithoutPipelineProgressesInput } from './pipeline-stage-create-without-pipeline-progresses.input';
+import { Type } from 'class-transformer';
+import { PipelineStageCreateOrConnectWithoutPipelineProgressesInput } from './pipeline-stage-create-or-connect-without-pipeline-progresses.input';
+import { PipelineStageUpsertWithoutPipelineProgressesInput } from './pipeline-stage-upsert-without-pipeline-progresses.input';
+import { PipelineStageWhereUniqueInput } from './pipeline-stage-where-unique.input';
+import { PipelineStageUpdateWithoutPipelineProgressesInput } from './pipeline-stage-update-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineStageUpdateOneRequiredWithoutPipelineProgressesNestedInput {
+  @Field(() => PipelineStageCreateWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineStageCreateWithoutPipelineProgressesInput)
+  create?: PipelineStageCreateWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageCreateOrConnectWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineStageCreateOrConnectWithoutPipelineProgressesInput)
+  connectOrCreate?: PipelineStageCreateOrConnectWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageUpsertWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineStageUpsertWithoutPipelineProgressesInput)
+  upsert?: PipelineStageUpsertWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageWhereUniqueInput, { nullable: true })
+  @Type(() => PipelineStageWhereUniqueInput)
+  connect?: PipelineStageWhereUniqueInput;
+
+  @Field(() => PipelineStageUpdateWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineStageUpdateWithoutPipelineProgressesInput)
+  update?: PipelineStageUpdateWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-update-without-pipeline-progresses.input.ts

@@ -0,0 +1,40 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
+import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
+import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
+import { PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput } from '../pipeline/pipeline-update-one-required-without-pipeline-stages-nested.input';
+import { WorkspaceUpdateOneRequiredWithoutPipelineStagesNestedInput } from '../workspace/workspace-update-one-required-without-pipeline-stages-nested.input';
+import { HideField } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineStageUpdateWithoutPipelineProgressesInput {
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  id?: StringFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  createdAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true })
+  updatedAt?: DateTimeFieldUpdateOperationsInput;
+
+  @Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true })
+  deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  name?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  type?: StringFieldUpdateOperationsInput;
+
+  @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
+  color?: StringFieldUpdateOperationsInput;
+
+  @Field(() => PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput, {
+    nullable: true,
+  })
+  pipeline?: PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput;
+
+  @HideField()
+  workspace?: WorkspaceUpdateOneRequiredWithoutPipelineStagesNestedInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-update-without-pipeline.input.ts

@@ -3,7 +3,7 @@ import { InputType } from '@nestjs/graphql';
 import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-operations.input';
 import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
 import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
-import { PipelineAssociationUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-association/pipeline-association-update-many-without-pipeline-stage-nested.input';
+import { PipelineProgressUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-progress/pipeline-progress-update-many-without-pipeline-stage-nested.input';
 import { WorkspaceUpdateOneRequiredWithoutPipelineStagesNestedInput } from '../workspace/workspace-update-one-required-without-pipeline-stages-nested.input';
 import { HideField } from '@nestjs/graphql';
 
@@ -30,10 +30,10 @@ export class PipelineStageUpdateWithoutPipelineInput {
   @Field(() => StringFieldUpdateOperationsInput, { nullable: true })
   color?: StringFieldUpdateOperationsInput;
 
-  @Field(() => PipelineAssociationUpdateManyWithoutPipelineStageNestedInput, {
+  @Field(() => PipelineProgressUpdateManyWithoutPipelineStageNestedInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationUpdateManyWithoutPipelineStageNestedInput;
+  pipelineProgresses?: PipelineProgressUpdateManyWithoutPipelineStageNestedInput;
 
   @HideField()
   workspace?: WorkspaceUpdateOneRequiredWithoutPipelineStagesNestedInput;

server/src/api/@generated/pipeline-stage/pipeline-stage-update-without-workspace.input.ts

@@ -4,7 +4,7 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
 import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
 import { PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput } from '../pipeline/pipeline-update-one-required-without-pipeline-stages-nested.input';
-import { PipelineAssociationUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-association/pipeline-association-update-many-without-pipeline-stage-nested.input';
+import { PipelineProgressUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-progress/pipeline-progress-update-many-without-pipeline-stage-nested.input';
 
 @InputType()
 export class PipelineStageUpdateWithoutWorkspaceInput {
@@ -34,8 +34,8 @@ export class PipelineStageUpdateWithoutWorkspaceInput {
   })
   pipeline?: PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput;
 
-  @Field(() => PipelineAssociationUpdateManyWithoutPipelineStageNestedInput, {
+  @Field(() => PipelineProgressUpdateManyWithoutPipelineStageNestedInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationUpdateManyWithoutPipelineStageNestedInput;
+  pipelineProgresses?: PipelineProgressUpdateManyWithoutPipelineStageNestedInput;
 }

server/src/api/@generated/pipeline-stage/pipeline-stage-update.input.ts

@@ -4,7 +4,7 @@ import { StringFieldUpdateOperationsInput } from '../prisma/string-field-update-
 import { DateTimeFieldUpdateOperationsInput } from '../prisma/date-time-field-update-operations.input';
 import { NullableDateTimeFieldUpdateOperationsInput } from '../prisma/nullable-date-time-field-update-operations.input';
 import { PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput } from '../pipeline/pipeline-update-one-required-without-pipeline-stages-nested.input';
-import { PipelineAssociationUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-association/pipeline-association-update-many-without-pipeline-stage-nested.input';
+import { PipelineProgressUpdateManyWithoutPipelineStageNestedInput } from '../pipeline-progress/pipeline-progress-update-many-without-pipeline-stage-nested.input';
 import { WorkspaceUpdateOneRequiredWithoutPipelineStagesNestedInput } from '../workspace/workspace-update-one-required-without-pipeline-stages-nested.input';
 import { HideField } from '@nestjs/graphql';
 
@@ -36,10 +36,10 @@ export class PipelineStageUpdateInput {
   })
   pipeline?: PipelineUpdateOneRequiredWithoutPipelineStagesNestedInput;
 
-  @Field(() => PipelineAssociationUpdateManyWithoutPipelineStageNestedInput, {
+  @Field(() => PipelineProgressUpdateManyWithoutPipelineStageNestedInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationUpdateManyWithoutPipelineStageNestedInput;
+  pipelineProgresses?: PipelineProgressUpdateManyWithoutPipelineStageNestedInput;
 
   @HideField()
   workspace?: WorkspaceUpdateOneRequiredWithoutPipelineStagesNestedInput;

server/src/api/@generated/pipeline-stage/pipeline-stage-upsert-without-pipeline-progresses.input.ts

@@ -0,0 +1,20 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineStageUpdateWithoutPipelineProgressesInput } from './pipeline-stage-update-without-pipeline-progresses.input';
+import { Type } from 'class-transformer';
+import { PipelineStageCreateWithoutPipelineProgressesInput } from './pipeline-stage-create-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineStageUpsertWithoutPipelineProgressesInput {
+  @Field(() => PipelineStageUpdateWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineStageUpdateWithoutPipelineProgressesInput)
+  update!: PipelineStageUpdateWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineStageCreateWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineStageCreateWithoutPipelineProgressesInput)
+  create!: PipelineStageCreateWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline-stage/pipeline-stage-where.input.ts

@@ -5,7 +5,7 @@ import { DateTimeFilter } from '../prisma/date-time-filter.input';
 import { DateTimeNullableFilter } from '../prisma/date-time-nullable-filter.input';
 import { HideField } from '@nestjs/graphql';
 import { PipelineRelationFilter } from '../pipeline/pipeline-relation-filter.input';
-import { PipelineAssociationListRelationFilter } from '../pipeline-association/pipeline-association-list-relation-filter.input';
+import { PipelineProgressListRelationFilter } from '../pipeline-progress/pipeline-progress-list-relation-filter.input';
 import { WorkspaceRelationFilter } from '../workspace/workspace-relation-filter.input';
 
 @InputType()
@@ -49,8 +49,8 @@ export class PipelineStageWhereInput {
   @Field(() => PipelineRelationFilter, { nullable: true })
   pipeline?: PipelineRelationFilter;
 
-  @Field(() => PipelineAssociationListRelationFilter, { nullable: true })
+  @Field(() => PipelineProgressListRelationFilter, { nullable: true })
-  pipelineAssociations?: PipelineAssociationListRelationFilter;
+  pipelineProgresses?: PipelineProgressListRelationFilter;
 
   @HideField()
   workspace?: WorkspaceRelationFilter;

server/src/api/@generated/pipeline-stage/pipeline-stage.model.ts

@@ -3,7 +3,7 @@ import { ObjectType } from '@nestjs/graphql';
 import { ID } from '@nestjs/graphql';
 import { HideField } from '@nestjs/graphql';
 import { Pipeline } from '../pipeline/pipeline.model';
-import { PipelineAssociation } from '../pipeline-association/pipeline-association.model';
+import { PipelineProgress } from '../pipeline-progress/pipeline-progress.model';
 import { Workspace } from '../workspace/workspace.model';
 import { PipelineStageCount } from './pipeline-stage-count.output';
 
@@ -39,8 +39,8 @@ export class PipelineStage {
   @Field(() => Pipeline, { nullable: false })
   pipeline?: Pipeline;
 
-  @Field(() => [PipelineAssociation], { nullable: true })
+  @Field(() => [PipelineProgress], { nullable: true })
-  pipelineAssociations?: Array<PipelineAssociation>;
+  pipelineProgresses?: Array<PipelineProgress>;
 
   @HideField()
   workspace?: Workspace;

server/src/api/@generated/pipeline/pipeline-count.output.ts

@@ -8,5 +8,5 @@ export class PipelineCount {
   pipelineStages?: number;
 
   @Field(() => Int, { nullable: false })
-  pipelineAssociations?: number;
+  pipelineProgresses?: number;
 }

server/src/api/@generated/pipeline/pipeline-create-nested-one-without-pipeline-progresses.input.ts

@@ -0,0 +1,23 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineCreateWithoutPipelineProgressesInput } from './pipeline-create-without-pipeline-progresses.input';
+import { Type } from 'class-transformer';
+import { PipelineCreateOrConnectWithoutPipelineProgressesInput } from './pipeline-create-or-connect-without-pipeline-progresses.input';
+import { PipelineWhereUniqueInput } from './pipeline-where-unique.input';
+
+@InputType()
+export class PipelineCreateNestedOneWithoutPipelineProgressesInput {
+  @Field(() => PipelineCreateWithoutPipelineProgressesInput, { nullable: true })
+  @Type(() => PipelineCreateWithoutPipelineProgressesInput)
+  create?: PipelineCreateWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineCreateOrConnectWithoutPipelineProgressesInput, {
+    nullable: true,
+  })
+  @Type(() => PipelineCreateOrConnectWithoutPipelineProgressesInput)
+  connectOrCreate?: PipelineCreateOrConnectWithoutPipelineProgressesInput;
+
+  @Field(() => PipelineWhereUniqueInput, { nullable: true })
+  @Type(() => PipelineWhereUniqueInput)
+  connect?: PipelineWhereUniqueInput;
+}

server/src/api/@generated/pipeline/pipeline-create-or-connect-without-pipeline-progresses.input.ts

@@ -0,0 +1,18 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineWhereUniqueInput } from './pipeline-where-unique.input';
+import { Type } from 'class-transformer';
+import { PipelineCreateWithoutPipelineProgressesInput } from './pipeline-create-without-pipeline-progresses.input';
+
+@InputType()
+export class PipelineCreateOrConnectWithoutPipelineProgressesInput {
+  @Field(() => PipelineWhereUniqueInput, { nullable: false })
+  @Type(() => PipelineWhereUniqueInput)
+  where!: PipelineWhereUniqueInput;
+
+  @Field(() => PipelineCreateWithoutPipelineProgressesInput, {
+    nullable: false,
+  })
+  @Type(() => PipelineCreateWithoutPipelineProgressesInput)
+  create!: PipelineCreateWithoutPipelineProgressesInput;
+}

server/src/api/@generated/pipeline/pipeline-create-without-pipeline-progresses.input.ts

@@ -0,0 +1,34 @@
+import { Field } from '@nestjs/graphql';
+import { InputType } from '@nestjs/graphql';
+import { PipelineStageCreateNestedManyWithoutPipelineInput } from '../pipeline-stage/pipeline-stage-create-nested-many-without-pipeline.input';
+import { WorkspaceCreateNestedOneWithoutPipelinesInput } from '../workspace/workspace-create-nested-one-without-pipelines.input';
+import { HideField } from '@nestjs/graphql';
+
+@InputType()
+export class PipelineCreateWithoutPipelineProgressesInput {
+  @Field(() => String, { nullable: false })
+  id!: string;
+
+  @Field(() => Date, { nullable: true })
+  createdAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  updatedAt?: Date | string;
+
+  @Field(() => Date, { nullable: true })
+  deletedAt?: Date | string;
+
+  @Field(() => String, { nullable: false })
+  name!: string;
+
+  @Field(() => String, { nullable: false })
+  icon!: string;
+
+  @Field(() => PipelineStageCreateNestedManyWithoutPipelineInput, {
+    nullable: true,
+  })
+  pipelineStages?: PipelineStageCreateNestedManyWithoutPipelineInput;
+
+  @HideField()
+  workspace!: WorkspaceCreateNestedOneWithoutPipelinesInput;
+}

server/src/api/@generated/pipeline/pipeline-create-without-pipeline-stages.input.ts

@@ -1,6 +1,6 @@
 import { Field } from '@nestjs/graphql';
 import { InputType } from '@nestjs/graphql';
-import { PipelineAssociationCreateNestedManyWithoutPipelineInput } from '../pipeline-association/pipeline-association-create-nested-many-without-pipeline.input';
+import { PipelineProgressCreateNestedManyWithoutPipelineInput } from '../pipeline-progress/pipeline-progress-create-nested-many-without-pipeline.input';
 import { WorkspaceCreateNestedOneWithoutPipelinesInput } from '../workspace/workspace-create-nested-one-without-pipelines.input';
 import { HideField } from '@nestjs/graphql';
 
@@ -24,10 +24,10 @@ export class PipelineCreateWithoutPipelineStagesInput {
   @Field(() => String, { nullable: false })
   icon!: string;
 
-  @Field(() => PipelineAssociationCreateNestedManyWithoutPipelineInput, {
+  @Field(() => PipelineProgressCreateNestedManyWithoutPipelineInput, {
     nullable: true,
   })
-  pipelineAssociations?: PipelineAssociationCreateNestedManyWithoutPipelineInput;
+  pipelineProgresses?: PipelineProgressCreateNestedManyWithoutPipelineInput;
 
   @HideField()
   workspace!: WorkspaceCreateNestedOneWithoutPipelinesInput;