+1 -1

codegen.yaml

reviewed

··· 104 104 # parent, and its sub-resolvers only read `org.id`. A bit unusual, as 105 105 # `MatchingBanks` could be a standalone type — may expand later. 106 106 MatchingBanks: ../graphql/datasources/orgKyselyPersistence.js#GraphQLOrgParent 107 107 - User: ../models/UserModel.js#User 107 107 + User: ../graphql/datasources/userKyselyPersistence.js#GraphQLUserParent 108 108 LocationBank: ./datasources/LocationBankApi.js#LocationBankWithoutFullPlacesAPIResponse 109 109 # TODO(Kysely migration): these parents will flip to 110 110 # `../models/rules/ruleTypes.js#Rule` once the Action/Policy resolvers

+32 -17

server/api.ts

reviewed

··· 29 29 makeLoginSsoRequiredError, 30 30 makeLoginUserDoesNotExistError, 31 31 } from './graphql/datasources/UserApi.js'; 32 32 + import { 33 33 + kyselyUserFindByEmail, 34 34 + kyselyUserFindById, 35 35 + } from './graphql/datasources/userKyselyPersistence.js'; 32 36 import resolvers, { type Context } from './graphql/resolvers.js'; 37 37 + import { passwordMatchesHash } from './services/userManagementService/index.js'; 33 38 import typeDefs from './graphql/schema.js'; 34 39 import { authSchemaWrapper } from './graphql/utils/authorization.js'; 35 40 import { type Dependencies } from './iocContainer/index.js'; ··· 91 96 92 97 export default async function makeApiServer(deps: Dependencies) { 93 98 const app = express(); 94 94 - const { User } = deps.Sequelize; 99 99 + const { KyselyPg } = deps; 95 100 96 101 app.use(cors()); 97 102 ··· 213 218 }, 214 219 async (_req, profile, done) => { 215 220 try { 216 216 - const user = await User.findOne({ 217 217 - where: { email: String(profile?.email) }, 218 218 - }); 221 221 + const user = await kyselyUserFindByEmail( 222 222 + KyselyPg, 223 223 + String(profile?.email), 224 224 + ); 219 225 // we should have already checked for this, but couldn't hurt to check 220 226 // again 221 227 if (user == null) { ··· 235 241 }, 236 242 async (_req, profile, done) => { 237 243 try { 238 238 - const user = await User.findOne({ 239 239 - where: { email: String(profile?.email) }, 240 240 - }); 244 244 + const user = await kyselyUserFindByEmail( 245 245 + KyselyPg, 246 246 + String(profile?.email), 247 247 + ); 241 248 // we should have already checked for this, but couldn't hurt to check 242 249 // again 243 250 if (user == null) { ··· 278 285 passport.use( 279 286 new GraphQLLocalStrategy(async (email, password, done) => { 280 287 try { 281 281 - const user = await User.findOne({ where: { email: String(email) } }); 288 288 + const user = await kyselyUserFindByEmail(KyselyPg, String(email)); 282 289 if (user == null) { 283 290 return done( 284 291 makeLoginUserDoesNotExistError({ shouldErrorSpan: true }), ··· 313 320 ); 314 321 } 315 322 316 316 - // if loginMethod is password, password should be set 323 323 + // `loginMethods` includes 'password', so the DB CHECK constraint 324 324 + // guarantees `user.password` is non-null here. 317 325 if ( 318 318 - await User.passwordMatchesHash( 319 319 - String(password), 320 320 - user.password satisfies string | null as string, 321 321 - ) 326 326 + user.password != null && 327 327 + (await passwordMatchesHash(String(password), user.password)) 322 328 ) { 323 329 done(null, user); 324 330 } else { ··· 340 346 }); 341 347 342 348 passport.deserializeUser(async (id, done) => { 343 343 - return User.findByPk(String(id), { rejectOnEmpty: true }).then((user) => { 344 344 - done(null, user); 345 345 - }, done); 349 349 + try { 350 350 + const user = await kyselyUserFindById(KyselyPg, String(id)); 351 351 + if (user == null) { 352 352 + return done( 353 353 + makeNotFoundError(`Session user ${String(id)} not found`, { 354 354 + shouldErrorSpan: true, 355 355 + }), 356 356 + ); 357 357 + } 358 358 + return done(null, user); 359 359 + } catch (e) { 360 360 + return done(e); 361 361 + } 346 362 }); 347 363 348 364 /** ··· 551 567 'PartialItemsService', 552 568 'ReportingService', 553 569 'RuleEvaluator', 554 554 - 'Sequelize', 555 570 'SignalsService', 556 571 'SigningKeyPairService', 557 572 'Tracer',

+13 -8

server/graphql/datasources/RuleApi.ts

reviewed

··· 8 8 9 9 import { inject, type Dependencies } from '../../iocContainer/index.js'; 10 10 import { type Backtest } from '../../models/rules/BacktestModel.js'; 11 11 - import { type User } from '../../models/UserModel.js'; 12 11 import { type ActionCountsInput } from '../../services/actionStatisticsService/index.js'; 13 12 import { type AggregationClause } from '../../services/aggregationsService/index.js'; 14 13 import { type ConditionSetWithResultAsLogged } from '../../services/analyticsLoggers/index.js'; ··· 68 67 kyselyListBacktestsForRule, 69 68 kyselyUpdateRule, 70 69 } from './ruleKyselyPersistence.js'; 70 70 + import { 71 71 + type GraphQLUserParent, 72 72 + kyselyUserFindByIdAndOrg, 73 73 + } from './userKyselyPersistence.js'; 71 74 import { locationAreaInputToLocationArea } from './LocationBankApi.js'; 72 75 import { unauthenticatedError } from '../utils/errors.js'; 73 76 import { isUniqueViolationError } from '../../utils/kysely.js'; ··· 302 305 public readonly ruleInsights: Dependencies['RuleActionInsights'], 303 306 private readonly actionStats: Dependencies['ActionStatisticsService'], 304 307 private readonly kyselyPg: Dependencies['KyselyPg'], 305 305 - private readonly models: Dependencies['Sequelize'], 306 308 private readonly moderationConfigService: Dependencies['ModerationConfigService'], 307 309 private readonly tracer: Dependencies['Tracer'], 308 310 private readonly signalsService: Dependencies['SignalsService'], ··· 315 317 ); 316 318 this.graphQlRuleParentDeps = { 317 319 moderationConfigService: this.moderationConfigService, 318 318 - // TODO(Kysely migration): replace with a ModerationConfigService / 319 319 - // user-service-backed lookup once users are migrated off Sequelize. 320 320 findUserByIdAndOrg: async (opts) => 321 321 - this.models.User.findOne({ where: opts.where }), 321 321 + kyselyUserFindByIdAndOrg(this.kyselyPg, opts), 322 322 }; 323 323 } 324 324 ··· 667 667 * `ruleKyselyPersistence.ts`, and the deleted private helpers (`getContentItemTypeIdsForRule`, 668 668 * `runSampledRuleExecutions`, `queryWarehouseSubmissionsForRule`). 669 669 */ 670 670 - async createBacktest(_input: GQLCreateBacktestInput, _user: User): Promise<Backtest> { 670 670 + async createBacktest( 671 671 + _input: GQLCreateBacktestInput, 672 672 + _user: GraphQLUserParent, 673 673 + ): Promise<Backtest> { 671 674 throw new Error( 672 675 'createBacktest is temporarily disabled (TODO BACKTEST_RETROACTION: no UI / env to validate).', 673 676 ); ··· 777 780 * TODO(BACKTEST_RETROACTION): Same as `createBacktest` — re-enable when UI and env 778 781 * support validation. 779 782 */ 780 780 - async runRetroaction(_input: GQLRunRetroactionInput, _user: User): Promise<{ _: boolean }> { 783 783 + async runRetroaction( 784 784 + _input: GQLRunRetroactionInput, 785 785 + _user: GraphQLUserParent, 786 786 + ): Promise<{ _: boolean }> { 781 787 throw new Error( 782 788 'runRetroaction is temporarily disabled (TODO BACKTEST_RETROACTION: no UI / env to validate).', 783 789 ); ··· 856 862 'RuleActionInsights', 857 863 'ActionStatisticsService', 858 864 'KyselyPg', 859 859 - 'Sequelize', 860 865 'ModerationConfigService', 861 866 'Tracer', 862 867 'SignalsService',

+183 -68

server/graphql/datasources/UserApi.ts

reviewed

··· 4 4 5 5 import { inject, type Dependencies } from '../../iocContainer/index.js'; 6 6 import { type Rule } from '../../models/rules/RuleModel.js'; 7 7 - import { type User as TUser } from '../../models/UserModel.js'; 8 8 - import { hashPassword } from '../../services/userManagementService/index.js'; 7 7 + import { type LoginMethod } from '../../services/coreAppTables.js'; 8 8 + import { 9 9 + hashPassword, 10 10 + passwordMatchesHash, 11 11 + } from '../../services/userManagementService/index.js'; 9 12 import { 10 13 CoopError, 11 14 ErrorType, 12 15 makeBadRequestError, 13 16 makeInternalServerError, 17 17 + makeNotFoundError, 14 18 makeUnauthorizedError, 15 19 type ErrorInstanceData, 16 20 } from '../../utils/errors.js'; 17 21 import { safePick } from '../../utils/misc.js'; 18 22 import { WEEK_MS } from '../../utils/time.js'; 23 23 + import { buildGraphqlRuleParent } from './buildGraphqlRuleParent.js'; 24 24 + import { 25 25 + type GraphQLUserParent, 26 26 + kyselyUserAddFavoriteRule, 27 27 + kyselyUserFindByEmail, 28 28 + kyselyUserFindByIdAndOrg, 29 29 + kyselyUserFindById, 30 30 + kyselyUserFindByIds, 31 31 + kyselyUserInsert, 32 32 + kyselyUserListFavoriteRuleIds, 33 33 + kyselyUserRemoveFavoriteRule, 34 34 + kyselyUserUpdate, 35 35 + } from './userKyselyPersistence.js'; 36 36 + import { 37 37 + type UserValidationFailure, 38 38 + validateUserCreateInput, 39 39 + validateUserUpdatePatch, 40 40 + } from './userValidation.js'; 19 41 20 42 /** 21 43 * GraphQL Object for a User 22 44 */ 23 45 class UserAPI { 24 46 constructor( 25 25 - private readonly sequelize: Dependencies['Sequelize'], 47 47 + private readonly kyselyPg: Dependencies['KyselyPg'], 26 48 private readonly tracer: Dependencies['Tracer'], 27 49 private readonly userManagementService: Dependencies['UserManagementService'], 28 28 - ) { 29 29 - } 50 50 + private readonly moderationConfigService: Dependencies['ModerationConfigService'], 51 51 + ) {} 30 52 31 31 - async getGraphQLUserFromId(opts: { id: string; orgId: string }) { 32 32 - const { id, orgId } = opts; 33 33 - 34 34 - return this.sequelize.User.findOne({ 35 35 - where: { 36 36 - id, 37 37 - orgId, 38 38 - }, 39 39 - rejectOnEmpty: true, 40 40 - }); 53 53 + async getGraphQLUserFromId(opts: { 54 54 + id: string; 55 55 + orgId: string; 56 56 + }): Promise<GraphQLUserParent> { 57 57 + const user = await kyselyUserFindByIdAndOrg(this.kyselyPg, opts); 58 58 + if (user === undefined) { 59 59 + // Matches the `rejectOnEmpty: true` semantics of the Sequelize call 60 60 + // this method replaced (callers rely on a throw when the row is 61 61 + // missing, e.g. `getFavoriteRules`). 62 62 + throw makeNotFoundError( 63 63 + `User ${opts.id} not found in org ${opts.orgId}`, 64 64 + { shouldErrorSpan: true }, 65 65 + ); 66 66 + } 67 67 + return user; 41 68 } 42 69 43 43 - async getGraphQLUsersFromIds(ids: string[]) { 44 44 - return this.sequelize.User.findAll({ 45 45 - where: { id: ids }, 46 46 - }); 70 70 + async getGraphQLUsersFromIds(ids: string[]): Promise<GraphQLUserParent[]> { 71 71 + return kyselyUserFindByIds(this.kyselyPg, ids); 47 72 } 48 73 49 49 - async login(params: any, context: PassportContext<TUser, any>) { 74 74 + async login(params: any, context: PassportContext<GraphQLUserParent, any>) { 50 75 const credentials = safePick(params.input, ['email', 'password']); 51 76 52 77 // NB: this will throw for bad credentials; will be handled in the resolver. ··· 72 97 } 73 98 } 74 99 75 75 - async signUp(params: any, _: any) { 100 100 + async signUp(params: any, _: any): Promise<GraphQLUserParent> { 76 101 const { role } = params.input; 77 102 const { 78 103 email, ··· 90 115 { shouldErrorSpan: true }, 91 116 ); 92 117 93 93 - const existingUser = await this.sequelize.User.findOne({ 94 94 - where: { email }, 95 95 - }); 118 118 + const existingUser = await kyselyUserFindByEmail(this.kyselyPg, email); 96 119 if (existingUser != null) { 97 120 throw makeSignUpUserExistsError({ shouldErrorSpan: true }); 98 121 } ··· 119 142 }); 120 143 } 121 144 122 122 - const user = await this.sequelize.User.create({ 145 145 + const loginMethodNormalized = String(loginMethod).toLowerCase() as LoginMethod; 146 146 + const createInput = { 147 147 + email, 148 148 + firstName, 149 149 + lastName, 150 150 + role: token.role, 151 151 + loginMethods: [loginMethodNormalized] as const, 152 152 + password: passwordToSave, 153 153 + }; 154 154 + 155 155 + const validation = validateUserCreateInput(createInput); 156 156 + if (!validation.ok) { 157 157 + throw userValidationFailureToBadRequestError(validation.failure); 158 158 + } 159 159 + 160 160 + const user = await kyselyUserInsert({ 161 161 + db: this.kyselyPg, 123 162 id: uid(), 163 163 + orgId, 124 164 email, 125 165 password: passwordToSave, 126 166 firstName, 127 167 lastName, 128 168 role: token.role, 129 169 approvedByAdmin: true, 130 130 - orgId, 131 131 - loginMethods: [loginMethod.toLowerCase()], 170 170 + loginMethods: [loginMethodNormalized], 132 171 }); 133 172 134 173 // Delete the invite token after successful user creation ··· 138 177 } 139 178 140 179 async updateAccountInfo( 141 141 - user: TUser, 180 180 + user: GraphQLUserParent, 142 181 params: { firstName?: string | null; lastName?: string | null }, 143 143 - ) { 144 144 - const { firstName, lastName } = params; 145 145 - if (firstName != null) { 146 146 - user.firstName = firstName; 182 182 + ): Promise<GraphQLUserParent> { 183 183 + const patch = { 184 184 + firstName: params.firstName ?? undefined, 185 185 + lastName: params.lastName ?? undefined, 186 186 + }; 187 187 + 188 188 + const validation = validateUserUpdatePatch(patch); 189 189 + if (!validation.ok) { 190 190 + throw userValidationFailureToBadRequestError(validation.failure); 147 191 } 148 148 - if (lastName != null) { 149 149 - user.lastName = lastName; 192 192 + 193 193 + const updated = await kyselyUserUpdate(this.kyselyPg, user.id, patch); 194 194 + if (updated == null) { 195 195 + // Row went missing between load and update (e.g. concurrent delete). 196 196 + throw makeNotFoundError(`User ${user.id} not found`, { 197 197 + shouldErrorSpan: true, 198 198 + }); 150 199 } 151 151 - await user.save(); 200 200 + return updated; 152 201 } 153 202 154 203 async changePassword( 155 155 - user: TUser, 204 204 + user: GraphQLUserParent, 156 205 params: { currentPassword: string; newPassword: string }, 157 206 ) { 158 207 const { currentPassword, newPassword } = params; 159 208 160 160 - // Check if user has password login method 161 209 if (!user.loginMethods.includes('password')) { 162 210 throw makeChangePasswordNotAllowedError({ 163 211 detail: 'Password login is not enabled for this user.', ··· 165 213 }); 166 214 } 167 215 168 168 - // Verify current password 169 216 if (user.password == null) { 170 217 throw makeChangePasswordIncorrectPasswordError({ 171 218 detail: 'Current password is not set.', ··· 173 220 }); 174 221 } 175 222 176 176 - const isCurrentPasswordValid = 177 177 - await this.sequelize.User.passwordMatchesHash( 178 178 - currentPassword, 179 179 - user.password, 180 180 - ); 223 223 + const isCurrentPasswordValid = await passwordMatchesHash( 224 224 + currentPassword, 225 225 + user.password, 226 226 + ); 181 227 182 228 if (!isCurrentPasswordValid) { 183 229 throw makeChangePasswordIncorrectPasswordError({ ··· 185 231 }); 186 232 } 187 233 188 188 - // Hash and save new password 189 234 const hashedNewPassword = await hashPassword(newPassword); 190 190 - user.password = hashedNewPassword; 191 191 - await user.save(); 235 235 + const updated = await kyselyUserUpdate(this.kyselyPg, user.id, { 236 236 + password: hashedNewPassword, 237 237 + }); 238 238 + if (updated == null) { 239 239 + // Row went missing between load and update (e.g. concurrent delete). 240 240 + throw makeNotFoundError(`User ${user.id} not found`, { 241 241 + shouldErrorSpan: true, 242 242 + }); 243 243 + } 192 244 193 245 return { 194 246 __typename: 'ChangePasswordSuccessResponse' as const, ··· 199 251 async deleteUser(opts: { id: string; orgId: string }) { 200 252 const { id, orgId } = opts; 201 253 try { 202 202 - const user = await this.sequelize.User.findOne({ where: { id, orgId } }); 203 203 - await user?.destroy(); 254 254 + const user = await kyselyUserFindByIdAndOrg(this.kyselyPg, { 255 255 + id, 256 256 + orgId, 257 257 + }); 258 258 + if (user != null) { 259 259 + await this.kyselyPg 260 260 + .deleteFrom('public.users') 261 261 + .where('id', '=', id) 262 262 + .where('org_id', '=', orgId) 263 263 + .execute(); 264 264 + } 204 265 } catch (exception) { 205 266 const activeSpan = this.tracer.getActiveSpan(); 206 267 if (activeSpan?.isRecording()) { ··· 212 273 } 213 274 214 275 async approveUser(id: string, invokerOrgId: string) { 215 215 - const user = await this.sequelize.User.findByPk(id, { 216 216 - rejectOnEmpty: true, 217 217 - }); 276 276 + const user = await kyselyUserFindById(this.kyselyPg, id); 277 277 + if (user == null) { 278 278 + throw makeNotFoundError(`User ${id} not found`, { 279 279 + shouldErrorSpan: true, 280 280 + }); 281 281 + } 218 282 219 219 - // Security check: ensure admin can only approve users in their own org 283 283 + // Security check: ensure admin can only approve users in their own org. 220 284 if (user.orgId !== invokerOrgId) { 221 285 throw makeUnauthorizedError( 222 286 'You can only approve users in your organization', ··· 224 288 ); 225 289 } 226 290 227 227 - user.approvedByAdmin = true; 228 228 - await user.save(); 291 291 + const updated = await kyselyUserUpdate(this.kyselyPg, id, { 292 292 + approvedByAdmin: true, 293 293 + }); 294 294 + if (updated == null) { 295 295 + // Row went missing between load and update (e.g. concurrent delete). 296 296 + throw makeNotFoundError(`User ${id} not found`, { 297 297 + shouldErrorSpan: true, 298 298 + }); 299 299 + } 229 300 return true; 230 301 } 231 302 232 303 async rejectUser(id: string, invokerOrgId: string) { 233 233 - const user = await this.sequelize.User.findByPk(id, { 234 234 - rejectOnEmpty: true, 235 235 - }); 304 304 + const user = await kyselyUserFindById(this.kyselyPg, id); 305 305 + if (user == null) { 306 306 + throw makeNotFoundError(`User ${id} not found`, { 307 307 + shouldErrorSpan: true, 308 308 + }); 309 309 + } 236 310 237 237 - // Security check: ensure admin can only reject users in their own org 311 311 + // Security check: ensure admin can only reject users in their own org. 238 312 if (user.orgId !== invokerOrgId) { 239 313 throw makeUnauthorizedError( 240 314 'You can only reject users in your organization', ··· 242 316 ); 243 317 } 244 318 245 245 - user.rejectedByAdmin = true; 246 246 - await user.save(); 319 319 + const updated = await kyselyUserUpdate(this.kyselyPg, id, { 320 320 + rejectedByAdmin: true, 321 321 + }); 322 322 + if (updated == null) { 323 323 + // Row went missing between load and update (e.g. concurrent delete). 324 324 + throw makeNotFoundError(`User ${id} not found`, { 325 325 + shouldErrorSpan: true, 326 326 + }); 327 327 + } 247 328 return true; 248 329 } 249 330 250 331 async getFavoriteRules(id: string, orgId: string): Promise<Array<Rule>> { 251 251 - const user = await this.getGraphQLUserFromId({ id, orgId }); 252 252 - const rules = await user.getFavoriteRules(); 253 253 - return rules; 332 332 + // Make sure the requested user lives in the invoker's org (the caller 333 333 + // always passes the invoker's orgId), then scope rule lookups to that 334 334 + // org so cross-org data can't leak even if stale favorites exist. 335 335 + await this.getGraphQLUserFromId({ id, orgId }); 336 336 + const ruleIds = await kyselyUserListFavoriteRuleIds(this.kyselyPg, id); 337 337 + const plains = ( 338 338 + await Promise.all( 339 339 + ruleIds.map(async (ruleId) => 340 340 + this.moderationConfigService.getRuleByIdAndOrg(ruleId, orgId), 341 341 + ), 342 342 + ) 343 343 + ).filter((plain): plain is NonNullable<typeof plain> => plain != null); 344 344 + return plains.map((plain) => 345 345 + buildGraphqlRuleParent(plain, { 346 346 + moderationConfigService: this.moderationConfigService, 347 347 + findUserByIdAndOrg: async (opts) => 348 348 + kyselyUserFindByIdAndOrg(this.kyselyPg, opts), 349 349 + }), 350 350 + ); 254 351 } 255 352 256 353 async addFavoriteRule(userId: string, ruleId: string, orgId: string) { 257 257 - const user = await this.getGraphQLUserFromId({ id: userId, orgId }); 258 258 - await user.addFavoriteRules([ruleId]); 354 354 + // Scope by org so a caller can't add a favorite targeting a rule in a 355 355 + // different org (the Sequelize association was unscoped). 356 356 + await this.getGraphQLUserFromId({ id: userId, orgId }); 357 357 + const rule = await this.moderationConfigService.getRuleByIdAndOrg( 358 358 + ruleId, 359 359 + orgId, 360 360 + ); 361 361 + if (rule == null) { 362 362 + throw makeNotFoundError(`Rule ${ruleId} not found in org ${orgId}`, { 363 363 + shouldErrorSpan: true, 364 364 + }); 365 365 + } 366 366 + await kyselyUserAddFavoriteRule(this.kyselyPg, userId, ruleId); 259 367 } 260 368 261 369 async removeFavoriteRule(userId: string, ruleId: string, orgId: string) { 262 262 - const user = await this.getGraphQLUserFromId({ id: userId, orgId }); 263 263 - await user.removeFavoriteRules([ruleId]); 370 370 + await this.getGraphQLUserFromId({ id: userId, orgId }); 371 371 + await kyselyUserRemoveFavoriteRule(this.kyselyPg, userId, ruleId); 264 372 } 265 373 } 266 374 375 375 + function userValidationFailureToBadRequestError(failure: UserValidationFailure) { 376 376 + return makeBadRequestError(failure.message, { 377 377 + pointer: `/input/${failure.field}`, 378 378 + shouldErrorSpan: false, 379 379 + }); 380 380 + } 381 381 + 267 382 export default inject( 268 268 - ['Sequelize', 'Tracer', 'UserManagementService'], 383 383 + ['KyselyPg', 'Tracer', 'UserManagementService', 'ModerationConfigService'], 269 384 UserAPI, 270 385 ); 271 386 export type { UserAPI };

+7 -5

server/graphql/datasources/buildGraphqlRuleParent.ts

reviewed

··· 1 1 import { type Rule as SequelizeRule } from '../../models/rules/RuleModel.js'; 2 2 - import { type User } from '../../models/UserModel.js'; 3 2 import { 4 3 type PlainRuleWithLatestVersion, 5 4 type Rule as RuleGraphqlParent, 6 5 } from '../../models/rules/ruleTypes.js'; 7 6 import { type ModerationConfigService } from '../../services/moderationConfigService/index.js'; 7 7 + import { type GraphQLUserParent } from './userKyselyPersistence.js'; 8 8 9 9 type FindUserByIdAndOrg = (opts: { 10 10 - where: { id: string; orgId: string }; 11 11 - }) => Promise<User | null>; 10 10 + id: string; 11 11 + orgId: string; 12 12 + }) => Promise<GraphQLUserParent | undefined>; 12 13 13 14 /** 14 15 * Builds a GraphQL Rule parent (plain row fields + the three association 15 16 * getters our resolvers actually use) backed by ModerationConfigService 16 16 - * reads and a Sequelize-backed User lookup for the creator. 17 17 + * reads and a Kysely-backed User lookup for the creator. 17 18 * 18 19 * The returned object only implements the {@link RuleGraphqlParent} contract 19 20 * (`getCreator` / `getActions` / `getPolicies`). We cast to `SequelizeRule` ··· 34 35 ...plain, 35 36 async getCreator() { 36 37 const user = await deps.findUserByIdAndOrg({ 37 37 - where: { id: plain.creatorId, orgId: plain.orgId }, 38 38 + id: plain.creatorId, 39 39 + orgId: plain.orgId, 38 40 }); 39 41 if (user == null) { 40 42 throw new Error(`User not found for rule creator ${plain.creatorId}`);

+438

server/graphql/datasources/userKyselyPersistence.test.ts

reviewed

··· 1 1 + import { faker } from '@faker-js/faker'; 2 2 + import { uid } from 'uid'; 3 3 + 4 4 + import { UserRole } from '../../models/types/permissioning.js'; 5 5 + import createOrg from '../../test/fixtureHelpers/createOrg.js'; 6 6 + import createRule from '../../test/fixtureHelpers/createRule.js'; 7 7 + import { makeMockedServer } from '../../test/setupMockedServer.js'; 8 8 + import { makeTestWithFixture } from '../../test/utils.js'; 9 9 + import { 10 10 + kyselyUserAddFavoriteRule, 11 11 + kyselyUserDeleteById, 12 12 + kyselyUserFindByEmail, 13 13 + kyselyUserFindById, 14 14 + kyselyUserFindByIdAndOrg, 15 15 + kyselyUserFindByIds, 16 16 + kyselyUserInsert, 17 17 + kyselyUserListByOrg, 18 18 + kyselyUserListFavoriteRuleIds, 19 19 + kyselyUserRemoveFavoriteRule, 20 20 + kyselyUserUpdate, 21 21 + } from './userKyselyPersistence.js'; 22 22 + 23 23 + /** 24 24 + * Builds a valid `kyselyUserInsert` input with SAML-only login (no password), 25 25 + * so we don't need bcrypt in the unit-ish happy paths. 26 26 + */ 27 27 + function samlUserInput(orgId: string) { 28 28 + return { 29 29 + id: uid(), 30 30 + orgId, 31 31 + email: faker.internet.email(), 32 32 + firstName: faker.name.firstName(), 33 33 + lastName: faker.name.lastName(), 34 34 + role: UserRole.ADMIN, 35 35 + loginMethods: ['saml'] as const, 36 36 + password: null, 37 37 + }; 38 38 + } 39 39 + 40 40 + describe('userKyselyPersistence', () => { 41 41 + const testWithFixture = makeTestWithFixture(async () => { 42 42 + const { deps, shutdown } = await makeMockedServer(); 43 43 + const { org, cleanup: orgCleanup } = await createOrg( 44 44 + { 45 45 + KyselyPg: deps.KyselyPg, 46 46 + ModerationConfigService: deps.ModerationConfigService, 47 47 + ApiKeyService: deps.ApiKeyService, 48 48 + }, 49 49 + uid(), 50 50 + ); 51 51 + return { 52 52 + deps, 53 53 + org, 54 54 + async cleanup() { 55 55 + await orgCleanup(); 56 56 + await shutdown(); 57 57 + }, 58 58 + }; 59 59 + }); 60 60 + 61 61 + describe('kyselyUserInsert', () => { 62 62 + testWithFixture( 63 63 + 'inserts a SAML user and round-trips fields + getPermissions()', 64 64 + async ({ deps, org }) => { 65 65 + const input = samlUserInput(org.id); 66 66 + const inserted = await kyselyUserInsert({ 67 67 + db: deps.KyselyPg, 68 68 + ...input, 69 69 + }); 70 70 + try { 71 71 + expect(inserted).toMatchObject({ 72 72 + id: input.id, 73 73 + orgId: org.id, 74 74 + email: input.email, 75 75 + firstName: input.firstName, 76 76 + lastName: input.lastName, 77 77 + role: UserRole.ADMIN, 78 78 + loginMethods: ['saml'], 79 79 + password: null, 80 80 + approvedByAdmin: false, 81 81 + rejectedByAdmin: false, 82 82 + }); 83 83 + expect(Array.isArray(inserted.getPermissions())).toBe(true); 84 84 + } finally { 85 85 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 86 86 + } 87 87 + }, 88 88 + ); 89 89 + 90 90 + testWithFixture( 91 91 + 'inserts a password-login user with a password set', 92 92 + async ({ deps, org }) => { 93 93 + const id = uid(); 94 94 + const row = await kyselyUserInsert({ 95 95 + db: deps.KyselyPg, 96 96 + id, 97 97 + orgId: org.id, 98 98 + email: faker.internet.email(), 99 99 + firstName: 'Jane', 100 100 + lastName: 'Doe', 101 101 + role: UserRole.ADMIN, 102 102 + loginMethods: ['password'], 103 103 + password: 'hashed-password-placeholder', 104 104 + }); 105 105 + try { 106 106 + expect(row.loginMethods).toEqual(['password']); 107 107 + expect(row.password).toBe('hashed-password-placeholder'); 108 108 + } finally { 109 109 + await kyselyUserDeleteById(deps.KyselyPg, id); 110 110 + } 111 111 + }, 112 112 + ); 113 113 + 114 114 + testWithFixture( 115 115 + 'throws an invariant error for malformed input (defense-in-depth)', 116 116 + async ({ deps, org }) => { 117 117 + await expect( 118 118 + kyselyUserInsert({ 119 119 + db: deps.KyselyPg, 120 120 + id: uid(), 121 121 + orgId: org.id, 122 122 + email: 'not-an-email', 123 123 + firstName: 'A', 124 124 + lastName: 'B', 125 125 + role: UserRole.ADMIN, 126 126 + loginMethods: ['saml'], 127 127 + password: null, 128 128 + }), 129 129 + ).rejects.toThrow(/kyselyUserInsert invariant violated: email/); 130 130 + }, 131 131 + ); 132 132 + 133 133 + testWithFixture( 134 134 + "throws an invariant error when password/loginMethods disagree (CHECK constraint shape)", 135 135 + async ({ deps, org }) => { 136 136 + await expect( 137 137 + kyselyUserInsert({ 138 138 + db: deps.KyselyPg, 139 139 + id: uid(), 140 140 + orgId: org.id, 141 141 + email: faker.internet.email(), 142 142 + firstName: 'A', 143 143 + lastName: 'B', 144 144 + role: UserRole.ADMIN, 145 145 + loginMethods: ['saml'], 146 146 + password: 'should-not-be-set', 147 147 + }), 148 148 + ).rejects.toThrow(/kyselyUserInsert invariant violated: password/); 149 149 + }, 150 150 + ); 151 151 + }); 152 152 + 153 153 + describe('kyselyUserFindBy*', () => { 154 154 + testWithFixture( 155 155 + 'findById / findByEmail / findByIdAndOrg return the row when it exists', 156 156 + async ({ deps, org }) => { 157 157 + const input = samlUserInput(org.id); 158 158 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 159 159 + try { 160 160 + const byId = await kyselyUserFindById(deps.KyselyPg, input.id); 161 161 + const byEmail = await kyselyUserFindByEmail( 162 162 + deps.KyselyPg, 163 163 + input.email, 164 164 + ); 165 165 + const byIdAndOrg = await kyselyUserFindByIdAndOrg(deps.KyselyPg, { 166 166 + id: input.id, 167 167 + orgId: org.id, 168 168 + }); 169 169 + 170 170 + expect(byId).toMatchObject({ id: input.id, email: input.email }); 171 171 + expect(byEmail).toMatchObject({ id: input.id }); 172 172 + expect(byIdAndOrg).toMatchObject({ id: input.id, orgId: org.id }); 173 173 + } finally { 174 174 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 175 175 + } 176 176 + }, 177 177 + ); 178 178 + 179 179 + testWithFixture( 180 180 + 'find helpers return undefined (not null) when missing', 181 181 + async ({ deps, org }) => { 182 182 + const byId = await kyselyUserFindById( 183 183 + deps.KyselyPg, 184 184 + `missing-${uid()}`, 185 185 + ); 186 186 + const byEmail = await kyselyUserFindByEmail( 187 187 + deps.KyselyPg, 188 188 + `missing-${uid()}@example.com`, 189 189 + ); 190 190 + const byIdAndOrg = await kyselyUserFindByIdAndOrg(deps.KyselyPg, { 191 191 + id: `missing-${uid()}`, 192 192 + orgId: org.id, 193 193 + }); 194 194 + 195 195 + expect(byId).toBeUndefined(); 196 196 + expect(byEmail).toBeUndefined(); 197 197 + expect(byIdAndOrg).toBeUndefined(); 198 198 + }, 199 199 + ); 200 200 + 201 201 + testWithFixture( 202 202 + 'findByIdAndOrg returns undefined when the user exists in a different org', 203 203 + async ({ deps, org }) => { 204 204 + const input = samlUserInput(org.id); 205 205 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 206 206 + try { 207 207 + const result = await kyselyUserFindByIdAndOrg(deps.KyselyPg, { 208 208 + id: input.id, 209 209 + orgId: `different-org-${uid()}`, 210 210 + }); 211 211 + expect(result).toBeUndefined(); 212 212 + } finally { 213 213 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 214 214 + } 215 215 + }, 216 216 + ); 217 217 + 218 218 + testWithFixture( 219 219 + 'findByIds returns [] for an empty input and handles mixed hits', 220 220 + async ({ deps, org }) => { 221 221 + expect(await kyselyUserFindByIds(deps.KyselyPg, [])).toEqual([]); 222 222 + 223 223 + const input = samlUserInput(org.id); 224 224 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 225 225 + try { 226 226 + const rows = await kyselyUserFindByIds(deps.KyselyPg, [ 227 227 + input.id, 228 228 + `missing-${uid()}`, 229 229 + ]); 230 230 + expect(rows).toHaveLength(1); 231 231 + expect(rows[0].id).toBe(input.id); 232 232 + } finally { 233 233 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 234 234 + } 235 235 + }, 236 236 + ); 237 237 + 238 238 + testWithFixture( 239 239 + 'listByOrg scopes results to the provided org', 240 240 + async ({ deps, org }) => { 241 241 + const a = samlUserInput(org.id); 242 242 + const b = samlUserInput(org.id); 243 243 + await kyselyUserInsert({ db: deps.KyselyPg, ...a }); 244 244 + await kyselyUserInsert({ db: deps.KyselyPg, ...b }); 245 245 + try { 246 246 + const rows = await kyselyUserListByOrg(deps.KyselyPg, org.id); 247 247 + const ids = rows.map((r) => r.id); 248 248 + expect(ids).toEqual(expect.arrayContaining([a.id, b.id])); 249 249 + expect(rows.every((r) => r.orgId === org.id)).toBe(true); 250 250 + } finally { 251 251 + await kyselyUserDeleteById(deps.KyselyPg, a.id); 252 252 + await kyselyUserDeleteById(deps.KyselyPg, b.id); 253 253 + } 254 254 + }, 255 255 + ); 256 256 + }); 257 257 + 258 258 + describe('kyselyUserUpdate', () => { 259 259 + testWithFixture( 260 260 + 'throws an invariant error for a malformed patch', 261 261 + async ({ deps, org }) => { 262 262 + const input = samlUserInput(org.id); 263 263 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 264 264 + try { 265 265 + await expect( 266 266 + kyselyUserUpdate(deps.KyselyPg, input.id, { 267 267 + email: 'not-an-email', 268 268 + }), 269 269 + ).rejects.toThrow(/kyselyUserUpdate invariant violated: email/); 270 270 + } finally { 271 271 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 272 272 + } 273 273 + }, 274 274 + ); 275 275 + 276 276 + testWithFixture( 277 277 + 'returns undefined when the user does not exist', 278 278 + async ({ deps }) => { 279 279 + const result = await kyselyUserUpdate( 280 280 + deps.KyselyPg, 281 281 + `missing-${uid()}`, 282 282 + { firstName: 'Nobody' }, 283 283 + ); 284 284 + expect(result).toBeUndefined(); 285 285 + }, 286 286 + ); 287 287 + 288 288 + testWithFixture( 289 289 + 'null firstName / lastName / email / role are skipped (password untouched)', 290 290 + async ({ deps, org }) => { 291 291 + const input = { 292 292 + ...samlUserInput(org.id), 293 293 + loginMethods: ['password'] as const, 294 294 + password: 'placeholder', 295 295 + }; 296 296 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 297 297 + try { 298 298 + const skipped = await kyselyUserUpdate(deps.KyselyPg, input.id, { 299 299 + firstName: null, 300 300 + lastName: null, 301 301 + email: null, 302 302 + role: null, 303 303 + }); 304 304 + expect(skipped).toBeDefined(); 305 305 + expect(skipped!.firstName).toBe(input.firstName); 306 306 + expect(skipped!.lastName).toBe(input.lastName); 307 307 + expect(skipped!.email).toBe(input.email); 308 308 + expect(skipped!.role).toBe(input.role); 309 309 + expect(skipped!.password).toBe('placeholder'); 310 310 + } finally { 311 311 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 312 312 + } 313 313 + }, 314 314 + ); 315 315 + 316 316 + // NB: `kyselyUserUpdate` doesn't expose `loginMethods`, so we can't 317 317 + // *cleanly* clear a password on a password-login user through this helper 318 318 + // (the DB CHECK constraint — and our app-layer `validateUserCreateInput` 319 319 + // mirror of it — requires `password IS NOT NULL ⇔ 'password' ∈ login_methods`). 320 320 + // A SAML user already has `password: null`, so the `password: null` path 321 321 + // is a shape-valid no-op we can verify end-to-end here. 322 322 + testWithFixture( 323 323 + 'password: null is a valid patch and leaves the column null on a SAML user', 324 324 + async ({ deps, org }) => { 325 325 + const input = samlUserInput(org.id); 326 326 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 327 327 + try { 328 328 + const updated = await kyselyUserUpdate(deps.KyselyPg, input.id, { 329 329 + password: null, 330 330 + }); 331 331 + expect(updated!.password).toBeNull(); 332 332 + } finally { 333 333 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 334 334 + } 335 335 + }, 336 336 + ); 337 337 + 338 338 + // And conversely: trying to clear a password on a password-login user 339 339 + // without transitioning `loginMethods` must surface the DB CHECK 340 340 + // constraint. This protects against regressions if we ever loosen 341 341 + // `validateUserUpdatePatch`. 342 342 + testWithFixture( 343 343 + "clearing password on a password-login user violates password_null_when_not_present", 344 344 + async ({ deps, org }) => { 345 345 + const input = { 346 346 + ...samlUserInput(org.id), 347 347 + loginMethods: ['password'] as const, 348 348 + password: 'placeholder', 349 349 + }; 350 350 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 351 351 + try { 352 352 + await expect( 353 353 + kyselyUserUpdate(deps.KyselyPg, input.id, { password: null }), 354 354 + ).rejects.toThrow(/password_null_when_not_present/); 355 355 + } finally { 356 356 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 357 357 + } 358 358 + }, 359 359 + ); 360 360 + 361 361 + testWithFixture( 362 362 + 'updates provided fields and bumps updated_at', 363 363 + async ({ deps, org }) => { 364 364 + const input = samlUserInput(org.id); 365 365 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 366 366 + try { 367 367 + const beforeRow = await deps.KyselyPg 368 368 + .selectFrom('public.users') 369 369 + .select(['updated_at']) 370 370 + .where('id', '=', input.id) 371 371 + .executeTakeFirstOrThrow(); 372 372 + 373 373 + await new Promise((resolve) => setTimeout(resolve, 5)); 374 374 + 375 375 + const updated = await kyselyUserUpdate(deps.KyselyPg, input.id, { 376 376 + firstName: 'Updated', 377 377 + approvedByAdmin: true, 378 378 + }); 379 379 + expect(updated!.firstName).toBe('Updated'); 380 380 + expect(updated!.approvedByAdmin).toBe(true); 381 381 + 382 382 + const afterRow = await deps.KyselyPg 383 383 + .selectFrom('public.users') 384 384 + .select(['updated_at']) 385 385 + .where('id', '=', input.id) 386 386 + .executeTakeFirstOrThrow(); 387 387 + expect(afterRow.updated_at.getTime()).toBeGreaterThan( 388 388 + beforeRow.updated_at.getTime(), 389 389 + ); 390 390 + } finally { 391 391 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 392 392 + } 393 393 + }, 394 394 + ); 395 395 + }); 396 396 + 397 397 + describe('favorite rules helpers', () => { 398 398 + testWithFixture( 399 399 + 'add / list / remove round-trip (and add is idempotent)', 400 400 + async ({ deps, org }) => { 401 401 + const input = samlUserInput(org.id); 402 402 + await kyselyUserInsert({ db: deps.KyselyPg, ...input }); 403 403 + // `users_and_favorite_rules.rule_id` has a FK to `public.rules`, so 404 404 + // we need a real rule row. Reuse the existing Sequelize fixture until 405 405 + // rule fixtures are themselves Kysely-backed. 406 406 + const rule = await createRule(deps.Sequelize, org.id, { 407 407 + creatorId: input.id, 408 408 + }); 409 409 + try { 410 410 + expect( 411 411 + await kyselyUserListFavoriteRuleIds(deps.KyselyPg, input.id), 412 412 + ).toEqual([]); 413 413 + 414 414 + await kyselyUserAddFavoriteRule(deps.KyselyPg, input.id, rule.id); 415 415 + // Second add must be a no-op (matches Sequelize `addFavoriteRules`). 416 416 + await kyselyUserAddFavoriteRule(deps.KyselyPg, input.id, rule.id); 417 417 + 418 418 + expect( 419 419 + await kyselyUserListFavoriteRuleIds(deps.KyselyPg, input.id), 420 420 + ).toEqual([rule.id]); 421 421 + 422 422 + await kyselyUserRemoveFavoriteRule(deps.KyselyPg, input.id, rule.id); 423 423 + expect( 424 424 + await kyselyUserListFavoriteRuleIds(deps.KyselyPg, input.id), 425 425 + ).toEqual([]); 426 426 + } finally { 427 427 + await kyselyUserRemoveFavoriteRule( 428 428 + deps.KyselyPg, 429 429 + input.id, 430 430 + rule.id, 431 431 + ).catch(() => undefined); 432 432 + await rule.destroy().catch(() => undefined); 433 433 + await kyselyUserDeleteById(deps.KyselyPg, input.id); 434 434 + } 435 435 + }, 436 436 + ); 437 437 + }); 438 438 + });

+346

server/graphql/datasources/userKyselyPersistence.ts

reviewed

··· 1 1 + import { type Kysely, sql } from 'kysely'; 2 2 + 3 3 + import { 4 4 + getPermissionsForRole, 5 5 + type UserPermission, 6 6 + type UserRole, 7 7 + } from '../../models/types/permissioning.js'; 8 8 + import { 9 9 + type CoreAppTablesPg, 10 10 + type LoginMethod, 11 11 + } from '../../services/coreAppTables.js'; 12 12 + import { 13 13 + validateUserCreateInput, 14 14 + validateUserUpdatePatch, 15 15 + } from './userValidation.js'; 16 16 + 17 17 + /** 18 18 + * GraphQL `User` parent shape. Mirrors the columns on `public.users` plus a 19 19 + * `getPermissions()` helper that resolvers call (e.g. in permission checks 20 20 + * and in `UserResolvers.permissions`). Intentionally mirrors the public 21 21 + * surface of the now-removed Sequelize `User` instance for a drop-in swap. 22 22 + * 23 23 + * `password` is included because the Passport local strategy needs it for 24 24 + * `passwordMatchesHash`; resolvers must not leak it to clients. 25 25 + */ 26 26 + export type GraphQLUserParent = { 27 27 + id: string; 28 28 + email: string; 29 29 + password: string | null; 30 30 + firstName: string; 31 31 + lastName: string; 32 32 + orgId: string; 33 33 + role: UserRole; 34 34 + approvedByAdmin: boolean; 35 35 + rejectedByAdmin: boolean; 36 36 + loginMethods: LoginMethod[]; 37 37 + createdAt: Date; 38 38 + updatedAt: Date; 39 39 + getPermissions(): UserPermission[]; 40 40 + }; 41 41 + 42 42 + type UsersDb = Kysely<CoreAppTablesPg>; 43 43 + 44 44 + type UserRow = { 45 45 + id: string; 46 46 + email: string; 47 47 + password: string | null; 48 48 + first_name: string; 49 49 + last_name: string; 50 50 + role: UserRole; 51 51 + approved_by_admin: boolean; 52 52 + rejected_by_admin: boolean; 53 53 + login_methods: LoginMethod[]; 54 54 + created_at: Date; 55 55 + updated_at: Date; 56 56 + org_id: string; 57 57 + }; 58 58 + 59 59 + // `public.users.login_methods` is a `login_method_enum[]`. Node-postgres ships 60 60 + // parsers for built-in array types (`text[]`, `int[]`, etc.) but not for 61 61 + // user-defined enum arrays, so without an explicit cast we get the raw 62 62 + // `"{password,saml}"` string back and GraphQL fails with 63 63 + // "Expected Iterable, but did not find one for field User.loginMethods". 64 64 + // Casting to `text[]` leans on the stock array parser and keeps the column 65 65 + // type aligned with our `LoginMethod` union (validated before writes). 66 66 + const loginMethodsAsTextArray = sql<LoginMethod[]>`login_methods::text[]`.as( 67 67 + 'login_methods', 68 68 + ); 69 69 + 70 70 + const USER_COLUMNS = [ 71 71 + 'id', 72 72 + 'email', 73 73 + 'password', 74 74 + 'first_name', 75 75 + 'last_name', 76 76 + 'role', 77 77 + 'approved_by_admin', 78 78 + 'rejected_by_admin', 79 79 + 'created_at', 80 80 + 'updated_at', 81 81 + 'org_id', 82 82 + ] as const; 83 83 + 84 84 + function rowToGraphQLUserParent(row: UserRow): GraphQLUserParent { 85 85 + return { 86 86 + id: row.id, 87 87 + email: row.email, 88 88 + password: row.password, 89 89 + firstName: row.first_name, 90 90 + lastName: row.last_name, 91 91 + orgId: row.org_id, 92 92 + role: row.role, 93 93 + approvedByAdmin: row.approved_by_admin, 94 94 + rejectedByAdmin: row.rejected_by_admin, 95 95 + loginMethods: row.login_methods, 96 96 + createdAt: row.created_at, 97 97 + updatedAt: row.updated_at, 98 98 + getPermissions() { 99 99 + return getPermissionsForRole(row.role); 100 100 + }, 101 101 + }; 102 102 + } 103 103 + 104 104 + export async function kyselyUserFindById( 105 105 + db: UsersDb, 106 106 + id: string, 107 107 + ): Promise<GraphQLUserParent | undefined> { 108 108 + const row = await db 109 109 + .selectFrom('public.users') 110 110 + .select(USER_COLUMNS) 111 111 + .select(loginMethodsAsTextArray) 112 112 + .where('id', '=', id) 113 113 + .executeTakeFirst(); 114 114 + return row === undefined ? undefined : rowToGraphQLUserParent(row); 115 115 + } 116 116 + 117 117 + export async function kyselyUserFindByIdAndOrg( 118 118 + db: UsersDb, 119 119 + opts: { id: string; orgId: string }, 120 120 + ): Promise<GraphQLUserParent | undefined> { 121 121 + const row = await db 122 122 + .selectFrom('public.users') 123 123 + .select(USER_COLUMNS) 124 124 + .select(loginMethodsAsTextArray) 125 125 + .where('id', '=', opts.id) 126 126 + .where('org_id', '=', opts.orgId) 127 127 + .executeTakeFirst(); 128 128 + return row === undefined ? undefined : rowToGraphQLUserParent(row); 129 129 + } 130 130 + 131 131 + export async function kyselyUserFindByEmail( 132 132 + db: UsersDb, 133 133 + email: string, 134 134 + ): Promise<GraphQLUserParent | undefined> { 135 135 + const row = await db 136 136 + .selectFrom('public.users') 137 137 + .select(USER_COLUMNS) 138 138 + .select(loginMethodsAsTextArray) 139 139 + .where('email', '=', email) 140 140 + .executeTakeFirst(); 141 141 + return row === undefined ? undefined : rowToGraphQLUserParent(row); 142 142 + } 143 143 + 144 144 + export async function kyselyUserFindByIds( 145 145 + db: UsersDb, 146 146 + ids: readonly string[], 147 147 + ): Promise<GraphQLUserParent[]> { 148 148 + if (ids.length === 0) { 149 149 + return []; 150 150 + } 151 151 + const rows = await db 152 152 + .selectFrom('public.users') 153 153 + .select(USER_COLUMNS) 154 154 + .select(loginMethodsAsTextArray) 155 155 + .where('id', 'in', ids) 156 156 + .execute(); 157 157 + return rows.map(rowToGraphQLUserParent); 158 158 + } 159 159 + 160 160 + export async function kyselyUserListByOrg( 161 161 + db: UsersDb, 162 162 + orgId: string, 163 163 + ): Promise<GraphQLUserParent[]> { 164 164 + const rows = await db 165 165 + .selectFrom('public.users') 166 166 + .select(USER_COLUMNS) 167 167 + .select(loginMethodsAsTextArray) 168 168 + .where('org_id', '=', orgId) 169 169 + .execute(); 170 170 + return rows.map(rowToGraphQLUserParent); 171 171 + } 172 172 + 173 173 + export async function kyselyUserInsert(opts: { 174 174 + db: UsersDb; 175 175 + id: string; 176 176 + orgId: string; 177 177 + email: string; 178 178 + firstName: string; 179 179 + lastName: string; 180 180 + role: UserRole; 181 181 + password: string | null; 182 182 + loginMethods: readonly LoginMethod[]; 183 183 + approvedByAdmin?: boolean; 184 184 + rejectedByAdmin?: boolean; 185 185 + }): Promise<GraphQLUserParent> { 186 186 + // Defense-in-depth so non-GraphQL callers (fixtures, scripts) can't insert 187 187 + // invalid rows; user-facing validation lives in `UserAPI`. 188 188 + const validation = validateUserCreateInput({ 189 189 + email: opts.email, 190 190 + firstName: opts.firstName, 191 191 + lastName: opts.lastName, 192 192 + role: opts.role, 193 193 + loginMethods: opts.loginMethods, 194 194 + password: opts.password, 195 195 + }); 196 196 + if (!validation.ok) { 197 197 + throw new Error( 198 198 + `kyselyUserInsert invariant violated: ${validation.failure.field}: ${validation.failure.message}`, 199 199 + ); 200 200 + } 201 201 + 202 202 + const now = new Date(); 203 203 + const row = await opts.db 204 204 + .insertInto('public.users') 205 205 + .values({ 206 206 + id: opts.id, 207 207 + org_id: opts.orgId, 208 208 + email: opts.email, 209 209 + password: opts.password, 210 210 + first_name: opts.firstName, 211 211 + last_name: opts.lastName, 212 212 + role: opts.role, 213 213 + approved_by_admin: opts.approvedByAdmin ?? false, 214 214 + rejected_by_admin: opts.rejectedByAdmin ?? false, 215 215 + login_methods: [...opts.loginMethods], 216 216 + created_at: now, 217 217 + updated_at: now, 218 218 + }) 219 219 + .returning(USER_COLUMNS) 220 220 + .returning(loginMethodsAsTextArray) 221 221 + .executeTakeFirstOrThrow(); 222 222 + return rowToGraphQLUserParent(row); 223 223 + } 224 224 + 225 225 + export async function kyselyUserUpdate( 226 226 + db: UsersDb, 227 227 + userId: string, 228 228 + patch: { 229 229 + email?: string | null; 230 230 + firstName?: string | null; 231 231 + lastName?: string | null; 232 232 + role?: UserRole | null; 233 233 + password?: string | null; 234 234 + approvedByAdmin?: boolean | null; 235 235 + rejectedByAdmin?: boolean | null; 236 236 + }, 237 237 + ): Promise<GraphQLUserParent | undefined> { 238 238 + const validation = validateUserUpdatePatch(patch); 239 239 + if (!validation.ok) { 240 240 + throw new Error( 241 241 + `kyselyUserUpdate invariant violated: ${validation.failure.field}: ${validation.failure.message}`, 242 242 + ); 243 243 + } 244 244 + 245 245 + // `password` is the only field where `null` is a meaningful set (clears 246 246 + // the column); other nullable fields treat `null` as "skip". 247 247 + const update: { 248 248 + email?: string; 249 249 + first_name?: string; 250 250 + last_name?: string; 251 251 + role?: UserRole; 252 252 + password?: string | null; 253 253 + approved_by_admin?: boolean; 254 254 + rejected_by_admin?: boolean; 255 255 + updated_at: Date; 256 256 + } = { updated_at: new Date() }; 257 257 + 258 258 + if (patch.email != null) { 259 259 + update.email = patch.email; 260 260 + } 261 261 + if (patch.firstName != null) { 262 262 + update.first_name = patch.firstName; 263 263 + } 264 264 + if (patch.lastName != null) { 265 265 + update.last_name = patch.lastName; 266 266 + } 267 267 + if (patch.role != null) { 268 268 + update.role = patch.role; 269 269 + } 270 270 + if (patch.password !== undefined) { 271 271 + update.password = patch.password; 272 272 + } 273 273 + if (patch.approvedByAdmin != null) { 274 274 + update.approved_by_admin = patch.approvedByAdmin; 275 275 + } 276 276 + if (patch.rejectedByAdmin != null) { 277 277 + update.rejected_by_admin = patch.rejectedByAdmin; 278 278 + } 279 279 + 280 280 + const row = await db 281 281 + .updateTable('public.users') 282 282 + .set(update) 283 283 + .where('id', '=', userId) 284 284 + .returning(USER_COLUMNS) 285 285 + .returning(loginMethodsAsTextArray) 286 286 + .executeTakeFirst(); 287 287 + 288 288 + return row === undefined ? undefined : rowToGraphQLUserParent(row); 289 289 + } 290 290 + 291 291 + export async function kyselyUserDeleteById( 292 292 + db: UsersDb, 293 293 + userId: string, 294 294 + ): Promise<void> { 295 295 + await db.deleteFrom('public.users').where('id', '=', userId).execute(); 296 296 + } 297 297 + 298 298 + /** 299 299 + * Favorite rules join-table helpers. The Sequelize association used the 300 300 + * auto-generated `users_and_favorite_rules` join table; preserving that 301 301 + * exact schema means existing rows keep working during/after the cutover. 302 302 + */ 303 303 + 304 304 + export async function kyselyUserListFavoriteRuleIds( 305 305 + db: UsersDb, 306 306 + userId: string, 307 307 + ): Promise<string[]> { 308 308 + const rows = await db 309 309 + .selectFrom('public.users_and_favorite_rules') 310 310 + .select('rule_id') 311 311 + .where('user_id', '=', userId) 312 312 + .execute(); 313 313 + return rows.map((r) => r.rule_id); 314 314 + } 315 315 + 316 316 + export async function kyselyUserAddFavoriteRule( 317 317 + db: UsersDb, 318 318 + userId: string, 319 319 + ruleId: string, 320 320 + ): Promise<void> { 321 321 + // `onConflict().doNothing()` matches Sequelize's `addFavoriteRules` semantics 322 322 + // when a favorite already exists (the composite PK on (user_id, rule_id) is 323 323 + // what de-duplicates). 324 324 + const now = new Date(); 325 325 + await db 326 326 + .insertInto('public.users_and_favorite_rules') 327 327 + .values({ 328 328 + user_id: userId, 329 329 + rule_id: ruleId, 330 330 + updated_at: now, 331 331 + }) 332 332 + .onConflict((oc) => oc.columns(['user_id', 'rule_id']).doNothing()) 333 333 + .execute(); 334 334 + } 335 335 + 336 336 + export async function kyselyUserRemoveFavoriteRule( 337 337 + db: UsersDb, 338 338 + userId: string, 339 339 + ruleId: string, 340 340 + ): Promise<void> { 341 341 + await db 342 342 + .deleteFrom('public.users_and_favorite_rules') 343 343 + .where('user_id', '=', userId) 344 344 + .where('rule_id', '=', ruleId) 345 345 + .execute(); 346 346 + }

+179

server/graphql/datasources/userValidation.test.ts

reviewed

··· 1 1 + import { 2 2 + validateUserCreateInput, 3 3 + validateUserUpdatePatch, 4 4 + } from './userValidation.js'; 5 5 + 6 6 + describe('userValidation', () => { 7 7 + describe('validateUserCreateInput', () => { 8 8 + const validInput = { 9 9 + email: 'test_user@example.com', 10 10 + firstName: 'Test', 11 11 + lastName: 'User', 12 12 + role: 'ADMIN', 13 13 + loginMethods: ['saml'] as const, 14 14 + password: null, 15 15 + }; 16 16 + 17 17 + test('accepts a fully valid input (SAML, no password)', () => { 18 18 + expect(validateUserCreateInput(validInput)).toEqual({ ok: true }); 19 19 + }); 20 20 + 21 21 + test('accepts a valid password-login input', () => { 22 22 + expect( 23 23 + validateUserCreateInput({ 24 24 + ...validInput, 25 25 + loginMethods: ['password'], 26 26 + password: 'hashed-password-placeholder', 27 27 + }), 28 28 + ).toEqual({ ok: true }); 29 29 + }); 30 30 + 31 31 + test.each([ 32 32 + ['empty', ''], 33 33 + ['missing @', 'not-an-email'], 34 34 + ['missing domain', 'foo@'], 35 35 + ['contains space', 'foo @bar.com'], 36 36 + ])('rejects email that is %s', (_label, email) => { 37 37 + const result = validateUserCreateInput({ ...validInput, email }); 38 38 + expect(result.ok).toBe(false); 39 39 + if (!result.ok) { 40 40 + expect(result.failure.field).toBe('email'); 41 41 + } 42 42 + }); 43 43 + 44 44 + test.each([ 45 45 + ['empty firstName', { firstName: '' }, 'firstName'], 46 46 + ['whitespace firstName', { firstName: ' ' }, 'firstName'], 47 47 + ['empty lastName', { lastName: '' }, 'lastName'], 48 48 + ['whitespace lastName', { lastName: ' ' }, 'lastName'], 49 49 + ] as const)('rejects %s', (_label, patch, expectedField) => { 50 50 + const result = validateUserCreateInput({ ...validInput, ...patch }); 51 51 + expect(result.ok).toBe(false); 52 52 + if (!result.ok) { 53 53 + expect(result.failure.field).toBe(expectedField); 54 54 + } 55 55 + }); 56 56 + 57 57 + test('rejects an unknown role', () => { 58 58 + const result = validateUserCreateInput({ 59 59 + ...validInput, 60 60 + role: 'NOT_A_REAL_ROLE', 61 61 + }); 62 62 + expect(result.ok).toBe(false); 63 63 + if (!result.ok) { 64 64 + expect(result.failure.field).toBe('role'); 65 65 + } 66 66 + }); 67 67 + 68 68 + test('rejects empty loginMethods', () => { 69 69 + const result = validateUserCreateInput({ 70 70 + ...validInput, 71 71 + loginMethods: [], 72 72 + }); 73 73 + expect(result.ok).toBe(false); 74 74 + if (!result.ok) { 75 75 + expect(result.failure.field).toBe('loginMethods'); 76 76 + } 77 77 + }); 78 78 + 79 79 + test('rejects unknown loginMethods entry', () => { 80 80 + const result = validateUserCreateInput({ 81 81 + ...validInput, 82 82 + loginMethods: ['saml', 'oauth' as never], 83 83 + }); 84 84 + expect(result.ok).toBe(false); 85 85 + if (!result.ok) { 86 86 + expect(result.failure.field).toBe('loginMethods'); 87 87 + } 88 88 + }); 89 89 + 90 90 + // Mirrors the DB `password_null_when_not_present` CHECK constraint. 91 91 + test("rejects password set but 'password' not in loginMethods", () => { 92 92 + const result = validateUserCreateInput({ 93 93 + ...validInput, 94 94 + loginMethods: ['saml'], 95 95 + password: 'hashed', 96 96 + }); 97 97 + expect(result.ok).toBe(false); 98 98 + if (!result.ok) { 99 99 + expect(result.failure.field).toBe('password'); 100 100 + } 101 101 + }); 102 102 + 103 103 + test("rejects 'password' in loginMethods without a password", () => { 104 104 + const result = validateUserCreateInput({ 105 105 + ...validInput, 106 106 + loginMethods: ['password'], 107 107 + password: null, 108 108 + }); 109 109 + expect(result.ok).toBe(false); 110 110 + if (!result.ok) { 111 111 + expect(result.failure.field).toBe('password'); 112 112 + } 113 113 + }); 114 114 + 115 115 + test("rejects empty-string password when 'password' in loginMethods", () => { 116 116 + const result = validateUserCreateInput({ 117 117 + ...validInput, 118 118 + loginMethods: ['password'], 119 119 + password: '', 120 120 + }); 121 121 + expect(result.ok).toBe(false); 122 122 + if (!result.ok) { 123 123 + expect(result.failure.field).toBe('password'); 124 124 + } 125 125 + }); 126 126 + }); 127 127 + 128 128 + describe('validateUserUpdatePatch', () => { 129 129 + test('accepts an empty patch (all fields undefined)', () => { 130 130 + expect(validateUserUpdatePatch({})).toEqual({ ok: true }); 131 131 + }); 132 132 + 133 133 + test('accepts explicit-null fields (skip semantics for non-password)', () => { 134 134 + expect( 135 135 + validateUserUpdatePatch({ 136 136 + email: null, 137 137 + firstName: null, 138 138 + lastName: null, 139 139 + role: null, 140 140 + }), 141 141 + ).toEqual({ ok: true }); 142 142 + }); 143 143 + 144 144 + test('accepts password: null (clears password)', () => { 145 145 + expect(validateUserUpdatePatch({ password: null })).toEqual({ ok: true }); 146 146 + }); 147 147 + 148 148 + test('rejects password: "" (shape error)', () => { 149 149 + const result = validateUserUpdatePatch({ password: '' }); 150 150 + expect(result.ok).toBe(false); 151 151 + if (!result.ok) { 152 152 + expect(result.failure.field).toBe('password'); 153 153 + } 154 154 + }); 155 155 + 156 156 + test('rejects empty / whitespace firstName / lastName', () => { 157 157 + expect(validateUserUpdatePatch({ firstName: '' }).ok).toBe(false); 158 158 + expect(validateUserUpdatePatch({ firstName: ' ' }).ok).toBe(false); 159 159 + expect(validateUserUpdatePatch({ lastName: '' }).ok).toBe(false); 160 160 + expect(validateUserUpdatePatch({ lastName: ' ' }).ok).toBe(false); 161 161 + }); 162 162 + 163 163 + test('rejects malformed email', () => { 164 164 + const result = validateUserUpdatePatch({ email: 'not-an-email' }); 165 165 + expect(result.ok).toBe(false); 166 166 + if (!result.ok) { 167 167 + expect(result.failure.field).toBe('email'); 168 168 + } 169 169 + }); 170 170 + 171 171 + test('rejects unknown role', () => { 172 172 + const result = validateUserUpdatePatch({ role: 'NOT_A_REAL_ROLE' }); 173 173 + expect(result.ok).toBe(false); 174 174 + if (!result.ok) { 175 175 + expect(result.failure.field).toBe('role'); 176 176 + } 177 177 + }); 178 178 + }); 179 179 + });

+169

server/graphql/datasources/userValidation.ts

reviewed

··· 1 1 + import { createRequire } from 'node:module'; 2 2 + import type { IsEmailOptions } from 'validator/lib/isEmail.js'; 3 3 + 4 4 + import { UserRole } from '../../models/types/permissioning.js'; 5 5 + import { type LoginMethod } from '../../services/coreAppTables.js'; 6 6 + 7 7 + // `validator` is CJS with UMD-style types whose `default` doesn't resolve to 8 8 + // a callable under `module: NodeNext`; `createRequire` gives us `module.exports` 9 9 + // directly, typed against the per-function defs that ship with `@types/validator`. 10 10 + type ValidatorLib = { 11 11 + isEmail: (str: string, options?: IsEmailOptions) => boolean; 12 12 + }; 13 13 + const validator = createRequire(import.meta.url)('validator') as ValidatorLib; 14 14 + 15 15 + /** 16 16 + * Server-side validation for `User` inputs, replacing the `isEmail`, 17 17 + * `notEmpty`, and `isIn` checks that lived on the Sequelize model, plus the 18 18 + * DB `password_null_when_not_present` CHECK constraint (which we still rely 19 19 + * on; this layer surfaces a useful error before the INSERT hits Postgres). 20 20 + * 21 21 + * Returned rather than thrown so each caller picks the right error surface: 22 22 + * the data source wraps failures in `makeBadRequestError`, while persistence 23 23 + * treats them as invariants. 24 24 + */ 25 25 + 26 26 + export type UserValidationFailure = { 27 27 + /** Kept stable for GraphQL JSON pointers. */ 28 28 + field: 29 29 + | 'email' 30 30 + | 'firstName' 31 31 + | 'lastName' 32 32 + | 'role' 33 33 + | 'loginMethods' 34 34 + | 'password'; 35 35 + message: string; 36 36 + }; 37 37 + 38 38 + export type UserValidationResult = 39 39 + | { ok: true } 40 40 + | { ok: false; failure: UserValidationFailure }; 41 41 + 42 42 + function isEmailShape(value: string): boolean { 43 43 + return validator.isEmail(value); 44 44 + } 45 45 + 46 46 + function isNonEmptyTrimmed(value: string): boolean { 47 47 + return value.trim().length > 0; 48 48 + } 49 49 + 50 50 + function fail( 51 51 + field: UserValidationFailure['field'], 52 52 + message: string, 53 53 + ): UserValidationResult { 54 54 + return { ok: false, failure: { field, message } }; 55 55 + } 56 56 + 57 57 + const ALLOWED_LOGIN_METHODS: readonly LoginMethod[] = ['password', 'saml']; 58 58 + 59 59 + function validateLoginMethodsShape( 60 60 + loginMethods: readonly string[], 61 61 + ): UserValidationResult { 62 62 + if (loginMethods.length === 0) { 63 63 + return fail('loginMethods', 'loginMethods must not be empty'); 64 64 + } 65 65 + for (const method of loginMethods) { 66 66 + if (!ALLOWED_LOGIN_METHODS.includes(method as LoginMethod)) { 67 67 + return fail( 68 68 + 'loginMethods', 69 69 + `loginMethods contains invalid entry '${method}'`, 70 70 + ); 71 71 + } 72 72 + } 73 73 + return { ok: true }; 74 74 + } 75 75 + 76 76 + /** 77 77 + * Mirrors the DB `password_null_when_not_present` CHECK: 78 78 + * password IS NOT NULL ⇔ 'password' ∈ login_methods 79 79 + */ 80 80 + function validatePasswordLoginMethodsInvariant(input: { 81 81 + password: string | null; 82 82 + loginMethods: readonly LoginMethod[]; 83 83 + }): UserValidationResult { 84 84 + const hasPassword = input.password != null && input.password !== ''; 85 85 + const usesPasswordLogin = input.loginMethods.includes('password'); 86 86 + if (hasPassword && !usesPasswordLogin) { 87 87 + return fail( 88 88 + 'password', 89 89 + "password must not be set when 'password' is not in loginMethods", 90 90 + ); 91 91 + } 92 92 + if (!hasPassword && usesPasswordLogin) { 93 93 + return fail( 94 94 + 'password', 95 95 + "password is required when 'password' is in loginMethods", 96 96 + ); 97 97 + } 98 98 + return { ok: true }; 99 99 + } 100 100 + 101 101 + export function validateUserCreateInput(input: { 102 102 + email: string; 103 103 + firstName: string; 104 104 + lastName: string; 105 105 + role: string; 106 106 + loginMethods: readonly string[]; 107 107 + password: string | null; 108 108 + }): UserValidationResult { 109 109 + if (!isNonEmptyTrimmed(input.email) || !isEmailShape(input.email)) { 110 110 + return fail('email', 'email must be a valid email address'); 111 111 + } 112 112 + if (!isNonEmptyTrimmed(input.firstName)) { 113 113 + return fail('firstName', 'firstName must not be empty'); 114 114 + } 115 115 + if (!isNonEmptyTrimmed(input.lastName)) { 116 116 + return fail('lastName', 'lastName must not be empty'); 117 117 + } 118 118 + const roleValues: readonly string[] = Object.values(UserRole); 119 119 + if (!roleValues.includes(input.role)) { 120 120 + return fail('role', `role must be one of: ${roleValues.join(', ')}`); 121 121 + } 122 122 + const loginResult = validateLoginMethodsShape(input.loginMethods); 123 123 + if (!loginResult.ok) { 124 124 + return loginResult; 125 125 + } 126 126 + const invariantResult = validatePasswordLoginMethodsInvariant({ 127 127 + password: input.password, 128 128 + loginMethods: input.loginMethods as readonly LoginMethod[], 129 129 + }); 130 130 + if (!invariantResult.ok) { 131 131 + return invariantResult; 132 132 + } 133 133 + return { ok: true }; 134 134 + } 135 135 + 136 136 + /** 137 137 + * Partial-update semantics match the Sequelize model: 138 138 + * - `undefined` fields are skipped 139 139 + * - `password: null` is a meaningful value (removes password login) 140 140 + * - `password: ''` is rejected as a shape error 141 141 + */ 142 142 + export function validateUserUpdatePatch(patch: { 143 143 + email?: string | null; 144 144 + firstName?: string | null; 145 145 + lastName?: string | null; 146 146 + role?: string | null; 147 147 + password?: string | null; 148 148 + }): UserValidationResult { 149 149 + if ( 150 150 + patch.email != null && 151 151 + (!isNonEmptyTrimmed(patch.email) || !isEmailShape(patch.email)) 152 152 + ) { 153 153 + return fail('email', 'email must be a valid email address'); 154 154 + } 155 155 + if (patch.firstName != null && !isNonEmptyTrimmed(patch.firstName)) { 156 156 + return fail('firstName', 'firstName must not be empty'); 157 157 + } 158 158 + if (patch.lastName != null && !isNonEmptyTrimmed(patch.lastName)) { 159 159 + return fail('lastName', 'lastName must not be empty'); 160 160 + } 161 161 + const roleValues: readonly string[] = Object.values(UserRole); 162 162 + if (patch.role != null && !roleValues.includes(patch.role)) { 163 163 + return fail('role', `role must be one of: ${roleValues.join(', ')}`); 164 164 + } 165 165 + if (patch.password === '') { 166 166 + return fail('password', 'password must not be an empty string'); 167 167 + } 168 168 + return { ok: true }; 169 169 + }

+669 -605

server/graphql/generated.ts

reviewed

··· 8 8 9 9 import type { UserHistoryForGQL } from '../graphql/datasources/InvestigationApi.js'; 10 10 import type { GraphQLOrgParent } from '../graphql/datasources/orgKyselyPersistence.js'; 11 11 + import type { GraphQLUserParent } from '../graphql/datasources/userKyselyPersistence.js'; 11 12 import type { 12 13 ContentItemTypeResolversParentType, 13 14 ItemTypeResolversParentType, ··· 21 22 import type { Backtest } from '../models/rules/BacktestModel.js'; 22 23 import type { ItemType } from '../models/rules/ItemTypeModel.js'; 23 24 import type { Rule } from '../models/rules/RuleModel.js'; 24 24 - import type { User } from '../models/UserModel.js'; 25 25 import type { SignalWithScore } from '../services/analyticsQueries/RuleActionInsights.js'; 26 26 import type { DerivedFieldSpecSource } from '../services/derivedFieldsService/helpers.js'; 27 27 import type { ··· 60 60 import type { Context } from './resolvers.js'; 61 61 import type { ItemSubmissionForGQL } from './types.js'; 62 62 63 63 - export type Maybe<T> = T extends Promise<infer U> 64 64 - ? Promise<U | null> 65 65 - : T | null; 66 66 - export type InputMaybe<T> = T extends Promise<infer U> 67 67 - ? Promise<U | null> 68 68 - : T | null; 63 63 + export type Maybe<T> = 64 64 + T extends Promise<infer U> ? Promise<U | null> : T | null; 65 65 + export type InputMaybe<T> = 66 66 + T extends Promise<infer U> ? Promise<U | null> : T | null; 69 67 export type Exact<T extends { [key: string]: unknown }> = { 70 68 [K in keyof T]: T[K]; 71 69 }; ··· 6187 6185 >; 6188 6186 UpdateUserStrikeTTLInput: GQLUpdateUserStrikeTtlInput; 6189 6187 UpdateUserStrikeTTLSuccessResponse: ResolverTypeWrapper<GQLUpdateUserStrikeTtlSuccessResponse>; 6190 6190 - User: ResolverTypeWrapper<User>; 6188 6188 + User: ResolverTypeWrapper<GraphQLUserParent>; 6191 6189 UserActionDecisionAction: GQLUserActionDecisionAction; 6192 6190 UserActionDecisionPolicy: GQLUserActionDecisionPolicy; 6193 6191 UserActionsHistory: ResolverTypeWrapper<GQLUserActionsHistory>; ··· 6824 6822 UpdateUserRuleResponse: GQLResolversUnionTypes<GQLResolversParentTypes>['UpdateUserRuleResponse']; 6825 6823 UpdateUserStrikeTTLInput: GQLUpdateUserStrikeTtlInput; 6826 6824 UpdateUserStrikeTTLSuccessResponse: GQLUpdateUserStrikeTtlSuccessResponse; 6827 6827 - User: User; 6825 6825 + User: GraphQLUserParent; 6828 6826 UserActionDecisionAction: GQLUserActionDecisionAction; 6829 6827 UserActionDecisionPolicy: GQLUserActionDecisionPolicy; 6830 6828 UserActionsHistory: GQLUserActionsHistory; ··· 6875 6873 6876 6874 export type GQLAcceptAppealDecisionComponentResolvers< 6877 6875 ContextType = Context, 6878 6878 - ParentType extends 6879 6879 - GQLResolversParentTypes['AcceptAppealDecisionComponent'] = GQLResolversParentTypes['AcceptAppealDecisionComponent'], 6876 6876 + ParentType extends GQLResolversParentTypes['AcceptAppealDecisionComponent'] = 6877 6877 + GQLResolversParentTypes['AcceptAppealDecisionComponent'], 6880 6878 > = { 6881 6879 actionIds?: Resolver< 6882 6880 ReadonlyArray<GQLResolversTypes['String']>, ··· 6894 6892 6895 6893 export type GQLActionResolvers< 6896 6894 ContextType = Context, 6897 6897 - ParentType extends 6898 6898 - GQLResolversParentTypes['Action'] = GQLResolversParentTypes['Action'], 6895 6895 + ParentType extends GQLResolversParentTypes['Action'] = 6896 6896 + GQLResolversParentTypes['Action'], 6899 6897 > = { 6900 6898 __resolveType: TypeResolveFn< 6901 6899 | 'CustomAction' ··· 6909 6907 6910 6908 export type GQLActionBaseResolvers< 6911 6909 ContextType = Context, 6912 6912 - ParentType extends 6913 6913 - GQLResolversParentTypes['ActionBase'] = GQLResolversParentTypes['ActionBase'], 6910 6910 + ParentType extends GQLResolversParentTypes['ActionBase'] = 6911 6911 + GQLResolversParentTypes['ActionBase'], 6914 6912 > = { 6915 6913 __resolveType: TypeResolveFn< 6916 6914 | 'CustomAction' ··· 6924 6922 6925 6923 export type GQLActionDataResolvers< 6926 6924 ContextType = Context, 6927 6927 - ParentType extends 6928 6928 - GQLResolversParentTypes['ActionData'] = GQLResolversParentTypes['ActionData'], 6925 6925 + ParentType extends GQLResolversParentTypes['ActionData'] = 6926 6926 + GQLResolversParentTypes['ActionData'], 6929 6927 > = { 6930 6928 action_id?: Resolver< 6931 6929 Maybe<GQLResolversTypes['String']>, ··· 6958 6956 6959 6957 export type GQLActionNameExistsErrorResolvers< 6960 6958 ContextType = Context, 6961 6961 - ParentType extends 6962 6962 - GQLResolversParentTypes['ActionNameExistsError'] = GQLResolversParentTypes['ActionNameExistsError'], 6959 6959 + ParentType extends GQLResolversParentTypes['ActionNameExistsError'] = 6960 6960 + GQLResolversParentTypes['ActionNameExistsError'], 6963 6961 > = { 6964 6962 detail?: Resolver< 6965 6963 Maybe<GQLResolversTypes['String']>, ··· 6989 6987 export type GQLAddAccessibleQueuesToUserResponseResolvers< 6990 6988 ContextType = Context, 6991 6989 ParentType extends 6992 6992 - GQLResolversParentTypes['AddAccessibleQueuesToUserResponse'] = GQLResolversParentTypes['AddAccessibleQueuesToUserResponse'], 6990 6990 + GQLResolversParentTypes['AddAccessibleQueuesToUserResponse'] = 6991 6991 + GQLResolversParentTypes['AddAccessibleQueuesToUserResponse'], 6993 6992 > = { 6994 6993 __resolveType: TypeResolveFn< 6995 6994 'MutateAccessibleQueuesForUserSuccessResponse', ··· 7000 6999 7001 7000 export type GQLAddCommentFailedErrorResolvers< 7002 7001 ContextType = Context, 7003 7003 - ParentType extends 7004 7004 - GQLResolversParentTypes['AddCommentFailedError'] = GQLResolversParentTypes['AddCommentFailedError'], 7002 7002 + ParentType extends GQLResolversParentTypes['AddCommentFailedError'] = 7003 7003 + GQLResolversParentTypes['AddCommentFailedError'], 7005 7004 > = { 7006 7005 detail?: Resolver< 7007 7006 Maybe<GQLResolversTypes['String']>, ··· 7031 7030 export type GQLAddFavoriteMrtQueueSuccessResponseResolvers< 7032 7031 ContextType = Context, 7033 7032 ParentType extends 7034 7034 - GQLResolversParentTypes['AddFavoriteMRTQueueSuccessResponse'] = GQLResolversParentTypes['AddFavoriteMRTQueueSuccessResponse'], 7033 7033 + GQLResolversParentTypes['AddFavoriteMRTQueueSuccessResponse'] = 7034 7034 + GQLResolversParentTypes['AddFavoriteMRTQueueSuccessResponse'], 7035 7035 > = { 7036 7036 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 7037 7037 }; 7038 7038 7039 7039 export type GQLAddFavoriteRuleResponseResolvers< 7040 7040 ContextType = Context, 7041 7041 - ParentType extends 7042 7042 - GQLResolversParentTypes['AddFavoriteRuleResponse'] = GQLResolversParentTypes['AddFavoriteRuleResponse'], 7041 7041 + ParentType extends GQLResolversParentTypes['AddFavoriteRuleResponse'] = 7042 7042 + GQLResolversParentTypes['AddFavoriteRuleResponse'], 7043 7043 > = { 7044 7044 __resolveType: TypeResolveFn< 7045 7045 'AddFavoriteRuleSuccessResponse', ··· 7050 7050 7051 7051 export type GQLAddFavoriteRuleSuccessResponseResolvers< 7052 7052 ContextType = Context, 7053 7053 - ParentType extends 7054 7054 - GQLResolversParentTypes['AddFavoriteRuleSuccessResponse'] = GQLResolversParentTypes['AddFavoriteRuleSuccessResponse'], 7053 7053 + ParentType extends GQLResolversParentTypes['AddFavoriteRuleSuccessResponse'] = 7054 7054 + GQLResolversParentTypes['AddFavoriteRuleSuccessResponse'], 7055 7055 > = { 7056 7056 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 7057 7057 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 7060 7060 export type GQLAddManualReviewJobCommentResponseResolvers< 7061 7061 ContextType = Context, 7062 7062 ParentType extends 7063 7063 - GQLResolversParentTypes['AddManualReviewJobCommentResponse'] = GQLResolversParentTypes['AddManualReviewJobCommentResponse'], 7063 7063 + GQLResolversParentTypes['AddManualReviewJobCommentResponse'] = 7064 7064 + GQLResolversParentTypes['AddManualReviewJobCommentResponse'], 7064 7065 > = { 7065 7066 __resolveType: TypeResolveFn< 7066 7067 'AddManualReviewJobCommentSuccessResponse' | 'NotFoundError', ··· 7072 7073 export type GQLAddManualReviewJobCommentSuccessResponseResolvers< 7073 7074 ContextType = Context, 7074 7075 ParentType extends 7075 7075 - GQLResolversParentTypes['AddManualReviewJobCommentSuccessResponse'] = GQLResolversParentTypes['AddManualReviewJobCommentSuccessResponse'], 7076 7076 + GQLResolversParentTypes['AddManualReviewJobCommentSuccessResponse'] = 7077 7077 + GQLResolversParentTypes['AddManualReviewJobCommentSuccessResponse'], 7076 7078 > = { 7077 7079 comment?: Resolver< 7078 7080 GQLResolversTypes['ManualReviewJobComment'], ··· 7084 7086 7085 7087 export type GQLAddPoliciesResponseResolvers< 7086 7088 ContextType = Context, 7087 7087 - ParentType extends 7088 7088 - GQLResolversParentTypes['AddPoliciesResponse'] = GQLResolversParentTypes['AddPoliciesResponse'], 7089 7089 + ParentType extends GQLResolversParentTypes['AddPoliciesResponse'] = 7090 7090 + GQLResolversParentTypes['AddPoliciesResponse'], 7089 7091 > = { 7090 7092 failures?: Resolver< 7091 7093 ReadonlyArray<GQLResolversTypes['String']>, ··· 7101 7103 7102 7104 export type GQLAggregationResolvers< 7103 7105 ContextType = Context, 7104 7104 - ParentType extends 7105 7105 - GQLResolversParentTypes['Aggregation'] = GQLResolversParentTypes['Aggregation'], 7106 7106 + ParentType extends GQLResolversParentTypes['Aggregation'] = 7107 7107 + GQLResolversParentTypes['Aggregation'], 7106 7108 > = { 7107 7109 type?: Resolver< 7108 7110 GQLResolversTypes['AggregationType'], ··· 7113 7115 7114 7116 export type GQLAggregationClauseResolvers< 7115 7117 ContextType = Context, 7116 7116 - ParentType extends 7117 7117 - GQLResolversParentTypes['AggregationClause'] = GQLResolversParentTypes['AggregationClause'], 7118 7118 + ParentType extends GQLResolversParentTypes['AggregationClause'] = 7119 7119 + GQLResolversParentTypes['AggregationClause'], 7118 7120 > = { 7119 7121 aggregation?: Resolver< 7120 7122 Maybe<GQLResolversTypes['Aggregation']>, ··· 7141 7143 7142 7144 export type GQLAggregationSignalArgsResolvers< 7143 7145 ContextType = Context, 7144 7144 - ParentType extends 7145 7145 - GQLResolversParentTypes['AggregationSignalArgs'] = GQLResolversParentTypes['AggregationSignalArgs'], 7146 7146 + ParentType extends GQLResolversParentTypes['AggregationSignalArgs'] = 7147 7147 + GQLResolversParentTypes['AggregationSignalArgs'], 7146 7148 > = { 7147 7149 aggregationClause?: Resolver< 7148 7150 Maybe<GQLResolversTypes['AggregationClause']>, ··· 7154 7156 7155 7157 export type GQLAllLanguagesResolvers< 7156 7158 ContextType = Context, 7157 7157 - ParentType extends 7158 7158 - GQLResolversParentTypes['AllLanguages'] = GQLResolversParentTypes['AllLanguages'], 7159 7159 + ParentType extends GQLResolversParentTypes['AllLanguages'] = 7160 7160 + GQLResolversParentTypes['AllLanguages'], 7159 7161 > = { 7160 7162 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 7161 7163 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 7163 7165 7164 7166 export type GQLAllRuleInsightsResolvers< 7165 7167 ContextType = Context, 7166 7166 - ParentType extends 7167 7167 - GQLResolversParentTypes['AllRuleInsights'] = GQLResolversParentTypes['AllRuleInsights'], 7168 7168 + ParentType extends GQLResolversParentTypes['AllRuleInsights'] = 7169 7169 + GQLResolversParentTypes['AllRuleInsights'], 7168 7170 > = { 7169 7171 actionedSubmissionsByActionByDay?: Resolver< 7170 7172 ReadonlyArray<GQLResolversTypes['CountByActionByDay']>, ··· 7195 7197 7196 7198 export type GQLApiKeyResolvers< 7197 7199 ContextType = Context, 7198 7198 - ParentType extends 7199 7199 - GQLResolversParentTypes['ApiKey'] = GQLResolversParentTypes['ApiKey'], 7200 7200 + ParentType extends GQLResolversParentTypes['ApiKey'] = 7201 7201 + GQLResolversParentTypes['ApiKey'], 7200 7202 > = { 7201 7203 createdAt?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 7202 7204 createdBy?: Resolver< ··· 7221 7223 7222 7224 export type GQLAppealEnqueueSourceInfoResolvers< 7223 7225 ContextType = Context, 7224 7224 - ParentType extends 7225 7225 - GQLResolversParentTypes['AppealEnqueueSourceInfo'] = GQLResolversParentTypes['AppealEnqueueSourceInfo'], 7226 7226 + ParentType extends GQLResolversParentTypes['AppealEnqueueSourceInfo'] = 7227 7227 + GQLResolversParentTypes['AppealEnqueueSourceInfo'], 7226 7228 > = { 7227 7229 kind?: Resolver< 7228 7230 GQLResolversTypes['JobCreationSourceOptions'], ··· 7234 7236 7235 7237 export type GQLAppealSettingsResolvers< 7236 7238 ContextType = Context, 7237 7237 - ParentType extends 7238 7238 - GQLResolversParentTypes['AppealSettings'] = GQLResolversParentTypes['AppealSettings'], 7239 7239 + ParentType extends GQLResolversParentTypes['AppealSettings'] = 7240 7240 + GQLResolversParentTypes['AppealSettings'], 7239 7241 > = { 7240 7242 appealsCallbackBody?: Resolver< 7241 7243 Maybe<GQLResolversTypes['JSONObject']>, ··· 7257 7259 export type GQLAutomaticCloseDecisionComponentResolvers< 7258 7260 ContextType = Context, 7259 7261 ParentType extends 7260 7260 - GQLResolversParentTypes['AutomaticCloseDecisionComponent'] = GQLResolversParentTypes['AutomaticCloseDecisionComponent'], 7262 7262 + GQLResolversParentTypes['AutomaticCloseDecisionComponent'] = 7263 7263 + GQLResolversParentTypes['AutomaticCloseDecisionComponent'], 7261 7264 > = { 7262 7265 type?: Resolver< 7263 7266 GQLResolversTypes['ManualReviewDecisionType'], ··· 7269 7272 7270 7273 export type GQLBacktestResolvers< 7271 7274 ContextType = Context, 7272 7272 - ParentType extends 7273 7273 - GQLResolversParentTypes['Backtest'] = GQLResolversParentTypes['Backtest'], 7275 7275 + ParentType extends GQLResolversParentTypes['Backtest'] = 7276 7276 + GQLResolversParentTypes['Backtest'], 7274 7277 > = { 7275 7278 contentItemsMatched?: Resolver< 7276 7279 GQLResolversTypes['Int'], ··· 7320 7323 7321 7324 export type GQLBaseFieldResolvers< 7322 7325 ContextType = Context, 7323 7323 - ParentType extends 7324 7324 - GQLResolversParentTypes['BaseField'] = GQLResolversParentTypes['BaseField'], 7326 7326 + ParentType extends GQLResolversParentTypes['BaseField'] = 7327 7327 + GQLResolversParentTypes['BaseField'], 7325 7328 > = { 7326 7329 container?: Resolver< 7327 7330 Maybe<GQLResolversTypes['Container']>, ··· 7336 7339 7337 7340 export type GQLCannotDeleteDefaultUserErrorResolvers< 7338 7341 ContextType = Context, 7339 7339 - ParentType extends 7340 7340 - GQLResolversParentTypes['CannotDeleteDefaultUserError'] = GQLResolversParentTypes['CannotDeleteDefaultUserError'], 7342 7342 + ParentType extends GQLResolversParentTypes['CannotDeleteDefaultUserError'] = 7343 7343 + GQLResolversParentTypes['CannotDeleteDefaultUserError'], 7341 7344 > = { 7342 7345 detail?: Resolver< 7343 7346 Maybe<GQLResolversTypes['String']>, ··· 7366 7369 7367 7370 export type GQLChangePasswordErrorResolvers< 7368 7371 ContextType = Context, 7369 7369 - ParentType extends 7370 7370 - GQLResolversParentTypes['ChangePasswordError'] = GQLResolversParentTypes['ChangePasswordError'], 7372 7372 + ParentType extends GQLResolversParentTypes['ChangePasswordError'] = 7373 7373 + GQLResolversParentTypes['ChangePasswordError'], 7371 7374 > = { 7372 7375 detail?: Resolver< 7373 7376 Maybe<GQLResolversTypes['String']>, ··· 7396 7399 7397 7400 export type GQLChangePasswordResponseResolvers< 7398 7401 ContextType = Context, 7399 7399 - ParentType extends 7400 7400 - GQLResolversParentTypes['ChangePasswordResponse'] = GQLResolversParentTypes['ChangePasswordResponse'], 7402 7402 + ParentType extends GQLResolversParentTypes['ChangePasswordResponse'] = 7403 7403 + GQLResolversParentTypes['ChangePasswordResponse'], 7401 7404 > = { 7402 7405 __resolveType: TypeResolveFn< 7403 7406 'ChangePasswordError' | 'ChangePasswordSuccessResponse', ··· 7408 7411 7409 7412 export type GQLChangePasswordSuccessResponseResolvers< 7410 7413 ContextType = Context, 7411 7411 - ParentType extends 7412 7412 - GQLResolversParentTypes['ChangePasswordSuccessResponse'] = GQLResolversParentTypes['ChangePasswordSuccessResponse'], 7414 7414 + ParentType extends GQLResolversParentTypes['ChangePasswordSuccessResponse'] = 7415 7415 + GQLResolversParentTypes['ChangePasswordSuccessResponse'], 7413 7416 > = { 7414 7417 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 7415 7418 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 7417 7420 7418 7421 export type GQLConditionResolvers< 7419 7422 ContextType = Context, 7420 7420 - ParentType extends 7421 7421 - GQLResolversParentTypes['Condition'] = GQLResolversParentTypes['Condition'], 7423 7423 + ParentType extends GQLResolversParentTypes['Condition'] = 7424 7424 + GQLResolversParentTypes['Condition'], 7422 7425 > = { 7423 7426 __resolveType: TypeResolveFn< 7424 7427 'ConditionSet' | 'LeafCondition', ··· 7429 7432 7430 7433 export type GQLConditionInputFieldResolvers< 7431 7434 ContextType = Context, 7432 7432 - ParentType extends 7433 7433 - GQLResolversParentTypes['ConditionInputField'] = GQLResolversParentTypes['ConditionInputField'], 7435 7435 + ParentType extends GQLResolversParentTypes['ConditionInputField'] = 7436 7436 + GQLResolversParentTypes['ConditionInputField'], 7434 7437 > = { 7435 7438 contentTypeId?: Resolver< 7436 7439 Maybe<GQLResolversTypes['String']>, ··· 7461 7464 7462 7465 export type GQLConditionResultResolvers< 7463 7466 ContextType = Context, 7464 7464 - ParentType extends 7465 7465 - GQLResolversParentTypes['ConditionResult'] = GQLResolversParentTypes['ConditionResult'], 7467 7467 + ParentType extends GQLResolversParentTypes['ConditionResult'] = 7468 7468 + GQLResolversParentTypes['ConditionResult'], 7466 7469 > = { 7467 7470 matchedValue?: Resolver< 7468 7471 Maybe<GQLResolversTypes['String']>, ··· 7479 7482 7480 7483 export type GQLConditionSetResolvers< 7481 7484 ContextType = Context, 7482 7482 - ParentType extends 7483 7483 - GQLResolversParentTypes['ConditionSet'] = GQLResolversParentTypes['ConditionSet'], 7485 7485 + ParentType extends GQLResolversParentTypes['ConditionSet'] = 7486 7486 + GQLResolversParentTypes['ConditionSet'], 7484 7487 > = { 7485 7488 conditions?: Resolver< 7486 7489 ReadonlyArray<GQLResolversTypes['Condition']>, ··· 7497 7500 7498 7501 export type GQLConditionSetWithResultResolvers< 7499 7502 ContextType = Context, 7500 7500 - ParentType extends 7501 7501 - GQLResolversParentTypes['ConditionSetWithResult'] = GQLResolversParentTypes['ConditionSetWithResult'], 7503 7503 + ParentType extends GQLResolversParentTypes['ConditionSetWithResult'] = 7504 7504 + GQLResolversParentTypes['ConditionSetWithResult'], 7502 7505 > = { 7503 7506 conditions?: Resolver< 7504 7507 ReadonlyArray<GQLResolversTypes['ConditionWithResult']>, ··· 7520 7523 7521 7524 export type GQLConditionWithResultResolvers< 7522 7525 ContextType = Context, 7523 7523 - ParentType extends 7524 7524 - GQLResolversParentTypes['ConditionWithResult'] = GQLResolversParentTypes['ConditionWithResult'], 7526 7526 + ParentType extends GQLResolversParentTypes['ConditionWithResult'] = 7527 7527 + GQLResolversParentTypes['ConditionWithResult'], 7525 7528 > = { 7526 7529 __resolveType: TypeResolveFn< 7527 7530 'ConditionSetWithResult' | 'LeafConditionWithResult', ··· 7532 7535 7533 7536 export type GQLContainerResolvers< 7534 7537 ContextType = Context, 7535 7535 - ParentType extends 7536 7536 - GQLResolversParentTypes['Container'] = GQLResolversParentTypes['Container'], 7538 7538 + ParentType extends GQLResolversParentTypes['Container'] = 7539 7539 + GQLResolversParentTypes['Container'], 7537 7540 > = { 7538 7541 containerType?: Resolver< 7539 7542 GQLResolversTypes['ContainerType'], ··· 7555 7558 export type GQLContentAppealManualReviewJobPayloadResolvers< 7556 7559 ContextType = Context, 7557 7560 ParentType extends 7558 7558 - GQLResolversParentTypes['ContentAppealManualReviewJobPayload'] = GQLResolversParentTypes['ContentAppealManualReviewJobPayload'], 7561 7561 + GQLResolversParentTypes['ContentAppealManualReviewJobPayload'] = 7562 7562 + GQLResolversParentTypes['ContentAppealManualReviewJobPayload'], 7559 7563 > = { 7560 7564 actionsTaken?: Resolver< 7561 7565 ReadonlyArray<GQLResolversTypes['String']>, ··· 7594 7598 7595 7599 export type GQLContentItemResolvers< 7596 7600 ContextType = Context, 7597 7597 - ParentType extends 7598 7598 - GQLResolversParentTypes['ContentItem'] = GQLResolversParentTypes['ContentItem'], 7601 7601 + ParentType extends GQLResolversParentTypes['ContentItem'] = 7602 7602 + GQLResolversParentTypes['ContentItem'], 7599 7603 > = { 7600 7604 data?: Resolver<GQLResolversTypes['JSONObject'], ParentType, ContextType>; 7601 7605 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; ··· 7615 7619 7616 7620 export type GQLContentItemTypeResolvers< 7617 7621 ContextType = Context, 7618 7618 - ParentType extends 7619 7619 - GQLResolversParentTypes['ContentItemType'] = GQLResolversParentTypes['ContentItemType'], 7622 7622 + ParentType extends GQLResolversParentTypes['ContentItemType'] = 7623 7623 + GQLResolversParentTypes['ContentItemType'], 7620 7624 > = { 7621 7625 baseFields?: Resolver< 7622 7626 ReadonlyArray<GQLResolversTypes['BaseField']>, ··· 7656 7660 7657 7661 export type GQLContentManualReviewJobPayloadResolvers< 7658 7662 ContextType = Context, 7659 7659 - ParentType extends 7660 7660 - GQLResolversParentTypes['ContentManualReviewJobPayload'] = GQLResolversParentTypes['ContentManualReviewJobPayload'], 7663 7663 + ParentType extends GQLResolversParentTypes['ContentManualReviewJobPayload'] = 7664 7664 + GQLResolversParentTypes['ContentManualReviewJobPayload'], 7661 7665 > = { 7662 7666 additionalContentItems?: Resolver< 7663 7667 ReadonlyArray<GQLResolversTypes['ContentItem']>, ··· 7700 7704 7701 7705 export type GQLContentRuleResolvers< 7702 7706 ContextType = Context, 7703 7703 - ParentType extends 7704 7704 - GQLResolversParentTypes['ContentRule'] = GQLResolversParentTypes['ContentRule'], 7707 7707 + ParentType extends GQLResolversParentTypes['ContentRule'] = 7708 7708 + GQLResolversParentTypes['ContentRule'], 7705 7709 > = { 7706 7710 actions?: Resolver< 7707 7711 ReadonlyArray<GQLResolversTypes['Action']>, ··· 7766 7770 7767 7771 export type GQLContentSchemaFieldRolesResolvers< 7768 7772 ContextType = Context, 7769 7769 - ParentType extends 7770 7770 - GQLResolversParentTypes['ContentSchemaFieldRoles'] = GQLResolversParentTypes['ContentSchemaFieldRoles'], 7773 7773 + ParentType extends GQLResolversParentTypes['ContentSchemaFieldRoles'] = 7774 7774 + GQLResolversParentTypes['ContentSchemaFieldRoles'], 7771 7775 > = { 7772 7776 createdAt?: Resolver< 7773 7777 Maybe<GQLResolversTypes['String']>, ··· 7804 7808 7805 7809 export type GQLContentTypeResolvers< 7806 7810 ContextType = Context, 7807 7807 - ParentType extends 7808 7808 - GQLResolversParentTypes['ContentType'] = GQLResolversParentTypes['ContentType'], 7811 7811 + ParentType extends GQLResolversParentTypes['ContentType'] = 7812 7812 + GQLResolversParentTypes['ContentType'], 7809 7813 > = { 7810 7814 actions?: Resolver< 7811 7815 ReadonlyArray<GQLResolversTypes['Action']>, ··· 7831 7835 name?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 7832 7836 }; 7833 7837 7834 7834 - export interface GQLCoopInputOrStringScalarConfig 7835 7835 - extends GraphQLScalarTypeConfig<GQLResolversTypes['CoopInputOrString'], any> { 7838 7838 + export interface GQLCoopInputOrStringScalarConfig extends GraphQLScalarTypeConfig< 7839 7839 + GQLResolversTypes['CoopInputOrString'], 7840 7840 + any 7841 7841 + > { 7836 7842 name: 'CoopInputOrString'; 7837 7843 } 7838 7844 7839 7845 export type GQLCountByActionByDayResolvers< 7840 7846 ContextType = Context, 7841 7841 - ParentType extends 7842 7842 - GQLResolversParentTypes['CountByActionByDay'] = GQLResolversParentTypes['CountByActionByDay'], 7847 7847 + ParentType extends GQLResolversParentTypes['CountByActionByDay'] = 7848 7848 + GQLResolversParentTypes['CountByActionByDay'], 7843 7849 > = { 7844 7850 action?: Resolver< 7845 7851 GQLResolversTypes['CountByActionByDayAction'], ··· 7852 7858 7853 7859 export type GQLCountByActionByDayActionResolvers< 7854 7860 ContextType = Context, 7855 7855 - ParentType extends 7856 7856 - GQLResolversParentTypes['CountByActionByDayAction'] = GQLResolversParentTypes['CountByActionByDayAction'], 7861 7861 + ParentType extends GQLResolversParentTypes['CountByActionByDayAction'] = 7862 7862 + GQLResolversParentTypes['CountByActionByDayAction'], 7857 7863 > = { 7858 7864 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; 7859 7865 name?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 7861 7867 7862 7868 export type GQLCountByDayResolvers< 7863 7869 ContextType = Context, 7864 7864 - ParentType extends 7865 7865 - GQLResolversParentTypes['CountByDay'] = GQLResolversParentTypes['CountByDay'], 7870 7870 + ParentType extends GQLResolversParentTypes['CountByDay'] = 7871 7871 + GQLResolversParentTypes['CountByDay'], 7866 7872 > = { 7867 7873 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 7868 7874 date?: Resolver<GQLResolversTypes['Date'], ParentType, ContextType>; ··· 7870 7876 7871 7877 export type GQLCountByDecisionTypeByDayResolvers< 7872 7878 ContextType = Context, 7873 7873 - ParentType extends 7874 7874 - GQLResolversParentTypes['CountByDecisionTypeByDay'] = GQLResolversParentTypes['CountByDecisionTypeByDay'], 7879 7879 + ParentType extends GQLResolversParentTypes['CountByDecisionTypeByDay'] = 7880 7880 + GQLResolversParentTypes['CountByDecisionTypeByDay'], 7875 7881 > = { 7876 7882 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 7877 7883 date?: Resolver<GQLResolversTypes['Date'], ParentType, ContextType>; ··· 7880 7886 7881 7887 export type GQLCountByPolicyByDayResolvers< 7882 7888 ContextType = Context, 7883 7883 - ParentType extends 7884 7884 - GQLResolversParentTypes['CountByPolicyByDay'] = GQLResolversParentTypes['CountByPolicyByDay'], 7889 7889 + ParentType extends GQLResolversParentTypes['CountByPolicyByDay'] = 7890 7890 + GQLResolversParentTypes['CountByPolicyByDay'], 7885 7891 > = { 7886 7892 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 7887 7893 date?: Resolver<GQLResolversTypes['Date'], ParentType, ContextType>; ··· 7894 7900 7895 7901 export type GQLCountByPolicyByDayPolicyResolvers< 7896 7902 ContextType = Context, 7897 7897 - ParentType extends 7898 7898 - GQLResolversParentTypes['CountByPolicyByDayPolicy'] = GQLResolversParentTypes['CountByPolicyByDayPolicy'], 7903 7903 + ParentType extends GQLResolversParentTypes['CountByPolicyByDayPolicy'] = 7904 7904 + GQLResolversParentTypes['CountByPolicyByDayPolicy'], 7899 7905 > = { 7900 7906 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; 7901 7907 name?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 7903 7909 7904 7910 export type GQLCountByTagByDayResolvers< 7905 7911 ContextType = Context, 7906 7906 - ParentType extends 7907 7907 - GQLResolversParentTypes['CountByTagByDay'] = GQLResolversParentTypes['CountByTagByDay'], 7912 7912 + ParentType extends GQLResolversParentTypes['CountByTagByDay'] = 7913 7913 + GQLResolversParentTypes['CountByTagByDay'], 7908 7914 > = { 7909 7915 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 7910 7916 date?: Resolver<GQLResolversTypes['Date'], ParentType, ContextType>; ··· 7913 7919 7914 7920 export type GQLCreateBacktestResponseResolvers< 7915 7921 ContextType = Context, 7916 7916 - ParentType extends 7917 7917 - GQLResolversParentTypes['CreateBacktestResponse'] = GQLResolversParentTypes['CreateBacktestResponse'], 7922 7922 + ParentType extends GQLResolversParentTypes['CreateBacktestResponse'] = 7923 7923 + GQLResolversParentTypes['CreateBacktestResponse'], 7918 7924 > = { 7919 7925 backtest?: Resolver<GQLResolversTypes['Backtest'], ParentType, ContextType>; 7920 7926 }; 7921 7927 7922 7928 export type GQLCreateContentRuleResponseResolvers< 7923 7929 ContextType = Context, 7924 7924 - ParentType extends 7925 7925 - GQLResolversParentTypes['CreateContentRuleResponse'] = GQLResolversParentTypes['CreateContentRuleResponse'], 7930 7930 + ParentType extends GQLResolversParentTypes['CreateContentRuleResponse'] = 7931 7931 + GQLResolversParentTypes['CreateContentRuleResponse'], 7926 7932 > = { 7927 7933 __resolveType: TypeResolveFn< 7928 7934 'MutateContentRuleSuccessResponse' | 'RuleNameExistsError', ··· 7934 7940 export type GQLCreateManualReviewQueueResponseResolvers< 7935 7941 ContextType = Context, 7936 7942 ParentType extends 7937 7937 - GQLResolversParentTypes['CreateManualReviewQueueResponse'] = GQLResolversParentTypes['CreateManualReviewQueueResponse'], 7943 7943 + GQLResolversParentTypes['CreateManualReviewQueueResponse'] = 7944 7944 + GQLResolversParentTypes['CreateManualReviewQueueResponse'], 7938 7945 > = { 7939 7946 __resolveType: TypeResolveFn< 7940 7947 | 'ManualReviewQueueNameExistsError' ··· 7946 7953 7947 7954 export type GQLCreateOrgResponseResolvers< 7948 7955 ContextType = Context, 7949 7949 - ParentType extends 7950 7950 - GQLResolversParentTypes['CreateOrgResponse'] = GQLResolversParentTypes['CreateOrgResponse'], 7956 7956 + ParentType extends GQLResolversParentTypes['CreateOrgResponse'] = 7957 7957 + GQLResolversParentTypes['CreateOrgResponse'], 7951 7958 > = { 7952 7959 __resolveType: TypeResolveFn< 7953 7960 | 'CreateOrgSuccessResponse' ··· 7960 7967 7961 7968 export type GQLCreateOrgSuccessResponseResolvers< 7962 7969 ContextType = Context, 7963 7963 - ParentType extends 7964 7964 - GQLResolversParentTypes['CreateOrgSuccessResponse'] = GQLResolversParentTypes['CreateOrgSuccessResponse'], 7970 7970 + ParentType extends GQLResolversParentTypes['CreateOrgSuccessResponse'] = 7971 7971 + GQLResolversParentTypes['CreateOrgSuccessResponse'], 7965 7972 > = { 7966 7973 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; 7967 7974 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 7969 7976 7970 7977 export type GQLCreateReportingRuleResponseResolvers< 7971 7978 ContextType = Context, 7972 7972 - ParentType extends 7973 7973 - GQLResolversParentTypes['CreateReportingRuleResponse'] = GQLResolversParentTypes['CreateReportingRuleResponse'], 7979 7979 + ParentType extends GQLResolversParentTypes['CreateReportingRuleResponse'] = 7980 7980 + GQLResolversParentTypes['CreateReportingRuleResponse'], 7974 7981 > = { 7975 7982 __resolveType: TypeResolveFn< 7976 7983 'MutateReportingRuleSuccessResponse' | 'ReportingRuleNameExistsError', ··· 7981 7988 7982 7989 export type GQLCreateRoutingRuleResponseResolvers< 7983 7990 ContextType = Context, 7984 7984 - ParentType extends 7985 7985 - GQLResolversParentTypes['CreateRoutingRuleResponse'] = GQLResolversParentTypes['CreateRoutingRuleResponse'], 7991 7991 + ParentType extends GQLResolversParentTypes['CreateRoutingRuleResponse'] = 7992 7992 + GQLResolversParentTypes['CreateRoutingRuleResponse'], 7986 7993 > = { 7987 7994 __resolveType: TypeResolveFn< 7988 7995 | 'MutateRoutingRuleSuccessResponse' ··· 7995 8002 7996 8003 export type GQLCreateUserRuleResponseResolvers< 7997 8004 ContextType = Context, 7998 7998 - ParentType extends 7999 7999 - GQLResolversParentTypes['CreateUserRuleResponse'] = GQLResolversParentTypes['CreateUserRuleResponse'], 8005 8005 + ParentType extends GQLResolversParentTypes['CreateUserRuleResponse'] = 8006 8006 + GQLResolversParentTypes['CreateUserRuleResponse'], 8000 8007 > = { 8001 8008 __resolveType: TypeResolveFn< 8002 8009 'MutateUserRuleSuccessResponse' | 'RuleNameExistsError', ··· 8005 8012 >; 8006 8013 }; 8007 8014 8008 8008 - export interface GQLCursorScalarConfig 8009 8009 - extends GraphQLScalarTypeConfig<GQLResolversTypes['Cursor'], any> { 8015 8015 + export interface GQLCursorScalarConfig extends GraphQLScalarTypeConfig< 8016 8016 + GQLResolversTypes['Cursor'], 8017 8017 + any 8018 8018 + > { 8010 8019 name: 'Cursor'; 8011 8020 } 8012 8021 8013 8022 export type GQLCustomActionResolvers< 8014 8023 ContextType = Context, 8015 8015 - ParentType extends 8016 8016 - GQLResolversParentTypes['CustomAction'] = GQLResolversParentTypes['CustomAction'], 8024 8024 + ParentType extends GQLResolversParentTypes['CustomAction'] = 8025 8025 + GQLResolversParentTypes['CustomAction'], 8017 8026 > = { 8018 8027 applyUserStrikes?: Resolver< 8019 8028 Maybe<GQLResolversTypes['Boolean']>, ··· 8059 8068 8060 8069 export type GQLCustomMrtApiParamSpecResolvers< 8061 8070 ContextType = Context, 8062 8062 - ParentType extends 8063 8063 - GQLResolversParentTypes['CustomMrtApiParamSpec'] = GQLResolversParentTypes['CustomMrtApiParamSpec'], 8071 8071 + ParentType extends GQLResolversParentTypes['CustomMrtApiParamSpec'] = 8072 8072 + GQLResolversParentTypes['CustomMrtApiParamSpec'], 8064 8073 > = { 8065 8074 displayName?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8066 8075 name?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8067 8076 type?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8068 8077 }; 8069 8078 8070 8070 - export interface GQLDateScalarConfig 8071 8071 - extends GraphQLScalarTypeConfig<GQLResolversTypes['Date'], any> { 8079 8079 + export interface GQLDateScalarConfig extends GraphQLScalarTypeConfig< 8080 8080 + GQLResolversTypes['Date'], 8081 8081 + any 8082 8082 + > { 8072 8083 name: 'Date'; 8073 8084 } 8074 8085 8075 8075 - export interface GQLDateTimeScalarConfig 8076 8076 - extends GraphQLScalarTypeConfig<GQLResolversTypes['DateTime'], any> { 8086 8086 + export interface GQLDateTimeScalarConfig extends GraphQLScalarTypeConfig< 8087 8087 + GQLResolversTypes['DateTime'], 8088 8088 + any 8089 8089 + > { 8077 8090 name: 'DateTime'; 8078 8091 } 8079 8092 8080 8093 export type GQLDecisionCountResolvers< 8081 8094 ContextType = Context, 8082 8082 - ParentType extends 8083 8083 - GQLResolversParentTypes['DecisionCount'] = GQLResolversParentTypes['DecisionCount'], 8095 8095 + ParentType extends GQLResolversParentTypes['DecisionCount'] = 8096 8096 + GQLResolversParentTypes['DecisionCount'], 8084 8097 > = { 8085 8098 action_id?: Resolver< 8086 8099 Maybe<GQLResolversTypes['String']>, ··· 8113 8126 8114 8127 export type GQLDecisionCountFilterByResolvers< 8115 8128 ContextType = Context, 8116 8116 - ParentType extends 8117 8117 - GQLResolversParentTypes['DecisionCountFilterBy'] = GQLResolversParentTypes['DecisionCountFilterBy'], 8129 8129 + ParentType extends GQLResolversParentTypes['DecisionCountFilterBy'] = 8130 8130 + GQLResolversParentTypes['DecisionCountFilterBy'], 8118 8131 > = { 8119 8132 actionIds?: Resolver< 8120 8133 ReadonlyArray<GQLResolversTypes['String']>, ··· 8157 8170 8158 8171 export type GQLDeleteAllJobsFromQueueResponseResolvers< 8159 8172 ContextType = Context, 8160 8160 - ParentType extends 8161 8161 - GQLResolversParentTypes['DeleteAllJobsFromQueueResponse'] = GQLResolversParentTypes['DeleteAllJobsFromQueueResponse'], 8173 8173 + ParentType extends GQLResolversParentTypes['DeleteAllJobsFromQueueResponse'] = 8174 8174 + GQLResolversParentTypes['DeleteAllJobsFromQueueResponse'], 8162 8175 > = { 8163 8176 __resolveType: TypeResolveFn< 8164 8177 'DeleteAllJobsFromQueueSuccessResponse' | 'DeleteAllJobsUnauthorizedError', ··· 8170 8183 export type GQLDeleteAllJobsFromQueueSuccessResponseResolvers< 8171 8184 ContextType = Context, 8172 8185 ParentType extends 8173 8173 - GQLResolversParentTypes['DeleteAllJobsFromQueueSuccessResponse'] = GQLResolversParentTypes['DeleteAllJobsFromQueueSuccessResponse'], 8186 8186 + GQLResolversParentTypes['DeleteAllJobsFromQueueSuccessResponse'] = 8187 8187 + GQLResolversParentTypes['DeleteAllJobsFromQueueSuccessResponse'], 8174 8188 > = { 8175 8189 _?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; 8176 8190 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 8178 8192 8179 8193 export type GQLDeleteAllJobsUnauthorizedErrorResolvers< 8180 8194 ContextType = Context, 8181 8181 - ParentType extends 8182 8182 - GQLResolversParentTypes['DeleteAllJobsUnauthorizedError'] = GQLResolversParentTypes['DeleteAllJobsUnauthorizedError'], 8195 8195 + ParentType extends GQLResolversParentTypes['DeleteAllJobsUnauthorizedError'] = 8196 8196 + GQLResolversParentTypes['DeleteAllJobsUnauthorizedError'], 8183 8197 > = { 8184 8198 detail?: Resolver< 8185 8199 Maybe<GQLResolversTypes['String']>, ··· 8208 8222 8209 8223 export type GQLDeleteItemTypeResponseResolvers< 8210 8224 ContextType = Context, 8211 8211 - ParentType extends 8212 8212 - GQLResolversParentTypes['DeleteItemTypeResponse'] = GQLResolversParentTypes['DeleteItemTypeResponse'], 8225 8225 + ParentType extends GQLResolversParentTypes['DeleteItemTypeResponse'] = 8226 8226 + GQLResolversParentTypes['DeleteItemTypeResponse'], 8213 8227 > = { 8214 8228 __resolveType: TypeResolveFn< 8215 8229 'CannotDeleteDefaultUserError' | 'DeleteItemTypeSuccessResponse', ··· 8220 8234 8221 8235 export type GQLDeleteItemTypeSuccessResponseResolvers< 8222 8236 ContextType = Context, 8223 8223 - ParentType extends 8224 8224 - GQLResolversParentTypes['DeleteItemTypeSuccessResponse'] = GQLResolversParentTypes['DeleteItemTypeSuccessResponse'], 8237 8237 + ParentType extends GQLResolversParentTypes['DeleteItemTypeSuccessResponse'] = 8238 8238 + GQLResolversParentTypes['DeleteItemTypeSuccessResponse'], 8225 8239 > = { 8226 8240 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 8227 8241 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 8229 8243 8230 8244 export type GQLDequeueManualReviewJobResponseResolvers< 8231 8245 ContextType = Context, 8232 8232 - ParentType extends 8233 8233 - GQLResolversParentTypes['DequeueManualReviewJobResponse'] = GQLResolversParentTypes['DequeueManualReviewJobResponse'], 8246 8246 + ParentType extends GQLResolversParentTypes['DequeueManualReviewJobResponse'] = 8247 8247 + GQLResolversParentTypes['DequeueManualReviewJobResponse'], 8234 8248 > = { 8235 8249 __resolveType: TypeResolveFn< 8236 8250 'DequeueManualReviewJobSuccessResponse', ··· 8242 8256 export type GQLDequeueManualReviewJobSuccessResponseResolvers< 8243 8257 ContextType = Context, 8244 8258 ParentType extends 8245 8245 - GQLResolversParentTypes['DequeueManualReviewJobSuccessResponse'] = GQLResolversParentTypes['DequeueManualReviewJobSuccessResponse'], 8259 8259 + GQLResolversParentTypes['DequeueManualReviewJobSuccessResponse'] = 8260 8260 + GQLResolversParentTypes['DequeueManualReviewJobSuccessResponse'], 8246 8261 > = { 8247 8262 job?: Resolver<GQLResolversTypes['ManualReviewJob'], ParentType, ContextType>; 8248 8263 lockToken?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 8252 8267 8253 8268 export type GQLDerivedFieldResolvers< 8254 8269 ContextType = Context, 8255 8255 - ParentType extends 8256 8256 - GQLResolversParentTypes['DerivedField'] = GQLResolversParentTypes['DerivedField'], 8270 8270 + ParentType extends GQLResolversParentTypes['DerivedField'] = 8271 8271 + GQLResolversParentTypes['DerivedField'], 8257 8272 > = { 8258 8273 container?: Resolver< 8259 8274 Maybe<GQLResolversTypes['Container']>, ··· 8272 8287 8273 8288 export type GQLDerivedFieldCoopInputSourceResolvers< 8274 8289 ContextType = Context, 8275 8275 - ParentType extends 8276 8276 - GQLResolversParentTypes['DerivedFieldCoopInputSource'] = GQLResolversParentTypes['DerivedFieldCoopInputSource'], 8290 8290 + ParentType extends GQLResolversParentTypes['DerivedFieldCoopInputSource'] = 8291 8291 + GQLResolversParentTypes['DerivedFieldCoopInputSource'], 8277 8292 > = { 8278 8293 name?: Resolver<GQLResolversTypes['CoopInput'], ParentType, ContextType>; 8279 8294 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 8281 8296 8282 8297 export type GQLDerivedFieldFieldSourceResolvers< 8283 8298 ContextType = Context, 8284 8284 - ParentType extends 8285 8285 - GQLResolversParentTypes['DerivedFieldFieldSource'] = GQLResolversParentTypes['DerivedFieldFieldSource'], 8299 8299 + ParentType extends GQLResolversParentTypes['DerivedFieldFieldSource'] = 8300 8300 + GQLResolversParentTypes['DerivedFieldFieldSource'], 8286 8301 > = { 8287 8302 contentTypeId?: Resolver< 8288 8303 GQLResolversTypes['String'], ··· 8295 8310 8296 8311 export type GQLDerivedFieldFullItemSourceResolvers< 8297 8312 ContextType = Context, 8298 8298 - ParentType extends 8299 8299 - GQLResolversParentTypes['DerivedFieldFullItemSource'] = GQLResolversParentTypes['DerivedFieldFullItemSource'], 8313 8313 + ParentType extends GQLResolversParentTypes['DerivedFieldFullItemSource'] = 8314 8314 + GQLResolversParentTypes['DerivedFieldFullItemSource'], 8300 8315 > = { 8301 8316 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 8302 8317 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 8304 8319 8305 8320 export type GQLDerivedFieldSourceResolvers< 8306 8321 ContextType = Context, 8307 8307 - ParentType extends 8308 8308 - GQLResolversParentTypes['DerivedFieldSource'] = GQLResolversParentTypes['DerivedFieldSource'], 8322 8322 + ParentType extends GQLResolversParentTypes['DerivedFieldSource'] = 8323 8323 + GQLResolversParentTypes['DerivedFieldSource'], 8309 8324 > = { 8310 8325 __resolveType: TypeResolveFn< 8311 8326 | 'DerivedFieldCoopInputSource' ··· 8318 8333 8319 8334 export type GQLDerivedFieldSpecResolvers< 8320 8335 ContextType = Context, 8321 8321 - ParentType extends 8322 8322 - GQLResolversParentTypes['DerivedFieldSpec'] = GQLResolversParentTypes['DerivedFieldSpec'], 8336 8336 + ParentType extends GQLResolversParentTypes['DerivedFieldSpec'] = 8337 8337 + GQLResolversParentTypes['DerivedFieldSpec'], 8323 8338 > = { 8324 8339 derivationType?: Resolver< 8325 8340 GQLResolversTypes['DerivedFieldDerivationType'], ··· 8335 8350 8336 8351 export type GQLDisabledInfoResolvers< 8337 8352 ContextType = Context, 8338 8338 - ParentType extends 8339 8339 - GQLResolversParentTypes['DisabledInfo'] = GQLResolversParentTypes['DisabledInfo'], 8353 8353 + ParentType extends GQLResolversParentTypes['DisabledInfo'] = 8354 8354 + GQLResolversParentTypes['DisabledInfo'], 8340 8355 > = { 8341 8356 disabled?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; 8342 8357 disabledMessage?: Resolver< ··· 8348 8363 8349 8364 export type GQLEnqueueAuthorToMrtActionResolvers< 8350 8365 ContextType = Context, 8351 8351 - ParentType extends 8352 8352 - GQLResolversParentTypes['EnqueueAuthorToMrtAction'] = GQLResolversParentTypes['EnqueueAuthorToMrtAction'], 8366 8366 + ParentType extends GQLResolversParentTypes['EnqueueAuthorToMrtAction'] = 8367 8367 + GQLResolversParentTypes['EnqueueAuthorToMrtAction'], 8353 8368 > = { 8354 8369 applyUserStrikes?: Resolver< 8355 8370 GQLResolversTypes['Boolean'], ··· 8379 8394 8380 8395 export type GQLEnqueueToMrtActionResolvers< 8381 8396 ContextType = Context, 8382 8382 - ParentType extends 8383 8383 - GQLResolversParentTypes['EnqueueToMrtAction'] = GQLResolversParentTypes['EnqueueToMrtAction'], 8397 8397 + ParentType extends GQLResolversParentTypes['EnqueueToMrtAction'] = 8398 8398 + GQLResolversParentTypes['EnqueueToMrtAction'], 8384 8399 > = { 8385 8400 applyUserStrikes?: Resolver< 8386 8401 Maybe<GQLResolversTypes['Boolean']>, ··· 8410 8425 8411 8426 export type GQLEnqueueToNcmecActionResolvers< 8412 8427 ContextType = Context, 8413 8413 - ParentType extends 8414 8414 - GQLResolversParentTypes['EnqueueToNcmecAction'] = GQLResolversParentTypes['EnqueueToNcmecAction'], 8428 8428 + ParentType extends GQLResolversParentTypes['EnqueueToNcmecAction'] = 8429 8429 + GQLResolversParentTypes['EnqueueToNcmecAction'], 8415 8430 > = { 8416 8431 applyUserStrikes?: Resolver< 8417 8432 Maybe<GQLResolversTypes['Boolean']>, ··· 8441 8456 8442 8457 export type GQLEnumSignalOutputTypeResolvers< 8443 8458 ContextType = Context, 8444 8444 - ParentType extends 8445 8445 - GQLResolversParentTypes['EnumSignalOutputType'] = GQLResolversParentTypes['EnumSignalOutputType'], 8459 8459 + ParentType extends GQLResolversParentTypes['EnumSignalOutputType'] = 8460 8460 + GQLResolversParentTypes['EnumSignalOutputType'], 8446 8461 > = { 8447 8462 enum?: Resolver< 8448 8463 ReadonlyArray<GQLResolversTypes['String']>, ··· 8460 8475 8461 8476 export type GQLErrorResolvers< 8462 8477 ContextType = Context, 8463 8463 - ParentType extends 8464 8464 - GQLResolversParentTypes['Error'] = GQLResolversParentTypes['Error'], 8478 8478 + ParentType extends GQLResolversParentTypes['Error'] = 8479 8479 + GQLResolversParentTypes['Error'], 8465 8480 > = { 8466 8481 __resolveType: TypeResolveFn< 8467 8482 | 'ActionNameExistsError' ··· 8508 8523 8509 8524 export type GQLExchangeApiInfoResolvers< 8510 8525 ContextType = Context, 8511 8511 - ParentType extends 8512 8512 - GQLResolversParentTypes['ExchangeApiInfo'] = GQLResolversParentTypes['ExchangeApiInfo'], 8526 8526 + ParentType extends GQLResolversParentTypes['ExchangeApiInfo'] = 8527 8527 + GQLResolversParentTypes['ExchangeApiInfo'], 8513 8528 > = { 8514 8529 has_auth?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; 8515 8530 name?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 8522 8537 8523 8538 export type GQLExchangeApiSchemaResolvers< 8524 8539 ContextType = Context, 8525 8525 - ParentType extends 8526 8526 - GQLResolversParentTypes['ExchangeApiSchema'] = GQLResolversParentTypes['ExchangeApiSchema'], 8540 8540 + ParentType extends GQLResolversParentTypes['ExchangeApiSchema'] = 8541 8541 + GQLResolversParentTypes['ExchangeApiSchema'], 8527 8542 > = { 8528 8543 config_schema?: Resolver< 8529 8544 GQLResolversTypes['ExchangeSchemaSection'], ··· 8539 8554 8540 8555 export type GQLExchangeFieldDescriptorResolvers< 8541 8556 ContextType = Context, 8542 8542 - ParentType extends 8543 8543 - GQLResolversParentTypes['ExchangeFieldDescriptor'] = GQLResolversParentTypes['ExchangeFieldDescriptor'], 8557 8557 + ParentType extends GQLResolversParentTypes['ExchangeFieldDescriptor'] = 8558 8558 + GQLResolversParentTypes['ExchangeFieldDescriptor'], 8544 8559 > = { 8545 8560 choices?: Resolver< 8546 8561 Maybe<ReadonlyArray<GQLResolversTypes['String']>>, ··· 8556 8571 8557 8572 export type GQLExchangeInfoResolvers< 8558 8573 ContextType = Context, 8559 8559 - ParentType extends 8560 8560 - GQLResolversParentTypes['ExchangeInfo'] = GQLResolversParentTypes['ExchangeInfo'], 8574 8574 + ParentType extends GQLResolversParentTypes['ExchangeInfo'] = 8575 8575 + GQLResolversParentTypes['ExchangeInfo'], 8561 8576 > = { 8562 8577 api?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8563 8578 enabled?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; ··· 8592 8607 8593 8608 export type GQLExchangeSchemaSectionResolvers< 8594 8609 ContextType = Context, 8595 8595 - ParentType extends 8596 8596 - GQLResolversParentTypes['ExchangeSchemaSection'] = GQLResolversParentTypes['ExchangeSchemaSection'], 8610 8610 + ParentType extends GQLResolversParentTypes['ExchangeSchemaSection'] = 8611 8611 + GQLResolversParentTypes['ExchangeSchemaSection'], 8597 8612 > = { 8598 8613 fields?: Resolver< 8599 8614 ReadonlyArray<GQLResolversTypes['ExchangeFieldDescriptor']>, ··· 8604 8619 8605 8620 export type GQLExecuteActionResponseResolvers< 8606 8621 ContextType = Context, 8607 8607 - ParentType extends 8608 8608 - GQLResolversParentTypes['ExecuteActionResponse'] = GQLResolversParentTypes['ExecuteActionResponse'], 8622 8622 + ParentType extends GQLResolversParentTypes['ExecuteActionResponse'] = 8623 8623 + GQLResolversParentTypes['ExecuteActionResponse'], 8609 8624 > = { 8610 8625 actionId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8611 8626 itemId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 8614 8629 8615 8630 export type GQLExecuteBulkActionResponseResolvers< 8616 8631 ContextType = Context, 8617 8617 - ParentType extends 8618 8618 - GQLResolversParentTypes['ExecuteBulkActionResponse'] = GQLResolversParentTypes['ExecuteBulkActionResponse'], 8632 8632 + ParentType extends GQLResolversParentTypes['ExecuteBulkActionResponse'] = 8633 8633 + GQLResolversParentTypes['ExecuteBulkActionResponse'], 8619 8634 > = { 8620 8635 results?: Resolver< 8621 8636 ReadonlyArray<GQLResolversTypes['ExecuteActionResponse']>, ··· 8626 8641 8627 8642 export type GQLFieldResolvers< 8628 8643 ContextType = Context, 8629 8629 - ParentType extends 8630 8630 - GQLResolversParentTypes['Field'] = GQLResolversParentTypes['Field'], 8644 8644 + ParentType extends GQLResolversParentTypes['Field'] = 8645 8645 + GQLResolversParentTypes['Field'], 8631 8646 > = { 8632 8647 __resolveType: TypeResolveFn< 8633 8648 'BaseField' | 'DerivedField', ··· 8638 8653 8639 8654 export type GQLGetDecisionCountSettingsResolvers< 8640 8655 ContextType = Context, 8641 8641 - ParentType extends 8642 8642 - GQLResolversParentTypes['GetDecisionCountSettings'] = GQLResolversParentTypes['GetDecisionCountSettings'], 8656 8656 + ParentType extends GQLResolversParentTypes['GetDecisionCountSettings'] = 8657 8657 + GQLResolversParentTypes['GetDecisionCountSettings'], 8643 8658 > = { 8644 8659 filterBy?: Resolver< 8645 8660 GQLResolversTypes['DecisionCountFilterBy'], ··· 8668 8683 export type GQLGetFullReportingRuleResultForItemResponseResolvers< 8669 8684 ContextType = Context, 8670 8685 ParentType extends 8671 8671 - GQLResolversParentTypes['GetFullReportingRuleResultForItemResponse'] = GQLResolversParentTypes['GetFullReportingRuleResultForItemResponse'], 8686 8686 + GQLResolversParentTypes['GetFullReportingRuleResultForItemResponse'] = 8687 8687 + GQLResolversParentTypes['GetFullReportingRuleResultForItemResponse'], 8672 8688 > = { 8673 8689 __resolveType: TypeResolveFn< 8674 8690 'NotFoundError' | 'ReportingRuleExecutionResult', ··· 8679 8695 8680 8696 export type GQLGetFullResultForItemResponseResolvers< 8681 8697 ContextType = Context, 8682 8682 - ParentType extends 8683 8683 - GQLResolversParentTypes['GetFullResultForItemResponse'] = GQLResolversParentTypes['GetFullResultForItemResponse'], 8698 8698 + ParentType extends GQLResolversParentTypes['GetFullResultForItemResponse'] = 8699 8699 + GQLResolversParentTypes['GetFullResultForItemResponse'], 8684 8700 > = { 8685 8701 __resolveType: TypeResolveFn< 8686 8702 'NotFoundError' | 'RuleExecutionResult', ··· 8691 8707 8692 8708 export type GQLGetJobCreationCountSettingsResolvers< 8693 8709 ContextType = Context, 8694 8694 - ParentType extends 8695 8695 - GQLResolversParentTypes['GetJobCreationCountSettings'] = GQLResolversParentTypes['GetJobCreationCountSettings'], 8710 8710 + ParentType extends GQLResolversParentTypes['GetJobCreationCountSettings'] = 8711 8711 + GQLResolversParentTypes['GetJobCreationCountSettings'], 8696 8712 > = { 8697 8713 filterBy?: Resolver< 8698 8714 GQLResolversTypes['JobCreationFilterBy'], ··· 8721 8737 export type GQLGoogleContentSafetyApiIntegrationApiCredentialResolvers< 8722 8738 ContextType = Context, 8723 8739 ParentType extends 8724 8724 - GQLResolversParentTypes['GoogleContentSafetyApiIntegrationApiCredential'] = GQLResolversParentTypes['GoogleContentSafetyApiIntegrationApiCredential'], 8740 8740 + GQLResolversParentTypes['GoogleContentSafetyApiIntegrationApiCredential'] = 8741 8741 + GQLResolversParentTypes['GoogleContentSafetyApiIntegrationApiCredential'], 8725 8742 > = { 8726 8743 apiKey?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8727 8744 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 8729 8746 8730 8747 export type GQLGooglePlaceLocationInfoResolvers< 8731 8748 ContextType = Context, 8732 8732 - ParentType extends 8733 8733 - GQLResolversParentTypes['GooglePlaceLocationInfo'] = GQLResolversParentTypes['GooglePlaceLocationInfo'], 8749 8749 + ParentType extends GQLResolversParentTypes['GooglePlaceLocationInfo'] = 8750 8750 + GQLResolversParentTypes['GooglePlaceLocationInfo'], 8734 8751 > = { 8735 8752 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; 8736 8753 }; 8737 8754 8738 8755 export type GQLHashBankResolvers< 8739 8756 ContextType = Context, 8740 8740 - ParentType extends 8741 8741 - GQLResolversParentTypes['HashBank'] = GQLResolversParentTypes['HashBank'], 8757 8757 + ParentType extends GQLResolversParentTypes['HashBank'] = 8758 8758 + GQLResolversParentTypes['HashBank'], 8742 8759 > = { 8743 8760 description?: Resolver< 8744 8761 Maybe<GQLResolversTypes['String']>, ··· 8759 8776 8760 8777 export type GQLIgnoreDecisionComponentResolvers< 8761 8778 ContextType = Context, 8762 8762 - ParentType extends 8763 8763 - GQLResolversParentTypes['IgnoreDecisionComponent'] = GQLResolversParentTypes['IgnoreDecisionComponent'], 8779 8779 + ParentType extends GQLResolversParentTypes['IgnoreDecisionComponent'] = 8780 8780 + GQLResolversParentTypes['IgnoreDecisionComponent'], 8764 8781 > = { 8765 8782 type?: Resolver< 8766 8783 GQLResolversTypes['ManualReviewDecisionType'], ··· 8772 8789 8773 8790 export type GQLIntegrationApiCredentialResolvers< 8774 8791 ContextType = Context, 8775 8775 - ParentType extends 8776 8776 - GQLResolversParentTypes['IntegrationApiCredential'] = GQLResolversParentTypes['IntegrationApiCredential'], 8792 8792 + ParentType extends GQLResolversParentTypes['IntegrationApiCredential'] = 8793 8793 + GQLResolversParentTypes['IntegrationApiCredential'], 8777 8794 > = { 8778 8795 __resolveType: TypeResolveFn< 8779 8796 | 'GoogleContentSafetyApiIntegrationApiCredential' ··· 8787 8804 8788 8805 export type GQLIntegrationConfigResolvers< 8789 8806 ContextType = Context, 8790 8790 - ParentType extends 8791 8791 - GQLResolversParentTypes['IntegrationConfig'] = GQLResolversParentTypes['IntegrationConfig'], 8807 8807 + ParentType extends GQLResolversParentTypes['IntegrationConfig'] = 8808 8808 + GQLResolversParentTypes['IntegrationConfig'], 8792 8809 > = { 8793 8810 apiCredential?: Resolver< 8794 8811 GQLResolversTypes['IntegrationApiCredential'], ··· 8823 8840 8824 8841 export type GQLIntegrationConfigQueryResponseResolvers< 8825 8842 ContextType = Context, 8826 8826 - ParentType extends 8827 8827 - GQLResolversParentTypes['IntegrationConfigQueryResponse'] = GQLResolversParentTypes['IntegrationConfigQueryResponse'], 8843 8843 + ParentType extends GQLResolversParentTypes['IntegrationConfigQueryResponse'] = 8844 8844 + GQLResolversParentTypes['IntegrationConfigQueryResponse'], 8828 8845 > = { 8829 8846 __resolveType: TypeResolveFn< 8830 8847 | 'IntegrationConfigSuccessResult' ··· 8836 8853 8837 8854 export type GQLIntegrationConfigSuccessResultResolvers< 8838 8855 ContextType = Context, 8839 8839 - ParentType extends 8840 8840 - GQLResolversParentTypes['IntegrationConfigSuccessResult'] = GQLResolversParentTypes['IntegrationConfigSuccessResult'], 8856 8856 + ParentType extends GQLResolversParentTypes['IntegrationConfigSuccessResult'] = 8857 8857 + GQLResolversParentTypes['IntegrationConfigSuccessResult'], 8841 8858 > = { 8842 8859 config?: Resolver< 8843 8860 Maybe<GQLResolversTypes['IntegrationConfig']>, ··· 8850 8867 export type GQLIntegrationConfigTooManyCredentialsErrorResolvers< 8851 8868 ContextType = Context, 8852 8869 ParentType extends 8853 8853 - GQLResolversParentTypes['IntegrationConfigTooManyCredentialsError'] = GQLResolversParentTypes['IntegrationConfigTooManyCredentialsError'], 8870 8870 + GQLResolversParentTypes['IntegrationConfigTooManyCredentialsError'] = 8871 8871 + GQLResolversParentTypes['IntegrationConfigTooManyCredentialsError'], 8854 8872 > = { 8855 8873 detail?: Resolver< 8856 8874 Maybe<GQLResolversTypes['String']>, ··· 8880 8898 export type GQLIntegrationConfigUnsupportedIntegrationErrorResolvers< 8881 8899 ContextType = Context, 8882 8900 ParentType extends 8883 8883 - GQLResolversParentTypes['IntegrationConfigUnsupportedIntegrationError'] = GQLResolversParentTypes['IntegrationConfigUnsupportedIntegrationError'], 8901 8901 + GQLResolversParentTypes['IntegrationConfigUnsupportedIntegrationError'] = 8902 8902 + GQLResolversParentTypes['IntegrationConfigUnsupportedIntegrationError'], 8884 8903 > = { 8885 8904 detail?: Resolver< 8886 8905 Maybe<GQLResolversTypes['String']>, ··· 8910 8929 export type GQLIntegrationEmptyInputCredentialsErrorResolvers< 8911 8930 ContextType = Context, 8912 8931 ParentType extends 8913 8913 - GQLResolversParentTypes['IntegrationEmptyInputCredentialsError'] = GQLResolversParentTypes['IntegrationEmptyInputCredentialsError'], 8932 8932 + GQLResolversParentTypes['IntegrationEmptyInputCredentialsError'] = 8933 8933 + GQLResolversParentTypes['IntegrationEmptyInputCredentialsError'], 8914 8934 > = { 8915 8935 detail?: Resolver< 8916 8936 Maybe<GQLResolversTypes['String']>, ··· 8939 8959 8940 8960 export type GQLIntegrationMetadataResolvers< 8941 8961 ContextType = Context, 8942 8942 - ParentType extends 8943 8943 - GQLResolversParentTypes['IntegrationMetadata'] = GQLResolversParentTypes['IntegrationMetadata'], 8962 8962 + ParentType extends GQLResolversParentTypes['IntegrationMetadata'] = 8963 8963 + GQLResolversParentTypes['IntegrationMetadata'], 8944 8964 > = { 8945 8965 docsUrl?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 8946 8966 logoUrl?: Resolver< ··· 8965 8985 export type GQLIntegrationNoInputCredentialsErrorResolvers< 8966 8986 ContextType = Context, 8967 8987 ParentType extends 8968 8968 - GQLResolversParentTypes['IntegrationNoInputCredentialsError'] = GQLResolversParentTypes['IntegrationNoInputCredentialsError'], 8988 8988 + GQLResolversParentTypes['IntegrationNoInputCredentialsError'] = 8989 8989 + GQLResolversParentTypes['IntegrationNoInputCredentialsError'], 8969 8990 > = { 8970 8991 detail?: Resolver< 8971 8992 Maybe<GQLResolversTypes['String']>, ··· 8994 9015 8995 9016 export type GQLInviteUserTokenResolvers< 8996 9017 ContextType = Context, 8997 8997 - ParentType extends 8998 8998 - GQLResolversParentTypes['InviteUserToken'] = GQLResolversParentTypes['InviteUserToken'], 9018 9018 + ParentType extends GQLResolversParentTypes['InviteUserToken'] = 9019 9019 + GQLResolversParentTypes['InviteUserToken'], 8999 9020 > = { 9000 9021 email?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 9001 9022 orgId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 9006 9027 9007 9028 export type GQLInviteUserTokenExpiredErrorResolvers< 9008 9029 ContextType = Context, 9009 9009 - ParentType extends 9010 9010 - GQLResolversParentTypes['InviteUserTokenExpiredError'] = GQLResolversParentTypes['InviteUserTokenExpiredError'], 9030 9030 + ParentType extends GQLResolversParentTypes['InviteUserTokenExpiredError'] = 9031 9031 + GQLResolversParentTypes['InviteUserTokenExpiredError'], 9011 9032 > = { 9012 9033 detail?: Resolver< 9013 9034 Maybe<GQLResolversTypes['String']>, ··· 9036 9057 9037 9058 export type GQLInviteUserTokenMissingErrorResolvers< 9038 9059 ContextType = Context, 9039 9039 - ParentType extends 9040 9040 - GQLResolversParentTypes['InviteUserTokenMissingError'] = GQLResolversParentTypes['InviteUserTokenMissingError'], 9060 9060 + ParentType extends GQLResolversParentTypes['InviteUserTokenMissingError'] = 9061 9061 + GQLResolversParentTypes['InviteUserTokenMissingError'], 9041 9062 > = { 9042 9063 detail?: Resolver< 9043 9064 Maybe<GQLResolversTypes['String']>, ··· 9066 9087 9067 9088 export type GQLInviteUserTokenResponseResolvers< 9068 9089 ContextType = Context, 9069 9069 - ParentType extends 9070 9070 - GQLResolversParentTypes['InviteUserTokenResponse'] = GQLResolversParentTypes['InviteUserTokenResponse'], 9090 9090 + ParentType extends GQLResolversParentTypes['InviteUserTokenResponse'] = 9091 9091 + GQLResolversParentTypes['InviteUserTokenResponse'], 9071 9092 > = { 9072 9093 __resolveType: TypeResolveFn< 9073 9094 | 'InviteUserTokenExpiredError' ··· 9080 9101 9081 9102 export type GQLInviteUserTokenSuccessResponseResolvers< 9082 9103 ContextType = Context, 9083 9083 - ParentType extends 9084 9084 - GQLResolversParentTypes['InviteUserTokenSuccessResponse'] = GQLResolversParentTypes['InviteUserTokenSuccessResponse'], 9104 9104 + ParentType extends GQLResolversParentTypes['InviteUserTokenSuccessResponse'] = 9105 9105 + GQLResolversParentTypes['InviteUserTokenSuccessResponse'], 9085 9106 > = { 9086 9107 tokenData?: Resolver< 9087 9108 GQLResolversTypes['InviteUserToken'], ··· 9093 9114 9094 9115 export type GQLIpAddressResolvers< 9095 9116 ContextType = Context, 9096 9096 - ParentType extends 9097 9097 - GQLResolversParentTypes['IpAddress'] = GQLResolversParentTypes['IpAddress'], 9117 9117 + ParentType extends GQLResolversParentTypes['IpAddress'] = 9118 9118 + GQLResolversParentTypes['IpAddress'], 9098 9119 > = { 9099 9120 ip?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 9100 9121 port?: Resolver<Maybe<GQLResolversTypes['Int']>, ParentType, ContextType>; ··· 9102 9123 9103 9124 export type GQLItemResolvers< 9104 9125 ContextType = Context, 9105 9105 - ParentType extends 9106 9106 - GQLResolversParentTypes['Item'] = GQLResolversParentTypes['Item'], 9126 9126 + ParentType extends GQLResolversParentTypes['Item'] = 9127 9127 + GQLResolversParentTypes['Item'], 9107 9128 > = { 9108 9129 __resolveType: TypeResolveFn< 9109 9130 'ContentItem' | 'ThreadItem' | 'UserItem', ··· 9114 9135 9115 9136 export type GQLItemActionResolvers< 9116 9137 ContextType = Context, 9117 9117 - ParentType extends 9118 9118 - GQLResolversParentTypes['ItemAction'] = GQLResolversParentTypes['ItemAction'], 9138 9138 + ParentType extends GQLResolversParentTypes['ItemAction'] = 9139 9139 + GQLResolversParentTypes['ItemAction'], 9119 9140 > = { 9120 9141 actionId?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; 9121 9142 actorId?: Resolver<Maybe<GQLResolversTypes['ID']>, ParentType, ContextType>; ··· 9147 9168 9148 9169 export type GQLItemBaseResolvers< 9149 9170 ContextType = Context, 9150 9150 - ParentType extends 9151 9151 - GQLResolversParentTypes['ItemBase'] = GQLResolversParentTypes['ItemBase'], 9171 9171 + ParentType extends GQLResolversParentTypes['ItemBase'] = 9172 9172 + GQLResolversParentTypes['ItemBase'], 9152 9173 > = { 9153 9174 __resolveType: TypeResolveFn< 9154 9175 'ContentItem' | 'ThreadItem' | 'UserItem', ··· 9159 9180 9160 9181 export type GQLItemHistoryResponseResolvers< 9161 9182 ContextType = Context, 9162 9162 - ParentType extends 9163 9163 - GQLResolversParentTypes['ItemHistoryResponse'] = GQLResolversParentTypes['ItemHistoryResponse'], 9183 9183 + ParentType extends GQLResolversParentTypes['ItemHistoryResponse'] = 9184 9184 + GQLResolversParentTypes['ItemHistoryResponse'], 9164 9185 > = { 9165 9186 __resolveType: TypeResolveFn< 9166 9187 'ItemHistoryResult' | 'NotFoundError', ··· 9171 9192 9172 9193 export type GQLItemHistoryResultResolvers< 9173 9194 ContextType = Context, 9174 9174 - ParentType extends 9175 9175 - GQLResolversParentTypes['ItemHistoryResult'] = GQLResolversParentTypes['ItemHistoryResult'], 9195 9195 + ParentType extends GQLResolversParentTypes['ItemHistoryResult'] = 9196 9196 + GQLResolversParentTypes['ItemHistoryResult'], 9176 9197 > = { 9177 9198 executions?: Resolver< 9178 9199 ReadonlyArray<GQLResolversTypes['RuleExecutionResult']>, ··· 9185 9206 9186 9207 export type GQLItemIdentifierResolvers< 9187 9208 ContextType = Context, 9188 9188 - ParentType extends 9189 9189 - GQLResolversParentTypes['ItemIdentifier'] = GQLResolversParentTypes['ItemIdentifier'], 9209 9209 + ParentType extends GQLResolversParentTypes['ItemIdentifier'] = 9210 9210 + GQLResolversParentTypes['ItemIdentifier'], 9190 9211 > = { 9191 9212 id?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 9192 9213 typeId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 9194 9215 9195 9216 export type GQLItemSubmissionsResolvers< 9196 9217 ContextType = Context, 9197 9197 - ParentType extends 9198 9198 - GQLResolversParentTypes['ItemSubmissions'] = GQLResolversParentTypes['ItemSubmissions'], 9218 9218 + ParentType extends GQLResolversParentTypes['ItemSubmissions'] = 9219 9219 + GQLResolversParentTypes['ItemSubmissions'], 9199 9220 > = { 9200 9221 latest?: Resolver<GQLResolversTypes['Item'], ParentType, ContextType>; 9201 9222 prior?: Resolver< ··· 9207 9228 9208 9229 export type GQLItemTypeResolvers< 9209 9230 ContextType = Context, 9210 9210 - ParentType extends 9211 9211 - GQLResolversParentTypes['ItemType'] = GQLResolversParentTypes['ItemType'], 9231 9231 + ParentType extends GQLResolversParentTypes['ItemType'] = 9232 9232 + GQLResolversParentTypes['ItemType'], 9212 9233 > = { 9213 9234 __resolveType: TypeResolveFn< 9214 9235 'ContentItemType' | 'ThreadItemType' | 'UserItemType', ··· 9219 9240 9220 9241 export type GQLItemTypeBaseResolvers< 9221 9242 ContextType = Context, 9222 9222 - ParentType extends 9223 9223 - GQLResolversParentTypes['ItemTypeBase'] = GQLResolversParentTypes['ItemTypeBase'], 9243 9243 + ParentType extends GQLResolversParentTypes['ItemTypeBase'] = 9244 9244 + GQLResolversParentTypes['ItemTypeBase'], 9224 9245 > = { 9225 9246 __resolveType: TypeResolveFn< 9226 9247 'ContentItemType' | 'ThreadItemType' | 'UserItemType', ··· 9231 9252 9232 9253 export type GQLItemTypeIdentifierResolvers< 9233 9254 ContextType = Context, 9234 9234 - ParentType extends 9235 9235 - GQLResolversParentTypes['ItemTypeIdentifier'] = GQLResolversParentTypes['ItemTypeIdentifier'], 9255 9255 + ParentType extends GQLResolversParentTypes['ItemTypeIdentifier'] = 9256 9256 + GQLResolversParentTypes['ItemTypeIdentifier'], 9236 9257 > = { 9237 9258 id?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 9238 9259 schemaVariant?: Resolver< ··· 9249 9270 9250 9271 export type GQLItemTypeNameAlreadyExistsErrorResolvers< 9251 9272 ContextType = Context, 9252 9252 - ParentType extends 9253 9253 - GQLResolversParentTypes['ItemTypeNameAlreadyExistsError'] = GQLResolversParentTypes['ItemTypeNameAlreadyExistsError'], 9273 9273 + ParentType extends GQLResolversParentTypes['ItemTypeNameAlreadyExistsError'] = 9274 9274 + GQLResolversParentTypes['ItemTypeNameAlreadyExistsError'], 9254 9275 > = { 9255 9276 detail?: Resolver< 9256 9277 Maybe<GQLResolversTypes['String']>, ··· 9289 9310 9290 9311 export type GQLItemWithParentsResolvers< 9291 9312 ContextType = Context, 9292 9292 - ParentType extends 9293 9293 - GQLResolversParentTypes['ItemWithParents'] = GQLResolversParentTypes['ItemWithParents'], 9313 9313 + ParentType extends GQLResolversParentTypes['ItemWithParents'] = 9314 9314 + GQLResolversParentTypes['ItemWithParents'], 9294 9315 > = { 9295 9316 item?: Resolver< 9296 9317 GQLResolversTypes['ItemSubmissions'], ··· 9304 9325 >; 9305 9326 }; 9306 9327 9307 9307 - export interface GQLJsonScalarConfig 9308 9308 - extends GraphQLScalarTypeConfig<GQLResolversTypes['JSON'], any> { 9328 9328 + export interface GQLJsonScalarConfig extends GraphQLScalarTypeConfig< 9329 9329 + GQLResolversTypes['JSON'], 9330 9330 + any 9331 9331 + > { 9309 9332 name: 'JSON'; 9310 9333 } 9311 9334 9312 9312 - export interface GQLJsonObjectScalarConfig 9313 9313 - extends GraphQLScalarTypeConfig<GQLResolversTypes['JSONObject'], any> { 9335 9335 + export interface GQLJsonObjectScalarConfig extends GraphQLScalarTypeConfig< 9336 9336 + GQLResolversTypes['JSONObject'], 9337 9337 + any 9338 9338 + > { 9314 9339 name: 'JSONObject'; 9315 9340 } 9316 9341 9317 9342 export type GQLJobCreationCountResolvers< 9318 9343 ContextType = Context, 9319 9319 - ParentType extends 9320 9320 - GQLResolversParentTypes['JobCreationCount'] = GQLResolversParentTypes['JobCreationCount'], 9344 9344 + ParentType extends GQLResolversParentTypes['JobCreationCount'] = 9345 9345 + GQLResolversParentTypes['JobCreationCount'], 9321 9346 > = { 9322 9347 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 9323 9348 itemTypeId?: Resolver< ··· 9350 9375 9351 9376 export type GQLJobCreationFilterByResolvers< 9352 9377 ContextType = Context, 9353 9353 - ParentType extends 9354 9354 - GQLResolversParentTypes['JobCreationFilterBy'] = GQLResolversParentTypes['JobCreationFilterBy'], 9378 9378 + ParentType extends GQLResolversParentTypes['JobCreationFilterBy'] = 9379 9379 + GQLResolversParentTypes['JobCreationFilterBy'], 9355 9380 > = { 9356 9381 endDate?: Resolver<GQLResolversTypes['DateTime'], ParentType, ContextType>; 9357 9382 itemTypeIds?: Resolver< ··· 9385 9410 export type GQLJobHasAlreadyBeenSubmittedErrorResolvers< 9386 9411 ContextType = Context, 9387 9412 ParentType extends 9388 9388 - GQLResolversParentTypes['JobHasAlreadyBeenSubmittedError'] = GQLResolversParentTypes['JobHasAlreadyBeenSubmittedError'], 9413 9413 + GQLResolversParentTypes['JobHasAlreadyBeenSubmittedError'] = 9414 9414 + GQLResolversParentTypes['JobHasAlreadyBeenSubmittedError'], 9389 9415 > = { 9390 9416 detail?: Resolver< 9391 9417 Maybe<GQLResolversTypes['String']>, ··· 9414 9440 9415 9441 export type GQLLanguagesResolvers< 9416 9442 ContextType = Context, 9417 9417 - ParentType extends 9418 9418 - GQLResolversParentTypes['Languages'] = GQLResolversParentTypes['Languages'], 9443 9443 + ParentType extends GQLResolversParentTypes['Languages'] = 9444 9444 + GQLResolversParentTypes['Languages'], 9419 9445 > = { 9420 9446 languages?: Resolver< 9421 9447 ReadonlyArray<GQLResolversTypes['Language']>, ··· 9427 9453 9428 9454 export type GQLLatLngResolvers< 9429 9455 ContextType = Context, 9430 9430 - ParentType extends 9431 9431 - GQLResolversParentTypes['LatLng'] = GQLResolversParentTypes['LatLng'], 9456 9456 + ParentType extends GQLResolversParentTypes['LatLng'] = 9457 9457 + GQLResolversParentTypes['LatLng'], 9432 9458 > = { 9433 9459 lat?: Resolver<GQLResolversTypes['Float'], ParentType, ContextType>; 9434 9460 lng?: Resolver<GQLResolversTypes['Float'], ParentType, ContextType>; ··· 9436 9462 9437 9463 export type GQLLeafConditionResolvers< 9438 9464 ContextType = Context, 9439 9439 - ParentType extends 9440 9440 - GQLResolversParentTypes['LeafCondition'] = GQLResolversParentTypes['LeafCondition'], 9465 9465 + ParentType extends GQLResolversParentTypes['LeafCondition'] = 9466 9466 + GQLResolversParentTypes['LeafCondition'], 9441 9467 > = { 9442 9468 comparator?: Resolver< 9443 9469 Maybe<GQLResolversTypes['ValueComparator']>, ··· 9469 9495 9470 9496 export type GQLLeafConditionWithResultResolvers< 9471 9497 ContextType = Context, 9472 9472 - ParentType extends 9473 9473 - GQLResolversParentTypes['LeafConditionWithResult'] = GQLResolversParentTypes['LeafConditionWithResult'], 9498 9498 + ParentType extends GQLResolversParentTypes['LeafConditionWithResult'] = 9499 9499 + GQLResolversParentTypes['LeafConditionWithResult'], 9474 9500 > = { 9475 9501 comparator?: Resolver< 9476 9502 Maybe<GQLResolversTypes['ValueComparator']>, ··· 9507 9533 9508 9534 export type GQLLocationAreaResolvers< 9509 9535 ContextType = Context, 9510 9510 - ParentType extends 9511 9511 - GQLResolversParentTypes['LocationArea'] = GQLResolversParentTypes['LocationArea'], 9536 9536 + ParentType extends GQLResolversParentTypes['LocationArea'] = 9537 9537 + GQLResolversParentTypes['LocationArea'], 9512 9538 > = { 9513 9539 bounds?: Resolver< 9514 9540 Maybe<GQLResolversTypes['PlaceBounds']>, ··· 9531 9557 9532 9558 export type GQLLocationBankResolvers< 9533 9559 ContextType = Context, 9534 9534 - ParentType extends 9535 9535 - GQLResolversParentTypes['LocationBank'] = GQLResolversParentTypes['LocationBank'], 9560 9560 + ParentType extends GQLResolversParentTypes['LocationBank'] = 9561 9561 + GQLResolversParentTypes['LocationBank'], 9536 9562 > = { 9537 9563 description?: Resolver< 9538 9564 Maybe<GQLResolversTypes['String']>, ··· 9550 9576 9551 9577 export type GQLLocationBankNameExistsErrorResolvers< 9552 9578 ContextType = Context, 9553 9553 - ParentType extends 9554 9554 - GQLResolversParentTypes['LocationBankNameExistsError'] = GQLResolversParentTypes['LocationBankNameExistsError'], 9579 9579 + ParentType extends GQLResolversParentTypes['LocationBankNameExistsError'] = 9580 9580 + GQLResolversParentTypes['LocationBankNameExistsError'], 9555 9581 > = { 9556 9582 detail?: Resolver< 9557 9583 Maybe<GQLResolversTypes['String']>, ··· 9580 9606 9581 9607 export type GQLLocationGeometryResolvers< 9582 9608 ContextType = Context, 9583 9583 - ParentType extends 9584 9584 - GQLResolversParentTypes['LocationGeometry'] = GQLResolversParentTypes['LocationGeometry'], 9609 9609 + ParentType extends GQLResolversParentTypes['LocationGeometry'] = 9610 9610 + GQLResolversParentTypes['LocationGeometry'], 9585 9611 > = { 9586 9612 center?: Resolver<GQLResolversTypes['LatLng'], ParentType, ContextType>; 9587 9613 radius?: Resolver<GQLResolversTypes['Float'], ParentType, ContextType>; ··· 9589 9615 9590 9616 export type GQLLoginIncorrectPasswordErrorResolvers< 9591 9617 ContextType = Context, 9592 9592 - ParentType extends 9593 9593 - GQLResolversParentTypes['LoginIncorrectPasswordError'] = GQLResolversParentTypes['LoginIncorrectPasswordError'], 9618 9618 + ParentType extends GQLResolversParentTypes['LoginIncorrectPasswordError'] = 9619 9619 + GQLResolversParentTypes['LoginIncorrectPasswordError'], 9594 9620 > = { 9595 9621 detail?: Resolver< 9596 9622 Maybe<GQLResolversTypes['String']>, ··· 9619 9645 9620 9646 export type GQLLoginResponseResolvers< 9621 9647 ContextType = Context, 9622 9622 - ParentType extends 9623 9623 - GQLResolversParentTypes['LoginResponse'] = GQLResolversParentTypes['LoginResponse'], 9648 9648 + ParentType extends GQLResolversParentTypes['LoginResponse'] = 9649 9649 + GQLResolversParentTypes['LoginResponse'], 9624 9650 > = { 9625 9651 __resolveType: TypeResolveFn< 9626 9652 | 'LoginIncorrectPasswordError' ··· 9634 9660 9635 9661 export type GQLLoginSsoRequiredErrorResolvers< 9636 9662 ContextType = Context, 9637 9637 - ParentType extends 9638 9638 - GQLResolversParentTypes['LoginSsoRequiredError'] = GQLResolversParentTypes['LoginSsoRequiredError'], 9663 9663 + ParentType extends GQLResolversParentTypes['LoginSsoRequiredError'] = 9664 9664 + GQLResolversParentTypes['LoginSsoRequiredError'], 9639 9665 > = { 9640 9666 detail?: Resolver< 9641 9667 Maybe<GQLResolversTypes['String']>, ··· 9664 9690 9665 9691 export type GQLLoginSuccessResponseResolvers< 9666 9692 ContextType = Context, 9667 9667 - ParentType extends 9668 9668 - GQLResolversParentTypes['LoginSuccessResponse'] = GQLResolversParentTypes['LoginSuccessResponse'], 9693 9693 + ParentType extends GQLResolversParentTypes['LoginSuccessResponse'] = 9694 9694 + GQLResolversParentTypes['LoginSuccessResponse'], 9669 9695 > = { 9670 9696 user?: Resolver<GQLResolversTypes['User'], ParentType, ContextType>; 9671 9697 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 9673 9699 9674 9700 export type GQLLoginUserDoesNotExistErrorResolvers< 9675 9701 ContextType = Context, 9676 9676 - ParentType extends 9677 9677 - GQLResolversParentTypes['LoginUserDoesNotExistError'] = GQLResolversParentTypes['LoginUserDoesNotExistError'], 9702 9702 + ParentType extends GQLResolversParentTypes['LoginUserDoesNotExistError'] = 9703 9703 + GQLResolversParentTypes['LoginUserDoesNotExistError'], 9678 9704 > = { 9679 9705 detail?: Resolver< 9680 9706 Maybe<GQLResolversTypes['String']>, ··· 9703 9729 9704 9730 export type GQLManualReviewChartSettingsResolvers< 9705 9731 ContextType = Context, 9706 9706 - ParentType extends 9707 9707 - GQLResolversParentTypes['ManualReviewChartSettings'] = GQLResolversParentTypes['ManualReviewChartSettings'], 9732 9732 + ParentType extends GQLResolversParentTypes['ManualReviewChartSettings'] = 9733 9733 + GQLResolversParentTypes['ManualReviewChartSettings'], 9708 9734 > = { 9709 9735 __resolveType: TypeResolveFn< 9710 9736 'GetDecisionCountSettings' | 'GetJobCreationCountSettings', ··· 9715 9741 9716 9742 export type GQLManualReviewDecisionResolvers< 9717 9743 ContextType = Context, 9718 9718 - ParentType extends 9719 9719 - GQLResolversParentTypes['ManualReviewDecision'] = GQLResolversParentTypes['ManualReviewDecision'], 9744 9744 + ParentType extends GQLResolversParentTypes['ManualReviewDecision'] = 9745 9745 + GQLResolversParentTypes['ManualReviewDecision'], 9720 9746 > = { 9721 9747 createdAt?: Resolver<GQLResolversTypes['DateTime'], ParentType, ContextType>; 9722 9748 decisionReason?: Resolver< ··· 9756 9782 9757 9783 export type GQLManualReviewDecisionComponentResolvers< 9758 9784 ContextType = Context, 9759 9759 - ParentType extends 9760 9760 - GQLResolversParentTypes['ManualReviewDecisionComponent'] = GQLResolversParentTypes['ManualReviewDecisionComponent'], 9785 9785 + ParentType extends GQLResolversParentTypes['ManualReviewDecisionComponent'] = 9786 9786 + GQLResolversParentTypes['ManualReviewDecisionComponent'], 9761 9787 > = { 9762 9788 __resolveType: TypeResolveFn< 9763 9789 | 'AcceptAppealDecisionComponent' ··· 9775 9801 export type GQLManualReviewDecisionComponentBaseResolvers< 9776 9802 ContextType = Context, 9777 9803 ParentType extends 9778 9778 - GQLResolversParentTypes['ManualReviewDecisionComponentBase'] = GQLResolversParentTypes['ManualReviewDecisionComponentBase'], 9804 9804 + GQLResolversParentTypes['ManualReviewDecisionComponentBase'] = 9805 9805 + GQLResolversParentTypes['ManualReviewDecisionComponentBase'], 9779 9806 > = { 9780 9807 __resolveType: TypeResolveFn< 9781 9808 | 'AcceptAppealDecisionComponent' ··· 9792 9819 9793 9820 export type GQLManualReviewExistingJobResolvers< 9794 9821 ContextType = Context, 9795 9795 - ParentType extends 9796 9796 - GQLResolversParentTypes['ManualReviewExistingJob'] = GQLResolversParentTypes['ManualReviewExistingJob'], 9822 9822 + ParentType extends GQLResolversParentTypes['ManualReviewExistingJob'] = 9823 9823 + GQLResolversParentTypes['ManualReviewExistingJob'], 9797 9824 > = { 9798 9825 job?: Resolver<GQLResolversTypes['ManualReviewJob'], ParentType, ContextType>; 9799 9826 queueId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 9801 9828 9802 9829 export type GQLManualReviewJobResolvers< 9803 9830 ContextType = Context, 9804 9804 - ParentType extends 9805 9805 - GQLResolversParentTypes['ManualReviewJob'] = GQLResolversParentTypes['ManualReviewJob'], 9831 9831 + ParentType extends GQLResolversParentTypes['ManualReviewJob'] = 9832 9832 + GQLResolversParentTypes['ManualReviewJob'], 9806 9833 > = { 9807 9834 comments?: Resolver< 9808 9835 ReadonlyArray<GQLResolversTypes['ManualReviewJobComment']>, ··· 9830 9857 9831 9858 export type GQLManualReviewJobCommentResolvers< 9832 9859 ContextType = Context, 9833 9833 - ParentType extends 9834 9834 - GQLResolversParentTypes['ManualReviewJobComment'] = GQLResolversParentTypes['ManualReviewJobComment'], 9860 9860 + ParentType extends GQLResolversParentTypes['ManualReviewJobComment'] = 9861 9861 + GQLResolversParentTypes['ManualReviewJobComment'], 9835 9862 > = { 9836 9863 author?: Resolver<GQLResolversTypes['User'], ParentType, ContextType>; 9837 9864 commentText?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 9842 9869 export type GQLManualReviewJobEnqueueSourceInfoResolvers< 9843 9870 ContextType = Context, 9844 9871 ParentType extends 9845 9845 - GQLResolversParentTypes['ManualReviewJobEnqueueSourceInfo'] = GQLResolversParentTypes['ManualReviewJobEnqueueSourceInfo'], 9872 9872 + GQLResolversParentTypes['ManualReviewJobEnqueueSourceInfo'] = 9873 9873 + GQLResolversParentTypes['ManualReviewJobEnqueueSourceInfo'], 9846 9874 > = { 9847 9875 __resolveType: TypeResolveFn< 9848 9876 | 'AppealEnqueueSourceInfo' ··· 9857 9885 9858 9886 export type GQLManualReviewJobPayloadResolvers< 9859 9887 ContextType = Context, 9860 9860 - ParentType extends 9861 9861 - GQLResolversParentTypes['ManualReviewJobPayload'] = GQLResolversParentTypes['ManualReviewJobPayload'], 9888 9888 + ParentType extends GQLResolversParentTypes['ManualReviewJobPayload'] = 9889 9889 + GQLResolversParentTypes['ManualReviewJobPayload'], 9862 9890 > = { 9863 9891 __resolveType: TypeResolveFn< 9864 9892 | 'ContentAppealManualReviewJobPayload' ··· 9875 9903 9876 9904 export type GQLManualReviewJobWithDecisionsResolvers< 9877 9905 ContextType = Context, 9878 9878 - ParentType extends 9879 9879 - GQLResolversParentTypes['ManualReviewJobWithDecisions'] = GQLResolversParentTypes['ManualReviewJobWithDecisions'], 9906 9906 + ParentType extends GQLResolversParentTypes['ManualReviewJobWithDecisions'] = 9907 9907 + GQLResolversParentTypes['ManualReviewJobWithDecisions'], 9880 9908 > = { 9881 9909 decision?: Resolver< 9882 9910 GQLResolversTypes['ManualReviewDecision'], ··· 9888 9916 9889 9917 export type GQLManualReviewQueueResolvers< 9890 9918 ContextType = Context, 9891 9891 - ParentType extends 9892 9892 - GQLResolversParentTypes['ManualReviewQueue'] = GQLResolversParentTypes['ManualReviewQueue'], 9919 9919 + ParentType extends GQLResolversParentTypes['ManualReviewQueue'] = 9920 9920 + GQLResolversParentTypes['ManualReviewQueue'], 9893 9921 > = { 9894 9922 autoCloseJobs?: Resolver< 9895 9923 GQLResolversTypes['Boolean'], ··· 9941 9969 export type GQLManualReviewQueueNameExistsErrorResolvers< 9942 9970 ContextType = Context, 9943 9971 ParentType extends 9944 9944 - GQLResolversParentTypes['ManualReviewQueueNameExistsError'] = GQLResolversParentTypes['ManualReviewQueueNameExistsError'], 9972 9972 + GQLResolversParentTypes['ManualReviewQueueNameExistsError'] = 9973 9973 + GQLResolversParentTypes['ManualReviewQueueNameExistsError'], 9945 9974 > = { 9946 9975 detail?: Resolver< 9947 9976 Maybe<GQLResolversTypes['String']>, ··· 9970 9999 9971 10000 export type GQLMatchingBankNameExistsErrorResolvers< 9972 10001 ContextType = Context, 9973 9973 - ParentType extends 9974 9974 - GQLResolversParentTypes['MatchingBankNameExistsError'] = GQLResolversParentTypes['MatchingBankNameExistsError'], 10002 10002 + ParentType extends GQLResolversParentTypes['MatchingBankNameExistsError'] = 10003 10003 + GQLResolversParentTypes['MatchingBankNameExistsError'], 9975 10004 > = { 9976 10005 detail?: Resolver< 9977 10006 Maybe<GQLResolversTypes['String']>, ··· 10000 10029 10001 10030 export type GQLMatchingBanksResolvers< 10002 10031 ContextType = Context, 10003 10003 - ParentType extends 10004 10004 - GQLResolversParentTypes['MatchingBanks'] = GQLResolversParentTypes['MatchingBanks'], 10032 10032 + ParentType extends GQLResolversParentTypes['MatchingBanks'] = 10033 10033 + GQLResolversParentTypes['MatchingBanks'], 10005 10034 > = { 10006 10035 hashBanks?: Resolver< 10007 10036 ReadonlyArray<GQLResolversTypes['HashBank']>, ··· 10022 10051 10023 10052 export type GQLMatchingValuesResolvers< 10024 10053 ContextType = Context, 10025 10025 - ParentType extends 10026 10026 - GQLResolversParentTypes['MatchingValues'] = GQLResolversParentTypes['MatchingValues'], 10054 10054 + ParentType extends GQLResolversParentTypes['MatchingValues'] = 10055 10055 + GQLResolversParentTypes['MatchingValues'], 10027 10056 > = { 10028 10057 imageBankIds?: Resolver< 10029 10058 Maybe<ReadonlyArray<GQLResolversTypes['String']>>, ··· 10054 10083 10055 10084 export type GQLMessageWithIpAddressResolvers< 10056 10085 ContextType = Context, 10057 10057 - ParentType extends 10058 10058 - GQLResolversParentTypes['MessageWithIpAddress'] = GQLResolversParentTypes['MessageWithIpAddress'], 10086 10086 + ParentType extends GQLResolversParentTypes['MessageWithIpAddress'] = 10087 10087 + GQLResolversParentTypes['MessageWithIpAddress'], 10059 10088 > = { 10060 10089 ipAddress?: Resolver<GQLResolversTypes['IpAddress'], ParentType, ContextType>; 10061 10090 message?: Resolver<GQLResolversTypes['ContentItem'], ParentType, ContextType>; ··· 10063 10092 10064 10093 export type GQLModelCardResolvers< 10065 10094 ContextType = Context, 10066 10066 - ParentType extends 10067 10067 - GQLResolversParentTypes['ModelCard'] = GQLResolversParentTypes['ModelCard'], 10095 10095 + ParentType extends GQLResolversParentTypes['ModelCard'] = 10096 10096 + GQLResolversParentTypes['ModelCard'], 10068 10097 > = { 10069 10098 modelName?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 10070 10099 releaseDate?: Resolver< ··· 10082 10111 10083 10112 export type GQLModelCardFieldResolvers< 10084 10113 ContextType = Context, 10085 10085 - ParentType extends 10086 10086 - GQLResolversParentTypes['ModelCardField'] = GQLResolversParentTypes['ModelCardField'], 10114 10114 + ParentType extends GQLResolversParentTypes['ModelCardField'] = 10115 10115 + GQLResolversParentTypes['ModelCardField'], 10087 10116 > = { 10088 10117 label?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 10089 10118 value?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 10091 10120 10092 10121 export type GQLModelCardSectionResolvers< 10093 10122 ContextType = Context, 10094 10094 - ParentType extends 10095 10095 - GQLResolversParentTypes['ModelCardSection'] = GQLResolversParentTypes['ModelCardSection'], 10123 10123 + ParentType extends GQLResolversParentTypes['ModelCardSection'] = 10124 10124 + GQLResolversParentTypes['ModelCardSection'], 10096 10125 > = { 10097 10126 fields?: Resolver< 10098 10127 Maybe<ReadonlyArray<GQLResolversTypes['ModelCardField']>>, ··· 10110 10139 10111 10140 export type GQLModelCardSubsectionResolvers< 10112 10141 ContextType = Context, 10113 10113 - ParentType extends 10114 10114 - GQLResolversParentTypes['ModelCardSubsection'] = GQLResolversParentTypes['ModelCardSubsection'], 10142 10142 + ParentType extends GQLResolversParentTypes['ModelCardSubsection'] = 10143 10143 + GQLResolversParentTypes['ModelCardSubsection'], 10115 10144 > = { 10116 10145 fields?: Resolver< 10117 10146 ReadonlyArray<GQLResolversTypes['ModelCardField']>, ··· 10123 10152 10124 10153 export type GQLMrtJobEnqueueSourceInfoResolvers< 10125 10154 ContextType = Context, 10126 10126 - ParentType extends 10127 10127 - GQLResolversParentTypes['MrtJobEnqueueSourceInfo'] = GQLResolversParentTypes['MrtJobEnqueueSourceInfo'], 10155 10155 + ParentType extends GQLResolversParentTypes['MrtJobEnqueueSourceInfo'] = 10156 10156 + GQLResolversParentTypes['MrtJobEnqueueSourceInfo'], 10128 10157 > = { 10129 10158 kind?: Resolver< 10130 10159 GQLResolversTypes['JobCreationSourceOptions'], ··· 10137 10166 export type GQLMutateAccessibleQueuesForUserSuccessResponseResolvers< 10138 10167 ContextType = Context, 10139 10168 ParentType extends 10140 10140 - GQLResolversParentTypes['MutateAccessibleQueuesForUserSuccessResponse'] = GQLResolversParentTypes['MutateAccessibleQueuesForUserSuccessResponse'], 10169 10169 + GQLResolversParentTypes['MutateAccessibleQueuesForUserSuccessResponse'] = 10170 10170 + GQLResolversParentTypes['MutateAccessibleQueuesForUserSuccessResponse'], 10141 10171 > = { 10142 10172 _?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; 10143 10173 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10145 10175 10146 10176 export type GQLMutateActionResponseResolvers< 10147 10177 ContextType = Context, 10148 10148 - ParentType extends 10149 10149 - GQLResolversParentTypes['MutateActionResponse'] = GQLResolversParentTypes['MutateActionResponse'], 10178 10178 + ParentType extends GQLResolversParentTypes['MutateActionResponse'] = 10179 10179 + GQLResolversParentTypes['MutateActionResponse'], 10150 10180 > = { 10151 10181 __resolveType: TypeResolveFn< 10152 10182 'ActionNameExistsError' | 'MutateActionSuccessResponse', ··· 10157 10187 10158 10188 export type GQLMutateActionSuccessResponseResolvers< 10159 10189 ContextType = Context, 10160 10160 - ParentType extends 10161 10161 - GQLResolversParentTypes['MutateActionSuccessResponse'] = GQLResolversParentTypes['MutateActionSuccessResponse'], 10190 10190 + ParentType extends GQLResolversParentTypes['MutateActionSuccessResponse'] = 10191 10191 + GQLResolversParentTypes['MutateActionSuccessResponse'], 10162 10192 > = { 10163 10193 data?: Resolver<GQLResolversTypes['CustomAction'], ParentType, ContextType>; 10164 10194 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10166 10196 10167 10197 export type GQLMutateBankResponseResolvers< 10168 10198 ContextType = Context, 10169 10169 - ParentType extends 10170 10170 - GQLResolversParentTypes['MutateBankResponse'] = GQLResolversParentTypes['MutateBankResponse'], 10199 10199 + ParentType extends GQLResolversParentTypes['MutateBankResponse'] = 10200 10200 + GQLResolversParentTypes['MutateBankResponse'], 10171 10201 > = { 10172 10202 error?: Resolver<Maybe<GQLResolversTypes['String']>, ParentType, ContextType>; 10173 10203 success?: Resolver< ··· 10179 10209 10180 10210 export type GQLMutateContentItemTypeResponseResolvers< 10181 10211 ContextType = Context, 10182 10182 - ParentType extends 10183 10183 - GQLResolversParentTypes['MutateContentItemTypeResponse'] = GQLResolversParentTypes['MutateContentItemTypeResponse'], 10212 10212 + ParentType extends GQLResolversParentTypes['MutateContentItemTypeResponse'] = 10213 10213 + GQLResolversParentTypes['MutateContentItemTypeResponse'], 10184 10214 > = { 10185 10215 __resolveType: TypeResolveFn< 10186 10216 'ItemTypeNameAlreadyExistsError' | 'MutateContentTypeSuccessResponse', ··· 10192 10222 export type GQLMutateContentRuleSuccessResponseResolvers< 10193 10223 ContextType = Context, 10194 10224 ParentType extends 10195 10195 - GQLResolversParentTypes['MutateContentRuleSuccessResponse'] = GQLResolversParentTypes['MutateContentRuleSuccessResponse'], 10225 10225 + GQLResolversParentTypes['MutateContentRuleSuccessResponse'] = 10226 10226 + GQLResolversParentTypes['MutateContentRuleSuccessResponse'], 10196 10227 > = { 10197 10228 data?: Resolver<GQLResolversTypes['ContentRule'], ParentType, ContextType>; 10198 10229 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10201 10232 export type GQLMutateContentTypeSuccessResponseResolvers< 10202 10233 ContextType = Context, 10203 10234 ParentType extends 10204 10204 - GQLResolversParentTypes['MutateContentTypeSuccessResponse'] = GQLResolversParentTypes['MutateContentTypeSuccessResponse'], 10235 10235 + GQLResolversParentTypes['MutateContentTypeSuccessResponse'] = 10236 10236 + GQLResolversParentTypes['MutateContentTypeSuccessResponse'], 10205 10237 > = { 10206 10238 data?: Resolver< 10207 10239 Maybe<GQLResolversTypes['ContentItemType']>, ··· 10213 10245 10214 10246 export type GQLMutateHashBankResponseResolvers< 10215 10247 ContextType = Context, 10216 10216 - ParentType extends 10217 10217 - GQLResolversParentTypes['MutateHashBankResponse'] = GQLResolversParentTypes['MutateHashBankResponse'], 10248 10248 + ParentType extends GQLResolversParentTypes['MutateHashBankResponse'] = 10249 10249 + GQLResolversParentTypes['MutateHashBankResponse'], 10218 10250 > = { 10219 10251 __resolveType: TypeResolveFn< 10220 10252 'MatchingBankNameExistsError' | 'MutateHashBankSuccessResponse', ··· 10225 10257 10226 10258 export type GQLMutateHashBankSuccessResponseResolvers< 10227 10259 ContextType = Context, 10228 10228 - ParentType extends 10229 10229 - GQLResolversParentTypes['MutateHashBankSuccessResponse'] = GQLResolversParentTypes['MutateHashBankSuccessResponse'], 10260 10260 + ParentType extends GQLResolversParentTypes['MutateHashBankSuccessResponse'] = 10261 10261 + GQLResolversParentTypes['MutateHashBankSuccessResponse'], 10230 10262 > = { 10231 10263 data?: Resolver<GQLResolversTypes['HashBank'], ParentType, ContextType>; 10232 10264 warning?: Resolver< ··· 10239 10271 10240 10272 export type GQLMutateLocationBankResponseResolvers< 10241 10273 ContextType = Context, 10242 10242 - ParentType extends 10243 10243 - GQLResolversParentTypes['MutateLocationBankResponse'] = GQLResolversParentTypes['MutateLocationBankResponse'], 10274 10274 + ParentType extends GQLResolversParentTypes['MutateLocationBankResponse'] = 10275 10275 + GQLResolversParentTypes['MutateLocationBankResponse'], 10244 10276 > = { 10245 10277 __resolveType: TypeResolveFn< 10246 10278 'LocationBankNameExistsError' | 'MutateLocationBankSuccessResponse', ··· 10252 10284 export type GQLMutateLocationBankSuccessResponseResolvers< 10253 10285 ContextType = Context, 10254 10286 ParentType extends 10255 10255 - GQLResolversParentTypes['MutateLocationBankSuccessResponse'] = GQLResolversParentTypes['MutateLocationBankSuccessResponse'], 10287 10287 + GQLResolversParentTypes['MutateLocationBankSuccessResponse'] = 10288 10288 + GQLResolversParentTypes['MutateLocationBankSuccessResponse'], 10256 10289 > = { 10257 10290 data?: Resolver<GQLResolversTypes['LocationBank'], ParentType, ContextType>; 10258 10291 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10261 10294 export type GQLMutateManualReviewQueueSuccessResponseResolvers< 10262 10295 ContextType = Context, 10263 10296 ParentType extends 10264 10264 - GQLResolversParentTypes['MutateManualReviewQueueSuccessResponse'] = GQLResolversParentTypes['MutateManualReviewQueueSuccessResponse'], 10297 10297 + GQLResolversParentTypes['MutateManualReviewQueueSuccessResponse'] = 10298 10298 + GQLResolversParentTypes['MutateManualReviewQueueSuccessResponse'], 10265 10299 > = { 10266 10300 data?: Resolver< 10267 10301 GQLResolversTypes['ManualReviewQueue'], ··· 10274 10308 export type GQLMutateReportingRuleSuccessResponseResolvers< 10275 10309 ContextType = Context, 10276 10310 ParentType extends 10277 10277 - GQLResolversParentTypes['MutateReportingRuleSuccessResponse'] = GQLResolversParentTypes['MutateReportingRuleSuccessResponse'], 10311 10311 + GQLResolversParentTypes['MutateReportingRuleSuccessResponse'] = 10312 10312 + GQLResolversParentTypes['MutateReportingRuleSuccessResponse'], 10278 10313 > = { 10279 10314 data?: Resolver<GQLResolversTypes['ReportingRule'], ParentType, ContextType>; 10280 10315 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10283 10318 export type GQLMutateRoutingRuleSuccessResponseResolvers< 10284 10319 ContextType = Context, 10285 10320 ParentType extends 10286 10286 - GQLResolversParentTypes['MutateRoutingRuleSuccessResponse'] = GQLResolversParentTypes['MutateRoutingRuleSuccessResponse'], 10321 10321 + GQLResolversParentTypes['MutateRoutingRuleSuccessResponse'] = 10322 10322 + GQLResolversParentTypes['MutateRoutingRuleSuccessResponse'], 10287 10323 > = { 10288 10324 data?: Resolver<GQLResolversTypes['RoutingRule'], ParentType, ContextType>; 10289 10325 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10292 10328 export type GQLMutateRoutingRulesOrderSuccessResponseResolvers< 10293 10329 ContextType = Context, 10294 10330 ParentType extends 10295 10295 - GQLResolversParentTypes['MutateRoutingRulesOrderSuccessResponse'] = GQLResolversParentTypes['MutateRoutingRulesOrderSuccessResponse'], 10331 10331 + GQLResolversParentTypes['MutateRoutingRulesOrderSuccessResponse'] = 10332 10332 + GQLResolversParentTypes['MutateRoutingRulesOrderSuccessResponse'], 10296 10333 > = { 10297 10334 data?: Resolver< 10298 10335 ReadonlyArray<GQLResolversTypes['RoutingRule']>, ··· 10304 10341 10305 10342 export type GQLMutateThreadItemTypeResponseResolvers< 10306 10343 ContextType = Context, 10307 10307 - ParentType extends 10308 10308 - GQLResolversParentTypes['MutateThreadItemTypeResponse'] = GQLResolversParentTypes['MutateThreadItemTypeResponse'], 10344 10344 + ParentType extends GQLResolversParentTypes['MutateThreadItemTypeResponse'] = 10345 10345 + GQLResolversParentTypes['MutateThreadItemTypeResponse'], 10309 10346 > = { 10310 10347 __resolveType: TypeResolveFn< 10311 10348 'ItemTypeNameAlreadyExistsError' | 'MutateThreadTypeSuccessResponse', ··· 10317 10354 export type GQLMutateThreadTypeSuccessResponseResolvers< 10318 10355 ContextType = Context, 10319 10356 ParentType extends 10320 10320 - GQLResolversParentTypes['MutateThreadTypeSuccessResponse'] = GQLResolversParentTypes['MutateThreadTypeSuccessResponse'], 10357 10357 + GQLResolversParentTypes['MutateThreadTypeSuccessResponse'] = 10358 10358 + GQLResolversParentTypes['MutateThreadTypeSuccessResponse'], 10321 10359 > = { 10322 10360 data?: Resolver< 10323 10361 Maybe<GQLResolversTypes['ThreadItemType']>, ··· 10329 10367 10330 10368 export type GQLMutateUserItemTypeResponseResolvers< 10331 10369 ContextType = Context, 10332 10332 - ParentType extends 10333 10333 - GQLResolversParentTypes['MutateUserItemTypeResponse'] = GQLResolversParentTypes['MutateUserItemTypeResponse'], 10370 10370 + ParentType extends GQLResolversParentTypes['MutateUserItemTypeResponse'] = 10371 10371 + GQLResolversParentTypes['MutateUserItemTypeResponse'], 10334 10372 > = { 10335 10373 __resolveType: TypeResolveFn< 10336 10374 'ItemTypeNameAlreadyExistsError' | 'MutateUserTypeSuccessResponse', ··· 10341 10379 10342 10380 export type GQLMutateUserRuleSuccessResponseResolvers< 10343 10381 ContextType = Context, 10344 10344 - ParentType extends 10345 10345 - GQLResolversParentTypes['MutateUserRuleSuccessResponse'] = GQLResolversParentTypes['MutateUserRuleSuccessResponse'], 10382 10382 + ParentType extends GQLResolversParentTypes['MutateUserRuleSuccessResponse'] = 10383 10383 + GQLResolversParentTypes['MutateUserRuleSuccessResponse'], 10346 10384 > = { 10347 10385 data?: Resolver<GQLResolversTypes['UserRule'], ParentType, ContextType>; 10348 10386 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 10350 10388 10351 10389 export type GQLMutateUserTypeSuccessResponseResolvers< 10352 10390 ContextType = Context, 10353 10353 - ParentType extends 10354 10354 - GQLResolversParentTypes['MutateUserTypeSuccessResponse'] = GQLResolversParentTypes['MutateUserTypeSuccessResponse'], 10391 10391 + ParentType extends GQLResolversParentTypes['MutateUserTypeSuccessResponse'] = 10392 10392 + GQLResolversParentTypes['MutateUserTypeSuccessResponse'], 10355 10393 > = { 10356 10394 data?: Resolver< 10357 10395 Maybe<GQLResolversTypes['UserItemType']>, ··· 10363 10401 10364 10402 export type GQLMutationResolvers< 10365 10403 ContextType = Context, 10366 10366 - ParentType extends 10367 10367 - GQLResolversParentTypes['Mutation'] = GQLResolversParentTypes['Mutation'], 10404 10404 + ParentType extends GQLResolversParentTypes['Mutation'] = 10405 10405 + GQLResolversParentTypes['Mutation'], 10368 10406 > = { 10369 10407 addAccessibleQueuesToUser?: Resolver< 10370 10408 GQLResolversTypes['AddAccessibleQueuesToUserResponse'], ··· 10878 10916 10879 10917 export type GQLNcmecReportResolvers< 10880 10918 ContextType = Context, 10881 10881 - ParentType extends 10882 10882 - GQLResolversParentTypes['NCMECReport'] = GQLResolversParentTypes['NCMECReport'], 10919 10919 + ParentType extends GQLResolversParentTypes['NCMECReport'] = 10920 10920 + GQLResolversParentTypes['NCMECReport'], 10883 10921 > = { 10884 10922 additionalFiles?: Resolver< 10885 10923 ReadonlyArray<GQLResolversTypes['NcmecAdditionalFile']>, ··· 10919 10957 10920 10958 export type GQLNcmecReportedMediaResolvers< 10921 10959 ContextType = Context, 10922 10922 - ParentType extends 10923 10923 - GQLResolversParentTypes['NCMECReportedMedia'] = GQLResolversParentTypes['NCMECReportedMedia'], 10960 10960 + ParentType extends GQLResolversParentTypes['NCMECReportedMedia'] = 10961 10961 + GQLResolversParentTypes['NCMECReportedMedia'], 10924 10962 > = { 10925 10963 id?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 10926 10964 xml?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 10928 10966 10929 10967 export type GQLNcmecReportedThreadResolvers< 10930 10968 ContextType = Context, 10931 10931 - ParentType extends 10932 10932 - GQLResolversParentTypes['NCMECReportedThread'] = GQLResolversParentTypes['NCMECReportedThread'], 10969 10969 + ParentType extends GQLResolversParentTypes['NCMECReportedThread'] = 10970 10970 + GQLResolversParentTypes['NCMECReportedThread'], 10933 10971 > = { 10934 10972 csv?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 10935 10973 fileName?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 10938 10976 10939 10977 export type GQLNcmecAdditionalFileResolvers< 10940 10978 ContextType = Context, 10941 10941 - ParentType extends 10942 10942 - GQLResolversParentTypes['NcmecAdditionalFile'] = GQLResolversParentTypes['NcmecAdditionalFile'], 10979 10979 + ParentType extends GQLResolversParentTypes['NcmecAdditionalFile'] = 10980 10980 + GQLResolversParentTypes['NcmecAdditionalFile'], 10943 10981 > = { 10944 10982 ncmecFileId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 10945 10983 url?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 10948 10986 10949 10987 export type GQLNcmecContentItemResolvers< 10950 10988 ContextType = Context, 10951 10951 - ParentType extends 10952 10952 - GQLResolversParentTypes['NcmecContentItem'] = GQLResolversParentTypes['NcmecContentItem'], 10989 10989 + ParentType extends GQLResolversParentTypes['NcmecContentItem'] = 10990 10990 + GQLResolversParentTypes['NcmecContentItem'], 10953 10991 > = { 10954 10992 contentItem?: Resolver<GQLResolversTypes['Item'], ParentType, ContextType>; 10955 10993 isConfirmedCSAM?: Resolver< ··· 10962 11000 10963 11001 export type GQLNcmecManualReviewJobPayloadResolvers< 10964 11002 ContextType = Context, 10965 10965 - ParentType extends 10966 10966 - GQLResolversParentTypes['NcmecManualReviewJobPayload'] = GQLResolversParentTypes['NcmecManualReviewJobPayload'], 11003 11003 + ParentType extends GQLResolversParentTypes['NcmecManualReviewJobPayload'] = 11004 11004 + GQLResolversParentTypes['NcmecManualReviewJobPayload'], 10967 11005 > = { 10968 11006 allMediaItems?: Resolver< 10969 11007 ReadonlyArray<GQLResolversTypes['NcmecContentItem']>, ··· 10986 11024 10987 11025 export type GQLNcmecOrgSettingsResolvers< 10988 11026 ContextType = Context, 10989 10989 - ParentType extends 10990 10990 - GQLResolversParentTypes['NcmecOrgSettings'] = GQLResolversParentTypes['NcmecOrgSettings'], 11027 11027 + ParentType extends GQLResolversParentTypes['NcmecOrgSettings'] = 11028 11028 + GQLResolversParentTypes['NcmecOrgSettings'], 10991 11029 > = { 10992 11030 companyTemplate?: Resolver< 10993 11031 Maybe<GQLResolversTypes['String']>, ··· 11060 11098 11061 11099 export type GQLNcmecReportedMediaDetailsResolvers< 11062 11100 ContextType = Context, 11063 11063 - ParentType extends 11064 11064 - GQLResolversParentTypes['NcmecReportedMediaDetails'] = GQLResolversParentTypes['NcmecReportedMediaDetails'], 11101 11101 + ParentType extends GQLResolversParentTypes['NcmecReportedMediaDetails'] = 11102 11102 + GQLResolversParentTypes['NcmecReportedMediaDetails'], 11065 11103 > = { 11066 11104 fileAnnotations?: Resolver< 11067 11105 ReadonlyArray<GQLResolversTypes['NcmecFileAnnotation']>, ··· 11080 11118 11081 11119 export type GQLNoJobWithIdInQueueErrorResolvers< 11082 11120 ContextType = Context, 11083 11083 - ParentType extends 11084 11084 - GQLResolversParentTypes['NoJobWithIdInQueueError'] = GQLResolversParentTypes['NoJobWithIdInQueueError'], 11121 11121 + ParentType extends GQLResolversParentTypes['NoJobWithIdInQueueError'] = 11122 11122 + GQLResolversParentTypes['NoJobWithIdInQueueError'], 11085 11123 > = { 11086 11124 detail?: Resolver< 11087 11125 Maybe<GQLResolversTypes['String']>, ··· 11108 11146 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; 11109 11147 }; 11110 11148 11111 11111 - export interface GQLNonEmptyStringScalarConfig 11112 11112 - extends GraphQLScalarTypeConfig<GQLResolversTypes['NonEmptyString'], any> { 11149 11149 + export interface GQLNonEmptyStringScalarConfig extends GraphQLScalarTypeConfig< 11150 11150 + GQLResolversTypes['NonEmptyString'], 11151 11151 + any 11152 11152 + > { 11113 11153 name: 'NonEmptyString'; 11114 11154 } 11115 11155 11116 11156 export type GQLNotFoundErrorResolvers< 11117 11157 ContextType = Context, 11118 11118 - ParentType extends 11119 11119 - GQLResolversParentTypes['NotFoundError'] = GQLResolversParentTypes['NotFoundError'], 11158 11158 + ParentType extends GQLResolversParentTypes['NotFoundError'] = 11159 11159 + GQLResolversParentTypes['NotFoundError'], 11120 11160 > = { 11121 11161 detail?: Resolver< 11122 11162 Maybe<GQLResolversTypes['String']>, ··· 11145 11185 11146 11186 export type GQLNotificationResolvers< 11147 11187 ContextType = Context, 11148 11148 - ParentType extends 11149 11149 - GQLResolversParentTypes['Notification'] = GQLResolversParentTypes['Notification'], 11188 11188 + ParentType extends GQLResolversParentTypes['Notification'] = 11189 11189 + GQLResolversParentTypes['Notification'], 11150 11190 > = { 11151 11191 createdAt?: Resolver<GQLResolversTypes['DateTime'], ParentType, ContextType>; 11152 11192 data?: Resolver< ··· 11170 11210 11171 11211 export type GQLOpenAiIntegrationApiCredentialResolvers< 11172 11212 ContextType = Context, 11173 11173 - ParentType extends 11174 11174 - GQLResolversParentTypes['OpenAiIntegrationApiCredential'] = GQLResolversParentTypes['OpenAiIntegrationApiCredential'], 11213 11213 + ParentType extends GQLResolversParentTypes['OpenAiIntegrationApiCredential'] = 11214 11214 + GQLResolversParentTypes['OpenAiIntegrationApiCredential'], 11175 11215 > = { 11176 11216 apiKey?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 11177 11217 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 11179 11219 11180 11220 export type GQLOrgResolvers< 11181 11221 ContextType = Context, 11182 11182 - ParentType extends 11183 11183 - GQLResolversParentTypes['Org'] = GQLResolversParentTypes['Org'], 11222 11222 + ParentType extends GQLResolversParentTypes['Org'] = 11223 11223 + GQLResolversParentTypes['Org'], 11184 11224 > = { 11185 11225 actions?: Resolver< 11186 11226 ReadonlyArray<GQLResolversTypes['Action']>, ··· 11349 11389 11350 11390 export type GQLOrgWithEmailExistsErrorResolvers< 11351 11391 ContextType = Context, 11352 11352 - ParentType extends 11353 11353 - GQLResolversParentTypes['OrgWithEmailExistsError'] = GQLResolversParentTypes['OrgWithEmailExistsError'], 11392 11392 + ParentType extends GQLResolversParentTypes['OrgWithEmailExistsError'] = 11393 11393 + GQLResolversParentTypes['OrgWithEmailExistsError'], 11354 11394 > = { 11355 11395 detail?: Resolver< 11356 11396 Maybe<GQLResolversTypes['String']>, ··· 11379 11419 11380 11420 export type GQLOrgWithNameExistsErrorResolvers< 11381 11421 ContextType = Context, 11382 11382 - ParentType extends 11383 11383 - GQLResolversParentTypes['OrgWithNameExistsError'] = GQLResolversParentTypes['OrgWithNameExistsError'], 11422 11422 + ParentType extends GQLResolversParentTypes['OrgWithNameExistsError'] = 11423 11423 + GQLResolversParentTypes['OrgWithNameExistsError'], 11384 11424 > = { 11385 11425 detail?: Resolver< 11386 11426 Maybe<GQLResolversTypes['String']>, ··· 11409 11449 11410 11450 export type GQLPageInfoResolvers< 11411 11451 ContextType = Context, 11412 11412 - ParentType extends 11413 11413 - GQLResolversParentTypes['PageInfo'] = GQLResolversParentTypes['PageInfo'], 11452 11452 + ParentType extends GQLResolversParentTypes['PageInfo'] = 11453 11453 + GQLResolversParentTypes['PageInfo'], 11414 11454 > = { 11415 11455 endCursor?: Resolver<GQLResolversTypes['Cursor'], ParentType, ContextType>; 11416 11456 hasNextPage?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; ··· 11425 11465 export type GQLPartialItemsEndpointResponseErrorResolvers< 11426 11466 ContextType = Context, 11427 11467 ParentType extends 11428 11428 - GQLResolversParentTypes['PartialItemsEndpointResponseError'] = GQLResolversParentTypes['PartialItemsEndpointResponseError'], 11468 11468 + GQLResolversParentTypes['PartialItemsEndpointResponseError'] = 11469 11469 + GQLResolversParentTypes['PartialItemsEndpointResponseError'], 11429 11470 > = { 11430 11471 detail?: Resolver< 11431 11472 Maybe<GQLResolversTypes['String']>, ··· 11455 11496 export type GQLPartialItemsInvalidResponseErrorResolvers< 11456 11497 ContextType = Context, 11457 11498 ParentType extends 11458 11458 - GQLResolversParentTypes['PartialItemsInvalidResponseError'] = GQLResolversParentTypes['PartialItemsInvalidResponseError'], 11499 11499 + GQLResolversParentTypes['PartialItemsInvalidResponseError'] = 11500 11500 + GQLResolversParentTypes['PartialItemsInvalidResponseError'], 11459 11501 > = { 11460 11502 detail?: Resolver< 11461 11503 Maybe<GQLResolversTypes['String']>, ··· 11485 11527 export type GQLPartialItemsMissingEndpointErrorResolvers< 11486 11528 ContextType = Context, 11487 11529 ParentType extends 11488 11488 - GQLResolversParentTypes['PartialItemsMissingEndpointError'] = GQLResolversParentTypes['PartialItemsMissingEndpointError'], 11530 11530 + GQLResolversParentTypes['PartialItemsMissingEndpointError'] = 11531 11531 + GQLResolversParentTypes['PartialItemsMissingEndpointError'], 11489 11532 > = { 11490 11533 detail?: Resolver< 11491 11534 Maybe<GQLResolversTypes['String']>, ··· 11514 11557 11515 11558 export type GQLPartialItemsResponseResolvers< 11516 11559 ContextType = Context, 11517 11517 - ParentType extends 11518 11518 - GQLResolversParentTypes['PartialItemsResponse'] = GQLResolversParentTypes['PartialItemsResponse'], 11560 11560 + ParentType extends GQLResolversParentTypes['PartialItemsResponse'] = 11561 11561 + GQLResolversParentTypes['PartialItemsResponse'], 11519 11562 > = { 11520 11563 __resolveType: TypeResolveFn< 11521 11564 | 'PartialItemsEndpointResponseError' ··· 11529 11572 11530 11573 export type GQLPartialItemsSuccessResponseResolvers< 11531 11574 ContextType = Context, 11532 11532 - ParentType extends 11533 11533 - GQLResolversParentTypes['PartialItemsSuccessResponse'] = GQLResolversParentTypes['PartialItemsSuccessResponse'], 11575 11575 + ParentType extends GQLResolversParentTypes['PartialItemsSuccessResponse'] = 11576 11576 + GQLResolversParentTypes['PartialItemsSuccessResponse'], 11534 11577 > = { 11535 11578 items?: Resolver< 11536 11579 ReadonlyArray<GQLResolversTypes['Item']>, ··· 11542 11585 11543 11586 export type GQLPendingInviteResolvers< 11544 11587 ContextType = Context, 11545 11545 - ParentType extends 11546 11546 - GQLResolversParentTypes['PendingInvite'] = GQLResolversParentTypes['PendingInvite'], 11588 11588 + ParentType extends GQLResolversParentTypes['PendingInvite'] = 11589 11589 + GQLResolversParentTypes['PendingInvite'], 11547 11590 > = { 11548 11591 createdAt?: Resolver<GQLResolversTypes['DateTime'], ParentType, ContextType>; 11549 11592 email?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 11553 11596 11554 11597 export type GQLPlaceBoundsResolvers< 11555 11598 ContextType = Context, 11556 11556 - ParentType extends 11557 11557 - GQLResolversParentTypes['PlaceBounds'] = GQLResolversParentTypes['PlaceBounds'], 11599 11599 + ParentType extends GQLResolversParentTypes['PlaceBounds'] = 11600 11600 + GQLResolversParentTypes['PlaceBounds'], 11558 11601 > = { 11559 11602 northeastCorner?: Resolver< 11560 11603 GQLResolversTypes['LatLng'], ··· 11570 11613 11571 11614 export type GQLPluginIntegrationApiCredentialResolvers< 11572 11615 ContextType = Context, 11573 11573 - ParentType extends 11574 11574 - GQLResolversParentTypes['PluginIntegrationApiCredential'] = GQLResolversParentTypes['PluginIntegrationApiCredential'], 11616 11616 + ParentType extends GQLResolversParentTypes['PluginIntegrationApiCredential'] = 11617 11617 + GQLResolversParentTypes['PluginIntegrationApiCredential'], 11575 11618 > = { 11576 11619 credential?: Resolver< 11577 11620 GQLResolversTypes['JSONObject'], ··· 11583 11626 11584 11627 export type GQLPolicyResolvers< 11585 11628 ContextType = Context, 11586 11586 - ParentType extends 11587 11587 - GQLResolversParentTypes['Policy'] = GQLResolversParentTypes['Policy'], 11629 11629 + ParentType extends GQLResolversParentTypes['Policy'] = 11630 11630 + GQLResolversParentTypes['Policy'], 11588 11631 > = { 11589 11632 applyUserStrikeCountConfigToChildren?: Resolver< 11590 11633 Maybe<GQLResolversTypes['Boolean']>, ··· 11619 11662 11620 11663 export type GQLPolicyActionCountResolvers< 11621 11664 ContextType = Context, 11622 11622 - ParentType extends 11623 11623 - GQLResolversParentTypes['PolicyActionCount'] = GQLResolversParentTypes['PolicyActionCount'], 11665 11665 + ParentType extends GQLResolversParentTypes['PolicyActionCount'] = 11666 11666 + GQLResolversParentTypes['PolicyActionCount'], 11624 11667 > = { 11625 11668 actionId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 11626 11669 actorId?: Resolver< ··· 11643 11686 11644 11687 export type GQLPolicyNameExistsErrorResolvers< 11645 11688 ContextType = Context, 11646 11646 - ParentType extends 11647 11647 - GQLResolversParentTypes['PolicyNameExistsError'] = GQLResolversParentTypes['PolicyNameExistsError'], 11689 11689 + ParentType extends GQLResolversParentTypes['PolicyNameExistsError'] = 11690 11690 + GQLResolversParentTypes['PolicyNameExistsError'], 11648 11691 > = { 11649 11692 detail?: Resolver< 11650 11693 Maybe<GQLResolversTypes['String']>, ··· 11673 11716 11674 11717 export type GQLPolicyViolationsCountResolvers< 11675 11718 ContextType = Context, 11676 11676 - ParentType extends 11677 11677 - GQLResolversParentTypes['PolicyViolationsCount'] = GQLResolversParentTypes['PolicyViolationsCount'], 11719 11719 + ParentType extends GQLResolversParentTypes['PolicyViolationsCount'] = 11720 11720 + GQLResolversParentTypes['PolicyViolationsCount'], 11678 11721 > = { 11679 11722 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 11680 11723 policyId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 11682 11725 11683 11726 export type GQLPostActionsEnqueueSourceInfoResolvers< 11684 11727 ContextType = Context, 11685 11685 - ParentType extends 11686 11686 - GQLResolversParentTypes['PostActionsEnqueueSourceInfo'] = GQLResolversParentTypes['PostActionsEnqueueSourceInfo'], 11728 11728 + ParentType extends GQLResolversParentTypes['PostActionsEnqueueSourceInfo'] = 11729 11729 + GQLResolversParentTypes['PostActionsEnqueueSourceInfo'], 11687 11730 > = { 11688 11731 kind?: Resolver< 11689 11732 GQLResolversTypes['JobCreationSourceOptions'], ··· 11695 11738 11696 11739 export type GQLQueryResolvers< 11697 11740 ContextType = Context, 11698 11698 - ParentType extends 11699 11699 - GQLResolversParentTypes['Query'] = GQLResolversParentTypes['Query'], 11741 11741 + ParentType extends GQLResolversParentTypes['Query'] = 11742 11742 + GQLResolversParentTypes['Query'], 11700 11743 > = { 11701 11744 action?: Resolver< 11702 11745 Maybe<GQLResolversTypes['Action']>, ··· 12060 12103 12061 12104 export type GQLQueueDoesNotExistErrorResolvers< 12062 12105 ContextType = Context, 12063 12063 - ParentType extends 12064 12064 - GQLResolversParentTypes['QueueDoesNotExistError'] = GQLResolversParentTypes['QueueDoesNotExistError'], 12106 12106 + ParentType extends GQLResolversParentTypes['QueueDoesNotExistError'] = 12107 12107 + GQLResolversParentTypes['QueueDoesNotExistError'], 12065 12108 > = { 12066 12109 detail?: Resolver< 12067 12110 Maybe<GQLResolversTypes['String']>, ··· 12090 12133 12091 12134 export type GQLRecentDecisionsForUserResolvers< 12092 12135 ContextType = Context, 12093 12093 - ParentType extends 12094 12094 - GQLResolversParentTypes['RecentDecisionsForUser'] = GQLResolversParentTypes['RecentDecisionsForUser'], 12136 12136 + ParentType extends GQLResolversParentTypes['RecentDecisionsForUser'] = 12137 12137 + GQLResolversParentTypes['RecentDecisionsForUser'], 12095 12138 > = { 12096 12139 recentDecisions?: Resolver< 12097 12140 ReadonlyArray<GQLResolversTypes['ManualReviewDecision']>, ··· 12107 12150 12108 12151 export type GQLRecentUserStrikeActionsResolvers< 12109 12152 ContextType = Context, 12110 12110 - ParentType extends 12111 12111 - GQLResolversParentTypes['RecentUserStrikeActions'] = GQLResolversParentTypes['RecentUserStrikeActions'], 12153 12153 + ParentType extends GQLResolversParentTypes['RecentUserStrikeActions'] = 12154 12154 + GQLResolversParentTypes['RecentUserStrikeActions'], 12112 12155 > = { 12113 12156 actionId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 12114 12157 itemId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 12119 12162 12120 12163 export type GQLRecommendedThresholdsResolvers< 12121 12164 ContextType = Context, 12122 12122 - ParentType extends 12123 12123 - GQLResolversParentTypes['RecommendedThresholds'] = GQLResolversParentTypes['RecommendedThresholds'], 12165 12165 + ParentType extends GQLResolversParentTypes['RecommendedThresholds'] = 12166 12166 + GQLResolversParentTypes['RecommendedThresholds'], 12124 12167 > = { 12125 12168 highPrecisionThreshold?: Resolver< 12126 12169 GQLResolversTypes['StringOrFloat'], ··· 12137 12180 export type GQLRecordingJobDecisionFailedErrorResolvers< 12138 12181 ContextType = Context, 12139 12182 ParentType extends 12140 12140 - GQLResolversParentTypes['RecordingJobDecisionFailedError'] = GQLResolversParentTypes['RecordingJobDecisionFailedError'], 12183 12183 + GQLResolversParentTypes['RecordingJobDecisionFailedError'] = 12184 12184 + GQLResolversParentTypes['RecordingJobDecisionFailedError'], 12141 12185 > = { 12142 12186 detail?: Resolver< 12143 12187 Maybe<GQLResolversTypes['String']>, ··· 12166 12210 12167 12211 export type GQLRejectAppealDecisionComponentResolvers< 12168 12212 ContextType = Context, 12169 12169 - ParentType extends 12170 12170 - GQLResolversParentTypes['RejectAppealDecisionComponent'] = GQLResolversParentTypes['RejectAppealDecisionComponent'], 12213 12213 + ParentType extends GQLResolversParentTypes['RejectAppealDecisionComponent'] = 12214 12214 + GQLResolversParentTypes['RejectAppealDecisionComponent'], 12171 12215 > = { 12172 12216 actionIds?: Resolver< 12173 12217 ReadonlyArray<GQLResolversTypes['String']>, ··· 12186 12230 export type GQLRemoveAccessibleQueuesToUserResponseResolvers< 12187 12231 ContextType = Context, 12188 12232 ParentType extends 12189 12189 - GQLResolversParentTypes['RemoveAccessibleQueuesToUserResponse'] = GQLResolversParentTypes['RemoveAccessibleQueuesToUserResponse'], 12233 12233 + GQLResolversParentTypes['RemoveAccessibleQueuesToUserResponse'] = 12234 12234 + GQLResolversParentTypes['RemoveAccessibleQueuesToUserResponse'], 12190 12235 > = { 12191 12236 __resolveType: TypeResolveFn< 12192 12237 'MutateAccessibleQueuesForUserSuccessResponse' | 'NotFoundError', ··· 12198 12243 export type GQLRemoveFavoriteMrtQueueSuccessResponseResolvers< 12199 12244 ContextType = Context, 12200 12245 ParentType extends 12201 12201 - GQLResolversParentTypes['RemoveFavoriteMRTQueueSuccessResponse'] = GQLResolversParentTypes['RemoveFavoriteMRTQueueSuccessResponse'], 12246 12246 + GQLResolversParentTypes['RemoveFavoriteMRTQueueSuccessResponse'] = 12247 12247 + GQLResolversParentTypes['RemoveFavoriteMRTQueueSuccessResponse'], 12202 12248 > = { 12203 12249 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 12204 12250 }; 12205 12251 12206 12252 export type GQLRemoveFavoriteRuleResponseResolvers< 12207 12253 ContextType = Context, 12208 12208 - ParentType extends 12209 12209 - GQLResolversParentTypes['RemoveFavoriteRuleResponse'] = GQLResolversParentTypes['RemoveFavoriteRuleResponse'], 12254 12254 + ParentType extends GQLResolversParentTypes['RemoveFavoriteRuleResponse'] = 12255 12255 + GQLResolversParentTypes['RemoveFavoriteRuleResponse'], 12210 12256 > = { 12211 12257 __resolveType: TypeResolveFn< 12212 12258 'RemoveFavoriteRuleSuccessResponse', ··· 12218 12264 export type GQLRemoveFavoriteRuleSuccessResponseResolvers< 12219 12265 ContextType = Context, 12220 12266 ParentType extends 12221 12221 - GQLResolversParentTypes['RemoveFavoriteRuleSuccessResponse'] = GQLResolversParentTypes['RemoveFavoriteRuleSuccessResponse'], 12267 12267 + GQLResolversParentTypes['RemoveFavoriteRuleSuccessResponse'] = 12268 12268 + GQLResolversParentTypes['RemoveFavoriteRuleSuccessResponse'], 12222 12269 > = { 12223 12270 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 12224 12271 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 12226 12273 12227 12274 export type GQLReorderRoutingRulesResponseResolvers< 12228 12275 ContextType = Context, 12229 12229 - ParentType extends 12230 12230 - GQLResolversParentTypes['ReorderRoutingRulesResponse'] = GQLResolversParentTypes['ReorderRoutingRulesResponse'], 12276 12276 + ParentType extends GQLResolversParentTypes['ReorderRoutingRulesResponse'] = 12277 12277 + GQLResolversParentTypes['ReorderRoutingRulesResponse'], 12231 12278 > = { 12232 12279 __resolveType: TypeResolveFn< 12233 12280 'MutateRoutingRulesOrderSuccessResponse', ··· 12238 12285 12239 12286 export type GQLReportEnqueueSourceInfoResolvers< 12240 12287 ContextType = Context, 12241 12241 - ParentType extends 12242 12242 - GQLResolversParentTypes['ReportEnqueueSourceInfo'] = GQLResolversParentTypes['ReportEnqueueSourceInfo'], 12288 12288 + ParentType extends GQLResolversParentTypes['ReportEnqueueSourceInfo'] = 12289 12289 + GQLResolversParentTypes['ReportEnqueueSourceInfo'], 12243 12290 > = { 12244 12291 kind?: Resolver< 12245 12292 GQLResolversTypes['JobCreationSourceOptions'], ··· 12251 12298 12252 12299 export type GQLReportHistoryEntryResolvers< 12253 12300 ContextType = Context, 12254 12254 - ParentType extends 12255 12255 - GQLResolversParentTypes['ReportHistoryEntry'] = GQLResolversParentTypes['ReportHistoryEntry'], 12301 12301 + ParentType extends GQLResolversParentTypes['ReportHistoryEntry'] = 12302 12302 + GQLResolversParentTypes['ReportHistoryEntry'], 12256 12303 > = { 12257 12304 policyId?: Resolver<Maybe<GQLResolversTypes['ID']>, ParentType, ContextType>; 12258 12305 reason?: Resolver< ··· 12271 12318 12272 12319 export type GQLReportedForReasonResolvers< 12273 12320 ContextType = Context, 12274 12274 - ParentType extends 12275 12275 - GQLResolversParentTypes['ReportedForReason'] = GQLResolversParentTypes['ReportedForReason'], 12321 12321 + ParentType extends GQLResolversParentTypes['ReportedForReason'] = 12322 12322 + GQLResolversParentTypes['ReportedForReason'], 12276 12323 > = { 12277 12324 reason?: Resolver< 12278 12325 Maybe<GQLResolversTypes['String']>, ··· 12288 12335 12289 12336 export type GQLReportingInsightsResolvers< 12290 12337 ContextType = Context, 12291 12291 - ParentType extends 12292 12292 - GQLResolversParentTypes['ReportingInsights'] = GQLResolversParentTypes['ReportingInsights'], 12338 12338 + ParentType extends GQLResolversParentTypes['ReportingInsights'] = 12339 12339 + GQLResolversParentTypes['ReportingInsights'], 12293 12340 > = { 12294 12341 totalIngestedReportsByDay?: Resolver< 12295 12342 ReadonlyArray<GQLResolversTypes['CountByDay']>, ··· 12300 12347 12301 12348 export type GQLReportingRuleResolvers< 12302 12349 ContextType = Context, 12303 12303 - ParentType extends 12304 12304 - GQLResolversParentTypes['ReportingRule'] = GQLResolversParentTypes['ReportingRule'], 12350 12350 + ParentType extends GQLResolversParentTypes['ReportingRule'] = 12351 12351 + GQLResolversParentTypes['ReportingRule'], 12305 12352 > = { 12306 12353 actions?: Resolver< 12307 12354 ReadonlyArray<GQLResolversTypes['Action']>, ··· 12346 12393 12347 12394 export type GQLReportingRuleExecutionResultResolvers< 12348 12395 ContextType = Context, 12349 12349 - ParentType extends 12350 12350 - GQLResolversParentTypes['ReportingRuleExecutionResult'] = GQLResolversParentTypes['ReportingRuleExecutionResult'], 12396 12396 + ParentType extends GQLResolversParentTypes['ReportingRuleExecutionResult'] = 12397 12397 + GQLResolversParentTypes['ReportingRuleExecutionResult'], 12351 12398 > = { 12352 12399 creatorId?: Resolver< 12353 12400 Maybe<GQLResolversTypes['String']>, ··· 12393 12440 12394 12441 export type GQLReportingRuleInsightsResolvers< 12395 12442 ContextType = Context, 12396 12396 - ParentType extends 12397 12397 - GQLResolversParentTypes['ReportingRuleInsights'] = GQLResolversParentTypes['ReportingRuleInsights'], 12443 12443 + ParentType extends GQLResolversParentTypes['ReportingRuleInsights'] = 12444 12444 + GQLResolversParentTypes['ReportingRuleInsights'], 12398 12445 > = { 12399 12446 latestVersionSamples?: Resolver< 12400 12447 ReadonlyArray<GQLResolversTypes['ReportingRuleExecutionResult']>, ··· 12416 12463 12417 12464 export type GQLReportingRuleNameExistsErrorResolvers< 12418 12465 ContextType = Context, 12419 12419 - ParentType extends 12420 12420 - GQLResolversParentTypes['ReportingRuleNameExistsError'] = GQLResolversParentTypes['ReportingRuleNameExistsError'], 12466 12466 + ParentType extends GQLResolversParentTypes['ReportingRuleNameExistsError'] = 12467 12467 + GQLResolversParentTypes['ReportingRuleNameExistsError'], 12421 12468 > = { 12422 12469 detail?: Resolver< 12423 12470 Maybe<GQLResolversTypes['String']>, ··· 12446 12493 12447 12494 export type GQLReportingRulePassRateDataResolvers< 12448 12495 ContextType = Context, 12449 12449 - ParentType extends 12450 12450 - GQLResolversParentTypes['ReportingRulePassRateData'] = GQLResolversParentTypes['ReportingRulePassRateData'], 12496 12496 + ParentType extends GQLResolversParentTypes['ReportingRulePassRateData'] = 12497 12497 + GQLResolversParentTypes['ReportingRulePassRateData'], 12451 12498 > = { 12452 12499 date?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 12453 12500 totalMatches?: Resolver<GQLResolversTypes['Float'], ParentType, ContextType>; ··· 12456 12503 12457 12504 export type GQLResolvedJobCountResolvers< 12458 12505 ContextType = Context, 12459 12459 - ParentType extends 12460 12460 - GQLResolversParentTypes['ResolvedJobCount'] = GQLResolversParentTypes['ResolvedJobCount'], 12506 12506 + ParentType extends GQLResolversParentTypes['ResolvedJobCount'] = 12507 12507 + GQLResolversParentTypes['ResolvedJobCount'], 12461 12508 > = { 12462 12509 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 12463 12510 queueId?: Resolver< ··· 12475 12522 12476 12523 export type GQLRotateApiKeyErrorResolvers< 12477 12524 ContextType = Context, 12478 12478 - ParentType extends 12479 12479 - GQLResolversParentTypes['RotateApiKeyError'] = GQLResolversParentTypes['RotateApiKeyError'], 12525 12525 + ParentType extends GQLResolversParentTypes['RotateApiKeyError'] = 12526 12526 + GQLResolversParentTypes['RotateApiKeyError'], 12480 12527 > = { 12481 12528 detail?: Resolver< 12482 12529 Maybe<GQLResolversTypes['String']>, ··· 12505 12552 12506 12553 export type GQLRotateApiKeyResponseResolvers< 12507 12554 ContextType = Context, 12508 12508 - ParentType extends 12509 12509 - GQLResolversParentTypes['RotateApiKeyResponse'] = GQLResolversParentTypes['RotateApiKeyResponse'], 12555 12555 + ParentType extends GQLResolversParentTypes['RotateApiKeyResponse'] = 12556 12556 + GQLResolversParentTypes['RotateApiKeyResponse'], 12510 12557 > = { 12511 12558 __resolveType: TypeResolveFn< 12512 12559 'RotateApiKeyError' | 'RotateApiKeySuccessResponse', ··· 12517 12564 12518 12565 export type GQLRotateApiKeySuccessResponseResolvers< 12519 12566 ContextType = Context, 12520 12520 - ParentType extends 12521 12521 - GQLResolversParentTypes['RotateApiKeySuccessResponse'] = GQLResolversParentTypes['RotateApiKeySuccessResponse'], 12567 12567 + ParentType extends GQLResolversParentTypes['RotateApiKeySuccessResponse'] = 12568 12568 + GQLResolversParentTypes['RotateApiKeySuccessResponse'], 12522 12569 > = { 12523 12570 apiKey?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 12524 12571 record?: Resolver<GQLResolversTypes['ApiKey'], ParentType, ContextType>; ··· 12527 12574 12528 12575 export type GQLRotateWebhookSigningKeyErrorResolvers< 12529 12576 ContextType = Context, 12530 12530 - ParentType extends 12531 12531 - GQLResolversParentTypes['RotateWebhookSigningKeyError'] = GQLResolversParentTypes['RotateWebhookSigningKeyError'], 12577 12577 + ParentType extends GQLResolversParentTypes['RotateWebhookSigningKeyError'] = 12578 12578 + GQLResolversParentTypes['RotateWebhookSigningKeyError'], 12532 12579 > = { 12533 12580 detail?: Resolver< 12534 12581 Maybe<GQLResolversTypes['String']>, ··· 12558 12605 export type GQLRotateWebhookSigningKeyResponseResolvers< 12559 12606 ContextType = Context, 12560 12607 ParentType extends 12561 12561 - GQLResolversParentTypes['RotateWebhookSigningKeyResponse'] = GQLResolversParentTypes['RotateWebhookSigningKeyResponse'], 12608 12608 + GQLResolversParentTypes['RotateWebhookSigningKeyResponse'] = 12609 12609 + GQLResolversParentTypes['RotateWebhookSigningKeyResponse'], 12562 12610 > = { 12563 12611 __resolveType: TypeResolveFn< 12564 12612 'RotateWebhookSigningKeyError' | 'RotateWebhookSigningKeySuccessResponse', ··· 12570 12618 export type GQLRotateWebhookSigningKeySuccessResponseResolvers< 12571 12619 ContextType = Context, 12572 12620 ParentType extends 12573 12573 - GQLResolversParentTypes['RotateWebhookSigningKeySuccessResponse'] = GQLResolversParentTypes['RotateWebhookSigningKeySuccessResponse'], 12621 12621 + GQLResolversParentTypes['RotateWebhookSigningKeySuccessResponse'] = 12622 12622 + GQLResolversParentTypes['RotateWebhookSigningKeySuccessResponse'], 12574 12623 > = { 12575 12624 publicSigningKey?: Resolver< 12576 12625 GQLResolversTypes['String'], ··· 12582 12631 12583 12632 export type GQLRoutingRuleResolvers< 12584 12633 ContextType = Context, 12585 12585 - ParentType extends 12586 12586 - GQLResolversParentTypes['RoutingRule'] = GQLResolversParentTypes['RoutingRule'], 12634 12634 + ParentType extends GQLResolversParentTypes['RoutingRule'] = 12635 12635 + GQLResolversParentTypes['RoutingRule'], 12587 12636 > = { 12588 12637 conditionSet?: Resolver< 12589 12638 GQLResolversTypes['ConditionSet'], ··· 12617 12666 12618 12667 export type GQLRoutingRuleNameExistsErrorResolvers< 12619 12668 ContextType = Context, 12620 12620 - ParentType extends 12621 12621 - GQLResolversParentTypes['RoutingRuleNameExistsError'] = GQLResolversParentTypes['RoutingRuleNameExistsError'], 12669 12669 + ParentType extends GQLResolversParentTypes['RoutingRuleNameExistsError'] = 12670 12670 + GQLResolversParentTypes['RoutingRuleNameExistsError'], 12622 12671 > = { 12623 12672 detail?: Resolver< 12624 12673 Maybe<GQLResolversTypes['String']>, ··· 12647 12696 12648 12697 export type GQLRuleResolvers< 12649 12698 ContextType = Context, 12650 12650 - ParentType extends 12651 12651 - GQLResolversParentTypes['Rule'] = GQLResolversParentTypes['Rule'], 12699 12699 + ParentType extends GQLResolversParentTypes['Rule'] = 12700 12700 + GQLResolversParentTypes['Rule'], 12652 12701 > = { 12653 12702 __resolveType: TypeResolveFn< 12654 12703 'ContentRule' | 'UserRule', ··· 12659 12708 12660 12709 export type GQLRuleExecutionEnqueueSourceInfoResolvers< 12661 12710 ContextType = Context, 12662 12662 - ParentType extends 12663 12663 - GQLResolversParentTypes['RuleExecutionEnqueueSourceInfo'] = GQLResolversParentTypes['RuleExecutionEnqueueSourceInfo'], 12711 12711 + ParentType extends GQLResolversParentTypes['RuleExecutionEnqueueSourceInfo'] = 12712 12712 + GQLResolversParentTypes['RuleExecutionEnqueueSourceInfo'], 12664 12713 > = { 12665 12714 kind?: Resolver< 12666 12715 GQLResolversTypes['JobCreationSourceOptions'], ··· 12677 12726 12678 12727 export type GQLRuleExecutionResultResolvers< 12679 12728 ContextType = Context, 12680 12680 - ParentType extends 12681 12681 - GQLResolversParentTypes['RuleExecutionResult'] = GQLResolversParentTypes['RuleExecutionResult'], 12729 12729 + ParentType extends GQLResolversParentTypes['RuleExecutionResult'] = 12730 12730 + GQLResolversParentTypes['RuleExecutionResult'], 12682 12731 > = { 12683 12732 content?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 12684 12733 contentId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 12729 12778 12730 12779 export type GQLRuleExecutionResultEdgeResolvers< 12731 12780 ContextType = Context, 12732 12732 - ParentType extends 12733 12733 - GQLResolversParentTypes['RuleExecutionResultEdge'] = GQLResolversParentTypes['RuleExecutionResultEdge'], 12781 12781 + ParentType extends GQLResolversParentTypes['RuleExecutionResultEdge'] = 12782 12782 + GQLResolversParentTypes['RuleExecutionResultEdge'], 12734 12783 > = { 12735 12784 cursor?: Resolver<GQLResolversTypes['Cursor'], ParentType, ContextType>; 12736 12785 node?: Resolver< ··· 12742 12791 12743 12792 export type GQLRuleExecutionResultsConnectionResolvers< 12744 12793 ContextType = Context, 12745 12745 - ParentType extends 12746 12746 - GQLResolversParentTypes['RuleExecutionResultsConnection'] = GQLResolversParentTypes['RuleExecutionResultsConnection'], 12794 12794 + ParentType extends GQLResolversParentTypes['RuleExecutionResultsConnection'] = 12795 12795 + GQLResolversParentTypes['RuleExecutionResultsConnection'], 12747 12796 > = { 12748 12797 edges?: Resolver< 12749 12798 ReadonlyArray<GQLResolversTypes['RuleExecutionResultEdge']>, ··· 12755 12804 12756 12805 export type GQLRuleHasRunningBacktestsErrorResolvers< 12757 12806 ContextType = Context, 12758 12758 - ParentType extends 12759 12759 - GQLResolversParentTypes['RuleHasRunningBacktestsError'] = GQLResolversParentTypes['RuleHasRunningBacktestsError'], 12807 12807 + ParentType extends GQLResolversParentTypes['RuleHasRunningBacktestsError'] = 12808 12808 + GQLResolversParentTypes['RuleHasRunningBacktestsError'], 12760 12809 > = { 12761 12810 detail?: Resolver< 12762 12811 Maybe<GQLResolversTypes['String']>, ··· 12785 12834 12786 12835 export type GQLRuleInsightsResolvers< 12787 12836 ContextType = Context, 12788 12788 - ParentType extends 12789 12789 - GQLResolversParentTypes['RuleInsights'] = GQLResolversParentTypes['RuleInsights'], 12837 12837 + ParentType extends GQLResolversParentTypes['RuleInsights'] = 12838 12838 + GQLResolversParentTypes['RuleInsights'], 12790 12839 > = { 12791 12840 latestVersionSamples?: Resolver< 12792 12841 ReadonlyArray<GQLResolversTypes['RuleExecutionResult']>, ··· 12808 12857 12809 12858 export type GQLRuleNameExistsErrorResolvers< 12810 12859 ContextType = Context, 12811 12811 - ParentType extends 12812 12812 - GQLResolversParentTypes['RuleNameExistsError'] = GQLResolversParentTypes['RuleNameExistsError'], 12860 12860 + ParentType extends GQLResolversParentTypes['RuleNameExistsError'] = 12861 12861 + GQLResolversParentTypes['RuleNameExistsError'], 12813 12862 > = { 12814 12863 detail?: Resolver< 12815 12864 Maybe<GQLResolversTypes['String']>, ··· 12838 12887 12839 12888 export type GQLRulePassRateDataResolvers< 12840 12889 ContextType = Context, 12841 12841 - ParentType extends 12842 12842 - GQLResolversParentTypes['RulePassRateData'] = GQLResolversParentTypes['RulePassRateData'], 12890 12890 + ParentType extends GQLResolversParentTypes['RulePassRateData'] = 12891 12891 + GQLResolversParentTypes['RulePassRateData'], 12843 12892 > = { 12844 12893 date?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 12845 12894 totalMatches?: Resolver<GQLResolversTypes['Float'], ParentType, ContextType>; ··· 12848 12897 12849 12898 export type GQLRunRetroactionResponseResolvers< 12850 12899 ContextType = Context, 12851 12851 - ParentType extends 12852 12852 - GQLResolversParentTypes['RunRetroactionResponse'] = GQLResolversParentTypes['RunRetroactionResponse'], 12900 12900 + ParentType extends GQLResolversParentTypes['RunRetroactionResponse'] = 12901 12901 + GQLResolversParentTypes['RunRetroactionResponse'], 12853 12902 > = { 12854 12903 __resolveType: TypeResolveFn< 12855 12904 'RunRetroactionSuccessResponse', ··· 12860 12909 12861 12910 export type GQLRunRetroactionSuccessResponseResolvers< 12862 12911 ContextType = Context, 12863 12863 - ParentType extends 12864 12864 - GQLResolversParentTypes['RunRetroactionSuccessResponse'] = GQLResolversParentTypes['RunRetroactionSuccessResponse'], 12912 12912 + ParentType extends GQLResolversParentTypes['RunRetroactionSuccessResponse'] = 12913 12913 + GQLResolversParentTypes['RunRetroactionSuccessResponse'], 12865 12914 > = { 12866 12915 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 12867 12916 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 12869 12918 12870 12919 export type GQLScalarSignalOutputTypeResolvers< 12871 12920 ContextType = Context, 12872 12872 - ParentType extends 12873 12873 - GQLResolversParentTypes['ScalarSignalOutputType'] = GQLResolversParentTypes['ScalarSignalOutputType'], 12921 12921 + ParentType extends GQLResolversParentTypes['ScalarSignalOutputType'] = 12922 12922 + GQLResolversParentTypes['ScalarSignalOutputType'], 12874 12923 > = { 12875 12924 scalarType?: Resolver< 12876 12925 GQLResolversTypes['ScalarType'], ··· 12882 12931 12883 12932 export type GQLSchemaFieldRolesResolvers< 12884 12933 ContextType = Context, 12885 12885 - ParentType extends 12886 12886 - GQLResolversParentTypes['SchemaFieldRoles'] = GQLResolversParentTypes['SchemaFieldRoles'], 12934 12934 + ParentType extends GQLResolversParentTypes['SchemaFieldRoles'] = 12935 12935 + GQLResolversParentTypes['SchemaFieldRoles'], 12887 12936 > = { 12888 12937 __resolveType: TypeResolveFn< 12889 12938 | 'ContentSchemaFieldRoles' ··· 12897 12946 export type GQLSetAllUserStrikeThresholdsSuccessResponseResolvers< 12898 12947 ContextType = Context, 12899 12948 ParentType extends 12900 12900 - GQLResolversParentTypes['SetAllUserStrikeThresholdsSuccessResponse'] = GQLResolversParentTypes['SetAllUserStrikeThresholdsSuccessResponse'], 12949 12949 + GQLResolversParentTypes['SetAllUserStrikeThresholdsSuccessResponse'] = 12950 12950 + GQLResolversParentTypes['SetAllUserStrikeThresholdsSuccessResponse'], 12901 12951 > = { 12902 12952 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 12903 12953 }; 12904 12954 12905 12955 export type GQLSetIntegrationConfigResponseResolvers< 12906 12956 ContextType = Context, 12907 12907 - ParentType extends 12908 12908 - GQLResolversParentTypes['SetIntegrationConfigResponse'] = GQLResolversParentTypes['SetIntegrationConfigResponse'], 12957 12957 + ParentType extends GQLResolversParentTypes['SetIntegrationConfigResponse'] = 12958 12958 + GQLResolversParentTypes['SetIntegrationConfigResponse'], 12909 12959 > = { 12910 12960 __resolveType: TypeResolveFn< 12911 12961 | 'IntegrationConfigTooManyCredentialsError' ··· 12920 12970 export type GQLSetIntegrationConfigSuccessResponseResolvers< 12921 12971 ContextType = Context, 12922 12972 ParentType extends 12923 12923 - GQLResolversParentTypes['SetIntegrationConfigSuccessResponse'] = GQLResolversParentTypes['SetIntegrationConfigSuccessResponse'], 12973 12973 + GQLResolversParentTypes['SetIntegrationConfigSuccessResponse'] = 12974 12974 + GQLResolversParentTypes['SetIntegrationConfigSuccessResponse'], 12924 12975 > = { 12925 12976 config?: Resolver< 12926 12977 GQLResolversTypes['IntegrationConfig'], ··· 12933 12984 export type GQLSetModeratorSafetySettingsSuccessResponseResolvers< 12934 12985 ContextType = Context, 12935 12986 ParentType extends 12936 12936 - GQLResolversParentTypes['SetModeratorSafetySettingsSuccessResponse'] = GQLResolversParentTypes['SetModeratorSafetySettingsSuccessResponse'], 12987 12987 + GQLResolversParentTypes['SetModeratorSafetySettingsSuccessResponse'] = 12988 12988 + GQLResolversParentTypes['SetModeratorSafetySettingsSuccessResponse'], 12937 12989 > = { 12938 12990 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 12939 12991 }; ··· 12941 12993 export type GQLSetMrtChartConfigurationSettingsSuccessResponseResolvers< 12942 12994 ContextType = Context, 12943 12995 ParentType extends 12944 12944 - GQLResolversParentTypes['SetMrtChartConfigurationSettingsSuccessResponse'] = GQLResolversParentTypes['SetMrtChartConfigurationSettingsSuccessResponse'], 12996 12996 + GQLResolversParentTypes['SetMrtChartConfigurationSettingsSuccessResponse'] = 12997 12997 + GQLResolversParentTypes['SetMrtChartConfigurationSettingsSuccessResponse'], 12945 12998 > = { 12946 12999 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 12947 13000 }; 12948 13001 12949 13002 export type GQLSignUpResponseResolvers< 12950 13003 ContextType = Context, 12951 12951 - ParentType extends 12952 12952 - GQLResolversParentTypes['SignUpResponse'] = GQLResolversParentTypes['SignUpResponse'], 13004 13004 + ParentType extends GQLResolversParentTypes['SignUpResponse'] = 13005 13005 + GQLResolversParentTypes['SignUpResponse'], 12953 13006 > = { 12954 13007 __resolveType: TypeResolveFn< 12955 13008 'SignUpSuccessResponse' | 'SignUpUserExistsError', ··· 12960 13013 12961 13014 export type GQLSignUpSuccessResponseResolvers< 12962 13015 ContextType = Context, 12963 12963 - ParentType extends 12964 12964 - GQLResolversParentTypes['SignUpSuccessResponse'] = GQLResolversParentTypes['SignUpSuccessResponse'], 13016 13016 + ParentType extends GQLResolversParentTypes['SignUpSuccessResponse'] = 13017 13017 + GQLResolversParentTypes['SignUpSuccessResponse'], 12965 13018 > = { 12966 13019 data?: Resolver<Maybe<GQLResolversTypes['User']>, ParentType, ContextType>; 12967 13020 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 12969 13022 12970 13023 export type GQLSignUpUserExistsErrorResolvers< 12971 13024 ContextType = Context, 12972 12972 - ParentType extends 12973 12973 - GQLResolversParentTypes['SignUpUserExistsError'] = GQLResolversParentTypes['SignUpUserExistsError'], 13025 13025 + ParentType extends GQLResolversParentTypes['SignUpUserExistsError'] = 13026 13026 + GQLResolversParentTypes['SignUpUserExistsError'], 12974 13027 > = { 12975 13028 detail?: Resolver< 12976 13029 Maybe<GQLResolversTypes['String']>, ··· 12999 13052 13000 13053 export type GQLSignalResolvers< 13001 13054 ContextType = Context, 13002 13002 - ParentType extends 13003 13003 - GQLResolversParentTypes['Signal'] = GQLResolversParentTypes['Signal'], 13055 13055 + ParentType extends GQLResolversParentTypes['Signal'] = 13056 13056 + GQLResolversParentTypes['Signal'], 13004 13057 > = { 13005 13058 allowedInAutomatedRules?: Resolver< 13006 13059 GQLResolversTypes['Boolean'], ··· 13105 13158 13106 13159 export type GQLSignalArgsResolvers< 13107 13160 ContextType = Context, 13108 13108 - ParentType extends 13109 13109 - GQLResolversParentTypes['SignalArgs'] = GQLResolversParentTypes['SignalArgs'], 13161 13161 + ParentType extends GQLResolversParentTypes['SignalArgs'] = 13162 13162 + GQLResolversParentTypes['SignalArgs'], 13110 13163 > = { 13111 13164 __resolveType: TypeResolveFn< 13112 13165 'AggregationSignalArgs', ··· 13117 13170 13118 13171 export type GQLSignalOutputTypeResolvers< 13119 13172 ContextType = Context, 13120 13120 - ParentType extends 13121 13121 - GQLResolversParentTypes['SignalOutputType'] = GQLResolversParentTypes['SignalOutputType'], 13173 13173 + ParentType extends GQLResolversParentTypes['SignalOutputType'] = 13174 13174 + GQLResolversParentTypes['SignalOutputType'], 13122 13175 > = { 13123 13176 __resolveType: TypeResolveFn< 13124 13177 'EnumSignalOutputType' | 'ScalarSignalOutputType', ··· 13129 13182 13130 13183 export type GQLSignalPricingStructureResolvers< 13131 13184 ContextType = Context, 13132 13132 - ParentType extends 13133 13133 - GQLResolversParentTypes['SignalPricingStructure'] = GQLResolversParentTypes['SignalPricingStructure'], 13185 13185 + ParentType extends GQLResolversParentTypes['SignalPricingStructure'] = 13186 13186 + GQLResolversParentTypes['SignalPricingStructure'], 13134 13187 > = { 13135 13188 type?: Resolver< 13136 13189 GQLResolversTypes['SignalPricingStructureType'], ··· 13141 13194 13142 13195 export type GQLSignalSubcategoryResolvers< 13143 13196 ContextType = Context, 13144 13144 - ParentType extends 13145 13145 - GQLResolversParentTypes['SignalSubcategory'] = GQLResolversParentTypes['SignalSubcategory'], 13197 13197 + ParentType extends GQLResolversParentTypes['SignalSubcategory'] = 13198 13198 + GQLResolversParentTypes['SignalSubcategory'], 13146 13199 > = { 13147 13200 childrenIds?: Resolver< 13148 13201 ReadonlyArray<GQLResolversTypes['String']>, ··· 13160 13213 13161 13214 export type GQLSignalWithScoreResolvers< 13162 13215 ContextType = Context, 13163 13163 - ParentType extends 13164 13164 - GQLResolversParentTypes['SignalWithScore'] = GQLResolversParentTypes['SignalWithScore'], 13216 13216 + ParentType extends GQLResolversParentTypes['SignalWithScore'] = 13217 13217 + GQLResolversParentTypes['SignalWithScore'], 13165 13218 > = { 13166 13219 integration?: Resolver< 13167 13220 Maybe<GQLResolversTypes['String']>, ··· 13179 13232 13180 13233 export type GQLSkippedJobResolvers< 13181 13234 ContextType = Context, 13182 13182 - ParentType extends 13183 13183 - GQLResolversParentTypes['SkippedJob'] = GQLResolversParentTypes['SkippedJob'], 13235 13235 + ParentType extends GQLResolversParentTypes['SkippedJob'] = 13236 13236 + GQLResolversParentTypes['SkippedJob'], 13184 13237 > = { 13185 13238 jobId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 13186 13239 queueId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 13190 13243 13191 13244 export type GQLSkippedJobCountResolvers< 13192 13245 ContextType = Context, 13193 13193 - ParentType extends 13194 13194 - GQLResolversParentTypes['SkippedJobCount'] = GQLResolversParentTypes['SkippedJobCount'], 13246 13246 + ParentType extends GQLResolversParentTypes['SkippedJobCount'] = 13247 13247 + GQLResolversParentTypes['SkippedJobCount'], 13195 13248 > = { 13196 13249 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 13197 13250 queueId?: Resolver< ··· 13207 13260 time?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 13208 13261 }; 13209 13262 13210 13210 - export interface GQLStringOrFloatScalarConfig 13211 13211 - extends GraphQLScalarTypeConfig<GQLResolversTypes['StringOrFloat'], any> { 13263 13263 + export interface GQLStringOrFloatScalarConfig extends GraphQLScalarTypeConfig< 13264 13264 + GQLResolversTypes['StringOrFloat'], 13265 13265 + any 13266 13266 + > { 13212 13267 name: 'StringOrFloat'; 13213 13268 } 13214 13269 13215 13270 export type GQLSubmitDecisionResponseResolvers< 13216 13271 ContextType = Context, 13217 13217 - ParentType extends 13218 13218 - GQLResolversParentTypes['SubmitDecisionResponse'] = GQLResolversParentTypes['SubmitDecisionResponse'], 13272 13272 + ParentType extends GQLResolversParentTypes['SubmitDecisionResponse'] = 13273 13273 + GQLResolversParentTypes['SubmitDecisionResponse'], 13219 13274 > = { 13220 13275 __resolveType: TypeResolveFn< 13221 13276 | 'JobHasAlreadyBeenSubmittedError' ··· 13230 13285 13231 13286 export type GQLSubmitDecisionSuccessResponseResolvers< 13232 13287 ContextType = Context, 13233 13233 - ParentType extends 13234 13234 - GQLResolversParentTypes['SubmitDecisionSuccessResponse'] = GQLResolversParentTypes['SubmitDecisionSuccessResponse'], 13288 13288 + ParentType extends GQLResolversParentTypes['SubmitDecisionSuccessResponse'] = 13289 13289 + GQLResolversParentTypes['SubmitDecisionSuccessResponse'], 13235 13290 > = { 13236 13291 success?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; 13237 13292 __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>; ··· 13240 13295 export type GQLSubmitNcmecReportDecisionComponentResolvers< 13241 13296 ContextType = Context, 13242 13297 ParentType extends 13243 13243 - GQLResolversParentTypes['SubmitNCMECReportDecisionComponent'] = GQLResolversParentTypes['SubmitNCMECReportDecisionComponent'], 13298 13298 + GQLResolversParentTypes['SubmitNCMECReportDecisionComponent'] = 13299 13299 + GQLResolversParentTypes['SubmitNCMECReportDecisionComponent'], 13244 13300 > = { 13245 13301 reportedMedia?: Resolver< 13246 13302 ReadonlyArray<GQLResolversTypes['NcmecReportedMediaDetails']>, ··· 13258 13314 export type GQLSubmittedJobActionNotFoundErrorResolvers< 13259 13315 ContextType = Context, 13260 13316 ParentType extends 13261 13261 - GQLResolversParentTypes['SubmittedJobActionNotFoundError'] = GQLResolversParentTypes['SubmittedJobActionNotFoundError'], 13317 13317 + GQLResolversParentTypes['SubmittedJobActionNotFoundError'] = 13318 13318 + GQLResolversParentTypes['SubmittedJobActionNotFoundError'], 13262 13319 > = { 13263 13320 detail?: Resolver< 13264 13321 Maybe<GQLResolversTypes['String']>, ··· 13287 13344 13288 13345 export type GQLSupportedLanguagesResolvers< 13289 13346 ContextType = Context, 13290 13290 - ParentType extends 13291 13291 - GQLResolversParentTypes['SupportedLanguages'] = GQLResolversParentTypes['SupportedLanguages'], 13347 13347 + ParentType extends GQLResolversParentTypes['SupportedLanguages'] = 13348 13348 + GQLResolversParentTypes['SupportedLanguages'], 13292 13349 > = { 13293 13350 __resolveType: TypeResolveFn< 13294 13351 'AllLanguages' | 'Languages', ··· 13299 13356 13300 13357 export type GQLTableDecisionCountResolvers< 13301 13358 ContextType = Context, 13302 13302 - ParentType extends 13303 13303 - GQLResolversParentTypes['TableDecisionCount'] = GQLResolversParentTypes['TableDecisionCount'], 13359 13359 + ParentType extends GQLResolversParentTypes['TableDecisionCount'] = 13360 13360 + GQLResolversParentTypes['TableDecisionCount'], 13304 13361 > = { 13305 13362 action_id?: Resolver< 13306 13363 Maybe<GQLResolversTypes['String']>, ··· 13327 13384 13328 13385 export type GQLTextBankResolvers< 13329 13386 ContextType = Context, 13330 13330 - ParentType extends 13331 13331 - GQLResolversParentTypes['TextBank'] = GQLResolversParentTypes['TextBank'], 13387 13387 + ParentType extends GQLResolversParentTypes['TextBank'] = 13388 13388 + GQLResolversParentTypes['TextBank'], 13332 13389 > = { 13333 13390 description?: Resolver< 13334 13391 Maybe<GQLResolversTypes['String']>, ··· 13348 13405 export type GQLThreadAppealManualReviewJobPayloadResolvers< 13349 13406 ContextType = Context, 13350 13407 ParentType extends 13351 13351 - GQLResolversParentTypes['ThreadAppealManualReviewJobPayload'] = GQLResolversParentTypes['ThreadAppealManualReviewJobPayload'], 13408 13408 + GQLResolversParentTypes['ThreadAppealManualReviewJobPayload'] = 13409 13409 + GQLResolversParentTypes['ThreadAppealManualReviewJobPayload'], 13352 13410 > = { 13353 13411 actionsTaken?: Resolver< 13354 13412 ReadonlyArray<GQLResolversTypes['String']>, ··· 13377 13435 13378 13436 export type GQLThreadItemResolvers< 13379 13437 ContextType = Context, 13380 13380 - ParentType extends 13381 13381 - GQLResolversParentTypes['ThreadItem'] = GQLResolversParentTypes['ThreadItem'], 13438 13438 + ParentType extends GQLResolversParentTypes['ThreadItem'] = 13439 13439 + GQLResolversParentTypes['ThreadItem'], 13382 13440 > = { 13383 13441 data?: Resolver<GQLResolversTypes['JSONObject'], ParentType, ContextType>; 13384 13442 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; ··· 13394 13452 13395 13453 export type GQLThreadItemTypeResolvers< 13396 13454 ContextType = Context, 13397 13397 - ParentType extends 13398 13398 - GQLResolversParentTypes['ThreadItemType'] = GQLResolversParentTypes['ThreadItemType'], 13455 13455 + ParentType extends GQLResolversParentTypes['ThreadItemType'] = 13456 13456 + GQLResolversParentTypes['ThreadItemType'], 13399 13457 > = { 13400 13458 baseFields?: Resolver< 13401 13459 ReadonlyArray<GQLResolversTypes['BaseField']>, ··· 13435 13493 13436 13494 export type GQLThreadManualReviewJobPayloadResolvers< 13437 13495 ContextType = Context, 13438 13438 - ParentType extends 13439 13439 - GQLResolversParentTypes['ThreadManualReviewJobPayload'] = GQLResolversParentTypes['ThreadManualReviewJobPayload'], 13496 13496 + ParentType extends GQLResolversParentTypes['ThreadManualReviewJobPayload'] = 13497 13497 + GQLResolversParentTypes['ThreadManualReviewJobPayload'], 13440 13498 > = { 13441 13499 enqueueSourceInfo?: Resolver< 13442 13500 Maybe<GQLResolversTypes['ManualReviewJobEnqueueSourceInfo']>, ··· 13469 13527 13470 13528 export type GQLThreadSchemaFieldRolesResolvers< 13471 13529 ContextType = Context, 13472 13472 - ParentType extends 13473 13473 - GQLResolversParentTypes['ThreadSchemaFieldRoles'] = GQLResolversParentTypes['ThreadSchemaFieldRoles'], 13530 13530 + ParentType extends GQLResolversParentTypes['ThreadSchemaFieldRoles'] = 13531 13531 + GQLResolversParentTypes['ThreadSchemaFieldRoles'], 13474 13532 > = { 13475 13533 createdAt?: Resolver< 13476 13534 Maybe<GQLResolversTypes['String']>, ··· 13497 13555 13498 13556 export type GQLThreadWithMessagesResolvers< 13499 13557 ContextType = Context, 13500 13500 - ParentType extends 13501 13501 - GQLResolversParentTypes['ThreadWithMessages'] = GQLResolversParentTypes['ThreadWithMessages'], 13558 13558 + ParentType extends GQLResolversParentTypes['ThreadWithMessages'] = 13559 13559 + GQLResolversParentTypes['ThreadWithMessages'], 13502 13560 > = { 13503 13561 messages?: Resolver< 13504 13562 ReadonlyArray<GQLResolversTypes['ItemSubmissions']>, ··· 13511 13569 13512 13570 export type GQLThreadWithMessagesAndIpAddressResolvers< 13513 13571 ContextType = Context, 13514 13514 - ParentType extends 13515 13515 - GQLResolversParentTypes['ThreadWithMessagesAndIpAddress'] = GQLResolversParentTypes['ThreadWithMessagesAndIpAddress'], 13572 13572 + ParentType extends GQLResolversParentTypes['ThreadWithMessagesAndIpAddress'] = 13573 13573 + GQLResolversParentTypes['ThreadWithMessagesAndIpAddress'], 13516 13574 > = { 13517 13575 messages?: Resolver< 13518 13576 ReadonlyArray<GQLResolversTypes['MessageWithIpAddress']>, ··· 13525 13583 13526 13584 export type GQLTimeToActionResolvers< 13527 13585 ContextType = Context, 13528 13528 - ParentType extends 13529 13529 - GQLResolversParentTypes['TimeToAction'] = GQLResolversParentTypes['TimeToAction'], 13586 13586 + ParentType extends GQLResolversParentTypes['TimeToAction'] = 13587 13587 + GQLResolversParentTypes['TimeToAction'], 13530 13588 > = { 13531 13589 itemTypeId?: Resolver< 13532 13590 Maybe<GQLResolversTypes['String']>, ··· 13548 13606 export type GQLTransformJobAndRecreateInQueueDecisionComponentResolvers< 13549 13607 ContextType = Context, 13550 13608 ParentType extends 13551 13551 - GQLResolversParentTypes['TransformJobAndRecreateInQueueDecisionComponent'] = GQLResolversParentTypes['TransformJobAndRecreateInQueueDecisionComponent'], 13609 13609 + GQLResolversParentTypes['TransformJobAndRecreateInQueueDecisionComponent'] = 13610 13610 + GQLResolversParentTypes['TransformJobAndRecreateInQueueDecisionComponent'], 13552 13611 > = { 13553 13612 newJobKind?: Resolver< 13554 13613 GQLResolversTypes['ManualReviewJobKind'], ··· 13580 13639 13581 13640 export type GQLUpdateContentRuleResponseResolvers< 13582 13641 ContextType = Context, 13583 13583 - ParentType extends 13584 13584 - GQLResolversParentTypes['UpdateContentRuleResponse'] = GQLResolversParentTypes['UpdateContentRuleResponse'], 13642 13642 + ParentType extends GQLResolversParentTypes['UpdateContentRuleResponse'] = 13643 13643 + GQLResolversParentTypes['UpdateContentRuleResponse'], 13585 13644 > = { 13586 13645 __resolveType: TypeResolveFn< 13587 13646 | 'MutateContentRuleSuccessResponse' ··· 13596 13655 export type GQLUpdateManualReviewQueueQueueResponseResolvers< 13597 13656 ContextType = Context, 13598 13657 ParentType extends 13599 13599 - GQLResolversParentTypes['UpdateManualReviewQueueQueueResponse'] = GQLResolversParentTypes['UpdateManualReviewQueueQueueResponse'], 13658 13658 + GQLResolversParentTypes['UpdateManualReviewQueueQueueResponse'] = 13659 13659 + GQLResolversParentTypes['UpdateManualReviewQueueQueueResponse'], 13600 13660 > = { 13601 13661 __resolveType: TypeResolveFn< 13602 13662 | 'ManualReviewQueueNameExistsError' ··· 13609 13669 13610 13670 export type GQLUpdateNcmecOrgSettingsResponseResolvers< 13611 13671 ContextType = Context, 13612 13612 - ParentType extends 13613 13613 - GQLResolversParentTypes['UpdateNcmecOrgSettingsResponse'] = GQLResolversParentTypes['UpdateNcmecOrgSettingsResponse'], 13672 13672 + ParentType extends GQLResolversParentTypes['UpdateNcmecOrgSettingsResponse'] = 13673 13673 + GQLResolversParentTypes['UpdateNcmecOrgSettingsResponse'], 13614 13674 > = { 13615 13675 success?: Resolver<GQLResolversTypes['Boolean'], ParentType, ContextType>; 13616 13676 }; 13617 13677 13618 13678 export type GQLUpdateOrgInfoSuccessResponseResolvers< 13619 13679 ContextType = Context, 13620 13620 - ParentType extends 13621 13621 - GQLResolversParentTypes['UpdateOrgInfoSuccessResponse'] = GQLResolversParentTypes['UpdateOrgInfoSuccessResponse'], 13680 13680 + ParentType extends GQLResolversParentTypes['UpdateOrgInfoSuccessResponse'] = 13681 13681 + GQLResolversParentTypes['UpdateOrgInfoSuccessResponse'], 13622 13682 > = { 13623 13683 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 13624 13684 }; 13625 13685 13626 13686 export type GQLUpdatePolicyResponseResolvers< 13627 13687 ContextType = Context, 13628 13628 - ParentType extends 13629 13629 - GQLResolversParentTypes['UpdatePolicyResponse'] = GQLResolversParentTypes['UpdatePolicyResponse'], 13688 13688 + ParentType extends GQLResolversParentTypes['UpdatePolicyResponse'] = 13689 13689 + GQLResolversParentTypes['UpdatePolicyResponse'], 13630 13690 > = { 13631 13691 __resolveType: TypeResolveFn< 13632 13692 'NotFoundError' | 'Policy', ··· 13637 13697 13638 13698 export type GQLUpdateReportingRuleResponseResolvers< 13639 13699 ContextType = Context, 13640 13640 - ParentType extends 13641 13641 - GQLResolversParentTypes['UpdateReportingRuleResponse'] = GQLResolversParentTypes['UpdateReportingRuleResponse'], 13700 13700 + ParentType extends GQLResolversParentTypes['UpdateReportingRuleResponse'] = 13701 13701 + GQLResolversParentTypes['UpdateReportingRuleResponse'], 13642 13702 > = { 13643 13703 __resolveType: TypeResolveFn< 13644 13704 | 'MutateReportingRuleSuccessResponse' ··· 13651 13711 13652 13712 export type GQLUpdateRoutingRuleResponseResolvers< 13653 13713 ContextType = Context, 13654 13654 - ParentType extends 13655 13655 - GQLResolversParentTypes['UpdateRoutingRuleResponse'] = GQLResolversParentTypes['UpdateRoutingRuleResponse'], 13714 13714 + ParentType extends GQLResolversParentTypes['UpdateRoutingRuleResponse'] = 13715 13715 + GQLResolversParentTypes['UpdateRoutingRuleResponse'], 13656 13716 > = { 13657 13717 __resolveType: TypeResolveFn< 13658 13718 | 'MutateRoutingRuleSuccessResponse' ··· 13666 13726 13667 13727 export type GQLUpdateUserRuleResponseResolvers< 13668 13728 ContextType = Context, 13669 13669 - ParentType extends 13670 13670 - GQLResolversParentTypes['UpdateUserRuleResponse'] = GQLResolversParentTypes['UpdateUserRuleResponse'], 13729 13729 + ParentType extends GQLResolversParentTypes['UpdateUserRuleResponse'] = 13730 13730 + GQLResolversParentTypes['UpdateUserRuleResponse'], 13671 13731 > = { 13672 13732 __resolveType: TypeResolveFn< 13673 13733 | 'MutateUserRuleSuccessResponse' ··· 13682 13742 export type GQLUpdateUserStrikeTtlSuccessResponseResolvers< 13683 13743 ContextType = Context, 13684 13744 ParentType extends 13685 13685 - GQLResolversParentTypes['UpdateUserStrikeTTLSuccessResponse'] = GQLResolversParentTypes['UpdateUserStrikeTTLSuccessResponse'], 13745 13745 + GQLResolversParentTypes['UpdateUserStrikeTTLSuccessResponse'] = 13746 13746 + GQLResolversParentTypes['UpdateUserStrikeTTLSuccessResponse'], 13686 13747 > = { 13687 13748 _?: Resolver<Maybe<GQLResolversTypes['Boolean']>, ParentType, ContextType>; 13688 13749 }; 13689 13750 13690 13751 export type GQLUserResolvers< 13691 13752 ContextType = Context, 13692 13692 - ParentType extends 13693 13693 - GQLResolversParentTypes['User'] = GQLResolversParentTypes['User'], 13753 13753 + ParentType extends GQLResolversParentTypes['User'] = 13754 13754 + GQLResolversParentTypes['User'], 13694 13755 > = { 13695 13756 approvedByAdmin?: Resolver< 13696 13757 Maybe<GQLResolversTypes['Boolean']>, ··· 13758 13819 13759 13820 export type GQLUserActionsHistoryResolvers< 13760 13821 ContextType = Context, 13761 13761 - ParentType extends 13762 13762 - GQLResolversParentTypes['UserActionsHistory'] = GQLResolversParentTypes['UserActionsHistory'], 13822 13822 + ParentType extends GQLResolversParentTypes['UserActionsHistory'] = 13823 13823 + GQLResolversParentTypes['UserActionsHistory'], 13763 13824 > = { 13764 13825 countsByPolicy?: Resolver< 13765 13826 ReadonlyArray<GQLResolversTypes['PolicyActionCount']>, ··· 13771 13832 export type GQLUserAppealManualReviewJobPayloadResolvers< 13772 13833 ContextType = Context, 13773 13834 ParentType extends 13774 13774 - GQLResolversParentTypes['UserAppealManualReviewJobPayload'] = GQLResolversParentTypes['UserAppealManualReviewJobPayload'], 13835 13835 + GQLResolversParentTypes['UserAppealManualReviewJobPayload'] = 13836 13836 + GQLResolversParentTypes['UserAppealManualReviewJobPayload'], 13775 13837 > = { 13776 13838 actionsTaken?: Resolver< 13777 13839 ReadonlyArray<GQLResolversTypes['String']>, ··· 13815 13877 13816 13878 export type GQLUserHistoryResolvers< 13817 13879 ContextType = Context, 13818 13818 - ParentType extends 13819 13819 - GQLResolversParentTypes['UserHistory'] = GQLResolversParentTypes['UserHistory'], 13880 13880 + ParentType extends GQLResolversParentTypes['UserHistory'] = 13881 13881 + GQLResolversParentTypes['UserHistory'], 13820 13882 > = { 13821 13883 actions?: Resolver< 13822 13884 GQLResolversTypes['UserActionsHistory'], ··· 13844 13906 13845 13907 export type GQLUserHistoryResponseResolvers< 13846 13908 ContextType = Context, 13847 13847 - ParentType extends 13848 13848 - GQLResolversParentTypes['UserHistoryResponse'] = GQLResolversParentTypes['UserHistoryResponse'], 13909 13909 + ParentType extends GQLResolversParentTypes['UserHistoryResponse'] = 13910 13910 + GQLResolversParentTypes['UserHistoryResponse'], 13849 13911 > = { 13850 13912 __resolveType: TypeResolveFn< 13851 13913 'NotFoundError' | 'UserHistory', ··· 13856 13918 13857 13919 export type GQLUserInterfacePreferencesResolvers< 13858 13920 ContextType = Context, 13859 13859 - ParentType extends 13860 13860 - GQLResolversParentTypes['UserInterfacePreferences'] = GQLResolversParentTypes['UserInterfacePreferences'], 13921 13921 + ParentType extends GQLResolversParentTypes['UserInterfacePreferences'] = 13922 13922 + GQLResolversParentTypes['UserInterfacePreferences'], 13861 13923 > = { 13862 13924 moderatorSafetyBlurLevel?: Resolver< 13863 13925 GQLResolversTypes['Int'], ··· 13883 13945 13884 13946 export type GQLUserItemResolvers< 13885 13947 ContextType = Context, 13886 13886 - ParentType extends 13887 13887 - GQLResolversParentTypes['UserItem'] = GQLResolversParentTypes['UserItem'], 13948 13948 + ParentType extends GQLResolversParentTypes['UserItem'] = 13949 13949 + GQLResolversParentTypes['UserItem'], 13888 13950 > = { 13889 13951 data?: Resolver<GQLResolversTypes['JSONObject'], ParentType, ContextType>; 13890 13952 id?: Resolver<GQLResolversTypes['ID'], ParentType, ContextType>; ··· 13901 13963 13902 13964 export type GQLUserItemTypeResolvers< 13903 13965 ContextType = Context, 13904 13904 - ParentType extends 13905 13905 - GQLResolversParentTypes['UserItemType'] = GQLResolversParentTypes['UserItemType'], 13966 13966 + ParentType extends GQLResolversParentTypes['UserItemType'] = 13967 13967 + GQLResolversParentTypes['UserItemType'], 13906 13968 > = { 13907 13969 baseFields?: Resolver< 13908 13970 ReadonlyArray<GQLResolversTypes['BaseField']>, ··· 13947 14009 13948 14010 export type GQLUserManualReviewJobPayloadResolvers< 13949 14011 ContextType = Context, 13950 13950 - ParentType extends 13951 13951 - GQLResolversParentTypes['UserManualReviewJobPayload'] = GQLResolversParentTypes['UserManualReviewJobPayload'], 14012 14012 + ParentType extends GQLResolversParentTypes['UserManualReviewJobPayload'] = 14013 14013 + GQLResolversParentTypes['UserManualReviewJobPayload'], 13952 14014 > = { 13953 14015 additionalContentItems?: Resolver< 13954 14016 ReadonlyArray<GQLResolversTypes['ContentItem']>, ··· 13996 14058 13997 14059 export type GQLUserNotificationEdgeResolvers< 13998 14060 ContextType = Context, 13999 13999 - ParentType extends 14000 14000 - GQLResolversParentTypes['UserNotificationEdge'] = GQLResolversParentTypes['UserNotificationEdge'], 14061 14061 + ParentType extends GQLResolversParentTypes['UserNotificationEdge'] = 14062 14062 + GQLResolversParentTypes['UserNotificationEdge'], 14001 14063 > = { 14002 14064 node?: Resolver<GQLResolversTypes['Notification'], ParentType, ContextType>; 14003 14065 }; 14004 14066 14005 14067 export type GQLUserNotificationsResolvers< 14006 14068 ContextType = Context, 14007 14007 - ParentType extends 14008 14008 - GQLResolversParentTypes['UserNotifications'] = GQLResolversParentTypes['UserNotifications'], 14069 14069 + ParentType extends GQLResolversParentTypes['UserNotifications'] = 14070 14070 + GQLResolversParentTypes['UserNotifications'], 14009 14071 > = { 14010 14072 edges?: Resolver< 14011 14073 ReadonlyArray<GQLResolversTypes['UserNotificationEdge']>, ··· 14017 14079 export type GQLUserOrRelatedActionDecisionComponentResolvers< 14018 14080 ContextType = Context, 14019 14081 ParentType extends 14020 14020 - GQLResolversParentTypes['UserOrRelatedActionDecisionComponent'] = GQLResolversParentTypes['UserOrRelatedActionDecisionComponent'], 14082 14082 + GQLResolversParentTypes['UserOrRelatedActionDecisionComponent'] = 14083 14083 + GQLResolversParentTypes['UserOrRelatedActionDecisionComponent'], 14021 14084 > = { 14022 14085 actionIds?: Resolver< 14023 14086 ReadonlyArray<GQLResolversTypes['String']>, ··· 14050 14113 14051 14114 export type GQLUserRuleResolvers< 14052 14115 ContextType = Context, 14053 14053 - ParentType extends 14054 14054 - GQLResolversParentTypes['UserRule'] = GQLResolversParentTypes['UserRule'], 14116 14116 + ParentType extends GQLResolversParentTypes['UserRule'] = 14117 14117 + GQLResolversParentTypes['UserRule'], 14055 14118 > = { 14056 14119 actions?: Resolver< 14057 14120 ReadonlyArray<GQLResolversTypes['Action']>, ··· 14111 14174 14112 14175 export type GQLUserSchemaFieldRolesResolvers< 14113 14176 ContextType = Context, 14114 14114 - ParentType extends 14115 14115 - GQLResolversParentTypes['UserSchemaFieldRoles'] = GQLResolversParentTypes['UserSchemaFieldRoles'], 14177 14177 + ParentType extends GQLResolversParentTypes['UserSchemaFieldRoles'] = 14178 14178 + GQLResolversParentTypes['UserSchemaFieldRoles'], 14116 14179 > = { 14117 14180 backgroundImage?: Resolver< 14118 14181 Maybe<GQLResolversTypes['String']>, ··· 14144 14207 14145 14208 export type GQLUserStrikeBucketResolvers< 14146 14209 ContextType = Context, 14147 14147 - ParentType extends 14148 14148 - GQLResolversParentTypes['UserStrikeBucket'] = GQLResolversParentTypes['UserStrikeBucket'], 14210 14210 + ParentType extends GQLResolversParentTypes['UserStrikeBucket'] = 14211 14211 + GQLResolversParentTypes['UserStrikeBucket'], 14149 14212 > = { 14150 14213 numStrikes?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 14151 14214 numUsers?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; ··· 14153 14216 14154 14217 export type GQLUserStrikeThresholdResolvers< 14155 14218 ContextType = Context, 14156 14156 - ParentType extends 14157 14157 - GQLResolversParentTypes['UserStrikeThreshold'] = GQLResolversParentTypes['UserStrikeThreshold'], 14219 14219 + ParentType extends GQLResolversParentTypes['UserStrikeThreshold'] = 14220 14220 + GQLResolversParentTypes['UserStrikeThreshold'], 14158 14221 > = { 14159 14222 actions?: Resolver< 14160 14223 ReadonlyArray<GQLResolversTypes['ID']>, ··· 14167 14230 14168 14231 export type GQLUserSubmissionCountResolvers< 14169 14232 ContextType = Context, 14170 14170 - ParentType extends 14171 14171 - GQLResolversParentTypes['UserSubmissionCount'] = GQLResolversParentTypes['UserSubmissionCount'], 14233 14233 + ParentType extends GQLResolversParentTypes['UserSubmissionCount'] = 14234 14234 + GQLResolversParentTypes['UserSubmissionCount'], 14172 14235 > = { 14173 14236 count?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 14174 14237 itemTypeId?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; ··· 14176 14239 14177 14240 export type GQLUserSubmissionsHistoryResolvers< 14178 14241 ContextType = Context, 14179 14179 - ParentType extends 14180 14180 - GQLResolversParentTypes['UserSubmissionsHistory'] = GQLResolversParentTypes['UserSubmissionsHistory'], 14242 14242 + ParentType extends GQLResolversParentTypes['UserSubmissionsHistory'] = 14243 14243 + GQLResolversParentTypes['UserSubmissionsHistory'], 14181 14244 > = { 14182 14245 countsByItemType?: Resolver< 14183 14246 ReadonlyArray<GQLResolversTypes['UserSubmissionCount']>, ··· 14188 14251 14189 14252 export type GQLWindowConfigurationResolvers< 14190 14253 ContextType = Context, 14191 14191 - ParentType extends 14192 14192 - GQLResolversParentTypes['WindowConfiguration'] = GQLResolversParentTypes['WindowConfiguration'], 14254 14254 + ParentType extends GQLResolversParentTypes['WindowConfiguration'] = 14255 14255 + GQLResolversParentTypes['WindowConfiguration'], 14193 14256 > = { 14194 14257 hopMs?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; 14195 14258 sizeMs?: Resolver<GQLResolversTypes['Int'], ParentType, ContextType>; ··· 14198 14261 export type GQLZentropiIntegrationApiCredentialResolvers< 14199 14262 ContextType = Context, 14200 14263 ParentType extends 14201 14201 - GQLResolversParentTypes['ZentropiIntegrationApiCredential'] = GQLResolversParentTypes['ZentropiIntegrationApiCredential'], 14264 14264 + GQLResolversParentTypes['ZentropiIntegrationApiCredential'] = 14265 14265 + GQLResolversParentTypes['ZentropiIntegrationApiCredential'], 14202 14266 > = { 14203 14267 apiKey?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 14204 14268 labelerVersions?: Resolver< ··· 14211 14275 14212 14276 export type GQLZentropiLabelerVersionResolvers< 14213 14277 ContextType = Context, 14214 14214 - ParentType extends 14215 14215 - GQLResolversParentTypes['ZentropiLabelerVersion'] = GQLResolversParentTypes['ZentropiLabelerVersion'], 14278 14278 + ParentType extends GQLResolversParentTypes['ZentropiLabelerVersion'] = 14279 14279 + GQLResolversParentTypes['ZentropiLabelerVersion'], 14216 14280 > = { 14217 14281 id?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>; 14218 14282 label?: Resolver<GQLResolversTypes['String'], ParentType, ContextType>;

+3 -3

server/graphql/resolvers.ts

reviewed

··· 4 4 5 5 import { type GQLServices } from '../api.js'; 6 6 import { type DataSources } from '../iocContainer/index.js'; 7 7 - import { type User } from '../models/UserModel.js'; 7 7 + import { type GraphQLUserParent } from './datasources/userKyselyPersistence.js'; 8 8 import { CoopError, isCoopErrorOfType } from '../utils/errors.js'; 9 9 import { 10 10 type GQLInviteUserToken, ··· 41 41 import { forbiddenError, unauthenticatedError } from './utils/errors.js'; 42 42 43 43 // eslint-disable-next-line @typescript-eslint/no-restricted-types 44 44 - export type Context = PassportContext<User, {}> & { 44 44 + export type Context = PassportContext<GraphQLUserParent, {}> & { 45 45 dataSources: DataSources; 46 46 services: GQLServices; 47 47 }; ··· 124 124 }, 125 125 }; 126 126 127 127 - type TSignUpResponse = { data: User } | CoopError; 127 127 + type TSignUpResponse = { data: GraphQLUserParent } | CoopError; 128 128 const SignUpResponse: ResolverMap<TSignUpResponse> = { 129 129 __resolveType(response) { 130 130 if (response instanceof CoopError) {

+2 -2

server/models/rules/ruleTypes.ts

reviewed

··· 6 6 type Action, 7 7 type Policy, 8 8 } from '../../services/moderationConfigService/index.js'; 9 9 - import { type User } from '../UserModel.js'; 9 9 + import { type GraphQLUserParent } from '../../graphql/datasources/userKyselyPersistence.js'; 10 10 11 11 export type RuleLatestVersionRow = { 12 12 ruleId: string; ··· 50 50 } 51 51 52 52 export type RuleGraphqlMethods = { 53 53 - getCreator(): Promise<User>; 53 53 + getCreator(): Promise<GraphQLUserParent>; 54 54 getActions(): Promise<Action[]>; 55 55 getPolicies(): Promise<Policy[]>; 56 56 };

+24

server/services/coreAppTables.ts

reviewed

··· 1 1 import { type Generated, type GeneratedAlways } from 'kysely'; 2 2 3 3 + import { type UserRole } from '../models/types/permissioning.js'; 4 4 + 3 5 /** Postgres enum for backtests.status (generated column — read-only in app). */ 4 6 export type BacktestStatusDb = 'RUNNING' | 'COMPLETE' | 'CANCELED'; 7 7 + 8 8 + /** Postgres enum for users.login_methods. */ 9 9 + export type LoginMethod = 'password' | 'saml'; 5 10 6 11 export type CoreAppTablesPg = { 7 12 'public.orgs': { ··· 13 18 created_at: Date; 14 19 updated_at: Date; 15 20 on_call_alert_email: string | null; 21 21 + }; 22 22 + // `id`, `created_at`, `updated_at` are all NOT NULL with no server-side 23 23 + // default — the app supplies them on INSERT, just like the Sequelize model 24 24 + // did. The DB enforces a CHECK constraint (`password_null_when_not_present`) 25 25 + // tying `password IS NOT NULL` to `'password' ∈ login_methods`; that 26 26 + // invariant is enforced at the app layer too (see `userValidation.ts`). 27 27 + 'public.users': { 28 28 + id: string; 29 29 + email: string; 30 30 + password: string | null; 31 31 + first_name: string; 32 32 + last_name: string; 33 33 + role: UserRole; 34 34 + approved_by_admin: boolean; 35 35 + rejected_by_admin: boolean; 36 36 + created_at: Date; 37 37 + updated_at: Date; 38 38 + org_id: string; 39 39 + login_methods: LoginMethod[]; 16 40 }; 17 41 'public.location_banks': { 18 42 id: string;

+4 -14

server/services/userManagementService/dbTypes.ts

reviewed

··· 1 1 import type { ColumnType, GeneratedAlways } from 'kysely'; 2 2 3 3 import type { UserRole } from '../../models/types/permissioning.js'; 4 4 + import { type CoreAppTablesPg } from '../coreAppTables.js'; 4 5 import type { 5 6 DecisionCountsInput, 6 7 JobCreationsInput, ··· 56 57 org_id: string; 57 58 created_at: Date; 58 59 }; 59 59 - 'public.users': { 60 60 - id: GeneratedAlways<string>; 61 61 - email: string; 62 62 - password: string | null; 63 63 - first_name: string; 64 64 - last_name: string; 65 65 - role: UserRole; 66 66 - approved_by_admin: boolean; 67 67 - rejected_by_admin: boolean; 68 68 - created_at: GeneratedAlways<Date>; 69 69 - updated_at: GeneratedAlways<Date>; 70 70 - org_id: string; 71 71 - login_methods: ('password' | 'saml')[]; 72 72 - }; 60 60 + // Shared definition lives in `services/coreAppTables.ts` so Kysely instances 61 61 + // typed on either `UserManagementPg` or `CombinedPg` see the same columns. 62 62 + 'public.users': CoreAppTablesPg['public.users']; 73 63 'public.invite_user_tokens': { 74 64 id: GeneratedAlways<string>; 75 65 token: string;

+1 -1

server/services/userManagementService/index.ts

reviewed

··· 3 3 default as makeUserManagementService, 4 4 type UserManagementService, 5 5 } from './userManagementService.js'; 6 6 - export { hashPassword } from './utils.js'; 6 6 + export { hashPassword, passwordMatchesHash } from './utils.js';

+13

server/services/userManagementService/utils.ts

reviewed

··· 1 1 + import { promisify } from 'util'; 1 2 import bcrypt from 'bcryptjs'; 2 3 3 4 export async function hashPassword(rawPassword: string) { 4 5 return bcrypt.hash(rawPassword, 5); 5 6 } 7 7 + 8 8 + // Matches the bcrypt.compare semantics used by the now-removed Sequelize 9 9 + // `User.passwordMatchesHash` static; kept here so `UserApi.changePassword` and 10 10 + // the Passport local strategy share a single implementation. 11 11 + const bcryptCompare = promisify(bcrypt.compare); 12 12 + 13 13 + export async function passwordMatchesHash( 14 14 + givenPassword: string, 15 15 + hash: string, 16 16 + ): Promise<boolean> { 17 17 + return bcryptCompare(givenPassword, hash); 18 18 + }