twentyhq/twenty
1
1
Fork 0
mirror of https://github.com/twentyhq/twenty.git synced 2025-01-03 17:53:58 +03:00
Code Issues Packages Projects Releases Wiki Activity

Disable linter on generated code (#363)

Browse Source
This commit is contained in:
Félix Malfait 2023-06-23 08:43:41 -07:00 committed by GitHub
parent ceaf482f62
commit 1c7980b270
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
976 changed files with 14917 additions and 15292 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.devcontainer/devcontainer.json
View File

@ -6,7 +6,7 @@
"ghcr.io/devcontainers-contrib/features/jshint:2": {} "ghcr.io/devcontainers-contrib/features/jshint:2": {}
}, },
"forwardPorts": [3000, 3001, 5432], "forwardPorts": [3000, 3001, 5432],
"postCreateCommand": "cd front && yarn && cd ../server && yarn", "postCreateCommand": "echo 'To start the server, run yarn start command in server and front folder'",
"customizations": { "customizations": {
"vscode": { "vscode": {
"extensions": [ "extensions": [

13
.vscode/tasks.json vendored Normal file
View File

@ -0,0 +1,13 @@
{
"version": "2.0.0",
"tasks": [
{
"type": "npm",
"script": "start",
"path": "server",
"problemMatcher": [],
"label": "yarn: start - server",
"detail": "yarn start"
}
]
}

2
server/.eslintrc.js
View File

@ -15,7 +15,7 @@ module.exports = {
node: true, node: true,
jest: true, jest: true,
}, },
ignorePatterns: ['.eslintrc.js'], ignorePatterns: ['.eslintrc.js', 'src/core/@generated/**'],
rules: { rules: {
'@typescript-eslint/interface-name-prefix': 'off', '@typescript-eslint/interface-name-prefix': 'off',
'@typescript-eslint/explicit-function-return-type': 'off', '@typescript-eslint/explicit-function-return-type': 'off',

4
server/package.json
View File

@ -21,10 +21,10 @@
"test:e2e": "jest --config ./test/jest-e2e.json", "test:e2e": "jest --config ./test/jest-e2e.json",
"prisma:generate-client": "npx prisma generate --generator client && yarn prisma:generate-gql-select", "prisma:generate-client": "npx prisma generate --generator client && yarn prisma:generate-gql-select",
"prisma:generate-gql-select": "node scripts/generate-model-select-map.js", "prisma:generate-gql-select": "node scripts/generate-model-select-map.js",
"prisma:generate-nest-graphql": "npx prisma generate --generator nestgraphql && eslint \"src/core/@generated/**\" --fix", "prisma:generate-nest-graphql": "npx prisma generate --generator nestgraphql",
"prisma:migrate": "npx prisma migrate deploy", "prisma:migrate": "npx prisma migrate deploy",
"prisma:seed": "npx prisma db seed", "prisma:seed": "npx prisma db seed",
"prisma:reset": "npx prisma migrate reset && eslint \"src/core/@generated/**\" --fix" "prisma:reset": "npx prisma migrate reset"
}, },
"dependencies": { "dependencies": {
"@apollo/server": "^4.7.3", "@apollo/server": "^4.7.3",

13
server/src/core/@generated/comment-thread-target/aggregate-comment-thread-target.output.ts
View File

@ -6,12 +6,13 @@ import { CommentThreadTargetMaxAggregate } from './comment-thread-target-max-agg
@ObjectType() @ObjectType()
export class AggregateCommentThreadTarget { export class AggregateCommentThreadTarget {
@Field(() => CommentThreadTargetCountAggregate, { nullable: true })
_count?: CommentThreadTargetCountAggregate;
@Field(() => CommentThreadTargetMinAggregate, { nullable: true }) @Field(() => CommentThreadTargetCountAggregate, {nullable:true})
_min?: CommentThreadTargetMinAggregate; _count?: CommentThreadTargetCountAggregate;
@Field(() => CommentThreadTargetMaxAggregate, { nullable: true }) @Field(() => CommentThreadTargetMinAggregate, {nullable:true})
_max?: CommentThreadTargetMaxAggregate; _min?: CommentThreadTargetMinAggregate;
@Field(() => CommentThreadTargetMaxAggregate, {nullable:true})
_max?: CommentThreadTargetMaxAggregate;
} }

37
server/src/core/@generated/comment-thread-target/comment-thread-target-aggregate.args.ts
View File

@ -11,30 +11,29 @@ import { CommentThreadTargetMaxAggregateInput } from './comment-thread-target-ma
@ArgsType() @ArgsType()
export class CommentThreadTargetAggregateArgs { export class CommentThreadTargetAggregateArgs {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], { @Field(() => CommentThreadTargetWhereInput, {nullable:true})
nullable: true, @Type(() => CommentThreadTargetWhereInput)
}) where?: CommentThreadTargetWhereInput;
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: true }) @Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput; orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
take?: number; cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => CommentThreadTargetCountAggregateInput, { nullable: true }) @Field(() => Int, {nullable:true})
_count?: CommentThreadTargetCountAggregateInput; skip?: number;
@Field(() => CommentThreadTargetMinAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetCountAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinAggregateInput; _count?: CommentThreadTargetCountAggregateInput;
@Field(() => CommentThreadTargetMaxAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetMinAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxAggregateInput; _min?: CommentThreadTargetMinAggregateInput;
@Field(() => CommentThreadTargetMaxAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxAggregateInput;
} }

33
server/src/core/@generated/comment-thread-target/comment-thread-target-count-aggregate.input.ts
View File

@ -3,27 +3,28 @@ import { InputType } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadTargetCountAggregateInput { export class CommentThreadTargetCountAggregateInput {
@Field(() => Boolean, { nullable: true })
id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
createdAt?: true; id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
updatedAt?: true; createdAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
deletedAt?: true; updatedAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentThreadId?: true; deletedAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentableType?: true; commentThreadId?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentableId?: true; commentableType?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
_all?: true; commentableId?: true;
@Field(() => Boolean, {nullable:true})
_all?: true;
} }

33
server/src/core/@generated/comment-thread-target/comment-thread-target-count-aggregate.output.ts
View File

@ -4,27 +4,28 @@ import { Int } from '@nestjs/graphql';
@ObjectType() @ObjectType()
export class CommentThreadTargetCountAggregate { export class CommentThreadTargetCountAggregate {
@Field(() => Int, { nullable: false })
id!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
createdAt!: number; id!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
updatedAt!: number; createdAt!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
deletedAt!: number; updatedAt!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
commentThreadId!: number; deletedAt!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
commentableType!: number; commentThreadId!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
commentableId!: number; commentableType!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
_all!: number; commentableId!: number;
@Field(() => Int, {nullable:false})
_all!: number;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-count-order-by-aggregate.input.ts
View File

@ -4,24 +4,25 @@ import { SortOrder } from '../prisma/sort-order.enum';
@InputType() @InputType()
export class CommentThreadTargetCountOrderByAggregateInput { export class CommentThreadTargetCountOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder; commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder; commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
} }

13
server/src/core/@generated/comment-thread-target/comment-thread-target-create-many-comment-thread-input-envelope.input.ts
View File

@ -5,12 +5,11 @@ import { Type } from 'class-transformer';
@InputType() @InputType()
export class CommentThreadTargetCreateManyCommentThreadInputEnvelope { export class CommentThreadTargetCreateManyCommentThreadInputEnvelope {
@Field(() => [CommentThreadTargetCreateManyCommentThreadInput], {
nullable: false,
})
@Type(() => CommentThreadTargetCreateManyCommentThreadInput)
data!: Array<CommentThreadTargetCreateManyCommentThreadInput>;
@Field(() => Boolean, { nullable: true }) @Field(() => [CommentThreadTargetCreateManyCommentThreadInput], {nullable:false})
skipDuplicates?: boolean; @Type(() => CommentThreadTargetCreateManyCommentThreadInput)
data!: Array<CommentThreadTargetCreateManyCommentThreadInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
} }

25
server/src/core/@generated/comment-thread-target/comment-thread-target-create-many-comment-thread.input.ts
View File

@ -4,21 +4,22 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@InputType() @InputType()
export class CommentThreadTargetCreateManyCommentThreadInput { export class CommentThreadTargetCreateManyCommentThreadInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => Date, {nullable:true})
commentableType!: keyof typeof CommentableType; deletedAt?: Date | string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-create-many.input.ts
View File

@ -4,24 +4,25 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@InputType() @InputType()
export class CommentThreadTargetCreateManyInput { export class CommentThreadTargetCreateManyInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => String, { nullable: false }) @Field(() => Date, {nullable:true})
commentThreadId!: string; deletedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => String, {nullable:false})
commentableType!: keyof typeof CommentableType; commentThreadId!: string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
} }

21
server/src/core/@generated/comment-thread-target/comment-thread-target-create-nested-many-without-comment-thread.input.ts
View File

@ -9,18 +9,17 @@ import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-whe
@InputType() @InputType()
export class CommentThreadTargetCreateNestedManyWithoutCommentThreadInput { export class CommentThreadTargetCreateNestedManyWithoutCommentThreadInput {
@HideField()
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@HideField() @HideField()
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>; create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, { @HideField()
nullable: true, connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
})
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@HideField() @Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
connect?: Array<CommentThreadTargetWhereUniqueInput>; @Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@HideField()
connect?: Array<CommentThreadTargetWhereUniqueInput>;
} }

15
server/src/core/@generated/comment-thread-target/comment-thread-target-create-or-connect-without-comment-thread.input.ts
View File

@ -6,13 +6,12 @@ import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-th
@InputType() @InputType()
export class CommentThreadTargetCreateOrConnectWithoutCommentThreadInput { export class CommentThreadTargetCreateOrConnectWithoutCommentThreadInput {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetCreateWithoutCommentThreadInput, { @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
nullable: false, @Type(() => CommentThreadTargetWhereUniqueInput)
}) where!: CommentThreadTargetWhereUniqueInput;
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create!: CommentThreadTargetCreateWithoutCommentThreadInput; @Field(() => CommentThreadTargetCreateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create!: CommentThreadTargetCreateWithoutCommentThreadInput;
} }

25
server/src/core/@generated/comment-thread-target/comment-thread-target-create-without-comment-thread.input.ts
View File

@ -4,21 +4,22 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@InputType() @InputType()
export class CommentThreadTargetCreateWithoutCommentThreadInput { export class CommentThreadTargetCreateWithoutCommentThreadInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => Date, {nullable:true})
commentableType!: keyof typeof CommentableType; deletedAt?: Date | string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
} }

31
server/src/core/@generated/comment-thread-target/comment-thread-target-create.input.ts
View File

@ -5,26 +5,25 @@ import { CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput } from '..
@InputType() @InputType()
export class CommentThreadTargetCreateInput { export class CommentThreadTargetCreateInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => Date, {nullable:true})
commentableType!: keyof typeof CommentableType; deletedAt?: Date | string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput, { @Field(() => String, {nullable:false})
nullable: false, commentableId!: string;
})
commentThread!: CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput; @Field(() => CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput, {nullable:false})
commentThread!: CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput;
} }

43
server/src/core/@generated/comment-thread-target/comment-thread-target-group-by.args.ts
View File

@ -12,35 +12,32 @@ import { CommentThreadTargetMaxAggregateInput } from './comment-thread-target-ma
@ArgsType() @ArgsType()
export class CommentThreadTargetGroupByArgs { export class CommentThreadTargetGroupByArgs {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithAggregationInput], { @Field(() => CommentThreadTargetWhereInput, {nullable:true})
nullable: true, @Type(() => CommentThreadTargetWhereInput)
}) where?: CommentThreadTargetWhereInput;
orderBy?: Array<CommentThreadTargetOrderByWithAggregationInput>;
@Field(() => [CommentThreadTargetScalarFieldEnum], { nullable: false }) @Field(() => [CommentThreadTargetOrderByWithAggregationInput], {nullable:true})
by!: Array<keyof typeof CommentThreadTargetScalarFieldEnum>; orderBy?: Array<CommentThreadTargetOrderByWithAggregationInput>;
@Field(() => CommentThreadTargetScalarWhereWithAggregatesInput, { @Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:false})
nullable: true, by!: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
})
having?: CommentThreadTargetScalarWhereWithAggregatesInput;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadTargetScalarWhereWithAggregatesInput, {nullable:true})
take?: number; having?: CommentThreadTargetScalarWhereWithAggregatesInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => CommentThreadTargetCountAggregateInput, { nullable: true }) @Field(() => Int, {nullable:true})
_count?: CommentThreadTargetCountAggregateInput; skip?: number;
@Field(() => CommentThreadTargetMinAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetCountAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinAggregateInput; _count?: CommentThreadTargetCountAggregateInput;
@Field(() => CommentThreadTargetMaxAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetMinAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxAggregateInput; _min?: CommentThreadTargetMinAggregateInput;
@Field(() => CommentThreadTargetMaxAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxAggregateInput;
} }

41
server/src/core/@generated/comment-thread-target/comment-thread-target-group-by.output.ts
View File

@ -7,33 +7,34 @@ import { CommentThreadTargetMaxAggregate } from './comment-thread-target-max-agg
@ObjectType() @ObjectType()
export class CommentThreadTargetGroupBy { export class CommentThreadTargetGroupBy {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: false }) @Field(() => String, {nullable:false})
createdAt!: Date | string; id!: string;
@Field(() => Date, { nullable: false }) @Field(() => Date, {nullable:false})
updatedAt!: Date | string; createdAt!: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:false})
deletedAt?: Date | string; updatedAt!: Date | string;
@Field(() => String, { nullable: false }) @Field(() => Date, {nullable:true})
commentThreadId!: string; deletedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => String, {nullable:false})
commentableType!: keyof typeof CommentableType; commentThreadId!: string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => CommentThreadTargetCountAggregate, { nullable: true }) @Field(() => String, {nullable:false})
_count?: CommentThreadTargetCountAggregate; commentableId!: string;
@Field(() => CommentThreadTargetMinAggregate, { nullable: true }) @Field(() => CommentThreadTargetCountAggregate, {nullable:true})
_min?: CommentThreadTargetMinAggregate; _count?: CommentThreadTargetCountAggregate;
@Field(() => CommentThreadTargetMaxAggregate, { nullable: true }) @Field(() => CommentThreadTargetMinAggregate, {nullable:true})
_max?: CommentThreadTargetMaxAggregate; _min?: CommentThreadTargetMinAggregate;
@Field(() => CommentThreadTargetMaxAggregate, {nullable:true})
_max?: CommentThreadTargetMaxAggregate;
} }

13
server/src/core/@generated/comment-thread-target/comment-thread-target-list-relation-filter.input.ts
View File

@ -4,12 +4,13 @@ import { CommentThreadTargetWhereInput } from './comment-thread-target-where.inp
@InputType() @InputType()
export class CommentThreadTargetListRelationFilter { export class CommentThreadTargetListRelationFilter {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
every?: CommentThreadTargetWhereInput;
@Field(() => CommentThreadTargetWhereInput, { nullable: true }) @Field(() => CommentThreadTargetWhereInput, {nullable:true})
some?: CommentThreadTargetWhereInput; every?: CommentThreadTargetWhereInput;
@Field(() => CommentThreadTargetWhereInput, { nullable: true }) @Field(() => CommentThreadTargetWhereInput, {nullable:true})
none?: CommentThreadTargetWhereInput; some?: CommentThreadTargetWhereInput;
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
none?: CommentThreadTargetWhereInput;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-max-aggregate.input.ts
View File

@ -3,24 +3,25 @@ import { InputType } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadTargetMaxAggregateInput { export class CommentThreadTargetMaxAggregateInput {
@Field(() => Boolean, { nullable: true })
id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
createdAt?: true; id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
updatedAt?: true; createdAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
deletedAt?: true; updatedAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentThreadId?: true; deletedAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentableType?: true; commentThreadId?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentableId?: true; commentableType?: true;
@Field(() => Boolean, {nullable:true})
commentableId?: true;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-max-aggregate.output.ts
View File

@ -4,24 +4,25 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@ObjectType() @ObjectType()
export class CommentThreadTargetMaxAggregate { export class CommentThreadTargetMaxAggregate {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => String, { nullable: true }) @Field(() => Date, {nullable:true})
commentThreadId?: string; deletedAt?: Date | string;
@Field(() => CommentableType, { nullable: true }) @Field(() => String, {nullable:true})
commentableType?: keyof typeof CommentableType; commentThreadId?: string;
@Field(() => String, { nullable: true }) @Field(() => CommentableType, {nullable:true})
commentableId?: string; commentableType?: keyof typeof CommentableType;
@Field(() => String, {nullable:true})
commentableId?: string;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-max-order-by-aggregate.input.ts
View File

@ -4,24 +4,25 @@ import { SortOrder } from '../prisma/sort-order.enum';
@InputType() @InputType()
export class CommentThreadTargetMaxOrderByAggregateInput { export class CommentThreadTargetMaxOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder; commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder; commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-min-aggregate.input.ts
View File

@ -3,24 +3,25 @@ import { InputType } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadTargetMinAggregateInput { export class CommentThreadTargetMinAggregateInput {
@Field(() => Boolean, { nullable: true })
id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
createdAt?: true; id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
updatedAt?: true; createdAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
deletedAt?: true; updatedAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentThreadId?: true; deletedAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentableType?: true; commentThreadId?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
commentableId?: true; commentableType?: true;
@Field(() => Boolean, {nullable:true})
commentableId?: true;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-min-aggregate.output.ts
View File

@ -4,24 +4,25 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@ObjectType() @ObjectType()
export class CommentThreadTargetMinAggregate { export class CommentThreadTargetMinAggregate {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => String, { nullable: true }) @Field(() => Date, {nullable:true})
commentThreadId?: string; deletedAt?: Date | string;
@Field(() => CommentableType, { nullable: true }) @Field(() => String, {nullable:true})
commentableType?: keyof typeof CommentableType; commentThreadId?: string;
@Field(() => String, { nullable: true }) @Field(() => CommentableType, {nullable:true})
commentableId?: string; commentableType?: keyof typeof CommentableType;
@Field(() => String, {nullable:true})
commentableId?: string;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-min-order-by-aggregate.input.ts
View File

@ -4,24 +4,25 @@ import { SortOrder } from '../prisma/sort-order.enum';
@InputType() @InputType()
export class CommentThreadTargetMinOrderByAggregateInput { export class CommentThreadTargetMinOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder; commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder; commentableType?: keyof typeof SortOrder;
@Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder;
} }

5
server/src/core/@generated/comment-thread-target/comment-thread-target-order-by-relation-aggregate.input.ts
View File

@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
@InputType() @InputType()
export class CommentThreadTargetOrderByRelationAggregateInput { export class CommentThreadTargetOrderByRelationAggregateInput {
@Field(() => SortOrder, { nullable: true })
_count?: keyof typeof SortOrder; @Field(() => SortOrder, {nullable:true})
_count?: keyof typeof SortOrder;
} }

43
server/src/core/@generated/comment-thread-target/comment-thread-target-order-by-with-aggregation.input.ts
View File

@ -7,35 +7,34 @@ import { CommentThreadTargetMinOrderByAggregateInput } from './comment-thread-ta
@InputType() @InputType()
export class CommentThreadTargetOrderByWithAggregationInput { export class CommentThreadTargetOrderByWithAggregationInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder; commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder; commentableType?: keyof typeof SortOrder;
@Field(() => CommentThreadTargetCountOrderByAggregateInput, { @Field(() => SortOrder, {nullable:true})
nullable: true, commentableId?: keyof typeof SortOrder;
})
_count?: CommentThreadTargetCountOrderByAggregateInput;
@Field(() => CommentThreadTargetMaxOrderByAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetCountOrderByAggregateInput, {nullable:true})
_max?: CommentThreadTargetMaxOrderByAggregateInput; _count?: CommentThreadTargetCountOrderByAggregateInput;
@Field(() => CommentThreadTargetMinOrderByAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetMaxOrderByAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinOrderByAggregateInput; _max?: CommentThreadTargetMaxOrderByAggregateInput;
@Field(() => CommentThreadTargetMinOrderByAggregateInput, {nullable:true})
_min?: CommentThreadTargetMinOrderByAggregateInput;
} }

33
server/src/core/@generated/comment-thread-target/comment-thread-target-order-by-with-relation.input.ts
View File

@ -5,27 +5,28 @@ import { CommentThreadOrderByWithRelationInput } from '../comment-thread/comment
@InputType() @InputType()
export class CommentThreadTargetOrderByWithRelationInput { export class CommentThreadTargetOrderByWithRelationInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentThreadId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableType?: keyof typeof SortOrder; commentThreadId?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentableId?: keyof typeof SortOrder; commentableType?: keyof typeof SortOrder;
@Field(() => CommentThreadOrderByWithRelationInput, { nullable: true }) @Field(() => SortOrder, {nullable:true})
commentThread?: CommentThreadOrderByWithRelationInput; commentableId?: keyof typeof SortOrder;
@Field(() => CommentThreadOrderByWithRelationInput, {nullable:true})
commentThread?: CommentThreadOrderByWithRelationInput;
} }

20
server/src/core/@generated/comment-thread-target/comment-thread-target-scalar-field.enum.ts
View File

@ -1,16 +1,14 @@
import { registerEnumType } from '@nestjs/graphql'; import { registerEnumType } from '@nestjs/graphql';
export enum CommentThreadTargetScalarFieldEnum { export enum CommentThreadTargetScalarFieldEnum {
id = 'id', id = "id",
createdAt = 'createdAt', createdAt = "createdAt",
updatedAt = 'updatedAt', updatedAt = "updatedAt",
deletedAt = 'deletedAt', deletedAt = "deletedAt",
commentThreadId = 'commentThreadId', commentThreadId = "commentThreadId",
commentableType = 'commentableType', commentableType = "commentableType",
commentableId = 'commentableId', commentableId = "commentableId"
} }
registerEnumType(CommentThreadTargetScalarFieldEnum, {
name: 'CommentThreadTargetScalarFieldEnum', registerEnumType(CommentThreadTargetScalarFieldEnum, { name: 'CommentThreadTargetScalarFieldEnum', description: undefined })
description: undefined,
});

47
server/src/core/@generated/comment-thread-target/comment-thread-target-scalar-where-with-aggregates.input.ts
View File

@ -7,39 +7,34 @@ import { EnumCommentableTypeWithAggregatesFilter } from '../prisma/enum-commenta
@InputType() @InputType()
export class CommentThreadTargetScalarWhereWithAggregatesInput { export class CommentThreadTargetScalarWhereWithAggregatesInput {
@Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {
nullable: true,
})
AND?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], { @Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {nullable:true})
nullable: true, AND?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
})
OR?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], { @Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {nullable:true})
nullable: true, OR?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
})
NOT?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => StringWithAggregatesFilter, { nullable: true }) @Field(() => [CommentThreadTargetScalarWhereWithAggregatesInput], {nullable:true})
id?: StringWithAggregatesFilter; NOT?: Array<CommentThreadTargetScalarWhereWithAggregatesInput>;
@Field(() => DateTimeWithAggregatesFilter, { nullable: true }) @Field(() => StringWithAggregatesFilter, {nullable:true})
createdAt?: DateTimeWithAggregatesFilter; id?: StringWithAggregatesFilter;
@Field(() => DateTimeWithAggregatesFilter, { nullable: true }) @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
updatedAt?: DateTimeWithAggregatesFilter; createdAt?: DateTimeWithAggregatesFilter;
@Field(() => DateTimeNullableWithAggregatesFilter, { nullable: true }) @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
deletedAt?: DateTimeNullableWithAggregatesFilter; updatedAt?: DateTimeWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, { nullable: true }) @Field(() => DateTimeNullableWithAggregatesFilter, {nullable:true})
commentThreadId?: StringWithAggregatesFilter; deletedAt?: DateTimeNullableWithAggregatesFilter;
@Field(() => EnumCommentableTypeWithAggregatesFilter, { nullable: true }) @Field(() => StringWithAggregatesFilter, {nullable:true})
commentableType?: EnumCommentableTypeWithAggregatesFilter; commentThreadId?: StringWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, { nullable: true }) @Field(() => EnumCommentableTypeWithAggregatesFilter, {nullable:true})
commentableId?: StringWithAggregatesFilter; commentableType?: EnumCommentableTypeWithAggregatesFilter;
@Field(() => StringWithAggregatesFilter, {nullable:true})
commentableId?: StringWithAggregatesFilter;
} }

41
server/src/core/@generated/comment-thread-target/comment-thread-target-scalar-where.input.ts
View File

@ -7,33 +7,34 @@ import { EnumCommentableTypeFilter } from '../prisma/enum-commentable-type-filte
@InputType() @InputType()
export class CommentThreadTargetScalarWhereInput { export class CommentThreadTargetScalarWhereInput {
@Field(() => [CommentThreadTargetScalarWhereInput], { nullable: true })
AND?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], { nullable: true }) @Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
OR?: Array<CommentThreadTargetScalarWhereInput>; AND?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], { nullable: true }) @Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
NOT?: Array<CommentThreadTargetScalarWhereInput>; OR?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => StringFilter, { nullable: true }) @Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
id?: StringFilter; NOT?: Array<CommentThreadTargetScalarWhereInput>;
@Field(() => DateTimeFilter, { nullable: true }) @Field(() => StringFilter, {nullable:true})
createdAt?: DateTimeFilter; id?: StringFilter;
@Field(() => DateTimeFilter, { nullable: true }) @Field(() => DateTimeFilter, {nullable:true})
updatedAt?: DateTimeFilter; createdAt?: DateTimeFilter;
@Field(() => DateTimeNullableFilter, { nullable: true }) @Field(() => DateTimeFilter, {nullable:true})
deletedAt?: DateTimeNullableFilter; updatedAt?: DateTimeFilter;
@Field(() => StringFilter, { nullable: true }) @Field(() => DateTimeNullableFilter, {nullable:true})
commentThreadId?: StringFilter; deletedAt?: DateTimeNullableFilter;
@Field(() => EnumCommentableTypeFilter, { nullable: true }) @Field(() => StringFilter, {nullable:true})
commentableType?: EnumCommentableTypeFilter; commentThreadId?: StringFilter;
@Field(() => StringFilter, { nullable: true }) @Field(() => EnumCommentableTypeFilter, {nullable:true})
commentableId?: StringFilter; commentableType?: EnumCommentableTypeFilter;
@Field(() => StringFilter, {nullable:true})
commentableId?: StringFilter;
} }

31
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-create-nested-many-without-comment-thread.input.ts
View File

@ -8,25 +8,20 @@ import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-whe
@InputType() @InputType()
export class CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput { export class CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput {
@Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {
nullable: true,
})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], { @Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {nullable:true})
nullable: true, @Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
}) create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, { @Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], {nullable:true})
nullable: true, @Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
}) connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
connect?: Array<CommentThreadTargetWhereUniqueInput>; createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput)
connect?: Array<CommentThreadTargetWhereUniqueInput>;
} }

25
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-create-without-comment-thread.input.ts
View File

@ -4,21 +4,22 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@InputType() @InputType()
export class CommentThreadTargetUncheckedCreateWithoutCommentThreadInput { export class CommentThreadTargetUncheckedCreateWithoutCommentThreadInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => Date, {nullable:true})
commentableType!: keyof typeof CommentableType; deletedAt?: Date | string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
} }

29
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-create.input.ts
View File

@ -4,24 +4,25 @@ import { CommentableType } from '../prisma/commentable-type.enum';
@InputType() @InputType()
export class CommentThreadTargetUncheckedCreateInput { export class CommentThreadTargetUncheckedCreateInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => String, { nullable: false }) @Field(() => Date, {nullable:true})
commentThreadId!: string; deletedAt?: Date | string;
@Field(() => CommentableType, { nullable: false }) @Field(() => String, {nullable:false})
commentableType!: keyof typeof CommentableType; commentThreadId!: string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => String, {nullable:false})
commentableId!: string;
} }

82
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-many-without-comment-thread-nested.input.ts
View File

@ -12,62 +12,48 @@ import { CommentThreadTargetScalarWhereInput } from './comment-thread-target-sca
@InputType() @InputType()
export class CommentThreadTargetUncheckedUpdateManyWithoutCommentThreadNestedInput { export class CommentThreadTargetUncheckedUpdateManyWithoutCommentThreadNestedInput {
@Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {
nullable: true,
})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], { @Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {nullable:true})
nullable: true, @Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
}) create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field( @Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], {nullable:true})
() => [CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput], @Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
{ nullable: true }, connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
)
@Type(() => CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput)
upsert?: Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, { @Field(() => [CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
nullable: true, @Type(() => CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput)
}) upsert?: Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>;
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
set?: Array<CommentThreadTargetWhereUniqueInput>; createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetWhereUniqueInput)
disconnect?: Array<CommentThreadTargetWhereUniqueInput>; set?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetWhereUniqueInput)
delete?: Array<CommentThreadTargetWhereUniqueInput>; disconnect?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetWhereUniqueInput)
connect?: Array<CommentThreadTargetWhereUniqueInput>; delete?: Array<CommentThreadTargetWhereUniqueInput>;
@Field( @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
() => [CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput], @Type(() => CommentThreadTargetWhereUniqueInput)
{ nullable: true }, connect?: Array<CommentThreadTargetWhereUniqueInput>;
)
@Type(() => CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput)
update?: Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>;
@Field( @Field(() => [CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
() => [CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput], @Type(() => CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput)
{ nullable: true }, update?: Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>;
)
@Type(() => CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput)
updateMany?: Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], { nullable: true }) @Field(() => [CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetScalarWhereInput) @Type(() => CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput)
deleteMany?: Array<CommentThreadTargetScalarWhereInput>; updateMany?: Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
@Type(() => CommentThreadTargetScalarWhereInput)
deleteMany?: Array<CommentThreadTargetScalarWhereInput>;
} }

27
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-many-without-comment-thread-targets.input.ts
View File

@ -7,23 +7,22 @@ import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-co
@InputType() @InputType()
export class CommentThreadTargetUncheckedUpdateManyWithoutCommentThreadTargetsInput { export class CommentThreadTargetUncheckedUpdateManyWithoutCommentThreadTargetsInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
nullable: true, deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
} }

31
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-many.input.ts
View File

@ -7,26 +7,25 @@ import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-co
@InputType() @InputType()
export class CommentThreadTargetUncheckedUpdateManyInput { export class CommentThreadTargetUncheckedUpdateManyInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
commentThreadId?: StringFieldUpdateOperationsInput; deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
nullable: true, commentThreadId?: StringFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
} }

27
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update-without-comment-thread.input.ts
View File

@ -7,23 +7,22 @@ import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-co
@InputType() @InputType()
export class CommentThreadTargetUncheckedUpdateWithoutCommentThreadInput { export class CommentThreadTargetUncheckedUpdateWithoutCommentThreadInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
nullable: true, deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
} }

31
server/src/core/@generated/comment-thread-target/comment-thread-target-unchecked-update.input.ts
View File

@ -7,26 +7,25 @@ import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-co
@InputType() @InputType()
export class CommentThreadTargetUncheckedUpdateInput { export class CommentThreadTargetUncheckedUpdateInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
commentThreadId?: StringFieldUpdateOperationsInput; deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
nullable: true, commentThreadId?: StringFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
} }

27
server/src/core/@generated/comment-thread-target/comment-thread-target-update-many-mutation.input.ts
View File

@ -7,23 +7,22 @@ import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-co
@InputType() @InputType()
export class CommentThreadTargetUpdateManyMutationInput { export class CommentThreadTargetUpdateManyMutationInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
nullable: true, deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
} }

13
server/src/core/@generated/comment-thread-target/comment-thread-target-update-many-with-where-without-comment-thread.input.ts
View File

@ -6,11 +6,12 @@ import { CommentThreadTargetUpdateManyMutationInput } from './comment-thread-tar
@InputType() @InputType()
export class CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput { export class CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput {
@Field(() => CommentThreadTargetScalarWhereInput, { nullable: false })
@Type(() => CommentThreadTargetScalarWhereInput)
where!: CommentThreadTargetScalarWhereInput;
@Field(() => CommentThreadTargetUpdateManyMutationInput, { nullable: false }) @Field(() => CommentThreadTargetScalarWhereInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateManyMutationInput) @Type(() => CommentThreadTargetScalarWhereInput)
data!: CommentThreadTargetUpdateManyMutationInput; where!: CommentThreadTargetScalarWhereInput;
@Field(() => CommentThreadTargetUpdateManyMutationInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateManyMutationInput)
data!: CommentThreadTargetUpdateManyMutationInput;
} }

82
server/src/core/@generated/comment-thread-target/comment-thread-target-update-many-without-comment-thread-nested.input.ts
View File

@ -12,62 +12,48 @@ import { CommentThreadTargetScalarWhereInput } from './comment-thread-target-sca
@InputType() @InputType()
export class CommentThreadTargetUpdateManyWithoutCommentThreadNestedInput { export class CommentThreadTargetUpdateManyWithoutCommentThreadNestedInput {
@Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {
nullable: true,
})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], { @Field(() => [CommentThreadTargetCreateWithoutCommentThreadInput], {nullable:true})
nullable: true, @Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
}) create?: Array<CommentThreadTargetCreateWithoutCommentThreadInput>;
@Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
@Field( @Field(() => [CommentThreadTargetCreateOrConnectWithoutCommentThreadInput], {nullable:true})
() => [CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput], @Type(() => CommentThreadTargetCreateOrConnectWithoutCommentThreadInput)
{ nullable: true }, connectOrCreate?: Array<CommentThreadTargetCreateOrConnectWithoutCommentThreadInput>;
)
@Type(() => CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput)
upsert?: Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>;
@Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, { @Field(() => [CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
nullable: true, @Type(() => CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput)
}) upsert?: Array<CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput>;
@Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope, {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetCreateManyCommentThreadInputEnvelope)
set?: Array<CommentThreadTargetWhereUniqueInput>; createMany?: CommentThreadTargetCreateManyCommentThreadInputEnvelope;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetWhereUniqueInput)
disconnect?: Array<CommentThreadTargetWhereUniqueInput>; set?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetWhereUniqueInput)
delete?: Array<CommentThreadTargetWhereUniqueInput>; disconnect?: Array<CommentThreadTargetWhereUniqueInput>;
@Field(() => [CommentThreadTargetWhereUniqueInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetWhereUniqueInput)
connect?: Array<CommentThreadTargetWhereUniqueInput>; delete?: Array<CommentThreadTargetWhereUniqueInput>;
@Field( @Field(() => [CommentThreadTargetWhereUniqueInput], {nullable:true})
() => [CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput], @Type(() => CommentThreadTargetWhereUniqueInput)
{ nullable: true }, connect?: Array<CommentThreadTargetWhereUniqueInput>;
)
@Type(() => CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput)
update?: Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>;
@Field( @Field(() => [CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput], {nullable:true})
() => [CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput], @Type(() => CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput)
{ nullable: true }, update?: Array<CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput>;
)
@Type(() => CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput)
updateMany?: Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], { nullable: true }) @Field(() => [CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput], {nullable:true})
@Type(() => CommentThreadTargetScalarWhereInput) @Type(() => CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput)
deleteMany?: Array<CommentThreadTargetScalarWhereInput>; updateMany?: Array<CommentThreadTargetUpdateManyWithWhereWithoutCommentThreadInput>;
@Field(() => [CommentThreadTargetScalarWhereInput], {nullable:true})
@Type(() => CommentThreadTargetScalarWhereInput)
deleteMany?: Array<CommentThreadTargetScalarWhereInput>;
} }

15
server/src/core/@generated/comment-thread-target/comment-thread-target-update-with-where-unique-without-comment-thread.input.ts
View File

@ -6,13 +6,12 @@ import { CommentThreadTargetUpdateWithoutCommentThreadInput } from './comment-th
@InputType() @InputType()
export class CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput { export class CommentThreadTargetUpdateWithWhereUniqueWithoutCommentThreadInput {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetUpdateWithoutCommentThreadInput, { @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
nullable: false, @Type(() => CommentThreadTargetWhereUniqueInput)
}) where!: CommentThreadTargetWhereUniqueInput;
@Type(() => CommentThreadTargetUpdateWithoutCommentThreadInput)
data!: CommentThreadTargetUpdateWithoutCommentThreadInput; @Field(() => CommentThreadTargetUpdateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateWithoutCommentThreadInput)
data!: CommentThreadTargetUpdateWithoutCommentThreadInput;
} }

27
server/src/core/@generated/comment-thread-target/comment-thread-target-update-without-comment-thread.input.ts
View File

@ -7,23 +7,22 @@ import { EnumCommentableTypeFieldUpdateOperationsInput } from '../prisma/enum-co
@InputType() @InputType()
export class CommentThreadTargetUpdateWithoutCommentThreadInput { export class CommentThreadTargetUpdateWithoutCommentThreadInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
nullable: true, deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput;
} }

34
server/src/core/@generated/comment-thread-target/comment-thread-target-update.input.ts
View File

@ -8,29 +8,25 @@ import { CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput }
@InputType() @InputType()
export class CommentThreadTargetUpdateInput { export class CommentThreadTargetUpdateInput {
@Field(() => StringFieldUpdateOperationsInput, { nullable: true })
id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
createdAt?: DateTimeFieldUpdateOperationsInput; id?: StringFieldUpdateOperationsInput;
@Field(() => DateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
updatedAt?: DateTimeFieldUpdateOperationsInput; createdAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => NullableDateTimeFieldUpdateOperationsInput, { nullable: true }) @Field(() => DateTimeFieldUpdateOperationsInput, {nullable:true})
deletedAt?: NullableDateTimeFieldUpdateOperationsInput; updatedAt?: DateTimeFieldUpdateOperationsInput;
@Field(() => EnumCommentableTypeFieldUpdateOperationsInput, { @Field(() => NullableDateTimeFieldUpdateOperationsInput, {nullable:true})
nullable: true, deletedAt?: NullableDateTimeFieldUpdateOperationsInput;
})
commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field(() => StringFieldUpdateOperationsInput, { nullable: true }) @Field(() => EnumCommentableTypeFieldUpdateOperationsInput, {nullable:true})
commentableId?: StringFieldUpdateOperationsInput; commentableType?: EnumCommentableTypeFieldUpdateOperationsInput;
@Field( @Field(() => StringFieldUpdateOperationsInput, {nullable:true})
() => CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput, commentableId?: StringFieldUpdateOperationsInput;
{ nullable: true },
) @Field(() => CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput, {nullable:true})
commentThread?: CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput; commentThread?: CommentThreadUpdateOneRequiredWithoutCommentThreadTargetsNestedInput;
} }

23
server/src/core/@generated/comment-thread-target/comment-thread-target-upsert-with-where-unique-without-comment-thread.input.ts
View File

@ -7,19 +7,16 @@ import { CommentThreadTargetCreateWithoutCommentThreadInput } from './comment-th
@InputType() @InputType()
export class CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput { export class CommentThreadTargetUpsertWithWhereUniqueWithoutCommentThreadInput {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetUpdateWithoutCommentThreadInput, { @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
nullable: false, @Type(() => CommentThreadTargetWhereUniqueInput)
}) where!: CommentThreadTargetWhereUniqueInput;
@Type(() => CommentThreadTargetUpdateWithoutCommentThreadInput)
update!: CommentThreadTargetUpdateWithoutCommentThreadInput;
@Field(() => CommentThreadTargetCreateWithoutCommentThreadInput, { @Field(() => CommentThreadTargetUpdateWithoutCommentThreadInput, {nullable:false})
nullable: false, @Type(() => CommentThreadTargetUpdateWithoutCommentThreadInput)
}) update!: CommentThreadTargetUpdateWithoutCommentThreadInput;
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create!: CommentThreadTargetCreateWithoutCommentThreadInput; @Field(() => CommentThreadTargetCreateWithoutCommentThreadInput, {nullable:false})
@Type(() => CommentThreadTargetCreateWithoutCommentThreadInput)
create!: CommentThreadTargetCreateWithoutCommentThreadInput;
} }

5
server/src/core/@generated/comment-thread-target/comment-thread-target-where-unique.input.ts
View File

@ -3,6 +3,7 @@ import { InputType } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadTargetWhereUniqueInput { export class CommentThreadTargetWhereUniqueInput {
@Field(() => String, { nullable: true })
id?: string; @Field(() => String, {nullable:true})
id?: string;
} }

45
server/src/core/@generated/comment-thread-target/comment-thread-target-where.input.ts
View File

@ -8,36 +8,37 @@ import { CommentThreadRelationFilter } from '../comment-thread/comment-thread-re
@InputType() @InputType()
export class CommentThreadTargetWhereInput { export class CommentThreadTargetWhereInput {
@Field(() => [CommentThreadTargetWhereInput], { nullable: true })
AND?: Array<CommentThreadTargetWhereInput>;
@Field(() => [CommentThreadTargetWhereInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereInput], {nullable:true})
OR?: Array<CommentThreadTargetWhereInput>; AND?: Array<CommentThreadTargetWhereInput>;
@Field(() => [CommentThreadTargetWhereInput], { nullable: true }) @Field(() => [CommentThreadTargetWhereInput], {nullable:true})
NOT?: Array<CommentThreadTargetWhereInput>; OR?: Array<CommentThreadTargetWhereInput>;
@Field(() => StringFilter, { nullable: true }) @Field(() => [CommentThreadTargetWhereInput], {nullable:true})
id?: StringFilter; NOT?: Array<CommentThreadTargetWhereInput>;
@Field(() => DateTimeFilter, { nullable: true }) @Field(() => StringFilter, {nullable:true})
createdAt?: DateTimeFilter; id?: StringFilter;
@Field(() => DateTimeFilter, { nullable: true }) @Field(() => DateTimeFilter, {nullable:true})
updatedAt?: DateTimeFilter; createdAt?: DateTimeFilter;
@Field(() => DateTimeNullableFilter, { nullable: true }) @Field(() => DateTimeFilter, {nullable:true})
deletedAt?: DateTimeNullableFilter; updatedAt?: DateTimeFilter;
@Field(() => StringFilter, { nullable: true }) @Field(() => DateTimeNullableFilter, {nullable:true})
commentThreadId?: StringFilter; deletedAt?: DateTimeNullableFilter;
@Field(() => EnumCommentableTypeFilter, { nullable: true }) @Field(() => StringFilter, {nullable:true})
commentableType?: EnumCommentableTypeFilter; commentThreadId?: StringFilter;
@Field(() => StringFilter, { nullable: true }) @Field(() => EnumCommentableTypeFilter, {nullable:true})
commentableId?: StringFilter; commentableType?: EnumCommentableTypeFilter;
@Field(() => CommentThreadRelationFilter, { nullable: true }) @Field(() => StringFilter, {nullable:true})
commentThread?: CommentThreadRelationFilter; commentableId?: StringFilter;
@Field(() => CommentThreadRelationFilter, {nullable:true})
commentThread?: CommentThreadRelationFilter;
} }

33
server/src/core/@generated/comment-thread-target/comment-thread-target.model.ts
View File

@ -6,27 +6,28 @@ import { CommentThread } from '../comment-thread/comment-thread.model';
@ObjectType() @ObjectType()
export class CommentThreadTarget { export class CommentThreadTarget {
@Field(() => ID, { nullable: false })
id!: string;
@Field(() => Date, { nullable: false }) @Field(() => ID, {nullable:false})
createdAt!: Date; id!: string;
@Field(() => Date, { nullable: false }) @Field(() => Date, {nullable:false})
updatedAt!: Date; createdAt!: Date;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:false})
deletedAt!: Date | null; updatedAt!: Date;
@Field(() => String, { nullable: false }) @Field(() => Date, {nullable:true})
commentThreadId!: string; deletedAt!: Date | null;
@Field(() => CommentableType, { nullable: false }) @Field(() => String, {nullable:false})
commentableType!: keyof typeof CommentableType; commentThreadId!: string;
@Field(() => String, { nullable: false }) @Field(() => CommentableType, {nullable:false})
commentableId!: string; commentableType!: keyof typeof CommentableType;
@Field(() => CommentThread, { nullable: false }) @Field(() => String, {nullable:false})
commentThread?: CommentThread; commentableId!: string;
@Field(() => CommentThread, {nullable:false})
commentThread?: CommentThread;
} }

11
server/src/core/@generated/comment-thread-target/create-many-comment-thread-target.args.ts
View File

@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
@ArgsType() @ArgsType()
export class CreateManyCommentThreadTargetArgs { export class CreateManyCommentThreadTargetArgs {
@Field(() => [CommentThreadTargetCreateManyInput], { nullable: false })
@Type(() => CommentThreadTargetCreateManyInput)
data!: Array<CommentThreadTargetCreateManyInput>;
@Field(() => Boolean, { nullable: true }) @Field(() => [CommentThreadTargetCreateManyInput], {nullable:false})
skipDuplicates?: boolean; @Type(() => CommentThreadTargetCreateManyInput)
data!: Array<CommentThreadTargetCreateManyInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
} }

7
server/src/core/@generated/comment-thread-target/create-one-comment-thread-target.args.ts
View File

@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
@ArgsType() @ArgsType()
export class CreateOneCommentThreadTargetArgs { export class CreateOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetCreateInput, { nullable: false })
@Type(() => CommentThreadTargetCreateInput) @Field(() => CommentThreadTargetCreateInput, {nullable:false})
data!: CommentThreadTargetCreateInput; @Type(() => CommentThreadTargetCreateInput)
data!: CommentThreadTargetCreateInput;
} }

7
server/src/core/@generated/comment-thread-target/delete-many-comment-thread-target.args.ts
View File

@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
@ArgsType() @ArgsType()
export class DeleteManyCommentThreadTargetArgs { export class DeleteManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput) @Field(() => CommentThreadTargetWhereInput, {nullable:true})
where?: CommentThreadTargetWhereInput; @Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
} }

7
server/src/core/@generated/comment-thread-target/delete-one-comment-thread-target.args.ts
View File

@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
@ArgsType() @ArgsType()
export class DeleteOneCommentThreadTargetArgs { export class DeleteOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
where!: CommentThreadTargetWhereUniqueInput; @Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
} }

29
server/src/core/@generated/comment-thread-target/find-first-comment-thread-target-or-throw.args.ts
View File

@ -9,24 +9,23 @@ import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scal
@ArgsType() @ArgsType()
export class FindFirstCommentThreadTargetOrThrowArgs { export class FindFirstCommentThreadTargetOrThrowArgs {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], { @Field(() => CommentThreadTargetWhereInput, {nullable:true})
nullable: true, @Type(() => CommentThreadTargetWhereInput)
}) where?: CommentThreadTargetWhereInput;
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: true }) @Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput; orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
take?: number; cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], { nullable: true }) @Field(() => Int, {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>; skip?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
} }

29
server/src/core/@generated/comment-thread-target/find-first-comment-thread-target.args.ts
View File

@ -9,24 +9,23 @@ import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scal
@ArgsType() @ArgsType()
export class FindFirstCommentThreadTargetArgs { export class FindFirstCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], { @Field(() => CommentThreadTargetWhereInput, {nullable:true})
nullable: true, @Type(() => CommentThreadTargetWhereInput)
}) where?: CommentThreadTargetWhereInput;
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: true }) @Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput; orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
take?: number; cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], { nullable: true }) @Field(() => Int, {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>; skip?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
} }

29
server/src/core/@generated/comment-thread-target/find-many-comment-thread-target.args.ts
View File

@ -9,24 +9,23 @@ import { CommentThreadTargetScalarFieldEnum } from './comment-thread-target-scal
@ArgsType() @ArgsType()
export class FindManyCommentThreadTargetArgs { export class FindManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereInput, { nullable: true })
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
@Field(() => [CommentThreadTargetOrderByWithRelationInput], { @Field(() => CommentThreadTargetWhereInput, {nullable:true})
nullable: true, @Type(() => CommentThreadTargetWhereInput)
}) where?: CommentThreadTargetWhereInput;
orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: true }) @Field(() => [CommentThreadTargetOrderByWithRelationInput], {nullable:true})
cursor?: CommentThreadTargetWhereUniqueInput; orderBy?: Array<CommentThreadTargetOrderByWithRelationInput>;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:true})
take?: number; cursor?: CommentThreadTargetWhereUniqueInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], { nullable: true }) @Field(() => Int, {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>; skip?: number;
@Field(() => [CommentThreadTargetScalarFieldEnum], {nullable:true})
distinct?: Array<keyof typeof CommentThreadTargetScalarFieldEnum>;
} }

7
server/src/core/@generated/comment-thread-target/find-unique-comment-thread-target-or-throw.args.ts
View File

@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
@ArgsType() @ArgsType()
export class FindUniqueCommentThreadTargetOrThrowArgs { export class FindUniqueCommentThreadTargetOrThrowArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
where!: CommentThreadTargetWhereUniqueInput; @Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
} }

7
server/src/core/@generated/comment-thread-target/find-unique-comment-thread-target.args.ts
View File

@ -5,7 +5,8 @@ import { Type } from 'class-transformer';
@ArgsType() @ArgsType()
export class FindUniqueCommentThreadTargetArgs { export class FindUniqueCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
where!: CommentThreadTargetWhereUniqueInput; @Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
} }

13
server/src/core/@generated/comment-thread-target/update-many-comment-thread-target.args.ts
View File

@ -6,11 +6,12 @@ import { CommentThreadTargetWhereInput } from './comment-thread-target-where.inp
@ArgsType() @ArgsType()
export class UpdateManyCommentThreadTargetArgs { export class UpdateManyCommentThreadTargetArgs {
@Field(() => CommentThreadTargetUpdateManyMutationInput, { nullable: false })
@Type(() => CommentThreadTargetUpdateManyMutationInput)
data!: CommentThreadTargetUpdateManyMutationInput;
@Field(() => CommentThreadTargetWhereInput, { nullable: true }) @Field(() => CommentThreadTargetUpdateManyMutationInput, {nullable:false})
@Type(() => CommentThreadTargetWhereInput) @Type(() => CommentThreadTargetUpdateManyMutationInput)
where?: CommentThreadTargetWhereInput; data!: CommentThreadTargetUpdateManyMutationInput;
@Field(() => CommentThreadTargetWhereInput, {nullable:true})
@Type(() => CommentThreadTargetWhereInput)
where?: CommentThreadTargetWhereInput;
} }

13
server/src/core/@generated/comment-thread-target/update-one-comment-thread-target.args.ts
View File

@ -6,11 +6,12 @@ import { CommentThreadTargetWhereUniqueInput } from './comment-thread-target-whe
@ArgsType() @ArgsType()
export class UpdateOneCommentThreadTargetArgs { export class UpdateOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetUpdateInput, { nullable: false })
@Type(() => CommentThreadTargetUpdateInput)
data!: CommentThreadTargetUpdateInput;
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false }) @Field(() => CommentThreadTargetUpdateInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput) @Type(() => CommentThreadTargetUpdateInput)
where!: CommentThreadTargetWhereUniqueInput; data!: CommentThreadTargetUpdateInput;
@Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
} }

19
server/src/core/@generated/comment-thread-target/upsert-one-comment-thread-target.args.ts
View File

@ -7,15 +7,16 @@ import { CommentThreadTargetUpdateInput } from './comment-thread-target-update.i
@ArgsType() @ArgsType()
export class UpsertOneCommentThreadTargetArgs { export class UpsertOneCommentThreadTargetArgs {
@Field(() => CommentThreadTargetWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadTargetWhereUniqueInput)
where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetCreateInput, { nullable: false }) @Field(() => CommentThreadTargetWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadTargetCreateInput) @Type(() => CommentThreadTargetWhereUniqueInput)
create!: CommentThreadTargetCreateInput; where!: CommentThreadTargetWhereUniqueInput;
@Field(() => CommentThreadTargetUpdateInput, { nullable: false }) @Field(() => CommentThreadTargetCreateInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateInput) @Type(() => CommentThreadTargetCreateInput)
update!: CommentThreadTargetUpdateInput; create!: CommentThreadTargetCreateInput;
@Field(() => CommentThreadTargetUpdateInput, {nullable:false})
@Type(() => CommentThreadTargetUpdateInput)
update!: CommentThreadTargetUpdateInput;
} }

13
server/src/core/@generated/comment-thread/aggregate-comment-thread.output.ts
View File

@ -6,12 +6,13 @@ import { CommentThreadMaxAggregate } from './comment-thread-max-aggregate.output
@ObjectType() @ObjectType()
export class AggregateCommentThread { export class AggregateCommentThread {
@Field(() => CommentThreadCountAggregate, { nullable: true })
_count?: CommentThreadCountAggregate;
@Field(() => CommentThreadMinAggregate, { nullable: true }) @Field(() => CommentThreadCountAggregate, {nullable:true})
_min?: CommentThreadMinAggregate; _count?: CommentThreadCountAggregate;
@Field(() => CommentThreadMaxAggregate, { nullable: true }) @Field(() => CommentThreadMinAggregate, {nullable:true})
_max?: CommentThreadMaxAggregate; _min?: CommentThreadMinAggregate;
@Field(() => CommentThreadMaxAggregate, {nullable:true})
_max?: CommentThreadMaxAggregate;
} }

35
server/src/core/@generated/comment-thread/comment-thread-aggregate.args.ts
View File

@ -11,28 +11,29 @@ import { CommentThreadMaxAggregateInput } from './comment-thread-max-aggregate.i
@ArgsType() @ArgsType()
export class CommentThreadAggregateArgs { export class CommentThreadAggregateArgs {
@Field(() => CommentThreadWhereInput, { nullable: true })
@Type(() => CommentThreadWhereInput)
where?: CommentThreadWhereInput;
@Field(() => [CommentThreadOrderByWithRelationInput], { nullable: true }) @Field(() => CommentThreadWhereInput, {nullable:true})
orderBy?: Array<CommentThreadOrderByWithRelationInput>; @Type(() => CommentThreadWhereInput)
where?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereUniqueInput, { nullable: true }) @Field(() => [CommentThreadOrderByWithRelationInput], {nullable:true})
cursor?: CommentThreadWhereUniqueInput; orderBy?: Array<CommentThreadOrderByWithRelationInput>;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadWhereUniqueInput, {nullable:true})
take?: number; cursor?: CommentThreadWhereUniqueInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => CommentThreadCountAggregateInput, { nullable: true }) @Field(() => Int, {nullable:true})
_count?: CommentThreadCountAggregateInput; skip?: number;
@Field(() => CommentThreadMinAggregateInput, { nullable: true }) @Field(() => CommentThreadCountAggregateInput, {nullable:true})
_min?: CommentThreadMinAggregateInput; _count?: CommentThreadCountAggregateInput;
@Field(() => CommentThreadMaxAggregateInput, { nullable: true }) @Field(() => CommentThreadMinAggregateInput, {nullable:true})
_max?: CommentThreadMaxAggregateInput; _min?: CommentThreadMinAggregateInput;
@Field(() => CommentThreadMaxAggregateInput, {nullable:true})
_max?: CommentThreadMaxAggregateInput;
} }

25
server/src/core/@generated/comment-thread/comment-thread-count-aggregate.input.ts
View File

@ -4,21 +4,22 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCountAggregateInput { export class CommentThreadCountAggregateInput {
@Field(() => Boolean, { nullable: true })
id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
createdAt?: true; id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
updatedAt?: true; createdAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
deletedAt?: true; updatedAt?: true;
@HideField() @Field(() => Boolean, {nullable:true})
workspaceId?: true; deletedAt?: true;
@Field(() => Boolean, { nullable: true }) @HideField()
_all?: true; workspaceId?: true;
@Field(() => Boolean, {nullable:true})
_all?: true;
} }

25
server/src/core/@generated/comment-thread/comment-thread-count-aggregate.output.ts
View File

@ -5,21 +5,22 @@ import { HideField } from '@nestjs/graphql';
@ObjectType() @ObjectType()
export class CommentThreadCountAggregate { export class CommentThreadCountAggregate {
@Field(() => Int, { nullable: false })
id!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
createdAt!: number; id!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
updatedAt!: number; createdAt!: number;
@Field(() => Int, { nullable: false }) @Field(() => Int, {nullable:false})
deletedAt!: number; updatedAt!: number;
@HideField() @Field(() => Int, {nullable:false})
workspaceId!: number; deletedAt!: number;
@Field(() => Int, { nullable: false }) @HideField()
_all!: number; workspaceId!: number;
@Field(() => Int, {nullable:false})
_all!: number;
} }

21
server/src/core/@generated/comment-thread/comment-thread-count-order-by-aggregate.input.ts
View File

@ -5,18 +5,19 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCountOrderByAggregateInput { export class CommentThreadCountOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@HideField() @Field(() => SortOrder, {nullable:true})
workspaceId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
} }

11
server/src/core/@generated/comment-thread/comment-thread-create-many-workspace-input-envelope.input.ts
View File

@ -5,10 +5,11 @@ import { Type } from 'class-transformer';
@InputType() @InputType()
export class CommentThreadCreateManyWorkspaceInputEnvelope { export class CommentThreadCreateManyWorkspaceInputEnvelope {
@Field(() => [CommentThreadCreateManyWorkspaceInput], { nullable: false })
@Type(() => CommentThreadCreateManyWorkspaceInput)
data!: Array<CommentThreadCreateManyWorkspaceInput>;
@Field(() => Boolean, { nullable: true }) @Field(() => [CommentThreadCreateManyWorkspaceInput], {nullable:false})
skipDuplicates?: boolean; @Type(() => CommentThreadCreateManyWorkspaceInput)
data!: Array<CommentThreadCreateManyWorkspaceInput>;
@Field(() => Boolean, {nullable:true})
skipDuplicates?: boolean;
} }

17
server/src/core/@generated/comment-thread/comment-thread-create-many-workspace.input.ts
View File

@ -3,15 +3,16 @@ import { InputType } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCreateManyWorkspaceInput { export class CommentThreadCreateManyWorkspaceInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => Date, {nullable:true})
deletedAt?: Date | string;
} }

21
server/src/core/@generated/comment-thread/comment-thread-create-many.input.ts
View File

@ -4,18 +4,19 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCreateManyInput { export class CommentThreadCreateManyInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId!: string; deletedAt?: Date | string;
@HideField()
workspaceId!: string;
} }

29
server/src/core/@generated/comment-thread/comment-thread-create-nested-many-without-workspace.input.ts
View File

@ -8,23 +8,20 @@ import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.inp
@InputType() @InputType()
export class CommentThreadCreateNestedManyWithoutWorkspaceInput { export class CommentThreadCreateNestedManyWithoutWorkspaceInput {
@Field(() => [CommentThreadCreateWithoutWorkspaceInput], { nullable: true })
@Type(() => CommentThreadCreateWithoutWorkspaceInput)
create?: Array<CommentThreadCreateWithoutWorkspaceInput>;
@Field(() => [CommentThreadCreateOrConnectWithoutWorkspaceInput], { @Field(() => [CommentThreadCreateWithoutWorkspaceInput], {nullable:true})
nullable: true, @Type(() => CommentThreadCreateWithoutWorkspaceInput)
}) create?: Array<CommentThreadCreateWithoutWorkspaceInput>;
@Type(() => CommentThreadCreateOrConnectWithoutWorkspaceInput)
connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutWorkspaceInput>;
@Field(() => CommentThreadCreateManyWorkspaceInputEnvelope, { @Field(() => [CommentThreadCreateOrConnectWithoutWorkspaceInput], {nullable:true})
nullable: true, @Type(() => CommentThreadCreateOrConnectWithoutWorkspaceInput)
}) connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutWorkspaceInput>;
@Type(() => CommentThreadCreateManyWorkspaceInputEnvelope)
createMany?: CommentThreadCreateManyWorkspaceInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], { nullable: true }) @Field(() => CommentThreadCreateManyWorkspaceInputEnvelope, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput) @Type(() => CommentThreadCreateManyWorkspaceInputEnvelope)
connect?: Array<CommentThreadWhereUniqueInput>; createMany?: CommentThreadCreateManyWorkspaceInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: Array<CommentThreadWhereUniqueInput>;
} }

23
server/src/core/@generated/comment-thread/comment-thread-create-nested-one-without-comment-thread-targets.input.ts
View File

@ -7,19 +7,16 @@ import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.inp
@InputType() @InputType()
export class CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput { export class CommentThreadCreateNestedOneWithoutCommentThreadTargetsInput {
@Field(() => CommentThreadCreateWithoutCommentThreadTargetsInput, {
nullable: true,
})
@Type(() => CommentThreadCreateWithoutCommentThreadTargetsInput)
create?: CommentThreadCreateWithoutCommentThreadTargetsInput;
@Field(() => CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput, { @Field(() => CommentThreadCreateWithoutCommentThreadTargetsInput, {nullable:true})
nullable: true, @Type(() => CommentThreadCreateWithoutCommentThreadTargetsInput)
}) create?: CommentThreadCreateWithoutCommentThreadTargetsInput;
@Type(() => CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput)
connectOrCreate?: CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput;
@Field(() => CommentThreadWhereUniqueInput, { nullable: true }) @Field(() => CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput) @Type(() => CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput)
connect?: CommentThreadWhereUniqueInput; connectOrCreate?: CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput;
@Field(() => CommentThreadWhereUniqueInput, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: CommentThreadWhereUniqueInput;
} }

15
server/src/core/@generated/comment-thread/comment-thread-create-nested-one-without-comments.input.ts
View File

@ -8,13 +8,14 @@ import { Type } from 'class-transformer';
@InputType() @InputType()
export class CommentThreadCreateNestedOneWithoutCommentsInput { export class CommentThreadCreateNestedOneWithoutCommentsInput {
@HideField()
create?: CommentThreadCreateWithoutCommentsInput;
@HideField() @HideField()
connectOrCreate?: CommentThreadCreateOrConnectWithoutCommentsInput; create?: CommentThreadCreateWithoutCommentsInput;
@Field(() => CommentThreadWhereUniqueInput, { nullable: true }) @HideField()
@Type(() => CommentThreadWhereUniqueInput) connectOrCreate?: CommentThreadCreateOrConnectWithoutCommentsInput;
connect?: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadWhereUniqueInput, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: CommentThreadWhereUniqueInput;
} }

15
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-comment-thread-targets.input.ts
View File

@ -6,13 +6,12 @@ import { CommentThreadCreateWithoutCommentThreadTargetsInput } from './comment-t
@InputType() @InputType()
export class CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput { export class CommentThreadCreateOrConnectWithoutCommentThreadTargetsInput {
@Field(() => CommentThreadWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutCommentThreadTargetsInput, { @Field(() => CommentThreadWhereUniqueInput, {nullable:false})
nullable: false, @Type(() => CommentThreadWhereUniqueInput)
}) where!: CommentThreadWhereUniqueInput;
@Type(() => CommentThreadCreateWithoutCommentThreadTargetsInput)
create!: CommentThreadCreateWithoutCommentThreadTargetsInput; @Field(() => CommentThreadCreateWithoutCommentThreadTargetsInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutCommentThreadTargetsInput)
create!: CommentThreadCreateWithoutCommentThreadTargetsInput;
} }

13
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-comments.input.ts
View File

@ -6,11 +6,12 @@ import { CommentThreadCreateWithoutCommentsInput } from './comment-thread-create
@InputType() @InputType()
export class CommentThreadCreateOrConnectWithoutCommentsInput { export class CommentThreadCreateOrConnectWithoutCommentsInput {
@Field(() => CommentThreadWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutCommentsInput, { nullable: false }) @Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutCommentsInput) @Type(() => CommentThreadWhereUniqueInput)
create!: CommentThreadCreateWithoutCommentsInput; where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutCommentsInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutCommentsInput)
create!: CommentThreadCreateWithoutCommentsInput;
} }

13
server/src/core/@generated/comment-thread/comment-thread-create-or-connect-without-workspace.input.ts
View File

@ -6,11 +6,12 @@ import { CommentThreadCreateWithoutWorkspaceInput } from './comment-thread-creat
@InputType() @InputType()
export class CommentThreadCreateOrConnectWithoutWorkspaceInput { export class CommentThreadCreateOrConnectWithoutWorkspaceInput {
@Field(() => CommentThreadWhereUniqueInput, { nullable: false })
@Type(() => CommentThreadWhereUniqueInput)
where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutWorkspaceInput, { nullable: false }) @Field(() => CommentThreadWhereUniqueInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutWorkspaceInput) @Type(() => CommentThreadWhereUniqueInput)
create!: CommentThreadCreateWithoutWorkspaceInput; where!: CommentThreadWhereUniqueInput;
@Field(() => CommentThreadCreateWithoutWorkspaceInput, {nullable:false})
@Type(() => CommentThreadCreateWithoutWorkspaceInput)
create!: CommentThreadCreateWithoutWorkspaceInput;
} }

27
server/src/core/@generated/comment-thread/comment-thread-create-without-comment-thread-targets.input.ts
View File

@ -6,23 +6,22 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCreateWithoutCommentThreadTargetsInput { export class CommentThreadCreateWithoutCommentThreadTargetsInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, { @Field(() => Date, {nullable:true})
nullable: true, deletedAt?: Date | string;
})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField() @Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput; comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
} }

27
server/src/core/@generated/comment-thread/comment-thread-create-without-comments.input.ts
View File

@ -6,23 +6,22 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCreateWithoutCommentsInput { export class CommentThreadCreateWithoutCommentsInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, { @Field(() => Date, {nullable:true})
nullable: true, deletedAt?: Date | string;
})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@HideField() @Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput; commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
} }

29
server/src/core/@generated/comment-thread/comment-thread-create-without-workspace.input.ts
View File

@ -5,25 +5,22 @@ import { CommentCreateNestedManyWithoutCommentThreadInput } from '../comment/com
@InputType() @InputType()
export class CommentThreadCreateWithoutWorkspaceInput { export class CommentThreadCreateWithoutWorkspaceInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, { @Field(() => Date, {nullable:true})
nullable: true, deletedAt?: Date | string;
})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, { @Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
nullable: true, commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
})
comments?: CommentCreateNestedManyWithoutCommentThreadInput; @Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
} }

33
server/src/core/@generated/comment-thread/comment-thread-create.input.ts
View File

@ -7,28 +7,25 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadCreateInput { export class CommentThreadCreateInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, { @Field(() => Date, {nullable:true})
nullable: true, deletedAt?: Date | string;
})
commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentCreateNestedManyWithoutCommentThreadInput, { @Field(() => CommentThreadTargetCreateNestedManyWithoutCommentThreadInput, {nullable:true})
nullable: true, commentThreadTargets?: CommentThreadTargetCreateNestedManyWithoutCommentThreadInput;
})
comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField() @Field(() => CommentCreateNestedManyWithoutCommentThreadInput, {nullable:true})
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput; comments?: CommentCreateNestedManyWithoutCommentThreadInput;
@HideField()
workspace!: WorkspaceCreateNestedOneWithoutCommentThreadsInput;
} }

39
server/src/core/@generated/comment-thread/comment-thread-group-by.args.ts
View File

@ -12,31 +12,32 @@ import { CommentThreadMaxAggregateInput } from './comment-thread-max-aggregate.i
@ArgsType() @ArgsType()
export class CommentThreadGroupByArgs { export class CommentThreadGroupByArgs {
@Field(() => CommentThreadWhereInput, { nullable: true })
@Type(() => CommentThreadWhereInput)
where?: CommentThreadWhereInput;
@Field(() => [CommentThreadOrderByWithAggregationInput], { nullable: true }) @Field(() => CommentThreadWhereInput, {nullable:true})
orderBy?: Array<CommentThreadOrderByWithAggregationInput>; @Type(() => CommentThreadWhereInput)
where?: CommentThreadWhereInput;
@Field(() => [CommentThreadScalarFieldEnum], { nullable: false }) @Field(() => [CommentThreadOrderByWithAggregationInput], {nullable:true})
by!: Array<keyof typeof CommentThreadScalarFieldEnum>; orderBy?: Array<CommentThreadOrderByWithAggregationInput>;
@Field(() => CommentThreadScalarWhereWithAggregatesInput, { nullable: true }) @Field(() => [CommentThreadScalarFieldEnum], {nullable:false})
having?: CommentThreadScalarWhereWithAggregatesInput; by!: Array<keyof typeof CommentThreadScalarFieldEnum>;
@Field(() => Int, { nullable: true }) @Field(() => CommentThreadScalarWhereWithAggregatesInput, {nullable:true})
take?: number; having?: CommentThreadScalarWhereWithAggregatesInput;
@Field(() => Int, { nullable: true }) @Field(() => Int, {nullable:true})
skip?: number; take?: number;
@Field(() => CommentThreadCountAggregateInput, { nullable: true }) @Field(() => Int, {nullable:true})
_count?: CommentThreadCountAggregateInput; skip?: number;
@Field(() => CommentThreadMinAggregateInput, { nullable: true }) @Field(() => CommentThreadCountAggregateInput, {nullable:true})
_min?: CommentThreadMinAggregateInput; _count?: CommentThreadCountAggregateInput;
@Field(() => CommentThreadMaxAggregateInput, { nullable: true }) @Field(() => CommentThreadMinAggregateInput, {nullable:true})
_max?: CommentThreadMaxAggregateInput; _min?: CommentThreadMinAggregateInput;
@Field(() => CommentThreadMaxAggregateInput, {nullable:true})
_max?: CommentThreadMaxAggregateInput;
} }

33
server/src/core/@generated/comment-thread/comment-thread-group-by.output.ts
View File

@ -7,27 +7,28 @@ import { CommentThreadMaxAggregate } from './comment-thread-max-aggregate.output
@ObjectType() @ObjectType()
export class CommentThreadGroupBy { export class CommentThreadGroupBy {
@Field(() => String, { nullable: false })
id!: string;
@Field(() => Date, { nullable: false }) @Field(() => String, {nullable:false})
createdAt!: Date | string; id!: string;
@Field(() => Date, { nullable: false }) @Field(() => Date, {nullable:false})
updatedAt!: Date | string; createdAt!: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:false})
deletedAt?: Date | string; updatedAt!: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId!: string; deletedAt?: Date | string;
@Field(() => CommentThreadCountAggregate, { nullable: true }) @HideField()
_count?: CommentThreadCountAggregate; workspaceId!: string;
@Field(() => CommentThreadMinAggregate, { nullable: true }) @Field(() => CommentThreadCountAggregate, {nullable:true})
_min?: CommentThreadMinAggregate; _count?: CommentThreadCountAggregate;
@Field(() => CommentThreadMaxAggregate, { nullable: true }) @Field(() => CommentThreadMinAggregate, {nullable:true})
_max?: CommentThreadMaxAggregate; _min?: CommentThreadMinAggregate;
@Field(() => CommentThreadMaxAggregate, {nullable:true})
_max?: CommentThreadMaxAggregate;
} }

13
server/src/core/@generated/comment-thread/comment-thread-list-relation-filter.input.ts
View File

@ -4,12 +4,13 @@ import { CommentThreadWhereInput } from './comment-thread-where.input';
@InputType() @InputType()
export class CommentThreadListRelationFilter { export class CommentThreadListRelationFilter {
@Field(() => CommentThreadWhereInput, { nullable: true })
every?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, { nullable: true }) @Field(() => CommentThreadWhereInput, {nullable:true})
some?: CommentThreadWhereInput; every?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, { nullable: true }) @Field(() => CommentThreadWhereInput, {nullable:true})
none?: CommentThreadWhereInput; some?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, {nullable:true})
none?: CommentThreadWhereInput;
} }

21
server/src/core/@generated/comment-thread/comment-thread-max-aggregate.input.ts
View File

@ -4,18 +4,19 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadMaxAggregateInput { export class CommentThreadMaxAggregateInput {
@Field(() => Boolean, { nullable: true })
id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
createdAt?: true; id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
updatedAt?: true; createdAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
deletedAt?: true; updatedAt?: true;
@HideField() @Field(() => Boolean, {nullable:true})
workspaceId?: true; deletedAt?: true;
@HideField()
workspaceId?: true;
} }

21
server/src/core/@generated/comment-thread/comment-thread-max-aggregate.output.ts
View File

@ -4,18 +4,19 @@ import { HideField } from '@nestjs/graphql';
@ObjectType() @ObjectType()
export class CommentThreadMaxAggregate { export class CommentThreadMaxAggregate {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId?: string; deletedAt?: Date | string;
@HideField()
workspaceId?: string;
} }

21
server/src/core/@generated/comment-thread/comment-thread-max-order-by-aggregate.input.ts
View File

@ -5,18 +5,19 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadMaxOrderByAggregateInput { export class CommentThreadMaxOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@HideField() @Field(() => SortOrder, {nullable:true})
workspaceId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
} }

21
server/src/core/@generated/comment-thread/comment-thread-min-aggregate.input.ts
View File

@ -4,18 +4,19 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadMinAggregateInput { export class CommentThreadMinAggregateInput {
@Field(() => Boolean, { nullable: true })
id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
createdAt?: true; id?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
updatedAt?: true; createdAt?: true;
@Field(() => Boolean, { nullable: true }) @Field(() => Boolean, {nullable:true})
deletedAt?: true; updatedAt?: true;
@HideField() @Field(() => Boolean, {nullable:true})
workspaceId?: true; deletedAt?: true;
@HideField()
workspaceId?: true;
} }

21
server/src/core/@generated/comment-thread/comment-thread-min-aggregate.output.ts
View File

@ -4,18 +4,19 @@ import { HideField } from '@nestjs/graphql';
@ObjectType() @ObjectType()
export class CommentThreadMinAggregate { export class CommentThreadMinAggregate {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId?: string; deletedAt?: Date | string;
@HideField()
workspaceId?: string;
} }

21
server/src/core/@generated/comment-thread/comment-thread-min-order-by-aggregate.input.ts
View File

@ -5,18 +5,19 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadMinOrderByAggregateInput { export class CommentThreadMinOrderByAggregateInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@HideField() @Field(() => SortOrder, {nullable:true})
workspaceId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@HideField()
workspaceId?: keyof typeof SortOrder;
} }

5
server/src/core/@generated/comment-thread/comment-thread-order-by-relation-aggregate.input.ts
View File

@ -4,6 +4,7 @@ import { SortOrder } from '../prisma/sort-order.enum';
@InputType() @InputType()
export class CommentThreadOrderByRelationAggregateInput { export class CommentThreadOrderByRelationAggregateInput {
@Field(() => SortOrder, { nullable: true })
_count?: keyof typeof SortOrder; @Field(() => SortOrder, {nullable:true})
_count?: keyof typeof SortOrder;
} }

33
server/src/core/@generated/comment-thread/comment-thread-order-by-with-aggregation.input.ts
View File

@ -8,27 +8,28 @@ import { CommentThreadMinOrderByAggregateInput } from './comment-thread-min-orde
@InputType() @InputType()
export class CommentThreadOrderByWithAggregationInput { export class CommentThreadOrderByWithAggregationInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@HideField() @Field(() => SortOrder, {nullable:true})
workspaceId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => CommentThreadCountOrderByAggregateInput, { nullable: true }) @HideField()
_count?: CommentThreadCountOrderByAggregateInput; workspaceId?: keyof typeof SortOrder;
@Field(() => CommentThreadMaxOrderByAggregateInput, { nullable: true }) @Field(() => CommentThreadCountOrderByAggregateInput, {nullable:true})
_max?: CommentThreadMaxOrderByAggregateInput; _count?: CommentThreadCountOrderByAggregateInput;
@Field(() => CommentThreadMinOrderByAggregateInput, { nullable: true }) @Field(() => CommentThreadMaxOrderByAggregateInput, {nullable:true})
_min?: CommentThreadMinOrderByAggregateInput; _max?: CommentThreadMaxOrderByAggregateInput;
@Field(() => CommentThreadMinOrderByAggregateInput, {nullable:true})
_min?: CommentThreadMinOrderByAggregateInput;
} }

35
server/src/core/@generated/comment-thread/comment-thread-order-by-with-relation.input.ts
View File

@ -8,29 +8,28 @@ import { WorkspaceOrderByWithRelationInput } from '../workspace/workspace-order-
@InputType() @InputType()
export class CommentThreadOrderByWithRelationInput { export class CommentThreadOrderByWithRelationInput {
@Field(() => SortOrder, { nullable: true })
id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
createdAt?: keyof typeof SortOrder; id?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
updatedAt?: keyof typeof SortOrder; createdAt?: keyof typeof SortOrder;
@Field(() => SortOrder, { nullable: true }) @Field(() => SortOrder, {nullable:true})
deletedAt?: keyof typeof SortOrder; updatedAt?: keyof typeof SortOrder;
@HideField() @Field(() => SortOrder, {nullable:true})
workspaceId?: keyof typeof SortOrder; deletedAt?: keyof typeof SortOrder;
@Field(() => CommentThreadTargetOrderByRelationAggregateInput, { @HideField()
nullable: true, workspaceId?: keyof typeof SortOrder;
})
commentThreadTargets?: CommentThreadTargetOrderByRelationAggregateInput;
@Field(() => CommentOrderByRelationAggregateInput, { nullable: true }) @Field(() => CommentThreadTargetOrderByRelationAggregateInput, {nullable:true})
comments?: CommentOrderByRelationAggregateInput; commentThreadTargets?: CommentThreadTargetOrderByRelationAggregateInput;
@HideField() @Field(() => CommentOrderByRelationAggregateInput, {nullable:true})
workspace?: WorkspaceOrderByWithRelationInput; comments?: CommentOrderByRelationAggregateInput;
@HideField()
workspace?: WorkspaceOrderByWithRelationInput;
} }

9
server/src/core/@generated/comment-thread/comment-thread-relation-filter.input.ts
View File

@ -4,9 +4,10 @@ import { CommentThreadWhereInput } from './comment-thread-where.input';
@InputType() @InputType()
export class CommentThreadRelationFilter { export class CommentThreadRelationFilter {
@Field(() => CommentThreadWhereInput, { nullable: true })
is?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, { nullable: true }) @Field(() => CommentThreadWhereInput, {nullable:true})
isNot?: CommentThreadWhereInput; is?: CommentThreadWhereInput;
@Field(() => CommentThreadWhereInput, {nullable:true})
isNot?: CommentThreadWhereInput;
} }

16
server/src/core/@generated/comment-thread/comment-thread-scalar-field.enum.ts
View File

@ -1,14 +1,12 @@
import { registerEnumType } from '@nestjs/graphql'; import { registerEnumType } from '@nestjs/graphql';
export enum CommentThreadScalarFieldEnum { export enum CommentThreadScalarFieldEnum {
id = 'id', id = "id",
createdAt = 'createdAt', createdAt = "createdAt",
updatedAt = 'updatedAt', updatedAt = "updatedAt",
deletedAt = 'deletedAt', deletedAt = "deletedAt",
workspaceId = 'workspaceId', workspaceId = "workspaceId"
} }
registerEnumType(CommentThreadScalarFieldEnum, {
name: 'CommentThreadScalarFieldEnum', registerEnumType(CommentThreadScalarFieldEnum, { name: 'CommentThreadScalarFieldEnum', description: undefined })
description: undefined,
});

39
server/src/core/@generated/comment-thread/comment-thread-scalar-where-with-aggregates.input.ts
View File

@ -7,33 +7,28 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadScalarWhereWithAggregatesInput { export class CommentThreadScalarWhereWithAggregatesInput {
@Field(() => [CommentThreadScalarWhereWithAggregatesInput], {
nullable: true,
})
AND?: Array<CommentThreadScalarWhereWithAggregatesInput>;
@Field(() => [CommentThreadScalarWhereWithAggregatesInput], { @Field(() => [CommentThreadScalarWhereWithAggregatesInput], {nullable:true})
nullable: true, AND?: Array<CommentThreadScalarWhereWithAggregatesInput>;
})
OR?: Array<CommentThreadScalarWhereWithAggregatesInput>;
@Field(() => [CommentThreadScalarWhereWithAggregatesInput], { @Field(() => [CommentThreadScalarWhereWithAggregatesInput], {nullable:true})
nullable: true, OR?: Array<CommentThreadScalarWhereWithAggregatesInput>;
})
NOT?: Array<CommentThreadScalarWhereWithAggregatesInput>;
@Field(() => StringWithAggregatesFilter, { nullable: true }) @Field(() => [CommentThreadScalarWhereWithAggregatesInput], {nullable:true})
id?: StringWithAggregatesFilter; NOT?: Array<CommentThreadScalarWhereWithAggregatesInput>;
@Field(() => DateTimeWithAggregatesFilter, { nullable: true }) @Field(() => StringWithAggregatesFilter, {nullable:true})
createdAt?: DateTimeWithAggregatesFilter; id?: StringWithAggregatesFilter;
@Field(() => DateTimeWithAggregatesFilter, { nullable: true }) @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
updatedAt?: DateTimeWithAggregatesFilter; createdAt?: DateTimeWithAggregatesFilter;
@Field(() => DateTimeNullableWithAggregatesFilter, { nullable: true }) @Field(() => DateTimeWithAggregatesFilter, {nullable:true})
deletedAt?: DateTimeNullableWithAggregatesFilter; updatedAt?: DateTimeWithAggregatesFilter;
@HideField() @Field(() => DateTimeNullableWithAggregatesFilter, {nullable:true})
workspaceId?: StringWithAggregatesFilter; deletedAt?: DateTimeNullableWithAggregatesFilter;
@HideField()
workspaceId?: StringWithAggregatesFilter;
} }

33
server/src/core/@generated/comment-thread/comment-thread-scalar-where.input.ts
View File

@ -7,27 +7,28 @@ import { HideField } from '@nestjs/graphql';
@InputType() @InputType()
export class CommentThreadScalarWhereInput { export class CommentThreadScalarWhereInput {
@Field(() => [CommentThreadScalarWhereInput], { nullable: true })
AND?: Array<CommentThreadScalarWhereInput>;
@Field(() => [CommentThreadScalarWhereInput], { nullable: true }) @Field(() => [CommentThreadScalarWhereInput], {nullable:true})
OR?: Array<CommentThreadScalarWhereInput>; AND?: Array<CommentThreadScalarWhereInput>;
@Field(() => [CommentThreadScalarWhereInput], { nullable: true }) @Field(() => [CommentThreadScalarWhereInput], {nullable:true})
NOT?: Array<CommentThreadScalarWhereInput>; OR?: Array<CommentThreadScalarWhereInput>;
@Field(() => StringFilter, { nullable: true }) @Field(() => [CommentThreadScalarWhereInput], {nullable:true})
id?: StringFilter; NOT?: Array<CommentThreadScalarWhereInput>;
@Field(() => DateTimeFilter, { nullable: true }) @Field(() => StringFilter, {nullable:true})
createdAt?: DateTimeFilter; id?: StringFilter;
@Field(() => DateTimeFilter, { nullable: true }) @Field(() => DateTimeFilter, {nullable:true})
updatedAt?: DateTimeFilter; createdAt?: DateTimeFilter;
@Field(() => DateTimeNullableFilter, { nullable: true }) @Field(() => DateTimeFilter, {nullable:true})
deletedAt?: DateTimeNullableFilter; updatedAt?: DateTimeFilter;
@HideField() @Field(() => DateTimeNullableFilter, {nullable:true})
workspaceId?: StringFilter; deletedAt?: DateTimeNullableFilter;
@HideField()
workspaceId?: StringFilter;
} }

29
server/src/core/@generated/comment-thread/comment-thread-unchecked-create-nested-many-without-workspace.input.ts
View File

@ -8,23 +8,20 @@ import { CommentThreadWhereUniqueInput } from './comment-thread-where-unique.inp
@InputType() @InputType()
export class CommentThreadUncheckedCreateNestedManyWithoutWorkspaceInput { export class CommentThreadUncheckedCreateNestedManyWithoutWorkspaceInput {
@Field(() => [CommentThreadCreateWithoutWorkspaceInput], { nullable: true })
@Type(() => CommentThreadCreateWithoutWorkspaceInput)
create?: Array<CommentThreadCreateWithoutWorkspaceInput>;
@Field(() => [CommentThreadCreateOrConnectWithoutWorkspaceInput], { @Field(() => [CommentThreadCreateWithoutWorkspaceInput], {nullable:true})
nullable: true, @Type(() => CommentThreadCreateWithoutWorkspaceInput)
}) create?: Array<CommentThreadCreateWithoutWorkspaceInput>;
@Type(() => CommentThreadCreateOrConnectWithoutWorkspaceInput)
connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutWorkspaceInput>;
@Field(() => CommentThreadCreateManyWorkspaceInputEnvelope, { @Field(() => [CommentThreadCreateOrConnectWithoutWorkspaceInput], {nullable:true})
nullable: true, @Type(() => CommentThreadCreateOrConnectWithoutWorkspaceInput)
}) connectOrCreate?: Array<CommentThreadCreateOrConnectWithoutWorkspaceInput>;
@Type(() => CommentThreadCreateManyWorkspaceInputEnvelope)
createMany?: CommentThreadCreateManyWorkspaceInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], { nullable: true }) @Field(() => CommentThreadCreateManyWorkspaceInputEnvelope, {nullable:true})
@Type(() => CommentThreadWhereUniqueInput) @Type(() => CommentThreadCreateManyWorkspaceInputEnvelope)
connect?: Array<CommentThreadWhereUniqueInput>; createMany?: CommentThreadCreateManyWorkspaceInputEnvelope;
@Field(() => [CommentThreadWhereUniqueInput], {nullable:true})
@Type(() => CommentThreadWhereUniqueInput)
connect?: Array<CommentThreadWhereUniqueInput>;
} }

27
server/src/core/@generated/comment-thread/comment-thread-unchecked-create-without-comment-thread-targets.input.ts
View File

@ -5,23 +5,22 @@ import { CommentUncheckedCreateNestedManyWithoutCommentThreadInput } from '../co
@InputType() @InputType()
export class CommentThreadUncheckedCreateWithoutCommentThreadTargetsInput { export class CommentThreadUncheckedCreateWithoutCommentThreadTargetsInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId!: string; deletedAt?: Date | string;
@Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, { @HideField()
nullable: true, workspaceId!: string;
})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput; @Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput;
} }

28
server/src/core/@generated/comment-thread/comment-thread-unchecked-create-without-comments.input.ts
View File

@ -5,24 +5,22 @@ import { CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput }
@InputType() @InputType()
export class CommentThreadUncheckedCreateWithoutCommentsInput { export class CommentThreadUncheckedCreateWithoutCommentsInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId!: string; deletedAt?: Date | string;
@Field( @HideField()
() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput, workspaceId!: string;
{ nullable: true },
) @Field(() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput, {nullable:true})
commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput; commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
} }

30
server/src/core/@generated/comment-thread/comment-thread-unchecked-create-without-workspace.input.ts
View File

@ -5,26 +5,22 @@ import { CommentUncheckedCreateNestedManyWithoutCommentThreadInput } from '../co
@InputType() @InputType()
export class CommentThreadUncheckedCreateWithoutWorkspaceInput { export class CommentThreadUncheckedCreateWithoutWorkspaceInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@Field( @Field(() => Date, {nullable:true})
() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput, deletedAt?: Date | string;
{ nullable: true },
)
commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, { @Field(() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput, {nullable:true})
nullable: true, commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput; @Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput;
} }

34
server/src/core/@generated/comment-thread/comment-thread-unchecked-create.input.ts
View File

@ -6,29 +6,25 @@ import { CommentUncheckedCreateNestedManyWithoutCommentThreadInput } from '../co
@InputType() @InputType()
export class CommentThreadUncheckedCreateInput { export class CommentThreadUncheckedCreateInput {
@Field(() => String, { nullable: true })
id?: string;
@Field(() => Date, { nullable: true }) @Field(() => String, {nullable:true})
createdAt?: Date | string; id?: string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
updatedAt?: Date | string; createdAt?: Date | string;
@Field(() => Date, { nullable: true }) @Field(() => Date, {nullable:true})
deletedAt?: Date | string; updatedAt?: Date | string;
@HideField() @Field(() => Date, {nullable:true})
workspaceId!: string; deletedAt?: Date | string;
@Field( @HideField()
() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput, workspaceId!: string;
{ nullable: true },
)
commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
@Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, { @Field(() => CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput, {nullable:true})
nullable: true, commentThreadTargets?: CommentThreadTargetUncheckedCreateNestedManyWithoutCommentThreadInput;
})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput; @Field(() => CommentUncheckedCreateNestedManyWithoutCommentThreadInput, {nullable:true})
comments?: CommentUncheckedCreateNestedManyWithoutCommentThreadInput;
} }

Some files were not shown because too many files have changed in this diff Show More