+806

lex/index.ts

reviewed

··· 14 14 import * as ToolsOzoneSignatureSearchAccounts from "./types/tools/ozone/signature/searchAccounts.ts"; 15 15 import * as ToolsOzoneSignatureFindRelatedAccounts from "./types/tools/ozone/signature/findRelatedAccounts.ts"; 16 16 import * as ToolsOzoneServerGetConfig from "./types/tools/ozone/server/getConfig.ts"; 17 17 + import * as ToolsOzoneVerificationRevokeVerifications from "./types/tools/ozone/verification/revokeVerifications.ts"; 18 18 + import * as ToolsOzoneVerificationGrantVerifications from "./types/tools/ozone/verification/grantVerifications.ts"; 19 19 + import * as ToolsOzoneVerificationListVerifications from "./types/tools/ozone/verification/listVerifications.ts"; 20 20 + import * as ToolsOzoneSafelinkAddRule from "./types/tools/ozone/safelink/addRule.ts"; 21 21 + import * as ToolsOzoneSafelinkRemoveRule from "./types/tools/ozone/safelink/removeRule.ts"; 22 22 + import * as ToolsOzoneSafelinkUpdateRule from "./types/tools/ozone/safelink/updateRule.ts"; 23 23 + import * as ToolsOzoneSafelinkQueryEvents from "./types/tools/ozone/safelink/queryEvents.ts"; 24 24 + import * as ToolsOzoneSafelinkQueryRules from "./types/tools/ozone/safelink/queryRules.ts"; 17 25 import * as ToolsOzoneTeamListMembers from "./types/tools/ozone/team/listMembers.ts"; 18 26 import * as ToolsOzoneTeamDeleteMember from "./types/tools/ozone/team/deleteMember.ts"; 19 27 import * as ToolsOzoneTeamUpdateMember from "./types/tools/ozone/team/updateMember.ts"; 20 28 import * as ToolsOzoneTeamAddMember from "./types/tools/ozone/team/addMember.ts"; 29 29 + import * as ToolsOzoneHostingGetAccountHistory from "./types/tools/ozone/hosting/getAccountHistory.ts"; 21 30 import * as ToolsOzoneCommunicationUpdateTemplate from "./types/tools/ozone/communication/updateTemplate.ts"; 22 31 import * as ToolsOzoneCommunicationCreateTemplate from "./types/tools/ozone/communication/createTemplate.ts"; 23 32 import * as ToolsOzoneCommunicationListTemplates from "./types/tools/ozone/communication/listTemplates.ts"; ··· 32 41 import * as ToolsOzoneSettingRemoveOptions from "./types/tools/ozone/setting/removeOptions.ts"; 33 42 import * as ToolsOzoneSettingUpsertOption from "./types/tools/ozone/setting/upsertOption.ts"; 34 43 import * as ToolsOzoneModerationGetReporterStats from "./types/tools/ozone/moderation/getReporterStats.ts"; 44 44 + import * as ToolsOzoneModerationCancelScheduledActions from "./types/tools/ozone/moderation/cancelScheduledActions.ts"; 45 45 + import * as ToolsOzoneModerationListScheduledActions from "./types/tools/ozone/moderation/listScheduledActions.ts"; 35 46 import * as ToolsOzoneModerationQueryStatuses from "./types/tools/ozone/moderation/queryStatuses.ts"; 36 47 import * as ToolsOzoneModerationGetRepo from "./types/tools/ozone/moderation/getRepo.ts"; 48 48 + import * as ToolsOzoneModerationGetSubjects from "./types/tools/ozone/moderation/getSubjects.ts"; 37 49 import * as ToolsOzoneModerationGetRecords from "./types/tools/ozone/moderation/getRecords.ts"; 50 50 + import * as ToolsOzoneModerationScheduleAction from "./types/tools/ozone/moderation/scheduleAction.ts"; 38 51 import * as ToolsOzoneModerationGetEvent from "./types/tools/ozone/moderation/getEvent.ts"; 39 52 import * as ToolsOzoneModerationQueryEvents from "./types/tools/ozone/moderation/queryEvents.ts"; 40 53 import * as ToolsOzoneModerationGetRecord from "./types/tools/ozone/moderation/getRecord.ts"; 41 54 import * as ToolsOzoneModerationEmitEvent from "./types/tools/ozone/moderation/emitEvent.ts"; 42 55 import * as ToolsOzoneModerationSearchRepos from "./types/tools/ozone/moderation/searchRepos.ts"; 56 56 + import * as ToolsOzoneModerationGetAccountTimeline from "./types/tools/ozone/moderation/getAccountTimeline.ts"; 43 57 import * as ToolsOzoneModerationGetRepos from "./types/tools/ozone/moderation/getRepos.ts"; 44 58 import * as AppBskyVideoUploadVideo from "./types/app/bsky/video/uploadVideo.ts"; 45 59 import * as AppBskyVideoGetJobStatus from "./types/app/bsky/video/getJobStatus.ts"; 46 60 import * as AppBskyVideoGetUploadLimits from "./types/app/bsky/video/getUploadLimits.ts"; 61 61 + import * as AppBskyBookmarkDeleteBookmark from "./types/app/bsky/bookmark/deleteBookmark.ts"; 62 62 + import * as AppBskyBookmarkGetBookmarks from "./types/app/bsky/bookmark/getBookmarks.ts"; 63 63 + import * as AppBskyBookmarkCreateBookmark from "./types/app/bsky/bookmark/createBookmark.ts"; 47 64 import * as AppBskyNotificationRegisterPush from "./types/app/bsky/notification/registerPush.ts"; 48 65 import * as AppBskyNotificationPutPreferences from "./types/app/bsky/notification/putPreferences.ts"; 66 66 + import * as AppBskyNotificationPutActivitySubscription from "./types/app/bsky/notification/putActivitySubscription.ts"; 67 67 + import * as AppBskyNotificationPutPreferencesV2 from "./types/app/bsky/notification/putPreferencesV2.ts"; 49 68 import * as AppBskyNotificationUpdateSeen from "./types/app/bsky/notification/updateSeen.ts"; 69 69 + import * as AppBskyNotificationListActivitySubscriptions from "./types/app/bsky/notification/listActivitySubscriptions.ts"; 70 70 + import * as AppBskyNotificationUnregisterPush from "./types/app/bsky/notification/unregisterPush.ts"; 71 71 + import * as AppBskyNotificationGetPreferences from "./types/app/bsky/notification/getPreferences.ts"; 50 72 import * as AppBskyNotificationListNotifications from "./types/app/bsky/notification/listNotifications.ts"; 51 73 import * as AppBskyNotificationGetUnreadCount from "./types/app/bsky/notification/getUnreadCount.ts"; 74 74 + import * as AppBskyUnspeccedGetSuggestedFeedsSkeleton from "./types/app/bsky/unspecced/getSuggestedFeedsSkeleton.ts"; 52 75 import * as AppBskyUnspeccedSearchStarterPacksSkeleton from "./types/app/bsky/unspecced/searchStarterPacksSkeleton.ts"; 76 76 + import * as AppBskyUnspeccedGetOnboardingSuggestedStarterPacksSkeleton from "./types/app/bsky/unspecced/getOnboardingSuggestedStarterPacksSkeleton.ts"; 77 77 + import * as AppBskyUnspeccedGetSuggestedUsers from "./types/app/bsky/unspecced/getSuggestedUsers.ts"; 78 78 + import * as AppBskyUnspeccedGetPostThreadOtherV2 from "./types/app/bsky/unspecced/getPostThreadOtherV2.ts"; 79 79 + import * as AppBskyUnspeccedGetSuggestedStarterPacks from "./types/app/bsky/unspecced/getSuggestedStarterPacks.ts"; 80 80 + import * as AppBskyUnspeccedGetSuggestedStarterPacksSkeleton from "./types/app/bsky/unspecced/getSuggestedStarterPacksSkeleton.ts"; 81 81 + import * as AppBskyUnspeccedGetOnboardingSuggestedStarterPacks from "./types/app/bsky/unspecced/getOnboardingSuggestedStarterPacks.ts"; 82 82 + import * as AppBskyUnspeccedGetSuggestedUsersSkeleton from "./types/app/bsky/unspecced/getSuggestedUsersSkeleton.ts"; 83 83 + import * as AppBskyUnspeccedGetPostThreadV2 from "./types/app/bsky/unspecced/getPostThreadV2.ts"; 84 84 + import * as AppBskyUnspeccedGetTrends from "./types/app/bsky/unspecced/getTrends.ts"; 53 85 import * as AppBskyUnspeccedSearchActorsSkeleton from "./types/app/bsky/unspecced/searchActorsSkeleton.ts"; 54 86 import * as AppBskyUnspeccedGetSuggestionsSkeleton from "./types/app/bsky/unspecced/getSuggestionsSkeleton.ts"; 55 87 import * as AppBskyUnspeccedSearchPostsSkeleton from "./types/app/bsky/unspecced/searchPostsSkeleton.ts"; 88 88 + import * as AppBskyUnspeccedGetAgeAssuranceState from "./types/app/bsky/unspecced/getAgeAssuranceState.ts"; 56 89 import * as AppBskyUnspeccedGetPopularFeedGenerators from "./types/app/bsky/unspecced/getPopularFeedGenerators.ts"; 90 90 + import * as AppBskyUnspeccedInitAgeAssurance from "./types/app/bsky/unspecced/initAgeAssurance.ts"; 57 91 import * as AppBskyUnspeccedGetTrendingTopics from "./types/app/bsky/unspecced/getTrendingTopics.ts"; 58 92 import * as AppBskyUnspeccedGetTaggedSuggestions from "./types/app/bsky/unspecced/getTaggedSuggestions.ts"; 93 93 + import * as AppBskyUnspeccedGetSuggestedFeeds from "./types/app/bsky/unspecced/getSuggestedFeeds.ts"; 94 94 + import * as AppBskyUnspeccedGetTrendsSkeleton from "./types/app/bsky/unspecced/getTrendsSkeleton.ts"; 59 95 import * as AppBskyUnspeccedGetConfig from "./types/app/bsky/unspecced/getConfig.ts"; 60 96 import * as AppBskyGraphGetStarterPacks from "./types/app/bsky/graph/getStarterPacks.ts"; 61 97 import * as AppBskyGraphGetSuggestedFollowsByActor from "./types/app/bsky/graph/getSuggestedFollowsByActor.ts"; 98 98 + import * as AppBskyGraphGetStarterPacksWithMembership from "./types/app/bsky/graph/getStarterPacksWithMembership.ts"; 99 99 + import * as AppBskyGraphGetListsWithMembership from "./types/app/bsky/graph/getListsWithMembership.ts"; 62 100 import * as AppBskyGraphUnmuteActorList from "./types/app/bsky/graph/unmuteActorList.ts"; 63 101 import * as AppBskyGraphGetListBlocks from "./types/app/bsky/graph/getListBlocks.ts"; 64 102 import * as AppBskyGraphGetStarterPack from "./types/app/bsky/graph/getStarterPack.ts"; ··· 96 134 import * as AppBskyFeedGetListFeed from "./types/app/bsky/feed/getListFeed.ts"; 97 135 import * as AppBskyFeedGetSuggestedFeeds from "./types/app/bsky/feed/getSuggestedFeeds.ts"; 98 136 import * as AppBskyFeedGetActorFeeds from "./types/app/bsky/feed/getActorFeeds.ts"; 137 137 + import * as AppBskyAgeassuranceBegin from "./types/app/bsky/ageassurance/begin.ts"; 138 138 + import * as AppBskyAgeassuranceGetState from "./types/app/bsky/ageassurance/getState.ts"; 139 139 + import * as AppBskyAgeassuranceGetConfig from "./types/app/bsky/ageassurance/getConfig.ts"; 99 140 import * as AppBskyActorSearchActorsTypeahead from "./types/app/bsky/actor/searchActorsTypeahead.ts"; 100 141 import * as AppBskyActorPutPreferences from "./types/app/bsky/actor/putPreferences.ts"; 101 142 import * as AppBskyActorGetProfile from "./types/app/bsky/actor/getProfile.ts"; ··· 110 151 import * as ChatBskyConvoGetLog from "./types/chat/bsky/convo/getLog.ts"; 111 152 import * as ChatBskyConvoSendMessage from "./types/chat/bsky/convo/sendMessage.ts"; 112 153 import * as ChatBskyConvoLeaveConvo from "./types/chat/bsky/convo/leaveConvo.ts"; 154 154 + import * as ChatBskyConvoAddReaction from "./types/chat/bsky/convo/addReaction.ts"; 113 155 import * as ChatBskyConvoAcceptConvo from "./types/chat/bsky/convo/acceptConvo.ts"; 114 156 import * as ChatBskyConvoMuteConvo from "./types/chat/bsky/convo/muteConvo.ts"; 115 157 import * as ChatBskyConvoDeleteMessageForSelf from "./types/chat/bsky/convo/deleteMessageForSelf.ts"; 158 158 + import * as ChatBskyConvoRemoveReaction from "./types/chat/bsky/convo/removeReaction.ts"; 116 159 import * as ChatBskyConvoUpdateRead from "./types/chat/bsky/convo/updateRead.ts"; 117 160 import * as ChatBskyConvoUpdateAllRead from "./types/chat/bsky/convo/updateAllRead.ts"; 118 161 import * as ChatBskyConvoGetConvo from "./types/chat/bsky/convo/getConvo.ts"; ··· 173 216 import * as SoSprkStoryGetTimeline from "./types/so/sprk/story/getTimeline.ts"; 174 217 import * as SoSprkStoryGetStories from "./types/so/sprk/story/getStories.ts"; 175 218 import * as SoSprkLabelerGetServices from "./types/so/sprk/labeler/getServices.ts"; 219 219 + import * as ComAtprotoTempDereferenceScope from "./types/com/atproto/temp/dereferenceScope.ts"; 176 220 import * as ComAtprotoTempAddReservedHandle from "./types/com/atproto/temp/addReservedHandle.ts"; 177 221 import * as ComAtprotoTempCheckSignupQueue from "./types/com/atproto/temp/checkSignupQueue.ts"; 222 222 + import * as ComAtprotoTempCheckHandleAvailability from "./types/com/atproto/temp/checkHandleAvailability.ts"; 178 223 import * as ComAtprotoTempRequestPhoneVerification from "./types/com/atproto/temp/requestPhoneVerification.ts"; 224 224 + import * as ComAtprotoTempRevokeAccountCredentials from "./types/com/atproto/temp/revokeAccountCredentials.ts"; 179 225 import * as ComAtprotoTempFetchLabels from "./types/com/atproto/temp/fetchLabels.ts"; 180 226 import * as ComAtprotoIdentityUpdateHandle from "./types/com/atproto/identity/updateHandle.ts"; 181 227 import * as ComAtprotoIdentitySignPlcOperation from "./types/com/atproto/identity/signPlcOperation.ts"; 182 228 import * as ComAtprotoIdentitySubmitPlcOperation from "./types/com/atproto/identity/submitPlcOperation.ts"; 229 229 + import * as ComAtprotoIdentityResolveIdentity from "./types/com/atproto/identity/resolveIdentity.ts"; 230 230 + import * as ComAtprotoIdentityRefreshIdentity from "./types/com/atproto/identity/refreshIdentity.ts"; 183 231 import * as ComAtprotoIdentityResolveHandle from "./types/com/atproto/identity/resolveHandle.ts"; 184 232 import * as ComAtprotoIdentityRequestPlcOperationSignature from "./types/com/atproto/identity/requestPlcOperationSignature.ts"; 185 233 import * as ComAtprotoIdentityGetRecommendedDidCredentials from "./types/com/atproto/identity/getRecommendedDidCredentials.ts"; 234 234 + import * as ComAtprotoIdentityResolveDid from "./types/com/atproto/identity/resolveDid.ts"; 186 235 import * as ComAtprotoAdminUpdateAccountEmail from "./types/com/atproto/admin/updateAccountEmail.ts"; 187 236 import * as ComAtprotoAdminGetAccountInfo from "./types/com/atproto/admin/getAccountInfo.ts"; 188 237 import * as ComAtprotoAdminGetSubjectStatus from "./types/com/atproto/admin/getSubjectStatus.ts"; ··· 190 239 import * as ComAtprotoAdminUpdateAccountPassword from "./types/com/atproto/admin/updateAccountPassword.ts"; 191 240 import * as ComAtprotoAdminUpdateAccountHandle from "./types/com/atproto/admin/updateAccountHandle.ts"; 192 241 import * as ComAtprotoAdminGetInviteCodes from "./types/com/atproto/admin/getInviteCodes.ts"; 242 242 + import * as ComAtprotoAdminUpdateAccountSigningKey from "./types/com/atproto/admin/updateAccountSigningKey.ts"; 193 243 import * as ComAtprotoAdminEnableAccountInvites from "./types/com/atproto/admin/enableAccountInvites.ts"; 194 244 import * as ComAtprotoAdminDisableAccountInvites from "./types/com/atproto/admin/disableAccountInvites.ts"; 195 245 import * as ComAtprotoAdminDisableInviteCodes from "./types/com/atproto/admin/disableInviteCodes.ts"; ··· 224 274 import * as ComAtprotoServerCreateAccount from "./types/com/atproto/server/createAccount.ts"; 225 275 import * as ComAtprotoServerDeleteAccount from "./types/com/atproto/server/deleteAccount.ts"; 226 276 import * as ComAtprotoServerCreateInviteCode from "./types/com/atproto/server/createInviteCode.ts"; 277 277 + import * as ComAtprotoLexiconResolveLexicon from "./types/com/atproto/lexicon/resolveLexicon.ts"; 227 278 import * as ComAtprotoSyncGetHead from "./types/com/atproto/sync/getHead.ts"; 228 279 import * as ComAtprotoSyncGetBlob from "./types/com/atproto/sync/getBlob.ts"; 229 280 import * as ComAtprotoSyncGetRepo from "./types/com/atproto/sync/getRepo.ts"; ··· 234 285 import * as ComAtprotoSyncSubscribeRepos from "./types/com/atproto/sync/subscribeRepos.ts"; 235 286 import * as ComAtprotoSyncGetRepoStatus from "./types/com/atproto/sync/getRepoStatus.ts"; 236 287 import * as ComAtprotoSyncGetRecord from "./types/com/atproto/sync/getRecord.ts"; 288 288 + import * as ComAtprotoSyncListHosts from "./types/com/atproto/sync/listHosts.ts"; 237 289 import * as ComAtprotoSyncListRepos from "./types/com/atproto/sync/listRepos.ts"; 290 290 + import * as ComAtprotoSyncGetHostStatus from "./types/com/atproto/sync/getHostStatus.ts"; 238 291 import * as ComAtprotoSyncGetBlocks from "./types/com/atproto/sync/getBlocks.ts"; 239 292 import * as ComAtprotoSyncListReposByCollection from "./types/com/atproto/sync/listReposByCollection.ts"; 240 293 import * as ComAtprotoSyncGetCheckout from "./types/com/atproto/sync/getCheckout.ts"; ··· 254 307 DefsRoleAdmin: "tools.ozone.team.defs#roleAdmin", 255 308 DefsRoleModerator: "tools.ozone.team.defs#roleModerator", 256 309 DefsRoleTriage: "tools.ozone.team.defs#roleTriage", 310 310 + DefsRoleVerifier: "tools.ozone.team.defs#roleVerifier", 311 311 + }; 312 312 + export const TOOLS_OZONE_REPORT = { 313 313 + DefsReasonAppeal: "tools.ozone.report.defs#reasonAppeal", 314 314 + DefsReasonOther: "tools.ozone.report.defs#reasonOther", 315 315 + DefsReasonViolenceAnimal: "tools.ozone.report.defs#reasonViolenceAnimal", 316 316 + DefsReasonViolenceThreats: "tools.ozone.report.defs#reasonViolenceThreats", 317 317 + DefsReasonViolenceGraphicContent: 318 318 + "tools.ozone.report.defs#reasonViolenceGraphicContent", 319 319 + DefsReasonViolenceGlorification: 320 320 + "tools.ozone.report.defs#reasonViolenceGlorification", 321 321 + DefsReasonViolenceExtremistContent: 322 322 + "tools.ozone.report.defs#reasonViolenceExtremistContent", 323 323 + DefsReasonViolenceTrafficking: 324 324 + "tools.ozone.report.defs#reasonViolenceTrafficking", 325 325 + DefsReasonViolenceOther: "tools.ozone.report.defs#reasonViolenceOther", 326 326 + DefsReasonSexualAbuseContent: 327 327 + "tools.ozone.report.defs#reasonSexualAbuseContent", 328 328 + DefsReasonSexualNCII: "tools.ozone.report.defs#reasonSexualNCII", 329 329 + DefsReasonSexualDeepfake: "tools.ozone.report.defs#reasonSexualDeepfake", 330 330 + DefsReasonSexualAnimal: "tools.ozone.report.defs#reasonSexualAnimal", 331 331 + DefsReasonSexualUnlabeled: "tools.ozone.report.defs#reasonSexualUnlabeled", 332 332 + DefsReasonSexualOther: "tools.ozone.report.defs#reasonSexualOther", 333 333 + DefsReasonChildSafetyCSAM: "tools.ozone.report.defs#reasonChildSafetyCSAM", 334 334 + DefsReasonChildSafetyGroom: "tools.ozone.report.defs#reasonChildSafetyGroom", 335 335 + DefsReasonChildSafetyPrivacy: 336 336 + "tools.ozone.report.defs#reasonChildSafetyPrivacy", 337 337 + DefsReasonChildSafetyHarassment: 338 338 + "tools.ozone.report.defs#reasonChildSafetyHarassment", 339 339 + DefsReasonChildSafetyOther: "tools.ozone.report.defs#reasonChildSafetyOther", 340 340 + DefsReasonHarassmentTroll: "tools.ozone.report.defs#reasonHarassmentTroll", 341 341 + DefsReasonHarassmentTargeted: 342 342 + "tools.ozone.report.defs#reasonHarassmentTargeted", 343 343 + DefsReasonHarassmentHateSpeech: 344 344 + "tools.ozone.report.defs#reasonHarassmentHateSpeech", 345 345 + DefsReasonHarassmentDoxxing: 346 346 + "tools.ozone.report.defs#reasonHarassmentDoxxing", 347 347 + DefsReasonHarassmentOther: "tools.ozone.report.defs#reasonHarassmentOther", 348 348 + DefsReasonMisleadingBot: "tools.ozone.report.defs#reasonMisleadingBot", 349 349 + DefsReasonMisleadingImpersonation: 350 350 + "tools.ozone.report.defs#reasonMisleadingImpersonation", 351 351 + DefsReasonMisleadingSpam: "tools.ozone.report.defs#reasonMisleadingSpam", 352 352 + DefsReasonMisleadingScam: "tools.ozone.report.defs#reasonMisleadingScam", 353 353 + DefsReasonMisleadingElections: 354 354 + "tools.ozone.report.defs#reasonMisleadingElections", 355 355 + DefsReasonMisleadingOther: "tools.ozone.report.defs#reasonMisleadingOther", 356 356 + DefsReasonRuleSiteSecurity: "tools.ozone.report.defs#reasonRuleSiteSecurity", 357 357 + DefsReasonRuleProhibitedSales: 358 358 + "tools.ozone.report.defs#reasonRuleProhibitedSales", 359 359 + DefsReasonRuleBanEvasion: "tools.ozone.report.defs#reasonRuleBanEvasion", 360 360 + DefsReasonRuleOther: "tools.ozone.report.defs#reasonRuleOther", 361 361 + DefsReasonSelfHarmContent: "tools.ozone.report.defs#reasonSelfHarmContent", 362 362 + DefsReasonSelfHarmED: "tools.ozone.report.defs#reasonSelfHarmED", 363 363 + DefsReasonSelfHarmStunts: "tools.ozone.report.defs#reasonSelfHarmStunts", 364 364 + DefsReasonSelfHarmSubstances: 365 365 + "tools.ozone.report.defs#reasonSelfHarmSubstances", 366 366 + DefsReasonSelfHarmOther: "tools.ozone.report.defs#reasonSelfHarmOther", 257 367 }; 258 368 export const TOOLS_OZONE_MODERATION = { 259 369 DefsReviewOpen: "tools.ozone.moderation.defs#reviewOpen", 260 370 DefsReviewEscalated: "tools.ozone.moderation.defs#reviewEscalated", 261 371 DefsReviewClosed: "tools.ozone.moderation.defs#reviewClosed", 262 372 DefsReviewNone: "tools.ozone.moderation.defs#reviewNone", 373 373 + DefsTimelineEventPlcCreate: 374 374 + "tools.ozone.moderation.defs#timelineEventPlcCreate", 375 375 + DefsTimelineEventPlcOperation: 376 376 + "tools.ozone.moderation.defs#timelineEventPlcOperation", 377 377 + DefsTimelineEventPlcTombstone: 378 378 + "tools.ozone.moderation.defs#timelineEventPlcTombstone", 263 379 }; 264 380 export const APP_BSKY_GRAPH = { 265 381 DefsModlist: "app.bsky.graph.defs#modlist", ··· 281 397 DefsInteractionReply: "app.bsky.feed.defs#interactionReply", 282 398 DefsInteractionQuote: "app.bsky.feed.defs#interactionQuote", 283 399 DefsInteractionShare: "app.bsky.feed.defs#interactionShare", 400 400 + }; 401 401 + export const APP_BSKY_ACTOR = { 402 402 + StatusLive: "app.bsky.actor.status#live", 284 403 }; 285 404 export const SO_SPRK_FEED = { 286 405 DefsRequestLess: "so.sprk.feed.defs#requestLess", ··· 341 460 _server: Server; 342 461 signature: ToolsOzoneSignatureNS; 343 462 server: ToolsOzoneServerNS; 463 463 + verification: ToolsOzoneVerificationNS; 464 464 + safelink: ToolsOzoneSafelinkNS; 344 465 team: ToolsOzoneTeamNS; 466 466 + hosting: ToolsOzoneHostingNS; 345 467 communication: ToolsOzoneCommunicationNS; 346 468 set: ToolsOzoneSetNS; 347 469 setting: ToolsOzoneSettingNS; ··· 351 473 this._server = server; 352 474 this.signature = new ToolsOzoneSignatureNS(server); 353 475 this.server = new ToolsOzoneServerNS(server); 476 476 + this.verification = new ToolsOzoneVerificationNS(server); 477 477 + this.safelink = new ToolsOzoneSafelinkNS(server); 354 478 this.team = new ToolsOzoneTeamNS(server); 479 479 + this.hosting = new ToolsOzoneHostingNS(server); 355 480 this.communication = new ToolsOzoneCommunicationNS(server); 356 481 this.set = new ToolsOzoneSetNS(server); 357 482 this.setting = new ToolsOzoneSettingNS(server); ··· 423 548 } 424 549 } 425 550 551 551 + export class ToolsOzoneVerificationNS { 552 552 + _server: Server; 553 553 + 554 554 + constructor(server: Server) { 555 555 + this._server = server; 556 556 + } 557 557 + 558 558 + revokeVerifications<A extends Auth = void>( 559 559 + cfg: MethodConfigOrHandler< 560 560 + A, 561 561 + ToolsOzoneVerificationRevokeVerifications.QueryParams, 562 562 + ToolsOzoneVerificationRevokeVerifications.HandlerInput, 563 563 + ToolsOzoneVerificationRevokeVerifications.HandlerOutput 564 564 + >, 565 565 + ) { 566 566 + const nsid = "tools.ozone.verification.revokeVerifications"; // @ts-ignore - dynamically generated 567 567 + return this._server.xrpc.method(nsid, cfg); 568 568 + } 569 569 + 570 570 + grantVerifications<A extends Auth = void>( 571 571 + cfg: MethodConfigOrHandler< 572 572 + A, 573 573 + ToolsOzoneVerificationGrantVerifications.QueryParams, 574 574 + ToolsOzoneVerificationGrantVerifications.HandlerInput, 575 575 + ToolsOzoneVerificationGrantVerifications.HandlerOutput 576 576 + >, 577 577 + ) { 578 578 + const nsid = "tools.ozone.verification.grantVerifications"; // @ts-ignore - dynamically generated 579 579 + return this._server.xrpc.method(nsid, cfg); 580 580 + } 581 581 + 582 582 + listVerifications<A extends Auth = void>( 583 583 + cfg: MethodConfigOrHandler< 584 584 + A, 585 585 + ToolsOzoneVerificationListVerifications.QueryParams, 586 586 + ToolsOzoneVerificationListVerifications.HandlerInput, 587 587 + ToolsOzoneVerificationListVerifications.HandlerOutput 588 588 + >, 589 589 + ) { 590 590 + const nsid = "tools.ozone.verification.listVerifications"; // @ts-ignore - dynamically generated 591 591 + return this._server.xrpc.method(nsid, cfg); 592 592 + } 593 593 + } 594 594 + 595 595 + export class ToolsOzoneSafelinkNS { 596 596 + _server: Server; 597 597 + 598 598 + constructor(server: Server) { 599 599 + this._server = server; 600 600 + } 601 601 + 602 602 + addRule<A extends Auth = void>( 603 603 + cfg: MethodConfigOrHandler< 604 604 + A, 605 605 + ToolsOzoneSafelinkAddRule.QueryParams, 606 606 + ToolsOzoneSafelinkAddRule.HandlerInput, 607 607 + ToolsOzoneSafelinkAddRule.HandlerOutput 608 608 + >, 609 609 + ) { 610 610 + const nsid = "tools.ozone.safelink.addRule"; // @ts-ignore - dynamically generated 611 611 + return this._server.xrpc.method(nsid, cfg); 612 612 + } 613 613 + 614 614 + removeRule<A extends Auth = void>( 615 615 + cfg: MethodConfigOrHandler< 616 616 + A, 617 617 + ToolsOzoneSafelinkRemoveRule.QueryParams, 618 618 + ToolsOzoneSafelinkRemoveRule.HandlerInput, 619 619 + ToolsOzoneSafelinkRemoveRule.HandlerOutput 620 620 + >, 621 621 + ) { 622 622 + const nsid = "tools.ozone.safelink.removeRule"; // @ts-ignore - dynamically generated 623 623 + return this._server.xrpc.method(nsid, cfg); 624 624 + } 625 625 + 626 626 + updateRule<A extends Auth = void>( 627 627 + cfg: MethodConfigOrHandler< 628 628 + A, 629 629 + ToolsOzoneSafelinkUpdateRule.QueryParams, 630 630 + ToolsOzoneSafelinkUpdateRule.HandlerInput, 631 631 + ToolsOzoneSafelinkUpdateRule.HandlerOutput 632 632 + >, 633 633 + ) { 634 634 + const nsid = "tools.ozone.safelink.updateRule"; // @ts-ignore - dynamically generated 635 635 + return this._server.xrpc.method(nsid, cfg); 636 636 + } 637 637 + 638 638 + queryEvents<A extends Auth = void>( 639 639 + cfg: MethodConfigOrHandler< 640 640 + A, 641 641 + ToolsOzoneSafelinkQueryEvents.QueryParams, 642 642 + ToolsOzoneSafelinkQueryEvents.HandlerInput, 643 643 + ToolsOzoneSafelinkQueryEvents.HandlerOutput 644 644 + >, 645 645 + ) { 646 646 + const nsid = "tools.ozone.safelink.queryEvents"; // @ts-ignore - dynamically generated 647 647 + return this._server.xrpc.method(nsid, cfg); 648 648 + } 649 649 + 650 650 + queryRules<A extends Auth = void>( 651 651 + cfg: MethodConfigOrHandler< 652 652 + A, 653 653 + ToolsOzoneSafelinkQueryRules.QueryParams, 654 654 + ToolsOzoneSafelinkQueryRules.HandlerInput, 655 655 + ToolsOzoneSafelinkQueryRules.HandlerOutput 656 656 + >, 657 657 + ) { 658 658 + const nsid = "tools.ozone.safelink.queryRules"; // @ts-ignore - dynamically generated 659 659 + return this._server.xrpc.method(nsid, cfg); 660 660 + } 661 661 + } 662 662 + 426 663 export class ToolsOzoneTeamNS { 427 664 _server: Server; 428 665 ··· 475 712 >, 476 713 ) { 477 714 const nsid = "tools.ozone.team.addMember"; // @ts-ignore - dynamically generated 715 715 + return this._server.xrpc.method(nsid, cfg); 716 716 + } 717 717 + } 718 718 + 719 719 + export class ToolsOzoneHostingNS { 720 720 + _server: Server; 721 721 + 722 722 + constructor(server: Server) { 723 723 + this._server = server; 724 724 + } 725 725 + 726 726 + getAccountHistory<A extends Auth = void>( 727 727 + cfg: MethodConfigOrHandler< 728 728 + A, 729 729 + ToolsOzoneHostingGetAccountHistory.QueryParams, 730 730 + ToolsOzoneHostingGetAccountHistory.HandlerInput, 731 731 + ToolsOzoneHostingGetAccountHistory.HandlerOutput 732 732 + >, 733 733 + ) { 734 734 + const nsid = "tools.ozone.hosting.getAccountHistory"; // @ts-ignore - dynamically generated 478 735 return this._server.xrpc.method(nsid, cfg); 479 736 } 480 737 } ··· 678 935 return this._server.xrpc.method(nsid, cfg); 679 936 } 680 937 938 938 + cancelScheduledActions<A extends Auth = void>( 939 939 + cfg: MethodConfigOrHandler< 940 940 + A, 941 941 + ToolsOzoneModerationCancelScheduledActions.QueryParams, 942 942 + ToolsOzoneModerationCancelScheduledActions.HandlerInput, 943 943 + ToolsOzoneModerationCancelScheduledActions.HandlerOutput 944 944 + >, 945 945 + ) { 946 946 + const nsid = "tools.ozone.moderation.cancelScheduledActions"; // @ts-ignore - dynamically generated 947 947 + return this._server.xrpc.method(nsid, cfg); 948 948 + } 949 949 + 950 950 + listScheduledActions<A extends Auth = void>( 951 951 + cfg: MethodConfigOrHandler< 952 952 + A, 953 953 + ToolsOzoneModerationListScheduledActions.QueryParams, 954 954 + ToolsOzoneModerationListScheduledActions.HandlerInput, 955 955 + ToolsOzoneModerationListScheduledActions.HandlerOutput 956 956 + >, 957 957 + ) { 958 958 + const nsid = "tools.ozone.moderation.listScheduledActions"; // @ts-ignore - dynamically generated 959 959 + return this._server.xrpc.method(nsid, cfg); 960 960 + } 961 961 + 681 962 queryStatuses<A extends Auth = void>( 682 963 cfg: MethodConfigOrHandler< 683 964 A, ··· 702 983 return this._server.xrpc.method(nsid, cfg); 703 984 } 704 985 986 986 + getSubjects<A extends Auth = void>( 987 987 + cfg: MethodConfigOrHandler< 988 988 + A, 989 989 + ToolsOzoneModerationGetSubjects.QueryParams, 990 990 + ToolsOzoneModerationGetSubjects.HandlerInput, 991 991 + ToolsOzoneModerationGetSubjects.HandlerOutput 992 992 + >, 993 993 + ) { 994 994 + const nsid = "tools.ozone.moderation.getSubjects"; // @ts-ignore - dynamically generated 995 995 + return this._server.xrpc.method(nsid, cfg); 996 996 + } 997 997 + 705 998 getRecords<A extends Auth = void>( 706 999 cfg: MethodConfigOrHandler< 707 1000 A, ··· 714 1007 return this._server.xrpc.method(nsid, cfg); 715 1008 } 716 1009 1010 1010 + scheduleAction<A extends Auth = void>( 1011 1011 + cfg: MethodConfigOrHandler< 1012 1012 + A, 1013 1013 + ToolsOzoneModerationScheduleAction.QueryParams, 1014 1014 + ToolsOzoneModerationScheduleAction.HandlerInput, 1015 1015 + ToolsOzoneModerationScheduleAction.HandlerOutput 1016 1016 + >, 1017 1017 + ) { 1018 1018 + const nsid = "tools.ozone.moderation.scheduleAction"; // @ts-ignore - dynamically generated 1019 1019 + return this._server.xrpc.method(nsid, cfg); 1020 1020 + } 1021 1021 + 717 1022 getEvent<A extends Auth = void>( 718 1023 cfg: MethodConfigOrHandler< 719 1024 A, ··· 774 1079 return this._server.xrpc.method(nsid, cfg); 775 1080 } 776 1081 1082 1082 + getAccountTimeline<A extends Auth = void>( 1083 1083 + cfg: MethodConfigOrHandler< 1084 1084 + A, 1085 1085 + ToolsOzoneModerationGetAccountTimeline.QueryParams, 1086 1086 + ToolsOzoneModerationGetAccountTimeline.HandlerInput, 1087 1087 + ToolsOzoneModerationGetAccountTimeline.HandlerOutput 1088 1088 + >, 1089 1089 + ) { 1090 1090 + const nsid = "tools.ozone.moderation.getAccountTimeline"; // @ts-ignore - dynamically generated 1091 1091 + return this._server.xrpc.method(nsid, cfg); 1092 1092 + } 1093 1093 + 777 1094 getRepos<A extends Auth = void>( 778 1095 cfg: MethodConfigOrHandler< 779 1096 A, ··· 800 1117 export class AppBskyNS { 801 1118 _server: Server; 802 1119 video: AppBskyVideoNS; 1120 1120 + bookmark: AppBskyBookmarkNS; 803 1121 embed: AppBskyEmbedNS; 804 1122 notification: AppBskyNotificationNS; 805 1123 unspecced: AppBskyUnspeccedNS; 806 1124 graph: AppBskyGraphNS; 807 1125 feed: AppBskyFeedNS; 808 1126 richtext: AppBskyRichtextNS; 1127 1127 + ageassurance: AppBskyAgeassuranceNS; 809 1128 actor: AppBskyActorNS; 810 1129 labeler: AppBskyLabelerNS; 811 1130 812 1131 constructor(server: Server) { 813 1132 this._server = server; 814 1133 this.video = new AppBskyVideoNS(server); 1134 1134 + this.bookmark = new AppBskyBookmarkNS(server); 815 1135 this.embed = new AppBskyEmbedNS(server); 816 1136 this.notification = new AppBskyNotificationNS(server); 817 1137 this.unspecced = new AppBskyUnspeccedNS(server); 818 1138 this.graph = new AppBskyGraphNS(server); 819 1139 this.feed = new AppBskyFeedNS(server); 820 1140 this.richtext = new AppBskyRichtextNS(server); 1141 1141 + this.ageassurance = new AppBskyAgeassuranceNS(server); 821 1142 this.actor = new AppBskyActorNS(server); 822 1143 this.labeler = new AppBskyLabelerNS(server); 823 1144 } ··· 867 1188 } 868 1189 } 869 1190 1191 1191 + export class AppBskyBookmarkNS { 1192 1192 + _server: Server; 1193 1193 + 1194 1194 + constructor(server: Server) { 1195 1195 + this._server = server; 1196 1196 + } 1197 1197 + 1198 1198 + deleteBookmark<A extends Auth = void>( 1199 1199 + cfg: MethodConfigOrHandler< 1200 1200 + A, 1201 1201 + AppBskyBookmarkDeleteBookmark.QueryParams, 1202 1202 + AppBskyBookmarkDeleteBookmark.HandlerInput, 1203 1203 + AppBskyBookmarkDeleteBookmark.HandlerOutput 1204 1204 + >, 1205 1205 + ) { 1206 1206 + const nsid = "app.bsky.bookmark.deleteBookmark"; // @ts-ignore - dynamically generated 1207 1207 + return this._server.xrpc.method(nsid, cfg); 1208 1208 + } 1209 1209 + 1210 1210 + getBookmarks<A extends Auth = void>( 1211 1211 + cfg: MethodConfigOrHandler< 1212 1212 + A, 1213 1213 + AppBskyBookmarkGetBookmarks.QueryParams, 1214 1214 + AppBskyBookmarkGetBookmarks.HandlerInput, 1215 1215 + AppBskyBookmarkGetBookmarks.HandlerOutput 1216 1216 + >, 1217 1217 + ) { 1218 1218 + const nsid = "app.bsky.bookmark.getBookmarks"; // @ts-ignore - dynamically generated 1219 1219 + return this._server.xrpc.method(nsid, cfg); 1220 1220 + } 1221 1221 + 1222 1222 + createBookmark<A extends Auth = void>( 1223 1223 + cfg: MethodConfigOrHandler< 1224 1224 + A, 1225 1225 + AppBskyBookmarkCreateBookmark.QueryParams, 1226 1226 + AppBskyBookmarkCreateBookmark.HandlerInput, 1227 1227 + AppBskyBookmarkCreateBookmark.HandlerOutput 1228 1228 + >, 1229 1229 + ) { 1230 1230 + const nsid = "app.bsky.bookmark.createBookmark"; // @ts-ignore - dynamically generated 1231 1231 + return this._server.xrpc.method(nsid, cfg); 1232 1232 + } 1233 1233 + } 1234 1234 + 870 1235 export class AppBskyEmbedNS { 871 1236 _server: Server; 872 1237 ··· 906 1271 return this._server.xrpc.method(nsid, cfg); 907 1272 } 908 1273 1274 1274 + putActivitySubscription<A extends Auth = void>( 1275 1275 + cfg: MethodConfigOrHandler< 1276 1276 + A, 1277 1277 + AppBskyNotificationPutActivitySubscription.QueryParams, 1278 1278 + AppBskyNotificationPutActivitySubscription.HandlerInput, 1279 1279 + AppBskyNotificationPutActivitySubscription.HandlerOutput 1280 1280 + >, 1281 1281 + ) { 1282 1282 + const nsid = "app.bsky.notification.putActivitySubscription"; // @ts-ignore - dynamically generated 1283 1283 + return this._server.xrpc.method(nsid, cfg); 1284 1284 + } 1285 1285 + 1286 1286 + putPreferencesV2<A extends Auth = void>( 1287 1287 + cfg: MethodConfigOrHandler< 1288 1288 + A, 1289 1289 + AppBskyNotificationPutPreferencesV2.QueryParams, 1290 1290 + AppBskyNotificationPutPreferencesV2.HandlerInput, 1291 1291 + AppBskyNotificationPutPreferencesV2.HandlerOutput 1292 1292 + >, 1293 1293 + ) { 1294 1294 + const nsid = "app.bsky.notification.putPreferencesV2"; // @ts-ignore - dynamically generated 1295 1295 + return this._server.xrpc.method(nsid, cfg); 1296 1296 + } 1297 1297 + 909 1298 updateSeen<A extends Auth = void>( 910 1299 cfg: MethodConfigOrHandler< 911 1300 A, ··· 918 1307 return this._server.xrpc.method(nsid, cfg); 919 1308 } 920 1309 1310 1310 + listActivitySubscriptions<A extends Auth = void>( 1311 1311 + cfg: MethodConfigOrHandler< 1312 1312 + A, 1313 1313 + AppBskyNotificationListActivitySubscriptions.QueryParams, 1314 1314 + AppBskyNotificationListActivitySubscriptions.HandlerInput, 1315 1315 + AppBskyNotificationListActivitySubscriptions.HandlerOutput 1316 1316 + >, 1317 1317 + ) { 1318 1318 + const nsid = "app.bsky.notification.listActivitySubscriptions"; // @ts-ignore - dynamically generated 1319 1319 + return this._server.xrpc.method(nsid, cfg); 1320 1320 + } 1321 1321 + 1322 1322 + unregisterPush<A extends Auth = void>( 1323 1323 + cfg: MethodConfigOrHandler< 1324 1324 + A, 1325 1325 + AppBskyNotificationUnregisterPush.QueryParams, 1326 1326 + AppBskyNotificationUnregisterPush.HandlerInput, 1327 1327 + AppBskyNotificationUnregisterPush.HandlerOutput 1328 1328 + >, 1329 1329 + ) { 1330 1330 + const nsid = "app.bsky.notification.unregisterPush"; // @ts-ignore - dynamically generated 1331 1331 + return this._server.xrpc.method(nsid, cfg); 1332 1332 + } 1333 1333 + 1334 1334 + getPreferences<A extends Auth = void>( 1335 1335 + cfg: MethodConfigOrHandler< 1336 1336 + A, 1337 1337 + AppBskyNotificationGetPreferences.QueryParams, 1338 1338 + AppBskyNotificationGetPreferences.HandlerInput, 1339 1339 + AppBskyNotificationGetPreferences.HandlerOutput 1340 1340 + >, 1341 1341 + ) { 1342 1342 + const nsid = "app.bsky.notification.getPreferences"; // @ts-ignore - dynamically generated 1343 1343 + return this._server.xrpc.method(nsid, cfg); 1344 1344 + } 1345 1345 + 921 1346 listNotifications<A extends Auth = void>( 922 1347 cfg: MethodConfigOrHandler< 923 1348 A, ··· 950 1375 this._server = server; 951 1376 } 952 1377 1378 1378 + getSuggestedFeedsSkeleton<A extends Auth = void>( 1379 1379 + cfg: MethodConfigOrHandler< 1380 1380 + A, 1381 1381 + AppBskyUnspeccedGetSuggestedFeedsSkeleton.QueryParams, 1382 1382 + AppBskyUnspeccedGetSuggestedFeedsSkeleton.HandlerInput, 1383 1383 + AppBskyUnspeccedGetSuggestedFeedsSkeleton.HandlerOutput 1384 1384 + >, 1385 1385 + ) { 1386 1386 + const nsid = "app.bsky.unspecced.getSuggestedFeedsSkeleton"; // @ts-ignore - dynamically generated 1387 1387 + return this._server.xrpc.method(nsid, cfg); 1388 1388 + } 1389 1389 + 953 1390 searchStarterPacksSkeleton<A extends Auth = void>( 954 1391 cfg: MethodConfigOrHandler< 955 1392 A, ··· 962 1399 return this._server.xrpc.method(nsid, cfg); 963 1400 } 964 1401 1402 1402 + getOnboardingSuggestedStarterPacksSkeleton<A extends Auth = void>( 1403 1403 + cfg: MethodConfigOrHandler< 1404 1404 + A, 1405 1405 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacksSkeleton.QueryParams, 1406 1406 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacksSkeleton.HandlerInput, 1407 1407 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacksSkeleton.HandlerOutput 1408 1408 + >, 1409 1409 + ) { 1410 1410 + const nsid = 1411 1411 + "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton"; // @ts-ignore - dynamically generated 1412 1412 + return this._server.xrpc.method(nsid, cfg); 1413 1413 + } 1414 1414 + 1415 1415 + getSuggestedUsers<A extends Auth = void>( 1416 1416 + cfg: MethodConfigOrHandler< 1417 1417 + A, 1418 1418 + AppBskyUnspeccedGetSuggestedUsers.QueryParams, 1419 1419 + AppBskyUnspeccedGetSuggestedUsers.HandlerInput, 1420 1420 + AppBskyUnspeccedGetSuggestedUsers.HandlerOutput 1421 1421 + >, 1422 1422 + ) { 1423 1423 + const nsid = "app.bsky.unspecced.getSuggestedUsers"; // @ts-ignore - dynamically generated 1424 1424 + return this._server.xrpc.method(nsid, cfg); 1425 1425 + } 1426 1426 + 1427 1427 + getPostThreadOtherV2<A extends Auth = void>( 1428 1428 + cfg: MethodConfigOrHandler< 1429 1429 + A, 1430 1430 + AppBskyUnspeccedGetPostThreadOtherV2.QueryParams, 1431 1431 + AppBskyUnspeccedGetPostThreadOtherV2.HandlerInput, 1432 1432 + AppBskyUnspeccedGetPostThreadOtherV2.HandlerOutput 1433 1433 + >, 1434 1434 + ) { 1435 1435 + const nsid = "app.bsky.unspecced.getPostThreadOtherV2"; // @ts-ignore - dynamically generated 1436 1436 + return this._server.xrpc.method(nsid, cfg); 1437 1437 + } 1438 1438 + 1439 1439 + getSuggestedStarterPacks<A extends Auth = void>( 1440 1440 + cfg: MethodConfigOrHandler< 1441 1441 + A, 1442 1442 + AppBskyUnspeccedGetSuggestedStarterPacks.QueryParams, 1443 1443 + AppBskyUnspeccedGetSuggestedStarterPacks.HandlerInput, 1444 1444 + AppBskyUnspeccedGetSuggestedStarterPacks.HandlerOutput 1445 1445 + >, 1446 1446 + ) { 1447 1447 + const nsid = "app.bsky.unspecced.getSuggestedStarterPacks"; // @ts-ignore - dynamically generated 1448 1448 + return this._server.xrpc.method(nsid, cfg); 1449 1449 + } 1450 1450 + 1451 1451 + getSuggestedStarterPacksSkeleton<A extends Auth = void>( 1452 1452 + cfg: MethodConfigOrHandler< 1453 1453 + A, 1454 1454 + AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.QueryParams, 1455 1455 + AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.HandlerInput, 1456 1456 + AppBskyUnspeccedGetSuggestedStarterPacksSkeleton.HandlerOutput 1457 1457 + >, 1458 1458 + ) { 1459 1459 + const nsid = "app.bsky.unspecced.getSuggestedStarterPacksSkeleton"; // @ts-ignore - dynamically generated 1460 1460 + return this._server.xrpc.method(nsid, cfg); 1461 1461 + } 1462 1462 + 1463 1463 + getOnboardingSuggestedStarterPacks<A extends Auth = void>( 1464 1464 + cfg: MethodConfigOrHandler< 1465 1465 + A, 1466 1466 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacks.QueryParams, 1467 1467 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacks.HandlerInput, 1468 1468 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacks.HandlerOutput 1469 1469 + >, 1470 1470 + ) { 1471 1471 + const nsid = "app.bsky.unspecced.getOnboardingSuggestedStarterPacks"; // @ts-ignore - dynamically generated 1472 1472 + return this._server.xrpc.method(nsid, cfg); 1473 1473 + } 1474 1474 + 1475 1475 + getSuggestedUsersSkeleton<A extends Auth = void>( 1476 1476 + cfg: MethodConfigOrHandler< 1477 1477 + A, 1478 1478 + AppBskyUnspeccedGetSuggestedUsersSkeleton.QueryParams, 1479 1479 + AppBskyUnspeccedGetSuggestedUsersSkeleton.HandlerInput, 1480 1480 + AppBskyUnspeccedGetSuggestedUsersSkeleton.HandlerOutput 1481 1481 + >, 1482 1482 + ) { 1483 1483 + const nsid = "app.bsky.unspecced.getSuggestedUsersSkeleton"; // @ts-ignore - dynamically generated 1484 1484 + return this._server.xrpc.method(nsid, cfg); 1485 1485 + } 1486 1486 + 1487 1487 + getPostThreadV2<A extends Auth = void>( 1488 1488 + cfg: MethodConfigOrHandler< 1489 1489 + A, 1490 1490 + AppBskyUnspeccedGetPostThreadV2.QueryParams, 1491 1491 + AppBskyUnspeccedGetPostThreadV2.HandlerInput, 1492 1492 + AppBskyUnspeccedGetPostThreadV2.HandlerOutput 1493 1493 + >, 1494 1494 + ) { 1495 1495 + const nsid = "app.bsky.unspecced.getPostThreadV2"; // @ts-ignore - dynamically generated 1496 1496 + return this._server.xrpc.method(nsid, cfg); 1497 1497 + } 1498 1498 + 1499 1499 + getTrends<A extends Auth = void>( 1500 1500 + cfg: MethodConfigOrHandler< 1501 1501 + A, 1502 1502 + AppBskyUnspeccedGetTrends.QueryParams, 1503 1503 + AppBskyUnspeccedGetTrends.HandlerInput, 1504 1504 + AppBskyUnspeccedGetTrends.HandlerOutput 1505 1505 + >, 1506 1506 + ) { 1507 1507 + const nsid = "app.bsky.unspecced.getTrends"; // @ts-ignore - dynamically generated 1508 1508 + return this._server.xrpc.method(nsid, cfg); 1509 1509 + } 1510 1510 + 965 1511 searchActorsSkeleton<A extends Auth = void>( 966 1512 cfg: MethodConfigOrHandler< 967 1513 A, ··· 998 1544 return this._server.xrpc.method(nsid, cfg); 999 1545 } 1000 1546 1547 1547 + getAgeAssuranceState<A extends Auth = void>( 1548 1548 + cfg: MethodConfigOrHandler< 1549 1549 + A, 1550 1550 + AppBskyUnspeccedGetAgeAssuranceState.QueryParams, 1551 1551 + AppBskyUnspeccedGetAgeAssuranceState.HandlerInput, 1552 1552 + AppBskyUnspeccedGetAgeAssuranceState.HandlerOutput 1553 1553 + >, 1554 1554 + ) { 1555 1555 + const nsid = "app.bsky.unspecced.getAgeAssuranceState"; // @ts-ignore - dynamically generated 1556 1556 + return this._server.xrpc.method(nsid, cfg); 1557 1557 + } 1558 1558 + 1001 1559 getPopularFeedGenerators<A extends Auth = void>( 1002 1560 cfg: MethodConfigOrHandler< 1003 1561 A, ··· 1010 1568 return this._server.xrpc.method(nsid, cfg); 1011 1569 } 1012 1570 1571 1571 + initAgeAssurance<A extends Auth = void>( 1572 1572 + cfg: MethodConfigOrHandler< 1573 1573 + A, 1574 1574 + AppBskyUnspeccedInitAgeAssurance.QueryParams, 1575 1575 + AppBskyUnspeccedInitAgeAssurance.HandlerInput, 1576 1576 + AppBskyUnspeccedInitAgeAssurance.HandlerOutput 1577 1577 + >, 1578 1578 + ) { 1579 1579 + const nsid = "app.bsky.unspecced.initAgeAssurance"; // @ts-ignore - dynamically generated 1580 1580 + return this._server.xrpc.method(nsid, cfg); 1581 1581 + } 1582 1582 + 1013 1583 getTrendingTopics<A extends Auth = void>( 1014 1584 cfg: MethodConfigOrHandler< 1015 1585 A, ··· 1034 1604 return this._server.xrpc.method(nsid, cfg); 1035 1605 } 1036 1606 1607 1607 + getSuggestedFeeds<A extends Auth = void>( 1608 1608 + cfg: MethodConfigOrHandler< 1609 1609 + A, 1610 1610 + AppBskyUnspeccedGetSuggestedFeeds.QueryParams, 1611 1611 + AppBskyUnspeccedGetSuggestedFeeds.HandlerInput, 1612 1612 + AppBskyUnspeccedGetSuggestedFeeds.HandlerOutput 1613 1613 + >, 1614 1614 + ) { 1615 1615 + const nsid = "app.bsky.unspecced.getSuggestedFeeds"; // @ts-ignore - dynamically generated 1616 1616 + return this._server.xrpc.method(nsid, cfg); 1617 1617 + } 1618 1618 + 1619 1619 + getTrendsSkeleton<A extends Auth = void>( 1620 1620 + cfg: MethodConfigOrHandler< 1621 1621 + A, 1622 1622 + AppBskyUnspeccedGetTrendsSkeleton.QueryParams, 1623 1623 + AppBskyUnspeccedGetTrendsSkeleton.HandlerInput, 1624 1624 + AppBskyUnspeccedGetTrendsSkeleton.HandlerOutput 1625 1625 + >, 1626 1626 + ) { 1627 1627 + const nsid = "app.bsky.unspecced.getTrendsSkeleton"; // @ts-ignore - dynamically generated 1628 1628 + return this._server.xrpc.method(nsid, cfg); 1629 1629 + } 1630 1630 + 1037 1631 getConfig<A extends Auth = void>( 1038 1632 cfg: MethodConfigOrHandler< 1039 1633 A, ··· 1078 1672 return this._server.xrpc.method(nsid, cfg); 1079 1673 } 1080 1674 1675 1675 + getStarterPacksWithMembership<A extends Auth = void>( 1676 1676 + cfg: MethodConfigOrHandler< 1677 1677 + A, 1678 1678 + AppBskyGraphGetStarterPacksWithMembership.QueryParams, 1679 1679 + AppBskyGraphGetStarterPacksWithMembership.HandlerInput, 1680 1680 + AppBskyGraphGetStarterPacksWithMembership.HandlerOutput 1681 1681 + >, 1682 1682 + ) { 1683 1683 + const nsid = "app.bsky.graph.getStarterPacksWithMembership"; // @ts-ignore - dynamically generated 1684 1684 + return this._server.xrpc.method(nsid, cfg); 1685 1685 + } 1686 1686 + 1687 1687 + getListsWithMembership<A extends Auth = void>( 1688 1688 + cfg: MethodConfigOrHandler< 1689 1689 + A, 1690 1690 + AppBskyGraphGetListsWithMembership.QueryParams, 1691 1691 + AppBskyGraphGetListsWithMembership.HandlerInput, 1692 1692 + AppBskyGraphGetListsWithMembership.HandlerOutput 1693 1693 + >, 1694 1694 + ) { 1695 1695 + const nsid = "app.bsky.graph.getListsWithMembership"; // @ts-ignore - dynamically generated 1696 1696 + return this._server.xrpc.method(nsid, cfg); 1697 1697 + } 1698 1698 + 1081 1699 unmuteActorList<A extends Auth = void>( 1082 1700 cfg: MethodConfigOrHandler< 1083 1701 A, ··· 1539 2157 } 1540 2158 } 1541 2159 2160 2160 + export class AppBskyAgeassuranceNS { 2161 2161 + _server: Server; 2162 2162 + 2163 2163 + constructor(server: Server) { 2164 2164 + this._server = server; 2165 2165 + } 2166 2166 + 2167 2167 + begin<A extends Auth = void>( 2168 2168 + cfg: MethodConfigOrHandler< 2169 2169 + A, 2170 2170 + AppBskyAgeassuranceBegin.QueryParams, 2171 2171 + AppBskyAgeassuranceBegin.HandlerInput, 2172 2172 + AppBskyAgeassuranceBegin.HandlerOutput 2173 2173 + >, 2174 2174 + ) { 2175 2175 + const nsid = "app.bsky.ageassurance.begin"; // @ts-ignore - dynamically generated 2176 2176 + return this._server.xrpc.method(nsid, cfg); 2177 2177 + } 2178 2178 + 2179 2179 + getState<A extends Auth = void>( 2180 2180 + cfg: MethodConfigOrHandler< 2181 2181 + A, 2182 2182 + AppBskyAgeassuranceGetState.QueryParams, 2183 2183 + AppBskyAgeassuranceGetState.HandlerInput, 2184 2184 + AppBskyAgeassuranceGetState.HandlerOutput 2185 2185 + >, 2186 2186 + ) { 2187 2187 + const nsid = "app.bsky.ageassurance.getState"; // @ts-ignore - dynamically generated 2188 2188 + return this._server.xrpc.method(nsid, cfg); 2189 2189 + } 2190 2190 + 2191 2191 + getConfig<A extends Auth = void>( 2192 2192 + cfg: MethodConfigOrHandler< 2193 2193 + A, 2194 2194 + AppBskyAgeassuranceGetConfig.QueryParams, 2195 2195 + AppBskyAgeassuranceGetConfig.HandlerInput, 2196 2196 + AppBskyAgeassuranceGetConfig.HandlerOutput 2197 2197 + >, 2198 2198 + ) { 2199 2199 + const nsid = "app.bsky.ageassurance.getConfig"; // @ts-ignore - dynamically generated 2200 2200 + return this._server.xrpc.method(nsid, cfg); 2201 2201 + } 2202 2202 + } 2203 2203 + 1542 2204 export class AppBskyActorNS { 1543 2205 _server: Server; 1544 2206 ··· 1754 2416 return this._server.xrpc.method(nsid, cfg); 1755 2417 } 1756 2418 2419 2419 + addReaction<A extends Auth = void>( 2420 2420 + cfg: MethodConfigOrHandler< 2421 2421 + A, 2422 2422 + ChatBskyConvoAddReaction.QueryParams, 2423 2423 + ChatBskyConvoAddReaction.HandlerInput, 2424 2424 + ChatBskyConvoAddReaction.HandlerOutput 2425 2425 + >, 2426 2426 + ) { 2427 2427 + const nsid = "chat.bsky.convo.addReaction"; // @ts-ignore - dynamically generated 2428 2428 + return this._server.xrpc.method(nsid, cfg); 2429 2429 + } 2430 2430 + 1757 2431 acceptConvo<A extends Auth = void>( 1758 2432 cfg: MethodConfigOrHandler< 1759 2433 A, ··· 1787 2461 >, 1788 2462 ) { 1789 2463 const nsid = "chat.bsky.convo.deleteMessageForSelf"; // @ts-ignore - dynamically generated 2464 2464 + return this._server.xrpc.method(nsid, cfg); 2465 2465 + } 2466 2466 + 2467 2467 + removeReaction<A extends Auth = void>( 2468 2468 + cfg: MethodConfigOrHandler< 2469 2469 + A, 2470 2470 + ChatBskyConvoRemoveReaction.QueryParams, 2471 2471 + ChatBskyConvoRemoveReaction.HandlerInput, 2472 2472 + ChatBskyConvoRemoveReaction.HandlerOutput 2473 2473 + >, 2474 2474 + ) { 2475 2475 + const nsid = "chat.bsky.convo.removeReaction"; // @ts-ignore - dynamically generated 1790 2476 return this._server.xrpc.method(nsid, cfg); 1791 2477 } 1792 2478 ··· 2688 3374 this._server = server; 2689 3375 } 2690 3376 3377 3377 + dereferenceScope<A extends Auth = void>( 3378 3378 + cfg: MethodConfigOrHandler< 3379 3379 + A, 3380 3380 + ComAtprotoTempDereferenceScope.QueryParams, 3381 3381 + ComAtprotoTempDereferenceScope.HandlerInput, 3382 3382 + ComAtprotoTempDereferenceScope.HandlerOutput 3383 3383 + >, 3384 3384 + ) { 3385 3385 + const nsid = "com.atproto.temp.dereferenceScope"; // @ts-ignore - dynamically generated 3386 3386 + return this._server.xrpc.method(nsid, cfg); 3387 3387 + } 3388 3388 + 2691 3389 addReservedHandle<A extends Auth = void>( 2692 3390 cfg: MethodConfigOrHandler< 2693 3391 A, ··· 2712 3410 return this._server.xrpc.method(nsid, cfg); 2713 3411 } 2714 3412 3413 3413 + checkHandleAvailability<A extends Auth = void>( 3414 3414 + cfg: MethodConfigOrHandler< 3415 3415 + A, 3416 3416 + ComAtprotoTempCheckHandleAvailability.QueryParams, 3417 3417 + ComAtprotoTempCheckHandleAvailability.HandlerInput, 3418 3418 + ComAtprotoTempCheckHandleAvailability.HandlerOutput 3419 3419 + >, 3420 3420 + ) { 3421 3421 + const nsid = "com.atproto.temp.checkHandleAvailability"; // @ts-ignore - dynamically generated 3422 3422 + return this._server.xrpc.method(nsid, cfg); 3423 3423 + } 3424 3424 + 2715 3425 requestPhoneVerification<A extends Auth = void>( 2716 3426 cfg: MethodConfigOrHandler< 2717 3427 A, ··· 2721 3431 >, 2722 3432 ) { 2723 3433 const nsid = "com.atproto.temp.requestPhoneVerification"; // @ts-ignore - dynamically generated 3434 3434 + return this._server.xrpc.method(nsid, cfg); 3435 3435 + } 3436 3436 + 3437 3437 + revokeAccountCredentials<A extends Auth = void>( 3438 3438 + cfg: MethodConfigOrHandler< 3439 3439 + A, 3440 3440 + ComAtprotoTempRevokeAccountCredentials.QueryParams, 3441 3441 + ComAtprotoTempRevokeAccountCredentials.HandlerInput, 3442 3442 + ComAtprotoTempRevokeAccountCredentials.HandlerOutput 3443 3443 + >, 3444 3444 + ) { 3445 3445 + const nsid = "com.atproto.temp.revokeAccountCredentials"; // @ts-ignore - dynamically generated 2724 3446 return this._server.xrpc.method(nsid, cfg); 2725 3447 } 2726 3448 ··· 2780 3502 return this._server.xrpc.method(nsid, cfg); 2781 3503 } 2782 3504 3505 3505 + resolveIdentity<A extends Auth = void>( 3506 3506 + cfg: MethodConfigOrHandler< 3507 3507 + A, 3508 3508 + ComAtprotoIdentityResolveIdentity.QueryParams, 3509 3509 + ComAtprotoIdentityResolveIdentity.HandlerInput, 3510 3510 + ComAtprotoIdentityResolveIdentity.HandlerOutput 3511 3511 + >, 3512 3512 + ) { 3513 3513 + const nsid = "com.atproto.identity.resolveIdentity"; // @ts-ignore - dynamically generated 3514 3514 + return this._server.xrpc.method(nsid, cfg); 3515 3515 + } 3516 3516 + 3517 3517 + refreshIdentity<A extends Auth = void>( 3518 3518 + cfg: MethodConfigOrHandler< 3519 3519 + A, 3520 3520 + ComAtprotoIdentityRefreshIdentity.QueryParams, 3521 3521 + ComAtprotoIdentityRefreshIdentity.HandlerInput, 3522 3522 + ComAtprotoIdentityRefreshIdentity.HandlerOutput 3523 3523 + >, 3524 3524 + ) { 3525 3525 + const nsid = "com.atproto.identity.refreshIdentity"; // @ts-ignore - dynamically generated 3526 3526 + return this._server.xrpc.method(nsid, cfg); 3527 3527 + } 3528 3528 + 2783 3529 resolveHandle<A extends Auth = void>( 2784 3530 cfg: MethodConfigOrHandler< 2785 3531 A, ··· 2813 3559 >, 2814 3560 ) { 2815 3561 const nsid = "com.atproto.identity.getRecommendedDidCredentials"; // @ts-ignore - dynamically generated 3562 3562 + return this._server.xrpc.method(nsid, cfg); 3563 3563 + } 3564 3564 + 3565 3565 + resolveDid<A extends Auth = void>( 3566 3566 + cfg: MethodConfigOrHandler< 3567 3567 + A, 3568 3568 + ComAtprotoIdentityResolveDid.QueryParams, 3569 3569 + ComAtprotoIdentityResolveDid.HandlerInput, 3570 3570 + ComAtprotoIdentityResolveDid.HandlerOutput 3571 3571 + >, 3572 3572 + ) { 3573 3573 + const nsid = "com.atproto.identity.resolveDid"; // @ts-ignore - dynamically generated 2816 3574 return this._server.xrpc.method(nsid, cfg); 2817 3575 } 2818 3576 } ··· 2905 3663 >, 2906 3664 ) { 2907 3665 const nsid = "com.atproto.admin.getInviteCodes"; // @ts-ignore - dynamically generated 3666 3666 + return this._server.xrpc.method(nsid, cfg); 3667 3667 + } 3668 3668 + 3669 3669 + updateAccountSigningKey<A extends Auth = void>( 3670 3670 + cfg: MethodConfigOrHandler< 3671 3671 + A, 3672 3672 + ComAtprotoAdminUpdateAccountSigningKey.QueryParams, 3673 3673 + ComAtprotoAdminUpdateAccountSigningKey.HandlerInput, 3674 3674 + ComAtprotoAdminUpdateAccountSigningKey.HandlerOutput 3675 3675 + >, 3676 3676 + ) { 3677 3677 + const nsid = "com.atproto.admin.updateAccountSigningKey"; // @ts-ignore - dynamically generated 2908 3678 return this._server.xrpc.method(nsid, cfg); 2909 3679 } 2910 3680 ··· 3338 4108 constructor(server: Server) { 3339 4109 this._server = server; 3340 4110 } 4111 4111 + 4112 4112 + resolveLexicon<A extends Auth = void>( 4113 4113 + cfg: MethodConfigOrHandler< 4114 4114 + A, 4115 4115 + ComAtprotoLexiconResolveLexicon.QueryParams, 4116 4116 + ComAtprotoLexiconResolveLexicon.HandlerInput, 4117 4117 + ComAtprotoLexiconResolveLexicon.HandlerOutput 4118 4118 + >, 4119 4119 + ) { 4120 4120 + const nsid = "com.atproto.lexicon.resolveLexicon"; // @ts-ignore - dynamically generated 4121 4121 + return this._server.xrpc.method(nsid, cfg); 4122 4122 + } 3341 4123 } 3342 4124 3343 4125 export class ComAtprotoSyncNS { ··· 3466 4248 return this._server.xrpc.method(nsid, cfg); 3467 4249 } 3468 4250 4251 4251 + listHosts<A extends Auth = void>( 4252 4252 + cfg: MethodConfigOrHandler< 4253 4253 + A, 4254 4254 + ComAtprotoSyncListHosts.QueryParams, 4255 4255 + ComAtprotoSyncListHosts.HandlerInput, 4256 4256 + ComAtprotoSyncListHosts.HandlerOutput 4257 4257 + >, 4258 4258 + ) { 4259 4259 + const nsid = "com.atproto.sync.listHosts"; // @ts-ignore - dynamically generated 4260 4260 + return this._server.xrpc.method(nsid, cfg); 4261 4261 + } 4262 4262 + 3469 4263 listRepos<A extends Auth = void>( 3470 4264 cfg: MethodConfigOrHandler< 3471 4265 A, ··· 3475 4269 >, 3476 4270 ) { 3477 4271 const nsid = "com.atproto.sync.listRepos"; // @ts-ignore - dynamically generated 4272 4272 + return this._server.xrpc.method(nsid, cfg); 4273 4273 + } 4274 4274 + 4275 4275 + getHostStatus<A extends Auth = void>( 4276 4276 + cfg: MethodConfigOrHandler< 4277 4277 + A, 4278 4278 + ComAtprotoSyncGetHostStatus.QueryParams, 4279 4279 + ComAtprotoSyncGetHostStatus.HandlerInput, 4280 4280 + ComAtprotoSyncGetHostStatus.HandlerOutput 4281 4281 + >, 4282 4282 + ) { 4283 4283 + const nsid = "com.atproto.sync.getHostStatus"; // @ts-ignore - dynamically generated 3478 4284 return this._server.xrpc.method(nsid, cfg); 3479 4285 } 3480 4286

+5960 -128

lex/lexicons.ts

reviewed

··· 235 235 "type": "ref", 236 236 "ref": "lex:tools.ozone.server.getConfig#viewerConfig", 237 237 }, 238 238 + "verifierDid": { 239 239 + "type": "string", 240 240 + "format": "did", 241 241 + "description": "The did of the verifier used for verification.", 242 242 + }, 238 243 }, 239 244 }, 240 245 }, ··· 257 262 "tools.ozone.team.defs#roleAdmin", 258 263 "tools.ozone.team.defs#roleModerator", 259 264 "tools.ozone.team.defs#roleTriage", 265 265 + "tools.ozone.team.defs#roleVerifier", 260 266 ], 261 267 }, 262 268 }, 263 269 }, 264 270 }, 265 271 }, 272 272 + "ToolsOzoneVerificationRevokeVerifications": { 273 273 + "lexicon": 1, 274 274 + "id": "tools.ozone.verification.revokeVerifications", 275 275 + "defs": { 276 276 + "main": { 277 277 + "type": "procedure", 278 278 + "description": 279 279 + "Revoke previously granted verifications in batches of up to 100.", 280 280 + "input": { 281 281 + "encoding": "application/json", 282 282 + "schema": { 283 283 + "type": "object", 284 284 + "required": [ 285 285 + "uris", 286 286 + ], 287 287 + "properties": { 288 288 + "uris": { 289 289 + "type": "array", 290 290 + "description": "Array of verification record uris to revoke", 291 291 + "maxLength": 100, 292 292 + "items": { 293 293 + "type": "string", 294 294 + "description": 295 295 + "The AT-URI of the verification record to revoke.", 296 296 + "format": "at-uri", 297 297 + }, 298 298 + }, 299 299 + "revokeReason": { 300 300 + "type": "string", 301 301 + "description": 302 302 + "Reason for revoking the verification. This is optional and can be omitted if not needed.", 303 303 + "maxLength": 1000, 304 304 + }, 305 305 + }, 306 306 + }, 307 307 + }, 308 308 + "output": { 309 309 + "encoding": "application/json", 310 310 + "schema": { 311 311 + "type": "object", 312 312 + "required": [ 313 313 + "revokedVerifications", 314 314 + "failedRevocations", 315 315 + ], 316 316 + "properties": { 317 317 + "revokedVerifications": { 318 318 + "type": "array", 319 319 + "description": "List of verification uris successfully revoked", 320 320 + "items": { 321 321 + "type": "string", 322 322 + "format": "at-uri", 323 323 + }, 324 324 + }, 325 325 + "failedRevocations": { 326 326 + "type": "array", 327 327 + "description": 328 328 + "List of verification uris that couldn't be revoked, including failure reasons", 329 329 + "items": { 330 330 + "type": "ref", 331 331 + "ref": 332 332 + "lex:tools.ozone.verification.revokeVerifications#revokeError", 333 333 + }, 334 334 + }, 335 335 + }, 336 336 + }, 337 337 + }, 338 338 + }, 339 339 + "revokeError": { 340 340 + "type": "object", 341 341 + "description": "Error object for failed revocations", 342 342 + "required": [ 343 343 + "uri", 344 344 + "error", 345 345 + ], 346 346 + "properties": { 347 347 + "uri": { 348 348 + "type": "string", 349 349 + "description": 350 350 + "The AT-URI of the verification record that failed to revoke.", 351 351 + "format": "at-uri", 352 352 + }, 353 353 + "error": { 354 354 + "type": "string", 355 355 + "description": 356 356 + "Description of the error that occurred during revocation.", 357 357 + }, 358 358 + }, 359 359 + }, 360 360 + }, 361 361 + }, 362 362 + "ToolsOzoneVerificationDefs": { 363 363 + "lexicon": 1, 364 364 + "id": "tools.ozone.verification.defs", 365 365 + "defs": { 366 366 + "verificationView": { 367 367 + "type": "object", 368 368 + "description": "Verification data for the associated subject.", 369 369 + "required": [ 370 370 + "issuer", 371 371 + "uri", 372 372 + "subject", 373 373 + "handle", 374 374 + "displayName", 375 375 + "createdAt", 376 376 + ], 377 377 + "properties": { 378 378 + "issuer": { 379 379 + "type": "string", 380 380 + "description": "The user who issued this verification.", 381 381 + "format": "did", 382 382 + }, 383 383 + "uri": { 384 384 + "type": "string", 385 385 + "description": "The AT-URI of the verification record.", 386 386 + "format": "at-uri", 387 387 + }, 388 388 + "subject": { 389 389 + "type": "string", 390 390 + "format": "did", 391 391 + "description": "The subject of the verification.", 392 392 + }, 393 393 + "handle": { 394 394 + "type": "string", 395 395 + "description": 396 396 + "Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.", 397 397 + "format": "handle", 398 398 + }, 399 399 + "displayName": { 400 400 + "type": "string", 401 401 + "description": 402 402 + "Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying.", 403 403 + }, 404 404 + "createdAt": { 405 405 + "type": "string", 406 406 + "description": "Timestamp when the verification was created.", 407 407 + "format": "datetime", 408 408 + }, 409 409 + "revokeReason": { 410 410 + "type": "string", 411 411 + "description": 412 412 + "Describes the reason for revocation, also indicating that the verification is no longer valid.", 413 413 + }, 414 414 + "revokedAt": { 415 415 + "type": "string", 416 416 + "description": "Timestamp when the verification was revoked.", 417 417 + "format": "datetime", 418 418 + }, 419 419 + "revokedBy": { 420 420 + "type": "string", 421 421 + "description": "The user who revoked this verification.", 422 422 + "format": "did", 423 423 + }, 424 424 + "subjectProfile": { 425 425 + "type": "union", 426 426 + "refs": [], 427 427 + }, 428 428 + "issuerProfile": { 429 429 + "type": "union", 430 430 + "refs": [], 431 431 + }, 432 432 + "subjectRepo": { 433 433 + "type": "union", 434 434 + "refs": [ 435 435 + "lex:tools.ozone.moderation.defs#repoViewDetail", 436 436 + "lex:tools.ozone.moderation.defs#repoViewNotFound", 437 437 + ], 438 438 + }, 439 439 + "issuerRepo": { 440 440 + "type": "union", 441 441 + "refs": [ 442 442 + "lex:tools.ozone.moderation.defs#repoViewDetail", 443 443 + "lex:tools.ozone.moderation.defs#repoViewNotFound", 444 444 + ], 445 445 + }, 446 446 + }, 447 447 + }, 448 448 + }, 449 449 + }, 450 450 + "ToolsOzoneVerificationGrantVerifications": { 451 451 + "lexicon": 1, 452 452 + "id": "tools.ozone.verification.grantVerifications", 453 453 + "defs": { 454 454 + "main": { 455 455 + "type": "procedure", 456 456 + "description": 457 457 + "Grant verifications to multiple subjects. Allows batch processing of up to 100 verifications at once.", 458 458 + "input": { 459 459 + "encoding": "application/json", 460 460 + "schema": { 461 461 + "type": "object", 462 462 + "required": [ 463 463 + "verifications", 464 464 + ], 465 465 + "properties": { 466 466 + "verifications": { 467 467 + "type": "array", 468 468 + "description": "Array of verification requests to process", 469 469 + "maxLength": 100, 470 470 + "items": { 471 471 + "type": "ref", 472 472 + "ref": 473 473 + "lex:tools.ozone.verification.grantVerifications#verificationInput", 474 474 + }, 475 475 + }, 476 476 + }, 477 477 + }, 478 478 + }, 479 479 + "output": { 480 480 + "encoding": "application/json", 481 481 + "schema": { 482 482 + "type": "object", 483 483 + "required": [ 484 484 + "verifications", 485 485 + "failedVerifications", 486 486 + ], 487 487 + "properties": { 488 488 + "verifications": { 489 489 + "type": "array", 490 490 + "items": { 491 491 + "type": "ref", 492 492 + "ref": "lex:tools.ozone.verification.defs#verificationView", 493 493 + }, 494 494 + }, 495 495 + "failedVerifications": { 496 496 + "type": "array", 497 497 + "items": { 498 498 + "type": "ref", 499 499 + "ref": 500 500 + "lex:tools.ozone.verification.grantVerifications#grantError", 501 501 + }, 502 502 + }, 503 503 + }, 504 504 + }, 505 505 + }, 506 506 + }, 507 507 + "verificationInput": { 508 508 + "type": "object", 509 509 + "required": [ 510 510 + "subject", 511 511 + "handle", 512 512 + "displayName", 513 513 + ], 514 514 + "properties": { 515 515 + "subject": { 516 516 + "type": "string", 517 517 + "description": "The did of the subject being verified", 518 518 + "format": "did", 519 519 + }, 520 520 + "handle": { 521 521 + "type": "string", 522 522 + "description": 523 523 + "Handle of the subject the verification applies to at the moment of verifying.", 524 524 + "format": "handle", 525 525 + }, 526 526 + "displayName": { 527 527 + "type": "string", 528 528 + "description": 529 529 + "Display name of the subject the verification applies to at the moment of verifying.", 530 530 + }, 531 531 + "createdAt": { 532 532 + "type": "string", 533 533 + "format": "datetime", 534 534 + "description": 535 535 + "Timestamp for verification record. Defaults to current time when not specified.", 536 536 + }, 537 537 + }, 538 538 + }, 539 539 + "grantError": { 540 540 + "type": "object", 541 541 + "description": "Error object for failed verifications.", 542 542 + "required": [ 543 543 + "error", 544 544 + "subject", 545 545 + ], 546 546 + "properties": { 547 547 + "error": { 548 548 + "type": "string", 549 549 + "description": "Error message describing the reason for failure.", 550 550 + }, 551 551 + "subject": { 552 552 + "type": "string", 553 553 + "description": "The did of the subject being verified", 554 554 + "format": "did", 555 555 + }, 556 556 + }, 557 557 + }, 558 558 + }, 559 559 + }, 560 560 + "ToolsOzoneVerificationListVerifications": { 561 561 + "lexicon": 1, 562 562 + "id": "tools.ozone.verification.listVerifications", 563 563 + "defs": { 564 564 + "main": { 565 565 + "type": "query", 566 566 + "description": "List verifications", 567 567 + "parameters": { 568 568 + "type": "params", 569 569 + "properties": { 570 570 + "cursor": { 571 571 + "type": "string", 572 572 + "description": "Pagination cursor", 573 573 + }, 574 574 + "limit": { 575 575 + "type": "integer", 576 576 + "description": "Maximum number of results to return", 577 577 + "minimum": 1, 578 578 + "maximum": 100, 579 579 + "default": 50, 580 580 + }, 581 581 + "createdAfter": { 582 582 + "type": "string", 583 583 + "format": "datetime", 584 584 + "description": 585 585 + "Filter to verifications created after this timestamp", 586 586 + }, 587 587 + "createdBefore": { 588 588 + "type": "string", 589 589 + "format": "datetime", 590 590 + "description": 591 591 + "Filter to verifications created before this timestamp", 592 592 + }, 593 593 + "issuers": { 594 594 + "type": "array", 595 595 + "maxLength": 100, 596 596 + "description": "Filter to verifications from specific issuers", 597 597 + "items": { 598 598 + "type": "string", 599 599 + "format": "did", 600 600 + }, 601 601 + }, 602 602 + "subjects": { 603 603 + "type": "array", 604 604 + "description": "Filter to specific verified DIDs", 605 605 + "maxLength": 100, 606 606 + "items": { 607 607 + "type": "string", 608 608 + "format": "did", 609 609 + }, 610 610 + }, 611 611 + "sortDirection": { 612 612 + "type": "string", 613 613 + "description": "Sort direction for creation date", 614 614 + "enum": [ 615 615 + "asc", 616 616 + "desc", 617 617 + ], 618 618 + "default": "desc", 619 619 + }, 620 620 + "isRevoked": { 621 621 + "type": "boolean", 622 622 + "description": 623 623 + "Filter to verifications that are revoked or not. By default, includes both.", 624 624 + }, 625 625 + }, 626 626 + }, 627 627 + "output": { 628 628 + "encoding": "application/json", 629 629 + "schema": { 630 630 + "type": "object", 631 631 + "required": [ 632 632 + "verifications", 633 633 + ], 634 634 + "properties": { 635 635 + "cursor": { 636 636 + "type": "string", 637 637 + }, 638 638 + "verifications": { 639 639 + "type": "array", 640 640 + "items": { 641 641 + "type": "ref", 642 642 + "ref": "lex:tools.ozone.verification.defs#verificationView", 643 643 + }, 644 644 + }, 645 645 + }, 646 646 + }, 647 647 + }, 648 648 + }, 649 649 + }, 650 650 + }, 651 651 + "ToolsOzoneSafelinkDefs": { 652 652 + "lexicon": 1, 653 653 + "id": "tools.ozone.safelink.defs", 654 654 + "defs": { 655 655 + "event": { 656 656 + "type": "object", 657 657 + "description": "An event for URL safety decisions", 658 658 + "required": [ 659 659 + "id", 660 660 + "eventType", 661 661 + "url", 662 662 + "pattern", 663 663 + "action", 664 664 + "reason", 665 665 + "createdBy", 666 666 + "createdAt", 667 667 + ], 668 668 + "properties": { 669 669 + "id": { 670 670 + "type": "integer", 671 671 + "description": "Auto-incrementing row ID", 672 672 + }, 673 673 + "eventType": { 674 674 + "type": "ref", 675 675 + "ref": "lex:tools.ozone.safelink.defs#eventType", 676 676 + }, 677 677 + "url": { 678 678 + "type": "string", 679 679 + "description": "The URL that this rule applies to", 680 680 + }, 681 681 + "pattern": { 682 682 + "type": "ref", 683 683 + "ref": "lex:tools.ozone.safelink.defs#patternType", 684 684 + }, 685 685 + "action": { 686 686 + "type": "ref", 687 687 + "ref": "lex:tools.ozone.safelink.defs#actionType", 688 688 + }, 689 689 + "reason": { 690 690 + "type": "ref", 691 691 + "ref": "lex:tools.ozone.safelink.defs#reasonType", 692 692 + }, 693 693 + "createdBy": { 694 694 + "type": "string", 695 695 + "format": "did", 696 696 + "description": "DID of the user who created this rule", 697 697 + }, 698 698 + "createdAt": { 699 699 + "type": "string", 700 700 + "format": "datetime", 701 701 + }, 702 702 + "comment": { 703 703 + "type": "string", 704 704 + "description": "Optional comment about the decision", 705 705 + }, 706 706 + }, 707 707 + }, 708 708 + "eventType": { 709 709 + "type": "string", 710 710 + "knownValues": [ 711 711 + "addRule", 712 712 + "updateRule", 713 713 + "removeRule", 714 714 + ], 715 715 + }, 716 716 + "patternType": { 717 717 + "type": "string", 718 718 + "knownValues": [ 719 719 + "domain", 720 720 + "url", 721 721 + ], 722 722 + }, 723 723 + "actionType": { 724 724 + "type": "string", 725 725 + "knownValues": [ 726 726 + "block", 727 727 + "warn", 728 728 + "whitelist", 729 729 + ], 730 730 + }, 731 731 + "reasonType": { 732 732 + "type": "string", 733 733 + "knownValues": [ 734 734 + "csam", 735 735 + "spam", 736 736 + "phishing", 737 737 + "none", 738 738 + ], 739 739 + }, 740 740 + "urlRule": { 741 741 + "type": "object", 742 742 + "description": "Input for creating a URL safety rule", 743 743 + "required": [ 744 744 + "url", 745 745 + "pattern", 746 746 + "action", 747 747 + "reason", 748 748 + "createdBy", 749 749 + "createdAt", 750 750 + "updatedAt", 751 751 + ], 752 752 + "properties": { 753 753 + "url": { 754 754 + "type": "string", 755 755 + "description": "The URL or domain to apply the rule to", 756 756 + }, 757 757 + "pattern": { 758 758 + "type": "ref", 759 759 + "ref": "lex:tools.ozone.safelink.defs#patternType", 760 760 + }, 761 761 + "action": { 762 762 + "type": "ref", 763 763 + "ref": "lex:tools.ozone.safelink.defs#actionType", 764 764 + }, 765 765 + "reason": { 766 766 + "type": "ref", 767 767 + "ref": "lex:tools.ozone.safelink.defs#reasonType", 768 768 + }, 769 769 + "comment": { 770 770 + "type": "string", 771 771 + "description": "Optional comment about the decision", 772 772 + }, 773 773 + "createdBy": { 774 774 + "type": "string", 775 775 + "format": "did", 776 776 + "description": "DID of the user added the rule.", 777 777 + }, 778 778 + "createdAt": { 779 779 + "type": "string", 780 780 + "format": "datetime", 781 781 + "description": "Timestamp when the rule was created", 782 782 + }, 783 783 + "updatedAt": { 784 784 + "type": "string", 785 785 + "format": "datetime", 786 786 + "description": "Timestamp when the rule was last updated", 787 787 + }, 788 788 + }, 789 789 + }, 790 790 + }, 791 791 + }, 792 792 + "ToolsOzoneSafelinkAddRule": { 793 793 + "lexicon": 1, 794 794 + "id": "tools.ozone.safelink.addRule", 795 795 + "defs": { 796 796 + "main": { 797 797 + "type": "procedure", 798 798 + "description": "Add a new URL safety rule", 799 799 + "input": { 800 800 + "encoding": "application/json", 801 801 + "schema": { 802 802 + "type": "object", 803 803 + "required": [ 804 804 + "url", 805 805 + "pattern", 806 806 + "action", 807 807 + "reason", 808 808 + ], 809 809 + "properties": { 810 810 + "url": { 811 811 + "type": "string", 812 812 + "description": "The URL or domain to apply the rule to", 813 813 + }, 814 814 + "pattern": { 815 815 + "type": "ref", 816 816 + "ref": "lex:tools.ozone.safelink.defs#patternType", 817 817 + }, 818 818 + "action": { 819 819 + "type": "ref", 820 820 + "ref": "lex:tools.ozone.safelink.defs#actionType", 821 821 + }, 822 822 + "reason": { 823 823 + "type": "ref", 824 824 + "ref": "lex:tools.ozone.safelink.defs#reasonType", 825 825 + }, 826 826 + "comment": { 827 827 + "type": "string", 828 828 + "description": "Optional comment about the decision", 829 829 + }, 830 830 + "createdBy": { 831 831 + "type": "string", 832 832 + "format": "did", 833 833 + "description": 834 834 + "Author DID. Only respected when using admin auth", 835 835 + }, 836 836 + }, 837 837 + }, 838 838 + }, 839 839 + "output": { 840 840 + "encoding": "application/json", 841 841 + "schema": { 842 842 + "type": "ref", 843 843 + "ref": "lex:tools.ozone.safelink.defs#event", 844 844 + }, 845 845 + }, 846 846 + "errors": [ 847 847 + { 848 848 + "name": "InvalidUrl", 849 849 + "description": "The provided URL is invalid", 850 850 + }, 851 851 + { 852 852 + "name": "RuleAlreadyExists", 853 853 + "description": "A rule for this URL/domain already exists", 854 854 + }, 855 855 + ], 856 856 + }, 857 857 + }, 858 858 + }, 859 859 + "ToolsOzoneSafelinkRemoveRule": { 860 860 + "lexicon": 1, 861 861 + "id": "tools.ozone.safelink.removeRule", 862 862 + "defs": { 863 863 + "main": { 864 864 + "type": "procedure", 865 865 + "description": "Remove an existing URL safety rule", 866 866 + "input": { 867 867 + "encoding": "application/json", 868 868 + "schema": { 869 869 + "type": "object", 870 870 + "required": [ 871 871 + "url", 872 872 + "pattern", 873 873 + ], 874 874 + "properties": { 875 875 + "url": { 876 876 + "type": "string", 877 877 + "description": "The URL or domain to remove the rule for", 878 878 + }, 879 879 + "pattern": { 880 880 + "type": "ref", 881 881 + "ref": "lex:tools.ozone.safelink.defs#patternType", 882 882 + }, 883 883 + "comment": { 884 884 + "type": "string", 885 885 + "description": 886 886 + "Optional comment about why the rule is being removed", 887 887 + }, 888 888 + "createdBy": { 889 889 + "type": "string", 890 890 + "format": "did", 891 891 + "description": 892 892 + "Optional DID of the user. Only respected when using admin auth.", 893 893 + }, 894 894 + }, 895 895 + }, 896 896 + }, 897 897 + "output": { 898 898 + "encoding": "application/json", 899 899 + "schema": { 900 900 + "type": "ref", 901 901 + "ref": "lex:tools.ozone.safelink.defs#event", 902 902 + }, 903 903 + }, 904 904 + "errors": [ 905 905 + { 906 906 + "name": "RuleNotFound", 907 907 + "description": "No active rule found for this URL/domain", 908 908 + }, 909 909 + ], 910 910 + }, 911 911 + }, 912 912 + }, 913 913 + "ToolsOzoneSafelinkUpdateRule": { 914 914 + "lexicon": 1, 915 915 + "id": "tools.ozone.safelink.updateRule", 916 916 + "defs": { 917 917 + "main": { 918 918 + "type": "procedure", 919 919 + "description": "Update an existing URL safety rule", 920 920 + "input": { 921 921 + "encoding": "application/json", 922 922 + "schema": { 923 923 + "type": "object", 924 924 + "required": [ 925 925 + "url", 926 926 + "pattern", 927 927 + "action", 928 928 + "reason", 929 929 + ], 930 930 + "properties": { 931 931 + "url": { 932 932 + "type": "string", 933 933 + "description": "The URL or domain to update the rule for", 934 934 + }, 935 935 + "pattern": { 936 936 + "type": "ref", 937 937 + "ref": "lex:tools.ozone.safelink.defs#patternType", 938 938 + }, 939 939 + "action": { 940 940 + "type": "ref", 941 941 + "ref": "lex:tools.ozone.safelink.defs#actionType", 942 942 + }, 943 943 + "reason": { 944 944 + "type": "ref", 945 945 + "ref": "lex:tools.ozone.safelink.defs#reasonType", 946 946 + }, 947 947 + "comment": { 948 948 + "type": "string", 949 949 + "description": "Optional comment about the update", 950 950 + }, 951 951 + "createdBy": { 952 952 + "type": "string", 953 953 + "format": "did", 954 954 + "description": 955 955 + "Optional DID to credit as the creator. Only respected for admin_token authentication.", 956 956 + }, 957 957 + }, 958 958 + }, 959 959 + }, 960 960 + "output": { 961 961 + "encoding": "application/json", 962 962 + "schema": { 963 963 + "type": "ref", 964 964 + "ref": "lex:tools.ozone.safelink.defs#event", 965 965 + }, 966 966 + }, 967 967 + "errors": [ 968 968 + { 969 969 + "name": "RuleNotFound", 970 970 + "description": "No active rule found for this URL/domain", 971 971 + }, 972 972 + ], 973 973 + }, 974 974 + }, 975 975 + }, 976 976 + "ToolsOzoneSafelinkQueryEvents": { 977 977 + "lexicon": 1, 978 978 + "id": "tools.ozone.safelink.queryEvents", 979 979 + "defs": { 980 980 + "main": { 981 981 + "type": "procedure", 982 982 + "description": "Query URL safety audit events", 983 983 + "input": { 984 984 + "encoding": "application/json", 985 985 + "schema": { 986 986 + "type": "object", 987 987 + "properties": { 988 988 + "cursor": { 989 989 + "type": "string", 990 990 + "description": "Cursor for pagination", 991 991 + }, 992 992 + "limit": { 993 993 + "type": "integer", 994 994 + "minimum": 1, 995 995 + "maximum": 100, 996 996 + "default": 50, 997 997 + "description": "Maximum number of results to return", 998 998 + }, 999 999 + "urls": { 1000 1000 + "type": "array", 1001 1001 + "items": { 1002 1002 + "type": "string", 1003 1003 + }, 1004 1004 + "description": "Filter by specific URLs or domains", 1005 1005 + }, 1006 1006 + "patternType": { 1007 1007 + "type": "string", 1008 1008 + "description": "Filter by pattern type", 1009 1009 + }, 1010 1010 + "sortDirection": { 1011 1011 + "type": "string", 1012 1012 + "knownValues": [ 1013 1013 + "asc", 1014 1014 + "desc", 1015 1015 + ], 1016 1016 + "default": "desc", 1017 1017 + "description": "Sort direction", 1018 1018 + }, 1019 1019 + }, 1020 1020 + }, 1021 1021 + }, 1022 1022 + "output": { 1023 1023 + "encoding": "application/json", 1024 1024 + "schema": { 1025 1025 + "type": "object", 1026 1026 + "required": [ 1027 1027 + "events", 1028 1028 + ], 1029 1029 + "properties": { 1030 1030 + "cursor": { 1031 1031 + "type": "string", 1032 1032 + "description": 1033 1033 + "Next cursor for pagination. Only present if there are more results.", 1034 1034 + }, 1035 1035 + "events": { 1036 1036 + "type": "array", 1037 1037 + "items": { 1038 1038 + "type": "ref", 1039 1039 + "ref": "lex:tools.ozone.safelink.defs#event", 1040 1040 + }, 1041 1041 + }, 1042 1042 + }, 1043 1043 + }, 1044 1044 + }, 1045 1045 + }, 1046 1046 + }, 1047 1047 + }, 1048 1048 + "ToolsOzoneSafelinkQueryRules": { 1049 1049 + "lexicon": 1, 1050 1050 + "id": "tools.ozone.safelink.queryRules", 1051 1051 + "defs": { 1052 1052 + "main": { 1053 1053 + "type": "procedure", 1054 1054 + "description": "Query URL safety rules", 1055 1055 + "input": { 1056 1056 + "encoding": "application/json", 1057 1057 + "schema": { 1058 1058 + "type": "object", 1059 1059 + "properties": { 1060 1060 + "cursor": { 1061 1061 + "type": "string", 1062 1062 + "description": "Cursor for pagination", 1063 1063 + }, 1064 1064 + "limit": { 1065 1065 + "type": "integer", 1066 1066 + "minimum": 1, 1067 1067 + "maximum": 100, 1068 1068 + "default": 50, 1069 1069 + "description": "Maximum number of results to return", 1070 1070 + }, 1071 1071 + "urls": { 1072 1072 + "type": "array", 1073 1073 + "items": { 1074 1074 + "type": "string", 1075 1075 + }, 1076 1076 + "description": "Filter by specific URLs or domains", 1077 1077 + }, 1078 1078 + "patternType": { 1079 1079 + "type": "string", 1080 1080 + "description": "Filter by pattern type", 1081 1081 + }, 1082 1082 + "actions": { 1083 1083 + "type": "array", 1084 1084 + "items": { 1085 1085 + "type": "string", 1086 1086 + }, 1087 1087 + "description": "Filter by action types", 1088 1088 + }, 1089 1089 + "reason": { 1090 1090 + "type": "string", 1091 1091 + "description": "Filter by reason type", 1092 1092 + }, 1093 1093 + "createdBy": { 1094 1094 + "type": "string", 1095 1095 + "format": "did", 1096 1096 + "description": "Filter by rule creator", 1097 1097 + }, 1098 1098 + "sortDirection": { 1099 1099 + "type": "string", 1100 1100 + "knownValues": [ 1101 1101 + "asc", 1102 1102 + "desc", 1103 1103 + ], 1104 1104 + "default": "desc", 1105 1105 + "description": "Sort direction", 1106 1106 + }, 1107 1107 + }, 1108 1108 + }, 1109 1109 + }, 1110 1110 + "output": { 1111 1111 + "encoding": "application/json", 1112 1112 + "schema": { 1113 1113 + "type": "object", 1114 1114 + "required": [ 1115 1115 + "rules", 1116 1116 + ], 1117 1117 + "properties": { 1118 1118 + "cursor": { 1119 1119 + "type": "string", 1120 1120 + "description": 1121 1121 + "Next cursor for pagination. Only present if there are more results.", 1122 1122 + }, 1123 1123 + "rules": { 1124 1124 + "type": "array", 1125 1125 + "items": { 1126 1126 + "type": "ref", 1127 1127 + "ref": "lex:tools.ozone.safelink.defs#urlRule", 1128 1128 + }, 1129 1129 + }, 1130 1130 + }, 1131 1131 + }, 1132 1132 + }, 1133 1133 + }, 1134 1134 + }, 1135 1135 + }, 266 1136 "ToolsOzoneTeamListMembers": { 267 1137 "lexicon": 1, 268 1138 "id": "tools.ozone.team.listMembers", ··· 273 1143 "parameters": { 274 1144 "type": "params", 275 1145 "properties": { 1146 1146 + "q": { 1147 1147 + "type": "string", 1148 1148 + }, 276 1149 "disabled": { 277 1150 "type": "boolean", 278 1151 }, ··· 353 1226 "role": { 354 1227 "type": "string", 355 1228 "knownValues": [ 356 356 - "lex:tools.ozone.team.defs#roleAdmin", 357 357 - "lex:tools.ozone.team.defs#roleModerator", 358 358 - "lex:tools.ozone.team.defs#roleTriage", 1229 1229 + "tools.ozone.team.defs#roleAdmin", 1230 1230 + "tools.ozone.team.defs#roleModerator", 1231 1231 + "tools.ozone.team.defs#roleTriage", 1232 1232 + "tools.ozone.team.defs#roleVerifier", 359 1233 ], 360 1234 }, 361 1235 }, ··· 374 1248 "description": 375 1249 "Triage role. Mostly intended for monitoring and escalating issues.", 376 1250 }, 1251 1251 + "roleVerifier": { 1252 1252 + "type": "token", 1253 1253 + "description": "Verifier role. Only allowed to issue verifications.", 1254 1254 + }, 377 1255 }, 378 1256 }, 379 1257 "ToolsOzoneTeamDeleteMember": { ··· 439 1317 "knownValues": [ 440 1318 "tools.ozone.team.defs#roleAdmin", 441 1319 "tools.ozone.team.defs#roleModerator", 1320 1320 + "tools.ozone.team.defs#roleVerifier", 442 1321 "tools.ozone.team.defs#roleTriage", 443 1322 ], 444 1323 }, ··· 487 1366 "knownValues": [ 488 1367 "tools.ozone.team.defs#roleAdmin", 489 1368 "tools.ozone.team.defs#roleModerator", 1369 1369 + "tools.ozone.team.defs#roleVerifier", 490 1370 "tools.ozone.team.defs#roleTriage", 491 1371 ], 492 1372 }, ··· 509 1389 }, 510 1390 }, 511 1391 }, 1392 1392 + "ToolsOzoneHostingGetAccountHistory": { 1393 1393 + "lexicon": 1, 1394 1394 + "id": "tools.ozone.hosting.getAccountHistory", 1395 1395 + "defs": { 1396 1396 + "main": { 1397 1397 + "type": "query", 1398 1398 + "description": 1399 1399 + "Get account history, e.g. log of updated email addresses or other identity information.", 1400 1400 + "parameters": { 1401 1401 + "type": "params", 1402 1402 + "required": [ 1403 1403 + "did", 1404 1404 + ], 1405 1405 + "properties": { 1406 1406 + "did": { 1407 1407 + "type": "string", 1408 1408 + "format": "did", 1409 1409 + }, 1410 1410 + "events": { 1411 1411 + "type": "array", 1412 1412 + "items": { 1413 1413 + "type": "string", 1414 1414 + "knownValues": [ 1415 1415 + "accountCreated", 1416 1416 + "emailUpdated", 1417 1417 + "emailConfirmed", 1418 1418 + "passwordUpdated", 1419 1419 + "handleUpdated", 1420 1420 + ], 1421 1421 + }, 1422 1422 + }, 1423 1423 + "cursor": { 1424 1424 + "type": "string", 1425 1425 + }, 1426 1426 + "limit": { 1427 1427 + "type": "integer", 1428 1428 + "minimum": 1, 1429 1429 + "maximum": 100, 1430 1430 + "default": 50, 1431 1431 + }, 1432 1432 + }, 1433 1433 + }, 1434 1434 + "output": { 1435 1435 + "encoding": "application/json", 1436 1436 + "schema": { 1437 1437 + "type": "object", 1438 1438 + "required": [ 1439 1439 + "events", 1440 1440 + ], 1441 1441 + "properties": { 1442 1442 + "cursor": { 1443 1443 + "type": "string", 1444 1444 + }, 1445 1445 + "events": { 1446 1446 + "type": "array", 1447 1447 + "items": { 1448 1448 + "type": "ref", 1449 1449 + "ref": "lex:tools.ozone.hosting.getAccountHistory#event", 1450 1450 + }, 1451 1451 + }, 1452 1452 + }, 1453 1453 + }, 1454 1454 + }, 1455 1455 + }, 1456 1456 + "event": { 1457 1457 + "type": "object", 1458 1458 + "required": [ 1459 1459 + "details", 1460 1460 + "createdBy", 1461 1461 + "createdAt", 1462 1462 + ], 1463 1463 + "properties": { 1464 1464 + "details": { 1465 1465 + "type": "union", 1466 1466 + "refs": [ 1467 1467 + "lex:tools.ozone.hosting.getAccountHistory#accountCreated", 1468 1468 + "lex:tools.ozone.hosting.getAccountHistory#emailUpdated", 1469 1469 + "lex:tools.ozone.hosting.getAccountHistory#emailConfirmed", 1470 1470 + "lex:tools.ozone.hosting.getAccountHistory#passwordUpdated", 1471 1471 + "lex:tools.ozone.hosting.getAccountHistory#handleUpdated", 1472 1472 + ], 1473 1473 + }, 1474 1474 + "createdBy": { 1475 1475 + "type": "string", 1476 1476 + }, 1477 1477 + "createdAt": { 1478 1478 + "type": "string", 1479 1479 + "format": "datetime", 1480 1480 + }, 1481 1481 + }, 1482 1482 + }, 1483 1483 + "accountCreated": { 1484 1484 + "type": "object", 1485 1485 + "required": [], 1486 1486 + "properties": { 1487 1487 + "email": { 1488 1488 + "type": "string", 1489 1489 + }, 1490 1490 + "handle": { 1491 1491 + "type": "string", 1492 1492 + "format": "handle", 1493 1493 + }, 1494 1494 + }, 1495 1495 + }, 1496 1496 + "emailUpdated": { 1497 1497 + "type": "object", 1498 1498 + "required": [ 1499 1499 + "email", 1500 1500 + ], 1501 1501 + "properties": { 1502 1502 + "email": { 1503 1503 + "type": "string", 1504 1504 + }, 1505 1505 + }, 1506 1506 + }, 1507 1507 + "emailConfirmed": { 1508 1508 + "type": "object", 1509 1509 + "required": [ 1510 1510 + "email", 1511 1511 + ], 1512 1512 + "properties": { 1513 1513 + "email": { 1514 1514 + "type": "string", 1515 1515 + }, 1516 1516 + }, 1517 1517 + }, 1518 1518 + "passwordUpdated": { 1519 1519 + "type": "object", 1520 1520 + "required": [], 1521 1521 + "properties": {}, 1522 1522 + }, 1523 1523 + "handleUpdated": { 1524 1524 + "type": "object", 1525 1525 + "required": [ 1526 1526 + "handle", 1527 1527 + ], 1528 1528 + "properties": { 1529 1529 + "handle": { 1530 1530 + "type": "string", 1531 1531 + "format": "handle", 1532 1532 + }, 1533 1533 + }, 1534 1534 + }, 1535 1535 + }, 1536 1536 + }, 1537 1537 + "ToolsOzoneReportDefs": { 1538 1538 + "lexicon": 1, 1539 1539 + "id": "tools.ozone.report.defs", 1540 1540 + "defs": { 1541 1541 + "reasonType": { 1542 1542 + "type": "string", 1543 1543 + "knownValues": [ 1544 1544 + "tools.ozone.report.defs#reasonAppeal", 1545 1545 + "tools.ozone.report.defs#reasonOther", 1546 1546 + "tools.ozone.report.defs#reasonViolenceAnimal", 1547 1547 + "tools.ozone.report.defs#reasonViolenceThreats", 1548 1548 + "tools.ozone.report.defs#reasonViolenceGraphicContent", 1549 1549 + "tools.ozone.report.defs#reasonViolenceGlorification", 1550 1550 + "tools.ozone.report.defs#reasonViolenceExtremistContent", 1551 1551 + "tools.ozone.report.defs#reasonViolenceTrafficking", 1552 1552 + "tools.ozone.report.defs#reasonViolenceOther", 1553 1553 + "tools.ozone.report.defs#reasonSexualAbuseContent", 1554 1554 + "tools.ozone.report.defs#reasonSexualNCII", 1555 1555 + "tools.ozone.report.defs#reasonSexualDeepfake", 1556 1556 + "tools.ozone.report.defs#reasonSexualAnimal", 1557 1557 + "tools.ozone.report.defs#reasonSexualUnlabeled", 1558 1558 + "tools.ozone.report.defs#reasonSexualOther", 1559 1559 + "tools.ozone.report.defs#reasonChildSafetyCSAM", 1560 1560 + "tools.ozone.report.defs#reasonChildSafetyGroom", 1561 1561 + "tools.ozone.report.defs#reasonChildSafetyPrivacy", 1562 1562 + "tools.ozone.report.defs#reasonChildSafetyHarassment", 1563 1563 + "tools.ozone.report.defs#reasonChildSafetyOther", 1564 1564 + "tools.ozone.report.defs#reasonHarassmentTroll", 1565 1565 + "tools.ozone.report.defs#reasonHarassmentTargeted", 1566 1566 + "tools.ozone.report.defs#reasonHarassmentHateSpeech", 1567 1567 + "tools.ozone.report.defs#reasonHarassmentDoxxing", 1568 1568 + "tools.ozone.report.defs#reasonHarassmentOther", 1569 1569 + "tools.ozone.report.defs#reasonMisleadingBot", 1570 1570 + "tools.ozone.report.defs#reasonMisleadingImpersonation", 1571 1571 + "tools.ozone.report.defs#reasonMisleadingSpam", 1572 1572 + "tools.ozone.report.defs#reasonMisleadingScam", 1573 1573 + "tools.ozone.report.defs#reasonMisleadingElections", 1574 1574 + "tools.ozone.report.defs#reasonMisleadingOther", 1575 1575 + "tools.ozone.report.defs#reasonRuleSiteSecurity", 1576 1576 + "tools.ozone.report.defs#reasonRuleProhibitedSales", 1577 1577 + "tools.ozone.report.defs#reasonRuleBanEvasion", 1578 1578 + "tools.ozone.report.defs#reasonRuleOther", 1579 1579 + "tools.ozone.report.defs#reasonSelfHarmContent", 1580 1580 + "tools.ozone.report.defs#reasonSelfHarmED", 1581 1581 + "tools.ozone.report.defs#reasonSelfHarmStunts", 1582 1582 + "tools.ozone.report.defs#reasonSelfHarmSubstances", 1583 1583 + "tools.ozone.report.defs#reasonSelfHarmOther", 1584 1584 + ], 1585 1585 + }, 1586 1586 + "reasonAppeal": { 1587 1587 + "type": "token", 1588 1588 + "description": "Appeal a previously taken moderation action", 1589 1589 + }, 1590 1590 + "reasonOther": { 1591 1591 + "type": "token", 1592 1592 + "description": "An issue not included in these options", 1593 1593 + }, 1594 1594 + "reasonViolenceAnimal": { 1595 1595 + "type": "token", 1596 1596 + "description": "Animal welfare violations", 1597 1597 + }, 1598 1598 + "reasonViolenceThreats": { 1599 1599 + "type": "token", 1600 1600 + "description": "Threats or incitement", 1601 1601 + }, 1602 1602 + "reasonViolenceGraphicContent": { 1603 1603 + "type": "token", 1604 1604 + "description": "Graphic violent content", 1605 1605 + }, 1606 1606 + "reasonViolenceGlorification": { 1607 1607 + "type": "token", 1608 1608 + "description": "Glorification of violence", 1609 1609 + }, 1610 1610 + "reasonViolenceExtremistContent": { 1611 1611 + "type": "token", 1612 1612 + "description": 1613 1613 + "Extremist content. These reports will be sent only be sent to the application's Moderation Authority.", 1614 1614 + }, 1615 1615 + "reasonViolenceTrafficking": { 1616 1616 + "type": "token", 1617 1617 + "description": "Human trafficking", 1618 1618 + }, 1619 1619 + "reasonViolenceOther": { 1620 1620 + "type": "token", 1621 1621 + "description": "Other violent content", 1622 1622 + }, 1623 1623 + "reasonSexualAbuseContent": { 1624 1624 + "type": "token", 1625 1625 + "description": "Adult sexual abuse content", 1626 1626 + }, 1627 1627 + "reasonSexualNCII": { 1628 1628 + "type": "token", 1629 1629 + "description": "Non-consensual intimate imagery", 1630 1630 + }, 1631 1631 + "reasonSexualDeepfake": { 1632 1632 + "type": "token", 1633 1633 + "description": "Deepfake adult content", 1634 1634 + }, 1635 1635 + "reasonSexualAnimal": { 1636 1636 + "type": "token", 1637 1637 + "description": "Animal sexual abuse", 1638 1638 + }, 1639 1639 + "reasonSexualUnlabeled": { 1640 1640 + "type": "token", 1641 1641 + "description": "Unlabelled adult content", 1642 1642 + }, 1643 1643 + "reasonSexualOther": { 1644 1644 + "type": "token", 1645 1645 + "description": "Other sexual violence content", 1646 1646 + }, 1647 1647 + "reasonChildSafetyCSAM": { 1648 1648 + "type": "token", 1649 1649 + "description": 1650 1650 + "Child sexual abuse material (CSAM). These reports will be sent only be sent to the application's Moderation Authority.", 1651 1651 + }, 1652 1652 + "reasonChildSafetyGroom": { 1653 1653 + "type": "token", 1654 1654 + "description": 1655 1655 + "Grooming or predatory behavior. These reports will be sent only be sent to the application's Moderation Authority.", 1656 1656 + }, 1657 1657 + "reasonChildSafetyPrivacy": { 1658 1658 + "type": "token", 1659 1659 + "description": "Privacy violation involving a minor", 1660 1660 + }, 1661 1661 + "reasonChildSafetyHarassment": { 1662 1662 + "type": "token", 1663 1663 + "description": "Harassment or bullying of minors", 1664 1664 + }, 1665 1665 + "reasonChildSafetyOther": { 1666 1666 + "type": "token", 1667 1667 + "description": 1668 1668 + "Other child safety. These reports will be sent only be sent to the application's Moderation Authority.", 1669 1669 + }, 1670 1670 + "reasonHarassmentTroll": { 1671 1671 + "type": "token", 1672 1672 + "description": "Trolling", 1673 1673 + }, 1674 1674 + "reasonHarassmentTargeted": { 1675 1675 + "type": "token", 1676 1676 + "description": "Targeted harassment", 1677 1677 + }, 1678 1678 + "reasonHarassmentHateSpeech": { 1679 1679 + "type": "token", 1680 1680 + "description": "Hate speech", 1681 1681 + }, 1682 1682 + "reasonHarassmentDoxxing": { 1683 1683 + "type": "token", 1684 1684 + "description": "Doxxing", 1685 1685 + }, 1686 1686 + "reasonHarassmentOther": { 1687 1687 + "type": "token", 1688 1688 + "description": "Other harassing or hateful content", 1689 1689 + }, 1690 1690 + "reasonMisleadingBot": { 1691 1691 + "type": "token", 1692 1692 + "description": "Fake account or bot", 1693 1693 + }, 1694 1694 + "reasonMisleadingImpersonation": { 1695 1695 + "type": "token", 1696 1696 + "description": "Impersonation", 1697 1697 + }, 1698 1698 + "reasonMisleadingSpam": { 1699 1699 + "type": "token", 1700 1700 + "description": "Spam", 1701 1701 + }, 1702 1702 + "reasonMisleadingScam": { 1703 1703 + "type": "token", 1704 1704 + "description": "Scam", 1705 1705 + }, 1706 1706 + "reasonMisleadingElections": { 1707 1707 + "type": "token", 1708 1708 + "description": "False information about elections", 1709 1709 + }, 1710 1710 + "reasonMisleadingOther": { 1711 1711 + "type": "token", 1712 1712 + "description": "Other misleading content", 1713 1713 + }, 1714 1714 + "reasonRuleSiteSecurity": { 1715 1715 + "type": "token", 1716 1716 + "description": "Hacking or system attacks", 1717 1717 + }, 1718 1718 + "reasonRuleProhibitedSales": { 1719 1719 + "type": "token", 1720 1720 + "description": "Promoting or selling prohibited items or services", 1721 1721 + }, 1722 1722 + "reasonRuleBanEvasion": { 1723 1723 + "type": "token", 1724 1724 + "description": "Banned user returning", 1725 1725 + }, 1726 1726 + "reasonRuleOther": { 1727 1727 + "type": "token", 1728 1728 + "description": "Other", 1729 1729 + }, 1730 1730 + "reasonSelfHarmContent": { 1731 1731 + "type": "token", 1732 1732 + "description": "Content promoting or depicting self-harm", 1733 1733 + }, 1734 1734 + "reasonSelfHarmED": { 1735 1735 + "type": "token", 1736 1736 + "description": "Eating disorders", 1737 1737 + }, 1738 1738 + "reasonSelfHarmStunts": { 1739 1739 + "type": "token", 1740 1740 + "description": "Dangerous challenges or activities", 1741 1741 + }, 1742 1742 + "reasonSelfHarmSubstances": { 1743 1743 + "type": "token", 1744 1744 + "description": "Dangerous substances or drug abuse", 1745 1745 + }, 1746 1746 + "reasonSelfHarmOther": { 1747 1747 + "type": "token", 1748 1748 + "description": "Other dangerous content", 1749 1749 + }, 1750 1750 + }, 1751 1751 + }, 512 1752 "ToolsOzoneCommunicationDefs": { 513 1753 "lexicon": 1, 514 1754 "id": "tools.ozone.communication.defs", ··· 1109 2349 "tools.ozone.team.defs#roleModerator", 1110 2350 "tools.ozone.team.defs#roleTriage", 1111 2351 "tools.ozone.team.defs#roleAdmin", 2352 2352 + "tools.ozone.team.defs#roleVerifier", 1112 2353 ], 1113 2354 }, 1114 2355 "scope": { ··· 1282 2523 "knownValues": [ 1283 2524 "tools.ozone.team.defs#roleModerator", 1284 2525 "tools.ozone.team.defs#roleTriage", 2526 2526 + "tools.ozone.team.defs#roleVerifier", 1285 2527 "tools.ozone.team.defs#roleAdmin", 1286 2528 ], 1287 2529 }, ··· 1350 2592 }, 1351 2593 }, 1352 2594 }, 2595 2595 + "ToolsOzoneModerationCancelScheduledActions": { 2596 2596 + "lexicon": 1, 2597 2597 + "id": "tools.ozone.moderation.cancelScheduledActions", 2598 2598 + "defs": { 2599 2599 + "main": { 2600 2600 + "type": "procedure", 2601 2601 + "description": 2602 2602 + "Cancel all pending scheduled moderation actions for specified subjects", 2603 2603 + "input": { 2604 2604 + "encoding": "application/json", 2605 2605 + "schema": { 2606 2606 + "type": "object", 2607 2607 + "required": [ 2608 2608 + "subjects", 2609 2609 + ], 2610 2610 + "properties": { 2611 2611 + "subjects": { 2612 2612 + "type": "array", 2613 2613 + "maxLength": 100, 2614 2614 + "items": { 2615 2615 + "type": "string", 2616 2616 + "format": "did", 2617 2617 + }, 2618 2618 + "description": 2619 2619 + "Array of DID subjects to cancel scheduled actions for", 2620 2620 + }, 2621 2621 + "comment": { 2622 2622 + "type": "string", 2623 2623 + "description": 2624 2624 + "Optional comment describing the reason for cancellation", 2625 2625 + }, 2626 2626 + }, 2627 2627 + }, 2628 2628 + }, 2629 2629 + "output": { 2630 2630 + "encoding": "application/json", 2631 2631 + "schema": { 2632 2632 + "type": "ref", 2633 2633 + "ref": 2634 2634 + "lex:tools.ozone.moderation.cancelScheduledActions#cancellationResults", 2635 2635 + }, 2636 2636 + }, 2637 2637 + }, 2638 2638 + "cancellationResults": { 2639 2639 + "type": "object", 2640 2640 + "required": [ 2641 2641 + "succeeded", 2642 2642 + "failed", 2643 2643 + ], 2644 2644 + "properties": { 2645 2645 + "succeeded": { 2646 2646 + "type": "array", 2647 2647 + "items": { 2648 2648 + "type": "string", 2649 2649 + "format": "did", 2650 2650 + }, 2651 2651 + "description": 2652 2652 + "DIDs for which all pending scheduled actions were successfully cancelled", 2653 2653 + }, 2654 2654 + "failed": { 2655 2655 + "type": "array", 2656 2656 + "items": { 2657 2657 + "type": "ref", 2658 2658 + "ref": 2659 2659 + "lex:tools.ozone.moderation.cancelScheduledActions#failedCancellation", 2660 2660 + }, 2661 2661 + "description": 2662 2662 + "DIDs for which cancellation failed with error details", 2663 2663 + }, 2664 2664 + }, 2665 2665 + }, 2666 2666 + "failedCancellation": { 2667 2667 + "type": "object", 2668 2668 + "required": [ 2669 2669 + "did", 2670 2670 + "error", 2671 2671 + ], 2672 2672 + "properties": { 2673 2673 + "did": { 2674 2674 + "type": "string", 2675 2675 + "format": "did", 2676 2676 + }, 2677 2677 + "error": { 2678 2678 + "type": "string", 2679 2679 + }, 2680 2680 + "errorCode": { 2681 2681 + "type": "string", 2682 2682 + }, 2683 2683 + }, 2684 2684 + }, 2685 2685 + }, 2686 2686 + }, 2687 2687 + "ToolsOzoneModerationListScheduledActions": { 2688 2688 + "lexicon": 1, 2689 2689 + "id": "tools.ozone.moderation.listScheduledActions", 2690 2690 + "defs": { 2691 2691 + "main": { 2692 2692 + "type": "procedure", 2693 2693 + "description": 2694 2694 + "List scheduled moderation actions with optional filtering", 2695 2695 + "input": { 2696 2696 + "encoding": "application/json", 2697 2697 + "schema": { 2698 2698 + "type": "object", 2699 2699 + "required": [ 2700 2700 + "statuses", 2701 2701 + ], 2702 2702 + "properties": { 2703 2703 + "startsAfter": { 2704 2704 + "type": "string", 2705 2705 + "format": "datetime", 2706 2706 + "description": 2707 2707 + "Filter actions scheduled to execute after this time", 2708 2708 + }, 2709 2709 + "endsBefore": { 2710 2710 + "type": "string", 2711 2711 + "format": "datetime", 2712 2712 + "description": 2713 2713 + "Filter actions scheduled to execute before this time", 2714 2714 + }, 2715 2715 + "subjects": { 2716 2716 + "type": "array", 2717 2717 + "maxLength": 100, 2718 2718 + "items": { 2719 2719 + "type": "string", 2720 2720 + "format": "did", 2721 2721 + }, 2722 2722 + "description": "Filter actions for specific DID subjects", 2723 2723 + }, 2724 2724 + "statuses": { 2725 2725 + "type": "array", 2726 2726 + "minLength": 1, 2727 2727 + "items": { 2728 2728 + "type": "string", 2729 2729 + "knownValues": [ 2730 2730 + "pending", 2731 2731 + "executed", 2732 2732 + "cancelled", 2733 2733 + "failed", 2734 2734 + ], 2735 2735 + }, 2736 2736 + "description": "Filter actions by status", 2737 2737 + }, 2738 2738 + "limit": { 2739 2739 + "type": "integer", 2740 2740 + "minimum": 1, 2741 2741 + "maximum": 100, 2742 2742 + "default": 50, 2743 2743 + "description": "Maximum number of results to return", 2744 2744 + }, 2745 2745 + "cursor": { 2746 2746 + "type": "string", 2747 2747 + "description": "Cursor for pagination", 2748 2748 + }, 2749 2749 + }, 2750 2750 + }, 2751 2751 + }, 2752 2752 + "output": { 2753 2753 + "encoding": "application/json", 2754 2754 + "schema": { 2755 2755 + "type": "object", 2756 2756 + "required": [ 2757 2757 + "actions", 2758 2758 + ], 2759 2759 + "properties": { 2760 2760 + "actions": { 2761 2761 + "type": "array", 2762 2762 + "items": { 2763 2763 + "type": "ref", 2764 2764 + "ref": "lex:tools.ozone.moderation.defs#scheduledActionView", 2765 2765 + }, 2766 2766 + }, 2767 2767 + "cursor": { 2768 2768 + "type": "string", 2769 2769 + "description": "Cursor for next page of results", 2770 2770 + }, 2771 2771 + }, 2772 2772 + }, 2773 2773 + }, 2774 2774 + }, 2775 2775 + }, 2776 2776 + }, 1353 2777 "ToolsOzoneModerationQueryStatuses": { 1354 2778 "lexicon": 1, 1355 2779 "id": "tools.ozone.moderation.queryStatuses", ··· 1456 2880 "type": "string", 1457 2881 "description": 1458 2882 "Specify when fetching subjects in a certain state", 2883 2883 + "knownValues": [ 2884 2884 + "tools.ozone.moderation.defs#reviewOpen", 2885 2885 + "tools.ozone.moderation.defs#reviewClosed", 2886 2886 + "tools.ozone.moderation.defs#reviewEscalated", 2887 2887 + "tools.ozone.moderation.defs#reviewNone", 2888 2888 + ], 1459 2889 }, 1460 2890 "ignoreSubjects": { 1461 2891 "type": "array", ··· 1562 2992 "description": 1563 2993 "If specified, only subjects that have priority score value above the given value will be returned.", 1564 2994 }, 2995 2995 + "minStrikeCount": { 2996 2996 + "type": "integer", 2997 2997 + "minimum": 1, 2998 2998 + "description": 2999 2999 + "If specified, only subjects that belong to an account that has at least this many active strikes will be returned.", 3000 3000 + }, 3001 3001 + "ageAssuranceState": { 3002 3002 + "type": "string", 3003 3003 + "description": 3004 3004 + "If specified, only subjects with the given age assurance state will be returned.", 3005 3005 + "knownValues": [ 3006 3006 + "pending", 3007 3007 + "assured", 3008 3008 + "unknown", 3009 3009 + "reset", 3010 3010 + "blocked", 3011 3011 + ], 3012 3012 + }, 1565 3013 }, 1566 3014 }, 1567 3015 "output": { ··· 1662 3110 "lex:tools.ozone.moderation.defs#identityEvent", 1663 3111 "lex:tools.ozone.moderation.defs#recordEvent", 1664 3112 "lex:tools.ozone.moderation.defs#modEventPriorityScore", 3113 3113 + "lex:tools.ozone.moderation.defs#ageAssuranceEvent", 3114 3114 + "lex:tools.ozone.moderation.defs#ageAssuranceOverrideEvent", 3115 3115 + "lex:tools.ozone.moderation.defs#revokeAccountCredentialsEvent", 3116 3116 + "lex:tools.ozone.moderation.defs#scheduleTakedownEvent", 3117 3117 + "lex:tools.ozone.moderation.defs#cancelScheduledTakedownEvent", 1665 3118 ], 1666 3119 }, 1667 3120 "subject": { ··· 1691 3144 }, 1692 3145 "subjectHandle": { 1693 3146 "type": "string", 3147 3147 + }, 3148 3148 + "modTool": { 3149 3149 + "type": "ref", 3150 3150 + "ref": "lex:tools.ozone.moderation.defs#modTool", 1694 3151 }, 1695 3152 }, 1696 3153 }, ··· 1730 3187 "lex:tools.ozone.moderation.defs#identityEvent", 1731 3188 "lex:tools.ozone.moderation.defs#recordEvent", 1732 3189 "lex:tools.ozone.moderation.defs#modEventPriorityScore", 3190 3190 + "lex:tools.ozone.moderation.defs#ageAssuranceEvent", 3191 3191 + "lex:tools.ozone.moderation.defs#ageAssuranceOverrideEvent", 3192 3192 + "lex:tools.ozone.moderation.defs#revokeAccountCredentialsEvent", 3193 3193 + "lex:tools.ozone.moderation.defs#scheduleTakedownEvent", 3194 3194 + "lex:tools.ozone.moderation.defs#cancelScheduledTakedownEvent", 1733 3195 ], 1734 3196 }, 1735 3197 "subject": { ··· 1756 3218 "type": "string", 1757 3219 "format": "datetime", 1758 3220 }, 3221 3221 + "modTool": { 3222 3222 + "type": "ref", 3223 3223 + "ref": "lex:tools.ozone.moderation.defs#modTool", 3224 3224 + }, 1759 3225 }, 1760 3226 }, 1761 3227 "subjectStatusView": { ··· 1776 3242 "refs": [ 1777 3243 "lex:com.atproto.admin.defs#repoRef", 1778 3244 "lex:com.atproto.repo.strongRef", 3245 3245 + "lex:chat.bsky.convo.defs#messageRef", 1779 3246 ], 1780 3247 }, 1781 3248 "hosting": { ··· 1877 3344 "type": "ref", 1878 3345 "ref": "lex:tools.ozone.moderation.defs#recordsStats", 1879 3346 }, 3347 3347 + "accountStrike": { 3348 3348 + "description": 3349 3349 + "Strike information for the account (account-level only)", 3350 3350 + "type": "ref", 3351 3351 + "ref": "lex:tools.ozone.moderation.defs#accountStrike", 3352 3352 + }, 3353 3353 + "ageAssuranceState": { 3354 3354 + "type": "string", 3355 3355 + "description": "Current age assurance state of the subject.", 3356 3356 + "knownValues": [ 3357 3357 + "pending", 3358 3358 + "assured", 3359 3359 + "unknown", 3360 3360 + "reset", 3361 3361 + "blocked", 3362 3362 + ], 3363 3363 + }, 3364 3364 + "ageAssuranceUpdatedBy": { 3365 3365 + "type": "string", 3366 3366 + "description": 3367 3367 + "Whether or not the last successful update to age assurance was made by the user or admin.", 3368 3368 + "knownValues": [ 3369 3369 + "admin", 3370 3370 + "user", 3371 3371 + ], 3372 3372 + }, 3373 3373 + }, 3374 3374 + }, 3375 3375 + "subjectView": { 3376 3376 + "description": 3377 3377 + "Detailed view of a subject. For record subjects, the author's repo and profile will be returned.", 3378 3378 + "type": "object", 3379 3379 + "required": [ 3380 3380 + "type", 3381 3381 + "subject", 3382 3382 + ], 3383 3383 + "properties": { 3384 3384 + "type": { 3385 3385 + "type": "ref", 3386 3386 + "ref": "lex:com.atproto.moderation.defs#subjectType", 3387 3387 + }, 3388 3388 + "subject": { 3389 3389 + "type": "string", 3390 3390 + }, 3391 3391 + "status": { 3392 3392 + "type": "ref", 3393 3393 + "ref": "lex:tools.ozone.moderation.defs#subjectStatusView", 3394 3394 + }, 3395 3395 + "repo": { 3396 3396 + "type": "ref", 3397 3397 + "ref": "lex:tools.ozone.moderation.defs#repoViewDetail", 3398 3398 + }, 3399 3399 + "profile": { 3400 3400 + "type": "union", 3401 3401 + "refs": [], 3402 3402 + }, 3403 3403 + "record": { 3404 3404 + "type": "ref", 3405 3405 + "ref": "lex:tools.ozone.moderation.defs#recordViewDetail", 3406 3406 + }, 1880 3407 }, 1881 3408 }, 1882 3409 "accountStats": { ··· 1947 3474 }, 1948 3475 }, 1949 3476 }, 3477 3477 + "accountStrike": { 3478 3478 + "description": "Strike information for an account", 3479 3479 + "type": "object", 3480 3480 + "properties": { 3481 3481 + "activeStrikeCount": { 3482 3482 + "description": 3483 3483 + "Current number of active strikes (excluding expired strikes)", 3484 3484 + "type": "integer", 3485 3485 + }, 3486 3486 + "totalStrikeCount": { 3487 3487 + "description": 3488 3488 + "Total number of strikes ever received (including expired strikes)", 3489 3489 + "type": "integer", 3490 3490 + }, 3491 3491 + "firstStrikeAt": { 3492 3492 + "description": "Timestamp of the first strike received", 3493 3493 + "type": "string", 3494 3494 + "format": "datetime", 3495 3495 + }, 3496 3496 + "lastStrikeAt": { 3497 3497 + "description": "Timestamp of the most recent strike received", 3498 3498 + "type": "string", 3499 3499 + "format": "datetime", 3500 3500 + }, 3501 3501 + }, 3502 3502 + }, 1950 3503 "subjectReviewState": { 1951 3504 "type": "string", 1952 3505 "knownValues": [ 1953 1953 - "lex:tools.ozone.moderation.defs#reviewOpen", 1954 1954 - "lex:tools.ozone.moderation.defs#reviewEscalated", 1955 1955 - "lex:tools.ozone.moderation.defs#reviewClosed", 1956 1956 - "lex:tools.ozone.moderation.defs#reviewNone", 3506 3506 + "tools.ozone.moderation.defs#reviewOpen", 3507 3507 + "tools.ozone.moderation.defs#reviewEscalated", 3508 3508 + "tools.ozone.moderation.defs#reviewClosed", 3509 3509 + "tools.ozone.moderation.defs#reviewNone", 1957 3510 ], 1958 3511 }, 1959 3512 "reviewOpen": { ··· 2002 3555 "description": 2003 3556 "Names/Keywords of the policies that drove the decision.", 2004 3557 }, 3558 3558 + "severityLevel": { 3559 3559 + "type": "string", 3560 3560 + "description": 3561 3561 + "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).", 3562 3562 + }, 3563 3563 + "targetServices": { 3564 3564 + "type": "array", 3565 3565 + "items": { 3566 3566 + "type": "string", 3567 3567 + "knownValues": [ 3568 3568 + "appview", 3569 3569 + "pds", 3570 3570 + ], 3571 3571 + }, 3572 3572 + "description": 3573 3573 + "List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services.", 3574 3574 + }, 3575 3575 + "strikeCount": { 3576 3576 + "type": "integer", 3577 3577 + "description": 3578 3578 + "Number of strikes to assign to the user for this violation.", 3579 3579 + }, 3580 3580 + "strikeExpiresAt": { 3581 3581 + "type": "string", 3582 3582 + "format": "datetime", 3583 3583 + "description": 3584 3584 + "When the strike should expire. If not provided, the strike never expires.", 3585 3585 + }, 2005 3586 }, 2006 3587 }, 2007 3588 "modEventReverseTakedown": { ··· 2011 3592 "comment": { 2012 3593 "type": "string", 2013 3594 "description": "Describe reasoning behind the reversal.", 3595 3595 + }, 3596 3596 + "policies": { 3597 3597 + "type": "array", 3598 3598 + "maxLength": 5, 3599 3599 + "items": { 3600 3600 + "type": "string", 3601 3601 + }, 3602 3602 + "description": 3603 3603 + "Names/Keywords of the policy infraction for which takedown is being reversed.", 3604 3604 + }, 3605 3605 + "severityLevel": { 3606 3606 + "type": "string", 3607 3607 + "description": 3608 3608 + "Severity level of the violation. Usually set from the last policy infraction's severity.", 3609 3609 + }, 3610 3610 + "strikeCount": { 3611 3611 + "type": "integer", 3612 3612 + "description": 3613 3613 + "Number of strikes to subtract from the user's strike count. Usually set from the last policy infraction's severity.", 2014 3614 }, 2015 3615 }, 2016 3616 }, ··· 2107 3707 }, 2108 3708 }, 2109 3709 }, 3710 3710 + "ageAssuranceEvent": { 3711 3711 + "type": "object", 3712 3712 + "description": 3713 3713 + "Age assurance info coming directly from users. Only works on DID subjects.", 3714 3714 + "required": [ 3715 3715 + "createdAt", 3716 3716 + "status", 3717 3717 + "attemptId", 3718 3718 + ], 3719 3719 + "properties": { 3720 3720 + "createdAt": { 3721 3721 + "type": "string", 3722 3722 + "format": "datetime", 3723 3723 + "description": "The date and time of this write operation.", 3724 3724 + }, 3725 3725 + "attemptId": { 3726 3726 + "type": "string", 3727 3727 + "description": 3728 3728 + "The unique identifier for this instance of the age assurance flow, in UUID format.", 3729 3729 + }, 3730 3730 + "status": { 3731 3731 + "type": "string", 3732 3732 + "description": "The status of the Age Assurance process.", 3733 3733 + "knownValues": [ 3734 3734 + "unknown", 3735 3735 + "pending", 3736 3736 + "assured", 3737 3737 + ], 3738 3738 + }, 3739 3739 + "access": { 3740 3740 + "type": "ref", 3741 3741 + "ref": "lex:app.bsky.ageassurance.defs#access", 3742 3742 + }, 3743 3743 + "countryCode": { 3744 3744 + "type": "string", 3745 3745 + "description": 3746 3746 + "The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow.", 3747 3747 + }, 3748 3748 + "regionCode": { 3749 3749 + "type": "string", 3750 3750 + "description": 3751 3751 + "The ISO 3166-2 region code provided when beginning the Age Assurance flow.", 3752 3752 + }, 3753 3753 + "initIp": { 3754 3754 + "type": "string", 3755 3755 + "description": "The IP address used when initiating the AA flow.", 3756 3756 + }, 3757 3757 + "initUa": { 3758 3758 + "type": "string", 3759 3759 + "description": "The user agent used when initiating the AA flow.", 3760 3760 + }, 3761 3761 + "completeIp": { 3762 3762 + "type": "string", 3763 3763 + "description": "The IP address used when completing the AA flow.", 3764 3764 + }, 3765 3765 + "completeUa": { 3766 3766 + "type": "string", 3767 3767 + "description": "The user agent used when completing the AA flow.", 3768 3768 + }, 3769 3769 + }, 3770 3770 + }, 3771 3771 + "ageAssuranceOverrideEvent": { 3772 3772 + "type": "object", 3773 3773 + "description": 3774 3774 + "Age assurance status override by moderators. Only works on DID subjects.", 3775 3775 + "required": [ 3776 3776 + "comment", 3777 3777 + "status", 3778 3778 + ], 3779 3779 + "properties": { 3780 3780 + "status": { 3781 3781 + "type": "string", 3782 3782 + "description": 3783 3783 + "The status to be set for the user decided by a moderator, overriding whatever value the user had previously. Use reset to default to original state.", 3784 3784 + "knownValues": [ 3785 3785 + "assured", 3786 3786 + "reset", 3787 3787 + "blocked", 3788 3788 + ], 3789 3789 + }, 3790 3790 + "access": { 3791 3791 + "type": "ref", 3792 3792 + "ref": "lex:app.bsky.ageassurance.defs#access", 3793 3793 + }, 3794 3794 + "comment": { 3795 3795 + "type": "string", 3796 3796 + "description": "Comment describing the reason for the override.", 3797 3797 + }, 3798 3798 + }, 3799 3799 + }, 3800 3800 + "revokeAccountCredentialsEvent": { 3801 3801 + "type": "object", 3802 3802 + "description": 3803 3803 + "Account credentials revocation by moderators. Only works on DID subjects.", 3804 3804 + "required": [ 3805 3805 + "comment", 3806 3806 + ], 3807 3807 + "properties": { 3808 3808 + "comment": { 3809 3809 + "type": "string", 3810 3810 + "description": "Comment describing the reason for the revocation.", 3811 3811 + }, 3812 3812 + }, 3813 3813 + }, 2110 3814 "modEventAcknowledge": { 2111 3815 "type": "object", 2112 3816 "properties": { ··· 2198 3902 "type": "string", 2199 3903 "description": "Additional comment about the outgoing comm.", 2200 3904 }, 3905 3905 + "policies": { 3906 3906 + "type": "array", 3907 3907 + "maxLength": 5, 3908 3908 + "items": { 3909 3909 + "type": "string", 3910 3910 + }, 3911 3911 + "description": 3912 3912 + "Names/Keywords of the policies that necessitated the email.", 3913 3913 + }, 3914 3914 + "severityLevel": { 3915 3915 + "type": "string", 3916 3916 + "description": 3917 3917 + "Severity level of the violation. Normally 'sev-1' that adds strike on repeat offense", 3918 3918 + }, 3919 3919 + "strikeCount": { 3920 3920 + "type": "integer", 3921 3921 + "description": 3922 3922 + "Number of strikes to assign to the user for this violation. Normally 0 as an indicator of a warning and only added as a strike on a repeat offense.", 3923 3923 + }, 3924 3924 + "strikeExpiresAt": { 3925 3925 + "type": "string", 3926 3926 + "format": "datetime", 3927 3927 + "description": 3928 3928 + "When the strike should expire. If not provided, the strike never expires.", 3929 3929 + }, 3930 3930 + "isDelivered": { 3931 3931 + "type": "boolean", 3932 3932 + "description": 3933 3933 + "Indicates whether the email was successfully delivered to the user's inbox.", 3934 3934 + }, 2201 3935 }, 2202 3936 }, 2203 3937 "modEventDivert": { ··· 2329 4063 "timestamp": { 2330 4064 "type": "string", 2331 4065 "format": "datetime", 4066 4066 + }, 4067 4067 + }, 4068 4068 + }, 4069 4069 + "scheduleTakedownEvent": { 4070 4070 + "type": "object", 4071 4071 + "description": "Logs a scheduled takedown action for an account.", 4072 4072 + "properties": { 4073 4073 + "comment": { 4074 4074 + "type": "string", 4075 4075 + }, 4076 4076 + "executeAt": { 4077 4077 + "type": "string", 4078 4078 + "format": "datetime", 4079 4079 + }, 4080 4080 + "executeAfter": { 4081 4081 + "type": "string", 4082 4082 + "format": "datetime", 4083 4083 + }, 4084 4084 + "executeUntil": { 4085 4085 + "type": "string", 4086 4086 + "format": "datetime", 4087 4087 + }, 4088 4088 + }, 4089 4089 + }, 4090 4090 + "cancelScheduledTakedownEvent": { 4091 4091 + "type": "object", 4092 4092 + "description": 4093 4093 + "Logs cancellation of a scheduled takedown action for an account.", 4094 4094 + "properties": { 4095 4095 + "comment": { 4096 4096 + "type": "string", 2332 4097 }, 2333 4098 }, 2334 4099 }, ··· 2796 4561 }, 2797 4562 }, 2798 4563 }, 4564 4564 + "modTool": { 4565 4565 + "type": "object", 4566 4566 + "description": 4567 4567 + "Moderation tool information for tracing the source of the action", 4568 4568 + "required": [ 4569 4569 + "name", 4570 4570 + ], 4571 4571 + "properties": { 4572 4572 + "name": { 4573 4573 + "type": "string", 4574 4574 + "description": 4575 4575 + "Name/identifier of the source (e.g., 'automod', 'ozone/workspace')", 4576 4576 + }, 4577 4577 + "meta": { 4578 4578 + "type": "unknown", 4579 4579 + "description": "Additional arbitrary metadata about the source", 4580 4580 + }, 4581 4581 + }, 4582 4582 + }, 4583 4583 + "timelineEventPlcCreate": { 4584 4584 + "type": "token", 4585 4585 + "description": 4586 4586 + "Moderation event timeline event for a PLC create operation", 4587 4587 + }, 4588 4588 + "timelineEventPlcOperation": { 4589 4589 + "type": "token", 4590 4590 + "description": 4591 4591 + "Moderation event timeline event for generic PLC operation", 4592 4592 + }, 4593 4593 + "timelineEventPlcTombstone": { 4594 4594 + "type": "token", 4595 4595 + "description": 4596 4596 + "Moderation event timeline event for a PLC tombstone operation", 4597 4597 + }, 4598 4598 + "scheduledActionView": { 4599 4599 + "type": "object", 4600 4600 + "description": "View of a scheduled moderation action", 4601 4601 + "required": [ 4602 4602 + "id", 4603 4603 + "action", 4604 4604 + "did", 4605 4605 + "createdBy", 4606 4606 + "createdAt", 4607 4607 + "status", 4608 4608 + ], 4609 4609 + "properties": { 4610 4610 + "id": { 4611 4611 + "type": "integer", 4612 4612 + "description": "Auto-incrementing row ID", 4613 4613 + }, 4614 4614 + "action": { 4615 4615 + "type": "string", 4616 4616 + "knownValues": [ 4617 4617 + "takedown", 4618 4618 + ], 4619 4619 + "description": "Type of action to be executed", 4620 4620 + }, 4621 4621 + "eventData": { 4622 4622 + "type": "unknown", 4623 4623 + "description": 4624 4624 + "Serialized event object that will be propagated to the event when performed", 4625 4625 + }, 4626 4626 + "did": { 4627 4627 + "type": "string", 4628 4628 + "format": "did", 4629 4629 + "description": "Subject DID for the action", 4630 4630 + }, 4631 4631 + "executeAt": { 4632 4632 + "type": "string", 4633 4633 + "format": "datetime", 4634 4634 + "description": "Exact time to execute the action", 4635 4635 + }, 4636 4636 + "executeAfter": { 4637 4637 + "type": "string", 4638 4638 + "format": "datetime", 4639 4639 + "description": 4640 4640 + "Earliest time to execute the action (for randomized scheduling)", 4641 4641 + }, 4642 4642 + "executeUntil": { 4643 4643 + "type": "string", 4644 4644 + "format": "datetime", 4645 4645 + "description": 4646 4646 + "Latest time to execute the action (for randomized scheduling)", 4647 4647 + }, 4648 4648 + "randomizeExecution": { 4649 4649 + "type": "boolean", 4650 4650 + "description": 4651 4651 + "Whether execution time should be randomized within the specified range", 4652 4652 + }, 4653 4653 + "createdBy": { 4654 4654 + "type": "string", 4655 4655 + "format": "did", 4656 4656 + "description": "DID of the user who created this scheduled action", 4657 4657 + }, 4658 4658 + "createdAt": { 4659 4659 + "type": "string", 4660 4660 + "format": "datetime", 4661 4661 + "description": "When the scheduled action was created", 4662 4662 + }, 4663 4663 + "updatedAt": { 4664 4664 + "type": "string", 4665 4665 + "format": "datetime", 4666 4666 + "description": "When the scheduled action was last updated", 4667 4667 + }, 4668 4668 + "status": { 4669 4669 + "type": "string", 4670 4670 + "knownValues": [ 4671 4671 + "pending", 4672 4672 + "executed", 4673 4673 + "cancelled", 4674 4674 + "failed", 4675 4675 + ], 4676 4676 + "description": "Current status of the scheduled action", 4677 4677 + }, 4678 4678 + "lastExecutedAt": { 4679 4679 + "type": "string", 4680 4680 + "format": "datetime", 4681 4681 + "description": "When the action was last attempted to be executed", 4682 4682 + }, 4683 4683 + "lastFailureReason": { 4684 4684 + "type": "string", 4685 4685 + "description": "Reason for the last execution failure", 4686 4686 + }, 4687 4687 + "executionEventId": { 4688 4688 + "type": "integer", 4689 4689 + "description": 4690 4690 + "ID of the moderation event created when action was successfully executed", 4691 4691 + }, 4692 4692 + }, 4693 4693 + }, 4694 4694 + }, 4695 4695 + }, 4696 4696 + "ToolsOzoneModerationGetSubjects": { 4697 4697 + "lexicon": 1, 4698 4698 + "id": "tools.ozone.moderation.getSubjects", 4699 4699 + "defs": { 4700 4700 + "main": { 4701 4701 + "type": "query", 4702 4702 + "description": "Get details about subjects.", 4703 4703 + "parameters": { 4704 4704 + "type": "params", 4705 4705 + "required": [ 4706 4706 + "subjects", 4707 4707 + ], 4708 4708 + "properties": { 4709 4709 + "subjects": { 4710 4710 + "type": "array", 4711 4711 + "maxLength": 100, 4712 4712 + "minLength": 1, 4713 4713 + "items": { 4714 4714 + "type": "string", 4715 4715 + }, 4716 4716 + }, 4717 4717 + }, 4718 4718 + }, 4719 4719 + "output": { 4720 4720 + "encoding": "application/json", 4721 4721 + "schema": { 4722 4722 + "type": "object", 4723 4723 + "required": [ 4724 4724 + "subjects", 4725 4725 + ], 4726 4726 + "properties": { 4727 4727 + "subjects": { 4728 4728 + "type": "array", 4729 4729 + "items": { 4730 4730 + "type": "ref", 4731 4731 + "ref": "lex:tools.ozone.moderation.defs#subjectView", 4732 4732 + }, 4733 4733 + }, 4734 4734 + }, 4735 4735 + }, 4736 4736 + }, 4737 4737 + }, 2799 4738 }, 2800 4739 }, 2801 4740 "ToolsOzoneModerationGetRecords": { ··· 2845 4784 }, 2846 4785 }, 2847 4786 }, 4787 4787 + "ToolsOzoneModerationScheduleAction": { 4788 4788 + "lexicon": 1, 4789 4789 + "id": "tools.ozone.moderation.scheduleAction", 4790 4790 + "defs": { 4791 4791 + "main": { 4792 4792 + "type": "procedure", 4793 4793 + "description": 4794 4794 + "Schedule a moderation action to be executed at a future time", 4795 4795 + "input": { 4796 4796 + "encoding": "application/json", 4797 4797 + "schema": { 4798 4798 + "type": "object", 4799 4799 + "required": [ 4800 4800 + "action", 4801 4801 + "subjects", 4802 4802 + "createdBy", 4803 4803 + "scheduling", 4804 4804 + ], 4805 4805 + "properties": { 4806 4806 + "action": { 4807 4807 + "type": "union", 4808 4808 + "refs": [ 4809 4809 + "lex:tools.ozone.moderation.scheduleAction#takedown", 4810 4810 + ], 4811 4811 + }, 4812 4812 + "subjects": { 4813 4813 + "type": "array", 4814 4814 + "maxLength": 100, 4815 4815 + "items": { 4816 4816 + "type": "string", 4817 4817 + "format": "did", 4818 4818 + }, 4819 4819 + "description": 4820 4820 + "Array of DID subjects to schedule the action for", 4821 4821 + }, 4822 4822 + "createdBy": { 4823 4823 + "type": "string", 4824 4824 + "format": "did", 4825 4825 + }, 4826 4826 + "scheduling": { 4827 4827 + "type": "ref", 4828 4828 + "ref": 4829 4829 + "lex:tools.ozone.moderation.scheduleAction#schedulingConfig", 4830 4830 + }, 4831 4831 + "modTool": { 4832 4832 + "type": "ref", 4833 4833 + "ref": "lex:tools.ozone.moderation.defs#modTool", 4834 4834 + "description": 4835 4835 + "This will be propagated to the moderation event when it is applied", 4836 4836 + }, 4837 4837 + }, 4838 4838 + }, 4839 4839 + }, 4840 4840 + "output": { 4841 4841 + "encoding": "application/json", 4842 4842 + "schema": { 4843 4843 + "type": "ref", 4844 4844 + "ref": 4845 4845 + "lex:tools.ozone.moderation.scheduleAction#scheduledActionResults", 4846 4846 + }, 4847 4847 + }, 4848 4848 + }, 4849 4849 + "takedown": { 4850 4850 + "type": "object", 4851 4851 + "description": "Schedule a takedown action", 4852 4852 + "properties": { 4853 4853 + "comment": { 4854 4854 + "type": "string", 4855 4855 + }, 4856 4856 + "durationInHours": { 4857 4857 + "type": "integer", 4858 4858 + "description": 4859 4859 + "Indicates how long the takedown should be in effect before automatically expiring.", 4860 4860 + }, 4861 4861 + "acknowledgeAccountSubjects": { 4862 4862 + "type": "boolean", 4863 4863 + "description": 4864 4864 + "If true, all other reports on content authored by this account will be resolved (acknowledged).", 4865 4865 + }, 4866 4866 + "policies": { 4867 4867 + "type": "array", 4868 4868 + "maxLength": 5, 4869 4869 + "items": { 4870 4870 + "type": "string", 4871 4871 + }, 4872 4872 + "description": 4873 4873 + "Names/Keywords of the policies that drove the decision.", 4874 4874 + }, 4875 4875 + "severityLevel": { 4876 4876 + "type": "string", 4877 4877 + "description": 4878 4878 + "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.).", 4879 4879 + }, 4880 4880 + "strikeCount": { 4881 4881 + "type": "integer", 4882 4882 + "description": 4883 4883 + "Number of strikes to assign to the user when takedown is applied.", 4884 4884 + }, 4885 4885 + "strikeExpiresAt": { 4886 4886 + "type": "string", 4887 4887 + "format": "datetime", 4888 4888 + "description": 4889 4889 + "When the strike should expire. If not provided, the strike never expires.", 4890 4890 + }, 4891 4891 + "emailContent": { 4892 4892 + "type": "string", 4893 4893 + "description": 4894 4894 + "Email content to be sent to the user upon takedown.", 4895 4895 + }, 4896 4896 + "emailSubject": { 4897 4897 + "type": "string", 4898 4898 + "description": 4899 4899 + "Subject of the email to be sent to the user upon takedown.", 4900 4900 + }, 4901 4901 + }, 4902 4902 + }, 4903 4903 + "schedulingConfig": { 4904 4904 + "type": "object", 4905 4905 + "description": "Configuration for when the action should be executed", 4906 4906 + "properties": { 4907 4907 + "executeAt": { 4908 4908 + "type": "string", 4909 4909 + "format": "datetime", 4910 4910 + "description": "Exact time to execute the action", 4911 4911 + }, 4912 4912 + "executeAfter": { 4913 4913 + "type": "string", 4914 4914 + "format": "datetime", 4915 4915 + "description": 4916 4916 + "Earliest time to execute the action (for randomized scheduling)", 4917 4917 + }, 4918 4918 + "executeUntil": { 4919 4919 + "type": "string", 4920 4920 + "format": "datetime", 4921 4921 + "description": 4922 4922 + "Latest time to execute the action (for randomized scheduling)", 4923 4923 + }, 4924 4924 + }, 4925 4925 + }, 4926 4926 + "scheduledActionResults": { 4927 4927 + "type": "object", 4928 4928 + "required": [ 4929 4929 + "succeeded", 4930 4930 + "failed", 4931 4931 + ], 4932 4932 + "properties": { 4933 4933 + "succeeded": { 4934 4934 + "type": "array", 4935 4935 + "items": { 4936 4936 + "type": "string", 4937 4937 + "format": "did", 4938 4938 + }, 4939 4939 + }, 4940 4940 + "failed": { 4941 4941 + "type": "array", 4942 4942 + "items": { 4943 4943 + "type": "ref", 4944 4944 + "ref": 4945 4945 + "lex:tools.ozone.moderation.scheduleAction#failedScheduling", 4946 4946 + }, 4947 4947 + }, 4948 4948 + }, 4949 4949 + }, 4950 4950 + "failedScheduling": { 4951 4951 + "type": "object", 4952 4952 + "required": [ 4953 4953 + "subject", 4954 4954 + "error", 4955 4955 + ], 4956 4956 + "properties": { 4957 4957 + "subject": { 4958 4958 + "type": "string", 4959 4959 + "format": "did", 4960 4960 + }, 4961 4961 + "error": { 4962 4962 + "type": "string", 4963 4963 + }, 4964 4964 + "errorCode": { 4965 4965 + "type": "string", 4966 4966 + }, 4967 4967 + }, 4968 4968 + }, 4969 4969 + }, 4970 4970 + }, 2848 4971 "ToolsOzoneModerationGetEvent": { 2849 4972 "lexicon": 1, 2850 4973 "id": "tools.ozone.moderation.getEvent", ··· 3005 5128 "If specified, only events where the action policies match any of the given policies are returned", 3006 5129 }, 3007 5130 }, 5131 5131 + "modTool": { 5132 5132 + "type": "array", 5133 5133 + "items": { 5134 5134 + "type": "string", 5135 5135 + }, 5136 5136 + "description": 5137 5137 + "If specified, only events where the modTool name matches any of the given values are returned", 5138 5138 + }, 5139 5139 + "batchId": { 5140 5140 + "type": "string", 5141 5141 + "description": 5142 5142 + "If specified, only events where the batchId matches the given value are returned", 5143 5143 + }, 5144 5144 + "ageAssuranceState": { 5145 5145 + "type": "string", 5146 5146 + "description": 5147 5147 + "If specified, only events where the age assurance state matches the given value are returned", 5148 5148 + "knownValues": [ 5149 5149 + "pending", 5150 5150 + "assured", 5151 5151 + "unknown", 5152 5152 + "reset", 5153 5153 + "blocked", 5154 5154 + ], 5155 5155 + }, 5156 5156 + "withStrike": { 5157 5157 + "type": "boolean", 5158 5158 + "description": 5159 5159 + "If specified, only events where strikeCount value is set are returned.", 5160 5160 + }, 3008 5161 "cursor": { 3009 5162 "type": "string", 3010 5163 }, ··· 3111 5264 "lex:tools.ozone.moderation.defs#identityEvent", 3112 5265 "lex:tools.ozone.moderation.defs#recordEvent", 3113 5266 "lex:tools.ozone.moderation.defs#modEventPriorityScore", 5267 5267 + "lex:tools.ozone.moderation.defs#ageAssuranceEvent", 5268 5268 + "lex:tools.ozone.moderation.defs#ageAssuranceOverrideEvent", 5269 5269 + "lex:tools.ozone.moderation.defs#revokeAccountCredentialsEvent", 5270 5270 + "lex:tools.ozone.moderation.defs#scheduleTakedownEvent", 5271 5271 + "lex:tools.ozone.moderation.defs#cancelScheduledTakedownEvent", 3114 5272 ], 3115 5273 }, 3116 5274 "subject": { ··· 3131 5289 "type": "string", 3132 5290 "format": "did", 3133 5291 }, 5292 5292 + "modTool": { 5293 5293 + "type": "ref", 5294 5294 + "ref": "lex:tools.ozone.moderation.defs#modTool", 5295 5295 + }, 5296 5296 + "externalId": { 5297 5297 + "type": "string", 5298 5298 + "description": 5299 5299 + "An optional external ID for the event, used to deduplicate events from external systems. Fails when an event of same type with the same external ID exists for the same subject.", 5300 5300 + }, 3134 5301 }, 3135 5302 }, 3136 5303 }, ··· 3144 5311 "errors": [ 3145 5312 { 3146 5313 "name": "SubjectHasAction", 5314 5314 + }, 5315 5315 + { 5316 5316 + "name": "DuplicateExternalId", 5317 5317 + "description": 5318 5318 + "An event with the same external ID already exists for the subject.", 3147 5319 }, 3148 5320 ], 3149 5321 }, ··· 3201 5373 }, 3202 5374 }, 3203 5375 }, 5376 5376 + "ToolsOzoneModerationGetAccountTimeline": { 5377 5377 + "lexicon": 1, 5378 5378 + "id": "tools.ozone.moderation.getAccountTimeline", 5379 5379 + "defs": { 5380 5380 + "main": { 5381 5381 + "type": "query", 5382 5382 + "description": 5383 5383 + "Get timeline of all available events of an account. This includes moderation events, account history and did history.", 5384 5384 + "parameters": { 5385 5385 + "type": "params", 5386 5386 + "required": [ 5387 5387 + "did", 5388 5388 + ], 5389 5389 + "properties": { 5390 5390 + "did": { 5391 5391 + "type": "string", 5392 5392 + "format": "did", 5393 5393 + }, 5394 5394 + }, 5395 5395 + }, 5396 5396 + "output": { 5397 5397 + "encoding": "application/json", 5398 5398 + "schema": { 5399 5399 + "type": "object", 5400 5400 + "required": [ 5401 5401 + "timeline", 5402 5402 + ], 5403 5403 + "properties": { 5404 5404 + "timeline": { 5405 5405 + "type": "array", 5406 5406 + "items": { 5407 5407 + "type": "ref", 5408 5408 + "ref": 5409 5409 + "lex:tools.ozone.moderation.getAccountTimeline#timelineItem", 5410 5410 + }, 5411 5411 + }, 5412 5412 + }, 5413 5413 + }, 5414 5414 + }, 5415 5415 + "errors": [ 5416 5416 + { 5417 5417 + "name": "RepoNotFound", 5418 5418 + }, 5419 5419 + ], 5420 5420 + }, 5421 5421 + "timelineItem": { 5422 5422 + "type": "object", 5423 5423 + "required": [ 5424 5424 + "day", 5425 5425 + "summary", 5426 5426 + ], 5427 5427 + "properties": { 5428 5428 + "day": { 5429 5429 + "type": "string", 5430 5430 + }, 5431 5431 + "summary": { 5432 5432 + "type": "array", 5433 5433 + "items": { 5434 5434 + "type": "ref", 5435 5435 + "ref": 5436 5436 + "lex:tools.ozone.moderation.getAccountTimeline#timelineItemSummary", 5437 5437 + }, 5438 5438 + }, 5439 5439 + }, 5440 5440 + }, 5441 5441 + "timelineItemSummary": { 5442 5442 + "type": "object", 5443 5443 + "required": [ 5444 5444 + "eventSubjectType", 5445 5445 + "eventType", 5446 5446 + "count", 5447 5447 + ], 5448 5448 + "properties": { 5449 5449 + "eventSubjectType": { 5450 5450 + "type": "string", 5451 5451 + "knownValues": [ 5452 5452 + "account", 5453 5453 + "record", 5454 5454 + "chat", 5455 5455 + ], 5456 5456 + }, 5457 5457 + "eventType": { 5458 5458 + "type": "string", 5459 5459 + "knownValues": [ 5460 5460 + "tools.ozone.moderation.defs#modEventTakedown", 5461 5461 + "tools.ozone.moderation.defs#modEventReverseTakedown", 5462 5462 + "tools.ozone.moderation.defs#modEventComment", 5463 5463 + "tools.ozone.moderation.defs#modEventReport", 5464 5464 + "tools.ozone.moderation.defs#modEventLabel", 5465 5465 + "tools.ozone.moderation.defs#modEventAcknowledge", 5466 5466 + "tools.ozone.moderation.defs#modEventEscalate", 5467 5467 + "tools.ozone.moderation.defs#modEventMute", 5468 5468 + "tools.ozone.moderation.defs#modEventUnmute", 5469 5469 + "tools.ozone.moderation.defs#modEventMuteReporter", 5470 5470 + "tools.ozone.moderation.defs#modEventUnmuteReporter", 5471 5471 + "tools.ozone.moderation.defs#modEventEmail", 5472 5472 + "tools.ozone.moderation.defs#modEventResolveAppeal", 5473 5473 + "tools.ozone.moderation.defs#modEventDivert", 5474 5474 + "tools.ozone.moderation.defs#modEventTag", 5475 5475 + "tools.ozone.moderation.defs#accountEvent", 5476 5476 + "tools.ozone.moderation.defs#identityEvent", 5477 5477 + "tools.ozone.moderation.defs#recordEvent", 5478 5478 + "tools.ozone.moderation.defs#modEventPriorityScore", 5479 5479 + "tools.ozone.moderation.defs#revokeAccountCredentialsEvent", 5480 5480 + "tools.ozone.moderation.defs#ageAssuranceEvent", 5481 5481 + "tools.ozone.moderation.defs#ageAssuranceOverrideEvent", 5482 5482 + "tools.ozone.moderation.defs#timelineEventPlcCreate", 5483 5483 + "tools.ozone.moderation.defs#timelineEventPlcOperation", 5484 5484 + "tools.ozone.moderation.defs#timelineEventPlcTombstone", 5485 5485 + "tools.ozone.hosting.getAccountHistory#accountCreated", 5486 5486 + "tools.ozone.hosting.getAccountHistory#emailConfirmed", 5487 5487 + "tools.ozone.hosting.getAccountHistory#passwordUpdated", 5488 5488 + "tools.ozone.hosting.getAccountHistory#handleUpdated", 5489 5489 + "tools.ozone.moderation.defs#scheduleTakedownEvent", 5490 5490 + "tools.ozone.moderation.defs#cancelScheduledTakedownEvent", 5491 5491 + ], 5492 5492 + }, 5493 5493 + "count": { 5494 5494 + "type": "integer", 5495 5495 + }, 5496 5496 + }, 5497 5497 + }, 5498 5498 + }, 5499 5499 + }, 3204 5500 "ToolsOzoneModerationGetRepos": { 3205 5501 "lexicon": 1, 3206 5502 "id": "tools.ozone.moderation.getRepos", ··· 3392 5688 }, 3393 5689 }, 3394 5690 }, 5691 5691 + }, 5692 5692 + }, 5693 5693 + }, 5694 5694 + "AppBskyBookmarkDefs": { 5695 5695 + "lexicon": 1, 5696 5696 + "id": "app.bsky.bookmark.defs", 5697 5697 + "defs": { 5698 5698 + "bookmark": { 5699 5699 + "description": "Object used to store bookmark data in stash.", 5700 5700 + "type": "object", 5701 5701 + "required": [ 5702 5702 + "subject", 5703 5703 + ], 5704 5704 + "properties": { 5705 5705 + "subject": { 5706 5706 + "description": 5707 5707 + "A strong ref to the record to be bookmarked. Currently, only `app.bsky.feed.post` records are supported.", 5708 5708 + "type": "ref", 5709 5709 + "ref": "lex:com.atproto.repo.strongRef", 5710 5710 + }, 5711 5711 + }, 5712 5712 + }, 5713 5713 + "bookmarkView": { 5714 5714 + "type": "object", 5715 5715 + "required": [ 5716 5716 + "subject", 5717 5717 + "item", 5718 5718 + ], 5719 5719 + "properties": { 5720 5720 + "subject": { 5721 5721 + "description": "A strong ref to the bookmarked record.", 5722 5722 + "type": "ref", 5723 5723 + "ref": "lex:com.atproto.repo.strongRef", 5724 5724 + }, 5725 5725 + "createdAt": { 5726 5726 + "type": "string", 5727 5727 + "format": "datetime", 5728 5728 + }, 5729 5729 + "item": { 5730 5730 + "type": "union", 5731 5731 + "refs": [ 5732 5732 + "lex:app.bsky.feed.defs#blockedPost", 5733 5733 + "lex:app.bsky.feed.defs#notFoundPost", 5734 5734 + "lex:app.bsky.feed.defs#postView", 5735 5735 + ], 5736 5736 + }, 5737 5737 + }, 5738 5738 + }, 5739 5739 + }, 5740 5740 + }, 5741 5741 + "AppBskyBookmarkDeleteBookmark": { 5742 5742 + "lexicon": 1, 5743 5743 + "id": "app.bsky.bookmark.deleteBookmark", 5744 5744 + "defs": { 5745 5745 + "main": { 5746 5746 + "type": "procedure", 5747 5747 + "description": 5748 5748 + "Deletes a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication.", 5749 5749 + "input": { 5750 5750 + "encoding": "application/json", 5751 5751 + "schema": { 5752 5752 + "type": "object", 5753 5753 + "required": [ 5754 5754 + "uri", 5755 5755 + ], 5756 5756 + "properties": { 5757 5757 + "uri": { 5758 5758 + "type": "string", 5759 5759 + "format": "at-uri", 5760 5760 + }, 5761 5761 + }, 5762 5762 + }, 5763 5763 + }, 5764 5764 + "errors": [ 5765 5765 + { 5766 5766 + "name": "UnsupportedCollection", 5767 5767 + "description": 5768 5768 + "The URI to be bookmarked is for an unsupported collection.", 5769 5769 + }, 5770 5770 + ], 5771 5771 + }, 5772 5772 + }, 5773 5773 + }, 5774 5774 + "AppBskyBookmarkGetBookmarks": { 5775 5775 + "lexicon": 1, 5776 5776 + "id": "app.bsky.bookmark.getBookmarks", 5777 5777 + "defs": { 5778 5778 + "main": { 5779 5779 + "type": "query", 5780 5780 + "description": 5781 5781 + "Gets views of records bookmarked by the authenticated user. Requires authentication.", 5782 5782 + "parameters": { 5783 5783 + "type": "params", 5784 5784 + "properties": { 5785 5785 + "limit": { 5786 5786 + "type": "integer", 5787 5787 + "minimum": 1, 5788 5788 + "maximum": 100, 5789 5789 + "default": 50, 5790 5790 + }, 5791 5791 + "cursor": { 5792 5792 + "type": "string", 5793 5793 + }, 5794 5794 + }, 5795 5795 + }, 5796 5796 + "output": { 5797 5797 + "encoding": "application/json", 5798 5798 + "schema": { 5799 5799 + "type": "object", 5800 5800 + "required": [ 5801 5801 + "bookmarks", 5802 5802 + ], 5803 5803 + "properties": { 5804 5804 + "cursor": { 5805 5805 + "type": "string", 5806 5806 + }, 5807 5807 + "bookmarks": { 5808 5808 + "type": "array", 5809 5809 + "items": { 5810 5810 + "type": "ref", 5811 5811 + "ref": "lex:app.bsky.bookmark.defs#bookmarkView", 5812 5812 + }, 5813 5813 + }, 5814 5814 + }, 5815 5815 + }, 5816 5816 + }, 5817 5817 + }, 5818 5818 + }, 5819 5819 + }, 5820 5820 + "AppBskyBookmarkCreateBookmark": { 5821 5821 + "lexicon": 1, 5822 5822 + "id": "app.bsky.bookmark.createBookmark", 5823 5823 + "defs": { 5824 5824 + "main": { 5825 5825 + "type": "procedure", 5826 5826 + "description": 5827 5827 + "Creates a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication.", 5828 5828 + "input": { 5829 5829 + "encoding": "application/json", 5830 5830 + "schema": { 5831 5831 + "type": "object", 5832 5832 + "required": [ 5833 5833 + "uri", 5834 5834 + "cid", 5835 5835 + ], 5836 5836 + "properties": { 5837 5837 + "uri": { 5838 5838 + "type": "string", 5839 5839 + "format": "at-uri", 5840 5840 + }, 5841 5841 + "cid": { 5842 5842 + "type": "string", 5843 5843 + "format": "cid", 5844 5844 + }, 5845 5845 + }, 5846 5846 + }, 5847 5847 + }, 5848 5848 + "errors": [ 5849 5849 + { 5850 5850 + "name": "UnsupportedCollection", 5851 5851 + "description": 5852 5852 + "The URI to be bookmarked is for an unsupported collection.", 5853 5853 + }, 5854 5854 + ], 3395 5855 }, 3396 5856 }, 3397 5857 }, ··· 3739 6199 "properties": { 3740 6200 "video": { 3741 6201 "type": "blob", 6202 6202 + "description": 6203 6203 + "The mp4 video file. May be up to 100mb, formerly limited to 50mb.", 3742 6204 "accept": [ 3743 6205 "video/mp4", 3744 6206 ], 3745 3745 - "maxSize": 50000000, 6207 6207 + "maxSize": 100000000, 3746 6208 }, 3747 6209 "captions": { 3748 6210 "type": "array", ··· 3900 6362 }, 3901 6363 }, 3902 6364 }, 6365 6365 + "AppBskyNotificationDefs": { 6366 6366 + "lexicon": 1, 6367 6367 + "id": "app.bsky.notification.defs", 6368 6368 + "defs": { 6369 6369 + "recordDeleted": { 6370 6370 + "type": "object", 6371 6371 + "properties": {}, 6372 6372 + }, 6373 6373 + "chatPreference": { 6374 6374 + "type": "object", 6375 6375 + "required": [ 6376 6376 + "include", 6377 6377 + "push", 6378 6378 + ], 6379 6379 + "properties": { 6380 6380 + "include": { 6381 6381 + "type": "string", 6382 6382 + "knownValues": [ 6383 6383 + "all", 6384 6384 + "accepted", 6385 6385 + ], 6386 6386 + }, 6387 6387 + "push": { 6388 6388 + "type": "boolean", 6389 6389 + }, 6390 6390 + }, 6391 6391 + }, 6392 6392 + "filterablePreference": { 6393 6393 + "type": "object", 6394 6394 + "required": [ 6395 6395 + "include", 6396 6396 + "list", 6397 6397 + "push", 6398 6398 + ], 6399 6399 + "properties": { 6400 6400 + "include": { 6401 6401 + "type": "string", 6402 6402 + "knownValues": [ 6403 6403 + "all", 6404 6404 + "follows", 6405 6405 + ], 6406 6406 + }, 6407 6407 + "list": { 6408 6408 + "type": "boolean", 6409 6409 + }, 6410 6410 + "push": { 6411 6411 + "type": "boolean", 6412 6412 + }, 6413 6413 + }, 6414 6414 + }, 6415 6415 + "preference": { 6416 6416 + "type": "object", 6417 6417 + "required": [ 6418 6418 + "list", 6419 6419 + "push", 6420 6420 + ], 6421 6421 + "properties": { 6422 6422 + "list": { 6423 6423 + "type": "boolean", 6424 6424 + }, 6425 6425 + "push": { 6426 6426 + "type": "boolean", 6427 6427 + }, 6428 6428 + }, 6429 6429 + }, 6430 6430 + "preferences": { 6431 6431 + "type": "object", 6432 6432 + "required": [ 6433 6433 + "chat", 6434 6434 + "follow", 6435 6435 + "like", 6436 6436 + "likeViaRepost", 6437 6437 + "mention", 6438 6438 + "quote", 6439 6439 + "reply", 6440 6440 + "repost", 6441 6441 + "repostViaRepost", 6442 6442 + "starterpackJoined", 6443 6443 + "subscribedPost", 6444 6444 + "unverified", 6445 6445 + "verified", 6446 6446 + ], 6447 6447 + "properties": { 6448 6448 + "chat": { 6449 6449 + "type": "ref", 6450 6450 + "ref": "lex:app.bsky.notification.defs#chatPreference", 6451 6451 + }, 6452 6452 + "follow": { 6453 6453 + "type": "ref", 6454 6454 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6455 6455 + }, 6456 6456 + "like": { 6457 6457 + "type": "ref", 6458 6458 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6459 6459 + }, 6460 6460 + "likeViaRepost": { 6461 6461 + "type": "ref", 6462 6462 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6463 6463 + }, 6464 6464 + "mention": { 6465 6465 + "type": "ref", 6466 6466 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6467 6467 + }, 6468 6468 + "quote": { 6469 6469 + "type": "ref", 6470 6470 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6471 6471 + }, 6472 6472 + "reply": { 6473 6473 + "type": "ref", 6474 6474 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6475 6475 + }, 6476 6476 + "repost": { 6477 6477 + "type": "ref", 6478 6478 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6479 6479 + }, 6480 6480 + "repostViaRepost": { 6481 6481 + "type": "ref", 6482 6482 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6483 6483 + }, 6484 6484 + "starterpackJoined": { 6485 6485 + "type": "ref", 6486 6486 + "ref": "lex:app.bsky.notification.defs#preference", 6487 6487 + }, 6488 6488 + "subscribedPost": { 6489 6489 + "type": "ref", 6490 6490 + "ref": "lex:app.bsky.notification.defs#preference", 6491 6491 + }, 6492 6492 + "unverified": { 6493 6493 + "type": "ref", 6494 6494 + "ref": "lex:app.bsky.notification.defs#preference", 6495 6495 + }, 6496 6496 + "verified": { 6497 6497 + "type": "ref", 6498 6498 + "ref": "lex:app.bsky.notification.defs#preference", 6499 6499 + }, 6500 6500 + }, 6501 6501 + }, 6502 6502 + "activitySubscription": { 6503 6503 + "type": "object", 6504 6504 + "required": [ 6505 6505 + "post", 6506 6506 + "reply", 6507 6507 + ], 6508 6508 + "properties": { 6509 6509 + "post": { 6510 6510 + "type": "boolean", 6511 6511 + }, 6512 6512 + "reply": { 6513 6513 + "type": "boolean", 6514 6514 + }, 6515 6515 + }, 6516 6516 + }, 6517 6517 + "subjectActivitySubscription": { 6518 6518 + "description": 6519 6519 + "Object used to store activity subscription data in stash.", 6520 6520 + "type": "object", 6521 6521 + "required": [ 6522 6522 + "subject", 6523 6523 + "activitySubscription", 6524 6524 + ], 6525 6525 + "properties": { 6526 6526 + "subject": { 6527 6527 + "type": "string", 6528 6528 + "format": "did", 6529 6529 + }, 6530 6530 + "activitySubscription": { 6531 6531 + "type": "ref", 6532 6532 + "ref": "lex:app.bsky.notification.defs#activitySubscription", 6533 6533 + }, 6534 6534 + }, 6535 6535 + }, 6536 6536 + }, 6537 6537 + }, 3903 6538 "AppBskyNotificationRegisterPush": { 3904 6539 "lexicon": 1, 3905 6540 "id": "app.bsky.notification.registerPush", ··· 3937 6572 "appId": { 3938 6573 "type": "string", 3939 6574 }, 6575 6575 + "ageRestricted": { 6576 6576 + "type": "boolean", 6577 6577 + "description": "Set to true when the actor is age restricted", 6578 6578 + }, 3940 6579 }, 3941 6580 }, 3942 6581 }, ··· 3968 6607 }, 3969 6608 }, 3970 6609 }, 6610 6610 + "AppBskyNotificationPutActivitySubscription": { 6611 6611 + "lexicon": 1, 6612 6612 + "id": "app.bsky.notification.putActivitySubscription", 6613 6613 + "defs": { 6614 6614 + "main": { 6615 6615 + "type": "procedure", 6616 6616 + "description": 6617 6617 + "Puts an activity subscription entry. The key should be omitted for creation and provided for updates. Requires auth.", 6618 6618 + "input": { 6619 6619 + "encoding": "application/json", 6620 6620 + "schema": { 6621 6621 + "type": "object", 6622 6622 + "required": [ 6623 6623 + "subject", 6624 6624 + "activitySubscription", 6625 6625 + ], 6626 6626 + "properties": { 6627 6627 + "subject": { 6628 6628 + "type": "string", 6629 6629 + "format": "did", 6630 6630 + }, 6631 6631 + "activitySubscription": { 6632 6632 + "type": "ref", 6633 6633 + "ref": "lex:app.bsky.notification.defs#activitySubscription", 6634 6634 + }, 6635 6635 + }, 6636 6636 + }, 6637 6637 + }, 6638 6638 + "output": { 6639 6639 + "encoding": "application/json", 6640 6640 + "schema": { 6641 6641 + "type": "object", 6642 6642 + "required": [ 6643 6643 + "subject", 6644 6644 + ], 6645 6645 + "properties": { 6646 6646 + "subject": { 6647 6647 + "type": "string", 6648 6648 + "format": "did", 6649 6649 + }, 6650 6650 + "activitySubscription": { 6651 6651 + "type": "ref", 6652 6652 + "ref": "lex:app.bsky.notification.defs#activitySubscription", 6653 6653 + }, 6654 6654 + }, 6655 6655 + }, 6656 6656 + }, 6657 6657 + }, 6658 6658 + }, 6659 6659 + }, 6660 6660 + "AppBskyNotificationDeclaration": { 6661 6661 + "lexicon": 1, 6662 6662 + "id": "app.bsky.notification.declaration", 6663 6663 + "defs": { 6664 6664 + "main": { 6665 6665 + "type": "record", 6666 6666 + "description": 6667 6667 + "A declaration of the user's choices related to notifications that can be produced by them.", 6668 6668 + "key": "literal:self", 6669 6669 + "record": { 6670 6670 + "type": "object", 6671 6671 + "required": [ 6672 6672 + "allowSubscriptions", 6673 6673 + ], 6674 6674 + "properties": { 6675 6675 + "allowSubscriptions": { 6676 6676 + "type": "string", 6677 6677 + "description": 6678 6678 + "A declaration of the user's preference for allowing activity subscriptions from other users. Absence of a record implies 'followers'.", 6679 6679 + "knownValues": [ 6680 6680 + "followers", 6681 6681 + "mutuals", 6682 6682 + "none", 6683 6683 + ], 6684 6684 + }, 6685 6685 + }, 6686 6686 + }, 6687 6687 + }, 6688 6688 + }, 6689 6689 + }, 6690 6690 + "AppBskyNotificationPutPreferencesV2": { 6691 6691 + "lexicon": 1, 6692 6692 + "id": "app.bsky.notification.putPreferencesV2", 6693 6693 + "defs": { 6694 6694 + "main": { 6695 6695 + "type": "procedure", 6696 6696 + "description": 6697 6697 + "Set notification-related preferences for an account. Requires auth.", 6698 6698 + "input": { 6699 6699 + "encoding": "application/json", 6700 6700 + "schema": { 6701 6701 + "type": "object", 6702 6702 + "properties": { 6703 6703 + "chat": { 6704 6704 + "type": "ref", 6705 6705 + "ref": "lex:app.bsky.notification.defs#chatPreference", 6706 6706 + }, 6707 6707 + "follow": { 6708 6708 + "type": "ref", 6709 6709 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6710 6710 + }, 6711 6711 + "like": { 6712 6712 + "type": "ref", 6713 6713 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6714 6714 + }, 6715 6715 + "likeViaRepost": { 6716 6716 + "type": "ref", 6717 6717 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6718 6718 + }, 6719 6719 + "mention": { 6720 6720 + "type": "ref", 6721 6721 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6722 6722 + }, 6723 6723 + "quote": { 6724 6724 + "type": "ref", 6725 6725 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6726 6726 + }, 6727 6727 + "reply": { 6728 6728 + "type": "ref", 6729 6729 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6730 6730 + }, 6731 6731 + "repost": { 6732 6732 + "type": "ref", 6733 6733 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6734 6734 + }, 6735 6735 + "repostViaRepost": { 6736 6736 + "type": "ref", 6737 6737 + "ref": "lex:app.bsky.notification.defs#filterablePreference", 6738 6738 + }, 6739 6739 + "starterpackJoined": { 6740 6740 + "type": "ref", 6741 6741 + "ref": "lex:app.bsky.notification.defs#preference", 6742 6742 + }, 6743 6743 + "subscribedPost": { 6744 6744 + "type": "ref", 6745 6745 + "ref": "lex:app.bsky.notification.defs#preference", 6746 6746 + }, 6747 6747 + "unverified": { 6748 6748 + "type": "ref", 6749 6749 + "ref": "lex:app.bsky.notification.defs#preference", 6750 6750 + }, 6751 6751 + "verified": { 6752 6752 + "type": "ref", 6753 6753 + "ref": "lex:app.bsky.notification.defs#preference", 6754 6754 + }, 6755 6755 + }, 6756 6756 + }, 6757 6757 + }, 6758 6758 + "output": { 6759 6759 + "encoding": "application/json", 6760 6760 + "schema": { 6761 6761 + "type": "object", 6762 6762 + "required": [ 6763 6763 + "preferences", 6764 6764 + ], 6765 6765 + "properties": { 6766 6766 + "preferences": { 6767 6767 + "type": "ref", 6768 6768 + "ref": "lex:app.bsky.notification.defs#preferences", 6769 6769 + }, 6770 6770 + }, 6771 6771 + }, 6772 6772 + }, 6773 6773 + }, 6774 6774 + }, 6775 6775 + }, 3971 6776 "AppBskyNotificationUpdateSeen": { 3972 6777 "lexicon": 1, 3973 6778 "id": "app.bsky.notification.updateSeen", ··· 3994 6799 }, 3995 6800 }, 3996 6801 }, 6802 6802 + "AppBskyNotificationListActivitySubscriptions": { 6803 6803 + "lexicon": 1, 6804 6804 + "id": "app.bsky.notification.listActivitySubscriptions", 6805 6805 + "defs": { 6806 6806 + "main": { 6807 6807 + "type": "query", 6808 6808 + "description": 6809 6809 + "Enumerate all accounts to which the requesting account is subscribed to receive notifications for. Requires auth.", 6810 6810 + "parameters": { 6811 6811 + "type": "params", 6812 6812 + "properties": { 6813 6813 + "limit": { 6814 6814 + "type": "integer", 6815 6815 + "minimum": 1, 6816 6816 + "maximum": 100, 6817 6817 + "default": 50, 6818 6818 + }, 6819 6819 + "cursor": { 6820 6820 + "type": "string", 6821 6821 + }, 6822 6822 + }, 6823 6823 + }, 6824 6824 + "output": { 6825 6825 + "encoding": "application/json", 6826 6826 + "schema": { 6827 6827 + "type": "object", 6828 6828 + "required": [ 6829 6829 + "subscriptions", 6830 6830 + ], 6831 6831 + "properties": { 6832 6832 + "cursor": { 6833 6833 + "type": "string", 6834 6834 + }, 6835 6835 + "subscriptions": { 6836 6836 + "type": "array", 6837 6837 + "items": { 6838 6838 + "type": "ref", 6839 6839 + "ref": "lex:app.bsky.actor.defs#profileView", 6840 6840 + }, 6841 6841 + }, 6842 6842 + }, 6843 6843 + }, 6844 6844 + }, 6845 6845 + }, 6846 6846 + }, 6847 6847 + }, 6848 6848 + "AppBskyNotificationUnregisterPush": { 6849 6849 + "lexicon": 1, 6850 6850 + "id": "app.bsky.notification.unregisterPush", 6851 6851 + "defs": { 6852 6852 + "main": { 6853 6853 + "type": "procedure", 6854 6854 + "description": 6855 6855 + "The inverse of registerPush - inform a specified service that push notifications should no longer be sent to the given token for the requesting account. Requires auth.", 6856 6856 + "input": { 6857 6857 + "encoding": "application/json", 6858 6858 + "schema": { 6859 6859 + "type": "object", 6860 6860 + "required": [ 6861 6861 + "serviceDid", 6862 6862 + "token", 6863 6863 + "platform", 6864 6864 + "appId", 6865 6865 + ], 6866 6866 + "properties": { 6867 6867 + "serviceDid": { 6868 6868 + "type": "string", 6869 6869 + "format": "did", 6870 6870 + }, 6871 6871 + "token": { 6872 6872 + "type": "string", 6873 6873 + }, 6874 6874 + "platform": { 6875 6875 + "type": "string", 6876 6876 + "knownValues": [ 6877 6877 + "ios", 6878 6878 + "android", 6879 6879 + "web", 6880 6880 + ], 6881 6881 + }, 6882 6882 + "appId": { 6883 6883 + "type": "string", 6884 6884 + }, 6885 6885 + }, 6886 6886 + }, 6887 6887 + }, 6888 6888 + }, 6889 6889 + }, 6890 6890 + }, 6891 6891 + "AppBskyNotificationGetPreferences": { 6892 6892 + "lexicon": 1, 6893 6893 + "id": "app.bsky.notification.getPreferences", 6894 6894 + "defs": { 6895 6895 + "main": { 6896 6896 + "type": "query", 6897 6897 + "description": 6898 6898 + "Get notification-related preferences for an account. Requires auth.", 6899 6899 + "parameters": { 6900 6900 + "type": "params", 6901 6901 + "properties": {}, 6902 6902 + }, 6903 6903 + "output": { 6904 6904 + "encoding": "application/json", 6905 6905 + "schema": { 6906 6906 + "type": "object", 6907 6907 + "required": [ 6908 6908 + "preferences", 6909 6909 + ], 6910 6910 + "properties": { 6911 6911 + "preferences": { 6912 6912 + "type": "ref", 6913 6913 + "ref": "lex:app.bsky.notification.defs#preferences", 6914 6914 + }, 6915 6915 + }, 6916 6916 + }, 6917 6917 + }, 6918 6918 + }, 6919 6919 + }, 6920 6920 + }, 3997 6921 "AppBskyNotificationListNotifications": { 3998 6922 "lexicon": 1, 3999 6923 "id": "app.bsky.notification.listNotifications", ··· 4089 7013 "reason": { 4090 7014 "type": "string", 4091 7015 "description": 4092 4092 - "Expected values are 'like', 'repost', 'follow', 'mention', 'reply', 'quote', and 'starterpack-joined'.", 7016 7016 + "The reason why this notification was delivered - e.g. your post was liked, or you received a new follower.", 4093 7017 "knownValues": [ 4094 7018 "like", 4095 7019 "repost", ··· 4098 7022 "reply", 4099 7023 "quote", 4100 7024 "starterpack-joined", 7025 7025 + "verified", 7026 7026 + "unverified", 7027 7027 + "like-via-repost", 7028 7028 + "repost-via-repost", 7029 7029 + "subscribed-post", 4101 7030 ], 4102 7031 }, 4103 7032 "reasonSubject": { ··· 4162 7091 }, 4163 7092 }, 4164 7093 }, 7094 7094 + "AppBskyUnspeccedGetSuggestedFeedsSkeleton": { 7095 7095 + "lexicon": 1, 7096 7096 + "id": "app.bsky.unspecced.getSuggestedFeedsSkeleton", 7097 7097 + "defs": { 7098 7098 + "main": { 7099 7099 + "type": "query", 7100 7100 + "description": 7101 7101 + "Get a skeleton of suggested feeds. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedFeeds", 7102 7102 + "parameters": { 7103 7103 + "type": "params", 7104 7104 + "properties": { 7105 7105 + "viewer": { 7106 7106 + "type": "string", 7107 7107 + "format": "did", 7108 7108 + "description": 7109 7109 + "DID of the account making the request (not included for public/unauthenticated queries).", 7110 7110 + }, 7111 7111 + "limit": { 7112 7112 + "type": "integer", 7113 7113 + "minimum": 1, 7114 7114 + "maximum": 25, 7115 7115 + "default": 10, 7116 7116 + }, 7117 7117 + }, 7118 7118 + }, 7119 7119 + "output": { 7120 7120 + "encoding": "application/json", 7121 7121 + "schema": { 7122 7122 + "type": "object", 7123 7123 + "required": [ 7124 7124 + "feeds", 7125 7125 + ], 7126 7126 + "properties": { 7127 7127 + "feeds": { 7128 7128 + "type": "array", 7129 7129 + "items": { 7130 7130 + "type": "string", 7131 7131 + "format": "at-uri", 7132 7132 + }, 7133 7133 + }, 7134 7134 + }, 7135 7135 + }, 7136 7136 + }, 7137 7137 + }, 7138 7138 + }, 7139 7139 + }, 4165 7140 "AppBskyUnspeccedSearchStarterPacksSkeleton": { 4166 7141 "lexicon": 1, 4167 7142 "id": "app.bsky.unspecced.searchStarterPacksSkeleton", ··· 4295 7270 }, 4296 7271 }, 4297 7272 }, 7273 7273 + "skeletonTrend": { 7274 7274 + "type": "object", 7275 7275 + "required": [ 7276 7276 + "topic", 7277 7277 + "displayName", 7278 7278 + "link", 7279 7279 + "startedAt", 7280 7280 + "postCount", 7281 7281 + "dids", 7282 7282 + ], 7283 7283 + "properties": { 7284 7284 + "topic": { 7285 7285 + "type": "string", 7286 7286 + }, 7287 7287 + "displayName": { 7288 7288 + "type": "string", 7289 7289 + }, 7290 7290 + "link": { 7291 7291 + "type": "string", 7292 7292 + }, 7293 7293 + "startedAt": { 7294 7294 + "type": "string", 7295 7295 + "format": "datetime", 7296 7296 + }, 7297 7297 + "postCount": { 7298 7298 + "type": "integer", 7299 7299 + }, 7300 7300 + "status": { 7301 7301 + "type": "string", 7302 7302 + "knownValues": [ 7303 7303 + "hot", 7304 7304 + ], 7305 7305 + }, 7306 7306 + "category": { 7307 7307 + "type": "string", 7308 7308 + }, 7309 7309 + "dids": { 7310 7310 + "type": "array", 7311 7311 + "items": { 7312 7312 + "type": "string", 7313 7313 + "format": "did", 7314 7314 + }, 7315 7315 + }, 7316 7316 + }, 7317 7317 + }, 7318 7318 + "trendView": { 7319 7319 + "type": "object", 7320 7320 + "required": [ 7321 7321 + "topic", 7322 7322 + "displayName", 7323 7323 + "link", 7324 7324 + "startedAt", 7325 7325 + "postCount", 7326 7326 + "actors", 7327 7327 + ], 7328 7328 + "properties": { 7329 7329 + "topic": { 7330 7330 + "type": "string", 7331 7331 + }, 7332 7332 + "displayName": { 7333 7333 + "type": "string", 7334 7334 + }, 7335 7335 + "link": { 7336 7336 + "type": "string", 7337 7337 + }, 7338 7338 + "startedAt": { 7339 7339 + "type": "string", 7340 7340 + "format": "datetime", 7341 7341 + }, 7342 7342 + "postCount": { 7343 7343 + "type": "integer", 7344 7344 + }, 7345 7345 + "status": { 7346 7346 + "type": "string", 7347 7347 + "knownValues": [ 7348 7348 + "hot", 7349 7349 + ], 7350 7350 + }, 7351 7351 + "category": { 7352 7352 + "type": "string", 7353 7353 + }, 7354 7354 + "actors": { 7355 7355 + "type": "array", 7356 7356 + "items": { 7357 7357 + "type": "ref", 7358 7358 + "ref": "lex:app.bsky.actor.defs#profileViewBasic", 7359 7359 + }, 7360 7360 + }, 7361 7361 + }, 7362 7362 + }, 7363 7363 + "threadItemPost": { 7364 7364 + "type": "object", 7365 7365 + "required": [ 7366 7366 + "post", 7367 7367 + "moreParents", 7368 7368 + "moreReplies", 7369 7369 + "opThread", 7370 7370 + "hiddenByThreadgate", 7371 7371 + "mutedByViewer", 7372 7372 + ], 7373 7373 + "properties": { 7374 7374 + "post": { 7375 7375 + "type": "ref", 7376 7376 + "ref": "lex:app.bsky.feed.defs#postView", 7377 7377 + }, 7378 7378 + "moreParents": { 7379 7379 + "type": "boolean", 7380 7380 + "description": 7381 7381 + "This post has more parents that were not present in the response. This is just a boolean, without the number of parents.", 7382 7382 + }, 7383 7383 + "moreReplies": { 7384 7384 + "type": "integer", 7385 7385 + "description": 7386 7386 + "This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate.", 7387 7387 + }, 7388 7388 + "opThread": { 7389 7389 + "type": "boolean", 7390 7390 + "description": 7391 7391 + "This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread.", 7392 7392 + }, 7393 7393 + "hiddenByThreadgate": { 7394 7394 + "type": "boolean", 7395 7395 + "description": 7396 7396 + "The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread.", 7397 7397 + }, 7398 7398 + "mutedByViewer": { 7399 7399 + "type": "boolean", 7400 7400 + "description": 7401 7401 + "This is by an account muted by the viewer requesting it.", 7402 7402 + }, 7403 7403 + }, 7404 7404 + }, 7405 7405 + "threadItemNoUnauthenticated": { 7406 7406 + "type": "object", 7407 7407 + "properties": {}, 7408 7408 + }, 7409 7409 + "threadItemNotFound": { 7410 7410 + "type": "object", 7411 7411 + "properties": {}, 7412 7412 + }, 7413 7413 + "threadItemBlocked": { 7414 7414 + "type": "object", 7415 7415 + "required": [ 7416 7416 + "author", 7417 7417 + ], 7418 7418 + "properties": { 7419 7419 + "author": { 7420 7420 + "type": "ref", 7421 7421 + "ref": "lex:app.bsky.feed.defs#blockedAuthor", 7422 7422 + }, 7423 7423 + }, 7424 7424 + }, 7425 7425 + "ageAssuranceState": { 7426 7426 + "type": "object", 7427 7427 + "description": 7428 7428 + "The computed state of the age assurance process, returned to the user in question on certain authenticated requests.", 7429 7429 + "required": [ 7430 7430 + "status", 7431 7431 + ], 7432 7432 + "properties": { 7433 7433 + "lastInitiatedAt": { 7434 7434 + "type": "string", 7435 7435 + "format": "datetime", 7436 7436 + "description": "The timestamp when this state was last updated.", 7437 7437 + }, 7438 7438 + "status": { 7439 7439 + "type": "string", 7440 7440 + "description": "The status of the age assurance process.", 7441 7441 + "knownValues": [ 7442 7442 + "unknown", 7443 7443 + "pending", 7444 7444 + "assured", 7445 7445 + "blocked", 7446 7446 + ], 7447 7447 + }, 7448 7448 + }, 7449 7449 + }, 7450 7450 + "ageAssuranceEvent": { 7451 7451 + "type": "object", 7452 7452 + "description": "Object used to store age assurance data in stash.", 7453 7453 + "required": [ 7454 7454 + "createdAt", 7455 7455 + "status", 7456 7456 + "attemptId", 7457 7457 + ], 7458 7458 + "properties": { 7459 7459 + "createdAt": { 7460 7460 + "type": "string", 7461 7461 + "format": "datetime", 7462 7462 + "description": "The date and time of this write operation.", 7463 7463 + }, 7464 7464 + "status": { 7465 7465 + "type": "string", 7466 7466 + "description": "The status of the age assurance process.", 7467 7467 + "knownValues": [ 7468 7468 + "unknown", 7469 7469 + "pending", 7470 7470 + "assured", 7471 7471 + ], 7472 7472 + }, 7473 7473 + "attemptId": { 7474 7474 + "type": "string", 7475 7475 + "description": 7476 7476 + "The unique identifier for this instance of the age assurance flow, in UUID format.", 7477 7477 + }, 7478 7478 + "email": { 7479 7479 + "type": "string", 7480 7480 + "description": "The email used for AA.", 7481 7481 + }, 7482 7482 + "initIp": { 7483 7483 + "type": "string", 7484 7484 + "description": "The IP address used when initiating the AA flow.", 7485 7485 + }, 7486 7486 + "initUa": { 7487 7487 + "type": "string", 7488 7488 + "description": "The user agent used when initiating the AA flow.", 7489 7489 + }, 7490 7490 + "completeIp": { 7491 7491 + "type": "string", 7492 7492 + "description": "The IP address used when completing the AA flow.", 7493 7493 + }, 7494 7494 + "completeUa": { 7495 7495 + "type": "string", 7496 7496 + "description": "The user agent used when completing the AA flow.", 7497 7497 + }, 7498 7498 + }, 7499 7499 + }, 7500 7500 + }, 7501 7501 + }, 7502 7502 + "AppBskyUnspeccedGetOnboardingSuggestedStarterPacksSkeleton": { 7503 7503 + "lexicon": 1, 7504 7504 + "id": "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton", 7505 7505 + "defs": { 7506 7506 + "main": { 7507 7507 + "type": "query", 7508 7508 + "description": 7509 7509 + "Get a skeleton of suggested starterpacks for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getOnboardingSuggestedStarterPacks", 7510 7510 + "parameters": { 7511 7511 + "type": "params", 7512 7512 + "properties": { 7513 7513 + "viewer": { 7514 7514 + "type": "string", 7515 7515 + "format": "did", 7516 7516 + "description": 7517 7517 + "DID of the account making the request (not included for public/unauthenticated queries).", 7518 7518 + }, 7519 7519 + "limit": { 7520 7520 + "type": "integer", 7521 7521 + "minimum": 1, 7522 7522 + "maximum": 25, 7523 7523 + "default": 10, 7524 7524 + }, 7525 7525 + }, 7526 7526 + }, 7527 7527 + "output": { 7528 7528 + "encoding": "application/json", 7529 7529 + "schema": { 7530 7530 + "type": "object", 7531 7531 + "required": [ 7532 7532 + "starterPacks", 7533 7533 + ], 7534 7534 + "properties": { 7535 7535 + "starterPacks": { 7536 7536 + "type": "array", 7537 7537 + "items": { 7538 7538 + "type": "string", 7539 7539 + "format": "at-uri", 7540 7540 + }, 7541 7541 + }, 7542 7542 + }, 7543 7543 + }, 7544 7544 + }, 7545 7545 + }, 7546 7546 + }, 7547 7547 + }, 7548 7548 + "AppBskyUnspeccedGetSuggestedUsers": { 7549 7549 + "lexicon": 1, 7550 7550 + "id": "app.bsky.unspecced.getSuggestedUsers", 7551 7551 + "defs": { 7552 7552 + "main": { 7553 7553 + "type": "query", 7554 7554 + "description": "Get a list of suggested users", 7555 7555 + "parameters": { 7556 7556 + "type": "params", 7557 7557 + "properties": { 7558 7558 + "category": { 7559 7559 + "type": "string", 7560 7560 + "description": "Category of users to get suggestions for.", 7561 7561 + }, 7562 7562 + "limit": { 7563 7563 + "type": "integer", 7564 7564 + "minimum": 1, 7565 7565 + "maximum": 50, 7566 7566 + "default": 25, 7567 7567 + }, 7568 7568 + }, 7569 7569 + }, 7570 7570 + "output": { 7571 7571 + "encoding": "application/json", 7572 7572 + "schema": { 7573 7573 + "type": "object", 7574 7574 + "required": [ 7575 7575 + "actors", 7576 7576 + ], 7577 7577 + "properties": { 7578 7578 + "actors": { 7579 7579 + "type": "array", 7580 7580 + "items": { 7581 7581 + "type": "ref", 7582 7582 + "ref": "lex:app.bsky.actor.defs#profileView", 7583 7583 + }, 7584 7584 + }, 7585 7585 + }, 7586 7586 + }, 7587 7587 + }, 7588 7588 + }, 7589 7589 + }, 7590 7590 + }, 7591 7591 + "AppBskyUnspeccedGetPostThreadOtherV2": { 7592 7592 + "lexicon": 1, 7593 7593 + "id": "app.bsky.unspecced.getPostThreadOtherV2", 7594 7594 + "defs": { 7595 7595 + "main": { 7596 7596 + "type": "query", 7597 7597 + "description": 7598 7598 + "(NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get additional posts under a thread e.g. replies hidden by threadgate. Based on an anchor post at any depth of the tree, returns top-level replies below that anchor. It does not include ancestors nor the anchor itself. This should be called after exhausting `app.bsky.unspecced.getPostThreadV2`. Does not require auth, but additional metadata and filtering will be applied for authed requests.", 7599 7599 + "parameters": { 7600 7600 + "type": "params", 7601 7601 + "required": [ 7602 7602 + "anchor", 7603 7603 + ], 7604 7604 + "properties": { 7605 7605 + "anchor": { 7606 7606 + "type": "string", 7607 7607 + "format": "at-uri", 7608 7608 + "description": 7609 7609 + "Reference (AT-URI) to post record. This is the anchor post.", 7610 7610 + }, 7611 7611 + }, 7612 7612 + }, 7613 7613 + "output": { 7614 7614 + "encoding": "application/json", 7615 7615 + "schema": { 7616 7616 + "type": "object", 7617 7617 + "required": [ 7618 7618 + "thread", 7619 7619 + ], 7620 7620 + "properties": { 7621 7621 + "thread": { 7622 7622 + "type": "array", 7623 7623 + "description": 7624 7624 + "A flat list of other thread items. The depth of each item is indicated by the depth property inside the item.", 7625 7625 + "items": { 7626 7626 + "type": "ref", 7627 7627 + "ref": 7628 7628 + "lex:app.bsky.unspecced.getPostThreadOtherV2#threadItem", 7629 7629 + }, 7630 7630 + }, 7631 7631 + }, 7632 7632 + }, 7633 7633 + }, 7634 7634 + }, 7635 7635 + "threadItem": { 7636 7636 + "type": "object", 7637 7637 + "required": [ 7638 7638 + "uri", 7639 7639 + "depth", 7640 7640 + "value", 7641 7641 + ], 7642 7642 + "properties": { 7643 7643 + "uri": { 7644 7644 + "type": "string", 7645 7645 + "format": "at-uri", 7646 7646 + }, 7647 7647 + "depth": { 7648 7648 + "type": "integer", 7649 7649 + "description": 7650 7650 + "The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths.", 7651 7651 + }, 7652 7652 + "value": { 7653 7653 + "type": "union", 7654 7654 + "refs": [ 7655 7655 + "lex:app.bsky.unspecced.defs#threadItemPost", 7656 7656 + ], 7657 7657 + }, 7658 7658 + }, 7659 7659 + }, 7660 7660 + }, 7661 7661 + }, 7662 7662 + "AppBskyUnspeccedGetSuggestedStarterPacks": { 7663 7663 + "lexicon": 1, 7664 7664 + "id": "app.bsky.unspecced.getSuggestedStarterPacks", 7665 7665 + "defs": { 7666 7666 + "main": { 7667 7667 + "type": "query", 7668 7668 + "description": "Get a list of suggested starterpacks", 7669 7669 + "parameters": { 7670 7670 + "type": "params", 7671 7671 + "properties": { 7672 7672 + "limit": { 7673 7673 + "type": "integer", 7674 7674 + "minimum": 1, 7675 7675 + "maximum": 25, 7676 7676 + "default": 10, 7677 7677 + }, 7678 7678 + }, 7679 7679 + }, 7680 7680 + "output": { 7681 7681 + "encoding": "application/json", 7682 7682 + "schema": { 7683 7683 + "type": "object", 7684 7684 + "required": [ 7685 7685 + "starterPacks", 7686 7686 + ], 7687 7687 + "properties": { 7688 7688 + "starterPacks": { 7689 7689 + "type": "array", 7690 7690 + "items": { 7691 7691 + "type": "ref", 7692 7692 + "ref": "lex:app.bsky.graph.defs#starterPackView", 7693 7693 + }, 7694 7694 + }, 7695 7695 + }, 7696 7696 + }, 7697 7697 + }, 7698 7698 + }, 7699 7699 + }, 7700 7700 + }, 7701 7701 + "AppBskyUnspeccedGetSuggestedStarterPacksSkeleton": { 7702 7702 + "lexicon": 1, 7703 7703 + "id": "app.bsky.unspecced.getSuggestedStarterPacksSkeleton", 7704 7704 + "defs": { 7705 7705 + "main": { 7706 7706 + "type": "query", 7707 7707 + "description": 7708 7708 + "Get a skeleton of suggested starterpacks. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedStarterpacks", 7709 7709 + "parameters": { 7710 7710 + "type": "params", 7711 7711 + "properties": { 7712 7712 + "viewer": { 7713 7713 + "type": "string", 7714 7714 + "format": "did", 7715 7715 + "description": 7716 7716 + "DID of the account making the request (not included for public/unauthenticated queries).", 7717 7717 + }, 7718 7718 + "limit": { 7719 7719 + "type": "integer", 7720 7720 + "minimum": 1, 7721 7721 + "maximum": 25, 7722 7722 + "default": 10, 7723 7723 + }, 7724 7724 + }, 7725 7725 + }, 7726 7726 + "output": { 7727 7727 + "encoding": "application/json", 7728 7728 + "schema": { 7729 7729 + "type": "object", 7730 7730 + "required": [ 7731 7731 + "starterPacks", 7732 7732 + ], 7733 7733 + "properties": { 7734 7734 + "starterPacks": { 7735 7735 + "type": "array", 7736 7736 + "items": { 7737 7737 + "type": "string", 7738 7738 + "format": "at-uri", 7739 7739 + }, 7740 7740 + }, 7741 7741 + }, 7742 7742 + }, 7743 7743 + }, 7744 7744 + }, 7745 7745 + }, 7746 7746 + }, 7747 7747 + "AppBskyUnspeccedGetOnboardingSuggestedStarterPacks": { 7748 7748 + "lexicon": 1, 7749 7749 + "id": "app.bsky.unspecced.getOnboardingSuggestedStarterPacks", 7750 7750 + "defs": { 7751 7751 + "main": { 7752 7752 + "type": "query", 7753 7753 + "description": "Get a list of suggested starterpacks for onboarding", 7754 7754 + "parameters": { 7755 7755 + "type": "params", 7756 7756 + "properties": { 7757 7757 + "limit": { 7758 7758 + "type": "integer", 7759 7759 + "minimum": 1, 7760 7760 + "maximum": 25, 7761 7761 + "default": 10, 7762 7762 + }, 7763 7763 + }, 7764 7764 + }, 7765 7765 + "output": { 7766 7766 + "encoding": "application/json", 7767 7767 + "schema": { 7768 7768 + "type": "object", 7769 7769 + "required": [ 7770 7770 + "starterPacks", 7771 7771 + ], 7772 7772 + "properties": { 7773 7773 + "starterPacks": { 7774 7774 + "type": "array", 7775 7775 + "items": { 7776 7776 + "type": "ref", 7777 7777 + "ref": "lex:app.bsky.graph.defs#starterPackView", 7778 7778 + }, 7779 7779 + }, 7780 7780 + }, 7781 7781 + }, 7782 7782 + }, 7783 7783 + }, 7784 7784 + }, 7785 7785 + }, 7786 7786 + "AppBskyUnspeccedGetSuggestedUsersSkeleton": { 7787 7787 + "lexicon": 1, 7788 7788 + "id": "app.bsky.unspecced.getSuggestedUsersSkeleton", 7789 7789 + "defs": { 7790 7790 + "main": { 7791 7791 + "type": "query", 7792 7792 + "description": 7793 7793 + "Get a skeleton of suggested users. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsers", 7794 7794 + "parameters": { 7795 7795 + "type": "params", 7796 7796 + "properties": { 7797 7797 + "viewer": { 7798 7798 + "type": "string", 7799 7799 + "format": "did", 7800 7800 + "description": 7801 7801 + "DID of the account making the request (not included for public/unauthenticated queries).", 7802 7802 + }, 7803 7803 + "category": { 7804 7804 + "type": "string", 7805 7805 + "description": "Category of users to get suggestions for.", 7806 7806 + }, 7807 7807 + "limit": { 7808 7808 + "type": "integer", 7809 7809 + "minimum": 1, 7810 7810 + "maximum": 50, 7811 7811 + "default": 25, 7812 7812 + }, 7813 7813 + }, 7814 7814 + }, 7815 7815 + "output": { 7816 7816 + "encoding": "application/json", 7817 7817 + "schema": { 7818 7818 + "type": "object", 7819 7819 + "required": [ 7820 7820 + "dids", 7821 7821 + ], 7822 7822 + "properties": { 7823 7823 + "dids": { 7824 7824 + "type": "array", 7825 7825 + "items": { 7826 7826 + "type": "string", 7827 7827 + "format": "did", 7828 7828 + }, 7829 7829 + }, 7830 7830 + }, 7831 7831 + }, 7832 7832 + }, 7833 7833 + }, 7834 7834 + }, 7835 7835 + }, 7836 7836 + "AppBskyUnspeccedGetPostThreadV2": { 7837 7837 + "lexicon": 1, 7838 7838 + "id": "app.bsky.unspecced.getPostThreadV2", 7839 7839 + "defs": { 7840 7840 + "main": { 7841 7841 + "type": "query", 7842 7842 + "description": 7843 7843 + "(NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get posts in a thread. It is based in an anchor post at any depth of the tree, and returns posts above it (recursively resolving the parent, without further branching to their replies) and below it (recursive replies, with branching to their replies). Does not require auth, but additional metadata and filtering will be applied for authed requests.", 7844 7844 + "parameters": { 7845 7845 + "type": "params", 7846 7846 + "required": [ 7847 7847 + "anchor", 7848 7848 + ], 7849 7849 + "properties": { 7850 7850 + "anchor": { 7851 7851 + "type": "string", 7852 7852 + "format": "at-uri", 7853 7853 + "description": 7854 7854 + "Reference (AT-URI) to post record. This is the anchor post, and the thread will be built around it. It can be any post in the tree, not necessarily a root post.", 7855 7855 + }, 7856 7856 + "above": { 7857 7857 + "type": "boolean", 7858 7858 + "description": "Whether to include parents above the anchor.", 7859 7859 + "default": true, 7860 7860 + }, 7861 7861 + "below": { 7862 7862 + "type": "integer", 7863 7863 + "description": 7864 7864 + "How many levels of replies to include below the anchor.", 7865 7865 + "default": 6, 7866 7866 + "minimum": 0, 7867 7867 + "maximum": 20, 7868 7868 + }, 7869 7869 + "branchingFactor": { 7870 7870 + "type": "integer", 7871 7871 + "description": 7872 7872 + "Maximum of replies to include at each level of the thread, except for the direct replies to the anchor, which are (NOTE: currently, during unspecced phase) all returned (NOTE: later they might be paginated).", 7873 7873 + "default": 10, 7874 7874 + "minimum": 0, 7875 7875 + "maximum": 100, 7876 7876 + }, 7877 7877 + "sort": { 7878 7878 + "type": "string", 7879 7879 + "description": "Sorting for the thread replies.", 7880 7880 + "knownValues": [ 7881 7881 + "newest", 7882 7882 + "oldest", 7883 7883 + "top", 7884 7884 + ], 7885 7885 + "default": "oldest", 7886 7886 + }, 7887 7887 + }, 7888 7888 + }, 7889 7889 + "output": { 7890 7890 + "encoding": "application/json", 7891 7891 + "schema": { 7892 7892 + "type": "object", 7893 7893 + "required": [ 7894 7894 + "thread", 7895 7895 + "hasOtherReplies", 7896 7896 + ], 7897 7897 + "properties": { 7898 7898 + "thread": { 7899 7899 + "type": "array", 7900 7900 + "description": 7901 7901 + "A flat list of thread items. The depth of each item is indicated by the depth property inside the item.", 7902 7902 + "items": { 7903 7903 + "type": "ref", 7904 7904 + "ref": "lex:app.bsky.unspecced.getPostThreadV2#threadItem", 7905 7905 + }, 7906 7906 + }, 7907 7907 + "threadgate": { 7908 7908 + "type": "ref", 7909 7909 + "ref": "lex:app.bsky.feed.defs#threadgateView", 7910 7910 + }, 7911 7911 + "hasOtherReplies": { 7912 7912 + "type": "boolean", 7913 7913 + "description": 7914 7914 + "Whether this thread has additional replies. If true, a call can be made to the `getPostThreadOtherV2` endpoint to retrieve them.", 7915 7915 + }, 7916 7916 + }, 7917 7917 + }, 7918 7918 + }, 7919 7919 + }, 7920 7920 + "threadItem": { 7921 7921 + "type": "object", 7922 7922 + "required": [ 7923 7923 + "uri", 7924 7924 + "depth", 7925 7925 + "value", 7926 7926 + ], 7927 7927 + "properties": { 7928 7928 + "uri": { 7929 7929 + "type": "string", 7930 7930 + "format": "at-uri", 7931 7931 + }, 7932 7932 + "depth": { 7933 7933 + "type": "integer", 7934 7934 + "description": 7935 7935 + "The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths.", 7936 7936 + }, 7937 7937 + "value": { 7938 7938 + "type": "union", 7939 7939 + "refs": [ 7940 7940 + "lex:app.bsky.unspecced.defs#threadItemPost", 7941 7941 + "lex:app.bsky.unspecced.defs#threadItemNoUnauthenticated", 7942 7942 + "lex:app.bsky.unspecced.defs#threadItemNotFound", 7943 7943 + "lex:app.bsky.unspecced.defs#threadItemBlocked", 7944 7944 + ], 7945 7945 + }, 7946 7946 + }, 7947 7947 + }, 7948 7948 + }, 7949 7949 + }, 7950 7950 + "AppBskyUnspeccedGetTrends": { 7951 7951 + "lexicon": 1, 7952 7952 + "id": "app.bsky.unspecced.getTrends", 7953 7953 + "defs": { 7954 7954 + "main": { 7955 7955 + "type": "query", 7956 7956 + "description": "Get the current trends on the network", 7957 7957 + "parameters": { 7958 7958 + "type": "params", 7959 7959 + "properties": { 7960 7960 + "limit": { 7961 7961 + "type": "integer", 7962 7962 + "minimum": 1, 7963 7963 + "maximum": 25, 7964 7964 + "default": 10, 7965 7965 + }, 7966 7966 + }, 7967 7967 + }, 7968 7968 + "output": { 7969 7969 + "encoding": "application/json", 7970 7970 + "schema": { 7971 7971 + "type": "object", 7972 7972 + "required": [ 7973 7973 + "trends", 7974 7974 + ], 7975 7975 + "properties": { 7976 7976 + "trends": { 7977 7977 + "type": "array", 7978 7978 + "items": { 7979 7979 + "type": "ref", 7980 7980 + "ref": "lex:app.bsky.unspecced.defs#trendView", 7981 7981 + }, 7982 7982 + }, 7983 7983 + }, 7984 7984 + }, 7985 7985 + }, 7986 7986 + }, 4298 7987 }, 4299 7988 }, 4300 7989 "AppBskyUnspeccedSearchActorsSkeleton": { ··· 4571 8260 }, 4572 8261 }, 4573 8262 }, 8263 8263 + "AppBskyUnspeccedGetAgeAssuranceState": { 8264 8264 + "lexicon": 1, 8265 8265 + "id": "app.bsky.unspecced.getAgeAssuranceState", 8266 8266 + "defs": { 8267 8267 + "main": { 8268 8268 + "type": "query", 8269 8269 + "description": 8270 8270 + "Returns the current state of the age assurance process for an account. This is used to check if the user has completed age assurance or if further action is required.", 8271 8271 + "output": { 8272 8272 + "encoding": "application/json", 8273 8273 + "schema": { 8274 8274 + "type": "ref", 8275 8275 + "ref": "lex:app.bsky.unspecced.defs#ageAssuranceState", 8276 8276 + }, 8277 8277 + }, 8278 8278 + }, 8279 8279 + }, 8280 8280 + }, 4574 8281 "AppBskyUnspeccedGetPopularFeedGenerators": { 4575 8282 "lexicon": 1, 4576 8283 "id": "app.bsky.unspecced.getPopularFeedGenerators", ··· 4619 8326 }, 4620 8327 }, 4621 8328 }, 8329 8329 + "AppBskyUnspeccedInitAgeAssurance": { 8330 8330 + "lexicon": 1, 8331 8331 + "id": "app.bsky.unspecced.initAgeAssurance", 8332 8332 + "defs": { 8333 8333 + "main": { 8334 8334 + "type": "procedure", 8335 8335 + "description": 8336 8336 + "Initiate age assurance for an account. This is a one-time action that will start the process of verifying the user's age.", 8337 8337 + "input": { 8338 8338 + "encoding": "application/json", 8339 8339 + "schema": { 8340 8340 + "type": "object", 8341 8341 + "required": [ 8342 8342 + "email", 8343 8343 + "language", 8344 8344 + "countryCode", 8345 8345 + ], 8346 8346 + "properties": { 8347 8347 + "email": { 8348 8348 + "type": "string", 8349 8349 + "description": 8350 8350 + "The user's email address to receive assurance instructions.", 8351 8351 + }, 8352 8352 + "language": { 8353 8353 + "type": "string", 8354 8354 + "description": 8355 8355 + "The user's preferred language for communication during the assurance process.", 8356 8356 + }, 8357 8357 + "countryCode": { 8358 8358 + "type": "string", 8359 8359 + "description": 8360 8360 + "An ISO 3166-1 alpha-2 code of the user's location.", 8361 8361 + }, 8362 8362 + }, 8363 8363 + }, 8364 8364 + }, 8365 8365 + "output": { 8366 8366 + "encoding": "application/json", 8367 8367 + "schema": { 8368 8368 + "type": "ref", 8369 8369 + "ref": "lex:app.bsky.unspecced.defs#ageAssuranceState", 8370 8370 + }, 8371 8371 + }, 8372 8372 + "errors": [ 8373 8373 + { 8374 8374 + "name": "InvalidEmail", 8375 8375 + }, 8376 8376 + { 8377 8377 + "name": "DidTooLong", 8378 8378 + }, 8379 8379 + { 8380 8380 + "name": "InvalidInitiation", 8381 8381 + }, 8382 8382 + ], 8383 8383 + }, 8384 8384 + }, 8385 8385 + }, 4622 8386 "AppBskyUnspeccedGetTrendingTopics": { 4623 8387 "lexicon": 1, 4624 8388 "id": "app.bsky.unspecced.getTrendingTopics", ··· 4730 8494 }, 4731 8495 }, 4732 8496 }, 8497 8497 + "AppBskyUnspeccedGetSuggestedFeeds": { 8498 8498 + "lexicon": 1, 8499 8499 + "id": "app.bsky.unspecced.getSuggestedFeeds", 8500 8500 + "defs": { 8501 8501 + "main": { 8502 8502 + "type": "query", 8503 8503 + "description": "Get a list of suggested feeds", 8504 8504 + "parameters": { 8505 8505 + "type": "params", 8506 8506 + "properties": { 8507 8507 + "limit": { 8508 8508 + "type": "integer", 8509 8509 + "minimum": 1, 8510 8510 + "maximum": 25, 8511 8511 + "default": 10, 8512 8512 + }, 8513 8513 + }, 8514 8514 + }, 8515 8515 + "output": { 8516 8516 + "encoding": "application/json", 8517 8517 + "schema": { 8518 8518 + "type": "object", 8519 8519 + "required": [ 8520 8520 + "feeds", 8521 8521 + ], 8522 8522 + "properties": { 8523 8523 + "feeds": { 8524 8524 + "type": "array", 8525 8525 + "items": { 8526 8526 + "type": "ref", 8527 8527 + "ref": "lex:app.bsky.feed.defs#generatorView", 8528 8528 + }, 8529 8529 + }, 8530 8530 + }, 8531 8531 + }, 8532 8532 + }, 8533 8533 + }, 8534 8534 + }, 8535 8535 + }, 8536 8536 + "AppBskyUnspeccedGetTrendsSkeleton": { 8537 8537 + "lexicon": 1, 8538 8538 + "id": "app.bsky.unspecced.getTrendsSkeleton", 8539 8539 + "defs": { 8540 8540 + "main": { 8541 8541 + "type": "query", 8542 8542 + "description": 8543 8543 + "Get the skeleton of trends on the network. Intended to be called and then hydrated through app.bsky.unspecced.getTrends", 8544 8544 + "parameters": { 8545 8545 + "type": "params", 8546 8546 + "properties": { 8547 8547 + "viewer": { 8548 8548 + "type": "string", 8549 8549 + "format": "did", 8550 8550 + "description": 8551 8551 + "DID of the account making the request (not included for public/unauthenticated queries).", 8552 8552 + }, 8553 8553 + "limit": { 8554 8554 + "type": "integer", 8555 8555 + "minimum": 1, 8556 8556 + "maximum": 25, 8557 8557 + "default": 10, 8558 8558 + }, 8559 8559 + }, 8560 8560 + }, 8561 8561 + "output": { 8562 8562 + "encoding": "application/json", 8563 8563 + "schema": { 8564 8564 + "type": "object", 8565 8565 + "required": [ 8566 8566 + "trends", 8567 8567 + ], 8568 8568 + "properties": { 8569 8569 + "trends": { 8570 8570 + "type": "array", 8571 8571 + "items": { 8572 8572 + "type": "ref", 8573 8573 + "ref": "lex:app.bsky.unspecced.defs#skeletonTrend", 8574 8574 + }, 8575 8575 + }, 8576 8576 + }, 8577 8577 + }, 8578 8578 + }, 8579 8579 + }, 8580 8580 + }, 8581 8581 + }, 4733 8582 "AppBskyUnspeccedGetConfig": { 4734 8583 "lexicon": 1, 4735 8584 "id": "app.bsky.unspecced.getConfig", ··· 4746 8595 "checkEmailConfirmed": { 4747 8596 "type": "boolean", 4748 8597 }, 8598 8598 + "liveNow": { 8599 8599 + "type": "array", 8600 8600 + "items": { 8601 8601 + "type": "ref", 8602 8602 + "ref": "lex:app.bsky.unspecced.getConfig#liveNowConfig", 8603 8603 + }, 8604 8604 + }, 8605 8605 + }, 8606 8606 + }, 8607 8607 + }, 8608 8608 + }, 8609 8609 + "liveNowConfig": { 8610 8610 + "type": "object", 8611 8611 + "required": [ 8612 8612 + "did", 8613 8613 + "domains", 8614 8614 + ], 8615 8615 + "properties": { 8616 8616 + "did": { 8617 8617 + "type": "string", 8618 8618 + "format": "did", 8619 8619 + }, 8620 8620 + "domains": { 8621 8621 + "type": "array", 8622 8622 + "items": { 8623 8623 + "type": "string", 4749 8624 }, 4750 8625 }, 4751 8626 }, ··· 4878 8753 }, 4879 8754 }, 4880 8755 }, 8756 8756 + "AppBskyGraphGetStarterPacksWithMembership": { 8757 8757 + "lexicon": 1, 8758 8758 + "id": "app.bsky.graph.getStarterPacksWithMembership", 8759 8759 + "defs": { 8760 8760 + "main": { 8761 8761 + "type": "query", 8762 8762 + "description": 8763 8763 + "Enumerates the starter packs created by the session user, and includes membership information about `actor` in those starter packs. Requires auth.", 8764 8764 + "parameters": { 8765 8765 + "type": "params", 8766 8766 + "required": [ 8767 8767 + "actor", 8768 8768 + ], 8769 8769 + "properties": { 8770 8770 + "actor": { 8771 8771 + "type": "string", 8772 8772 + "format": "at-identifier", 8773 8773 + "description": "The account (actor) to check for membership.", 8774 8774 + }, 8775 8775 + "limit": { 8776 8776 + "type": "integer", 8777 8777 + "minimum": 1, 8778 8778 + "maximum": 100, 8779 8779 + "default": 50, 8780 8780 + }, 8781 8781 + "cursor": { 8782 8782 + "type": "string", 8783 8783 + }, 8784 8784 + }, 8785 8785 + }, 8786 8786 + "output": { 8787 8787 + "encoding": "application/json", 8788 8788 + "schema": { 8789 8789 + "type": "object", 8790 8790 + "required": [ 8791 8791 + "starterPacksWithMembership", 8792 8792 + ], 8793 8793 + "properties": { 8794 8794 + "cursor": { 8795 8795 + "type": "string", 8796 8796 + }, 8797 8797 + "starterPacksWithMembership": { 8798 8798 + "type": "array", 8799 8799 + "items": { 8800 8800 + "type": "ref", 8801 8801 + "ref": 8802 8802 + "lex:app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership", 8803 8803 + }, 8804 8804 + }, 8805 8805 + }, 8806 8806 + }, 8807 8807 + }, 8808 8808 + }, 8809 8809 + "starterPackWithMembership": { 8810 8810 + "description": 8811 8811 + "A starter pack and an optional list item indicating membership of a target user to that starter pack.", 8812 8812 + "type": "object", 8813 8813 + "required": [ 8814 8814 + "starterPack", 8815 8815 + ], 8816 8816 + "properties": { 8817 8817 + "starterPack": { 8818 8818 + "type": "ref", 8819 8819 + "ref": "lex:app.bsky.graph.defs#starterPackView", 8820 8820 + }, 8821 8821 + "listItem": { 8822 8822 + "type": "ref", 8823 8823 + "ref": "lex:app.bsky.graph.defs#listItemView", 8824 8824 + }, 8825 8825 + }, 8826 8826 + }, 8827 8827 + }, 8828 8828 + }, 4881 8829 "AppBskyGraphFollow": { 4882 8830 "lexicon": 1, 4883 8831 "id": "app.bsky.graph.follow", ··· 4901 8849 "createdAt": { 4902 8850 "type": "string", 4903 8851 "format": "datetime", 8852 8852 + }, 8853 8853 + "via": { 8854 8854 + "type": "ref", 8855 8855 + "ref": "lex:com.atproto.repo.strongRef", 4904 8856 }, 4905 8857 }, 4906 8858 }, ··· 5245 9197 }, 5246 9198 }, 5247 9199 }, 9200 9200 + "AppBskyGraphGetListsWithMembership": { 9201 9201 + "lexicon": 1, 9202 9202 + "id": "app.bsky.graph.getListsWithMembership", 9203 9203 + "defs": { 9204 9204 + "main": { 9205 9205 + "type": "query", 9206 9206 + "description": 9207 9207 + "Enumerates the lists created by the session user, and includes membership information about `actor` in those lists. Only supports curation and moderation lists (no reference lists, used in starter packs). Requires auth.", 9208 9208 + "parameters": { 9209 9209 + "type": "params", 9210 9210 + "required": [ 9211 9211 + "actor", 9212 9212 + ], 9213 9213 + "properties": { 9214 9214 + "actor": { 9215 9215 + "type": "string", 9216 9216 + "format": "at-identifier", 9217 9217 + "description": "The account (actor) to check for membership.", 9218 9218 + }, 9219 9219 + "limit": { 9220 9220 + "type": "integer", 9221 9221 + "minimum": 1, 9222 9222 + "maximum": 100, 9223 9223 + "default": 50, 9224 9224 + }, 9225 9225 + "cursor": { 9226 9226 + "type": "string", 9227 9227 + }, 9228 9228 + "purposes": { 9229 9229 + "type": "array", 9230 9230 + "description": 9231 9231 + "Optional filter by list purpose. If not specified, all supported types are returned.", 9232 9232 + "items": { 9233 9233 + "type": "string", 9234 9234 + "knownValues": [ 9235 9235 + "modlist", 9236 9236 + "curatelist", 9237 9237 + ], 9238 9238 + }, 9239 9239 + }, 9240 9240 + }, 9241 9241 + }, 9242 9242 + "output": { 9243 9243 + "encoding": "application/json", 9244 9244 + "schema": { 9245 9245 + "type": "object", 9246 9246 + "required": [ 9247 9247 + "listsWithMembership", 9248 9248 + ], 9249 9249 + "properties": { 9250 9250 + "cursor": { 9251 9251 + "type": "string", 9252 9252 + }, 9253 9253 + "listsWithMembership": { 9254 9254 + "type": "array", 9255 9255 + "items": { 9256 9256 + "type": "ref", 9257 9257 + "ref": 9258 9258 + "lex:app.bsky.graph.getListsWithMembership#listWithMembership", 9259 9259 + }, 9260 9260 + }, 9261 9261 + }, 9262 9262 + }, 9263 9263 + }, 9264 9264 + }, 9265 9265 + "listWithMembership": { 9266 9266 + "description": 9267 9267 + "A list and an optional list item indicating membership of a target user to that list.", 9268 9268 + "type": "object", 9269 9269 + "required": [ 9270 9270 + "list", 9271 9271 + ], 9272 9272 + "properties": { 9273 9273 + "list": { 9274 9274 + "type": "ref", 9275 9275 + "ref": "lex:app.bsky.graph.defs#listView", 9276 9276 + }, 9277 9277 + "listItem": { 9278 9278 + "type": "ref", 9279 9279 + "ref": "lex:app.bsky.graph.defs#listItemView", 9280 9280 + }, 9281 9281 + }, 9282 9282 + }, 9283 9283 + }, 9284 9284 + }, 5248 9285 "AppBskyGraphUnmuteActorList": { 5249 9286 "lexicon": 1, 5250 9287 "id": "app.bsky.graph.unmuteActorList", ··· 5640 9677 "cursor": { 5641 9678 "type": "string", 5642 9679 }, 9680 9680 + "purposes": { 9681 9681 + "type": "array", 9682 9682 + "description": 9683 9683 + "Optional filter by list purpose. If not specified, all supported types are returned.", 9684 9684 + "items": { 9685 9685 + "type": "string", 9686 9686 + "knownValues": [ 9687 9687 + "modlist", 9688 9688 + "curatelist", 9689 9689 + ], 9690 9690 + }, 9691 9691 + }, 5643 9692 }, 5644 9693 }, 5645 9694 "output": { ··· 5980 10029 }, 5981 10030 }, 5982 10031 }, 10032 10032 + "AppBskyGraphVerification": { 10033 10033 + "lexicon": 1, 10034 10034 + "id": "app.bsky.graph.verification", 10035 10035 + "defs": { 10036 10036 + "main": { 10037 10037 + "type": "record", 10038 10038 + "description": 10039 10039 + "Record declaring a verification relationship between two accounts. Verifications are only considered valid by an app if issued by an account the app considers trusted.", 10040 10040 + "key": "tid", 10041 10041 + "record": { 10042 10042 + "type": "object", 10043 10043 + "required": [ 10044 10044 + "subject", 10045 10045 + "handle", 10046 10046 + "displayName", 10047 10047 + "createdAt", 10048 10048 + ], 10049 10049 + "properties": { 10050 10050 + "subject": { 10051 10051 + "description": "DID of the subject the verification applies to.", 10052 10052 + "type": "string", 10053 10053 + "format": "did", 10054 10054 + }, 10055 10055 + "handle": { 10056 10056 + "description": 10057 10057 + "Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.", 10058 10058 + "type": "string", 10059 10059 + "format": "handle", 10060 10060 + }, 10061 10061 + "displayName": { 10062 10062 + "description": 10063 10063 + "Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying.", 10064 10064 + "type": "string", 10065 10065 + }, 10066 10066 + "createdAt": { 10067 10067 + "description": "Date of when the verification was created.", 10068 10068 + "type": "string", 10069 10069 + "format": "datetime", 10070 10070 + }, 10071 10071 + }, 10072 10072 + }, 10073 10073 + }, 10074 10074 + }, 10075 10075 + }, 5983 10076 "AppBskyGraphGetListMutes": { 5984 10077 "lexicon": 1, 5985 10078 "id": "app.bsky.graph.getListMutes", ··· 6430 10523 "lex:app.bsky.embed.recordWithMedia#view", 6431 10524 ], 6432 10525 }, 10526 10526 + "bookmarkCount": { 10527 10527 + "type": "integer", 10528 10528 + }, 6433 10529 "replyCount": { 6434 10530 "type": "integer", 6435 10531 }, ··· 6461 10557 "type": "ref", 6462 10558 "ref": "lex:app.bsky.feed.defs#threadgateView", 6463 10559 }, 10560 10560 + "debug": { 10561 10561 + "type": "unknown", 10562 10562 + "description": "Debug information for internal development", 10563 10563 + }, 6464 10564 }, 6465 10565 }, 6466 10566 "viewerState": { ··· 6475 10575 "like": { 6476 10576 "type": "string", 6477 10577 "format": "at-uri", 10578 10578 + }, 10579 10579 + "bookmarked": { 10580 10580 + "type": "boolean", 6478 10581 }, 6479 10582 "threadMuted": { 6480 10583 "type": "boolean", ··· 6528 10631 "Context provided by feed generator that may be passed back alongside interactions.", 6529 10632 "maxLength": 2000, 6530 10633 }, 10634 10634 + "reqId": { 10635 10635 + "type": "string", 10636 10636 + "description": 10637 10637 + "Unique identifier per request that may be passed back alongside interactions.", 10638 10638 + "maxLength": 100, 10639 10639 + }, 6531 10640 }, 6532 10641 }, 6533 10642 "replyRef": { ··· 6571 10680 "by": { 6572 10681 "type": "ref", 6573 10682 "ref": "lex:app.bsky.actor.defs#profileViewBasic", 10683 10683 + }, 10684 10684 + "uri": { 10685 10685 + "type": "string", 10686 10686 + "format": "at-uri", 10687 10687 + }, 10688 10688 + "cid": { 10689 10689 + "type": "string", 10690 10690 + "format": "cid", 6574 10691 }, 6575 10692 "indexedAt": { 6576 10693 "type": "string", ··· 6852 10969 "Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton.", 6853 10970 "maxLength": 2000, 6854 10971 }, 10972 10972 + "reqId": { 10973 10973 + "type": "string", 10974 10974 + "description": 10975 10975 + "Unique identifier per request that may be passed back alongside interactions.", 10976 10976 + "maxLength": 100, 10977 10977 + }, 6855 10978 }, 6856 10979 }, 6857 10980 "requestLess": { ··· 7330 11453 }, 7331 11454 "hiddenReplies": { 7332 11455 "type": "array", 7333 7333 - "maxLength": 50, 11456 11456 + "maxLength": 300, 7334 11457 "items": { 7335 11458 "type": "string", 7336 11459 "format": "at-uri", ··· 7701 11824 "main": { 7702 11825 "type": "query", 7703 11826 "description": 7704 7704 - "Find posts matching search criteria, returning views of those posts.", 11827 11827 + "Find posts matching search criteria, returning views of those posts. Note that this API endpoint may require authentication (eg, not public) for some service providers and implementations.", 7705 11828 "parameters": { 7706 11829 "type": "params", 7707 11830 "required": [ ··· 8039 12162 "type": "ref", 8040 12163 "ref": "lex:app.bsky.feed.defs#skeletonFeedPost", 8041 12164 }, 12165 12165 + }, 12166 12166 + "reqId": { 12167 12167 + "type": "string", 12168 12168 + "description": 12169 12169 + "Unique identifier per request that may be passed back alongside interactions.", 12170 12170 + "maxLength": 100, 8042 12171 }, 8043 12172 }, 8044 12173 }, ··· 8453 12582 }, 8454 12583 }, 8455 12584 }, 12585 12585 + "AppBskyAgeassuranceBegin": { 12586 12586 + "lexicon": 1, 12587 12587 + "id": "app.bsky.ageassurance.begin", 12588 12588 + "defs": { 12589 12589 + "main": { 12590 12590 + "type": "procedure", 12591 12591 + "description": "Initiate Age Assurance for an account.", 12592 12592 + "input": { 12593 12593 + "encoding": "application/json", 12594 12594 + "schema": { 12595 12595 + "type": "object", 12596 12596 + "required": [ 12597 12597 + "email", 12598 12598 + "language", 12599 12599 + "countryCode", 12600 12600 + ], 12601 12601 + "properties": { 12602 12602 + "email": { 12603 12603 + "type": "string", 12604 12604 + "description": 12605 12605 + "The user's email address to receive Age Assurance instructions.", 12606 12606 + }, 12607 12607 + "language": { 12608 12608 + "type": "string", 12609 12609 + "description": 12610 12610 + "The user's preferred language for communication during the Age Assurance process.", 12611 12611 + }, 12612 12612 + "countryCode": { 12613 12613 + "type": "string", 12614 12614 + "description": 12615 12615 + "An ISO 3166-1 alpha-2 code of the user's location.", 12616 12616 + }, 12617 12617 + "regionCode": { 12618 12618 + "type": "string", 12619 12619 + "description": 12620 12620 + "An optional ISO 3166-2 code of the user's region or state within the country.", 12621 12621 + }, 12622 12622 + }, 12623 12623 + }, 12624 12624 + }, 12625 12625 + "output": { 12626 12626 + "encoding": "application/json", 12627 12627 + "schema": { 12628 12628 + "type": "ref", 12629 12629 + "ref": "lex:app.bsky.ageassurance.defs#state", 12630 12630 + }, 12631 12631 + }, 12632 12632 + "errors": [ 12633 12633 + { 12634 12634 + "name": "InvalidEmail", 12635 12635 + }, 12636 12636 + { 12637 12637 + "name": "DidTooLong", 12638 12638 + }, 12639 12639 + { 12640 12640 + "name": "InvalidInitiation", 12641 12641 + }, 12642 12642 + { 12643 12643 + "name": "RegionNotSupported", 12644 12644 + }, 12645 12645 + ], 12646 12646 + }, 12647 12647 + }, 12648 12648 + }, 12649 12649 + "AppBskyAgeassuranceDefs": { 12650 12650 + "lexicon": 1, 12651 12651 + "id": "app.bsky.ageassurance.defs", 12652 12652 + "defs": { 12653 12653 + "access": { 12654 12654 + "description": 12655 12655 + "The access level granted based on Age Assurance data we've processed.", 12656 12656 + "type": "string", 12657 12657 + "knownValues": [ 12658 12658 + "unknown", 12659 12659 + "none", 12660 12660 + "safe", 12661 12661 + "full", 12662 12662 + ], 12663 12663 + }, 12664 12664 + "status": { 12665 12665 + "type": "string", 12666 12666 + "description": "The status of the Age Assurance process.", 12667 12667 + "knownValues": [ 12668 12668 + "unknown", 12669 12669 + "pending", 12670 12670 + "assured", 12671 12671 + "blocked", 12672 12672 + ], 12673 12673 + }, 12674 12674 + "state": { 12675 12675 + "type": "object", 12676 12676 + "description": "The user's computed Age Assurance state.", 12677 12677 + "required": [ 12678 12678 + "status", 12679 12679 + "access", 12680 12680 + ], 12681 12681 + "properties": { 12682 12682 + "lastInitiatedAt": { 12683 12683 + "type": "string", 12684 12684 + "format": "datetime", 12685 12685 + "description": "The timestamp when this state was last updated.", 12686 12686 + }, 12687 12687 + "status": { 12688 12688 + "type": "ref", 12689 12689 + "ref": "lex:app.bsky.ageassurance.defs#status", 12690 12690 + }, 12691 12691 + "access": { 12692 12692 + "type": "ref", 12693 12693 + "ref": "lex:app.bsky.ageassurance.defs#access", 12694 12694 + }, 12695 12695 + }, 12696 12696 + }, 12697 12697 + "stateMetadata": { 12698 12698 + "type": "object", 12699 12699 + "description": 12700 12700 + "Additional metadata needed to compute Age Assurance state client-side.", 12701 12701 + "required": [], 12702 12702 + "properties": { 12703 12703 + "accountCreatedAt": { 12704 12704 + "type": "string", 12705 12705 + "format": "datetime", 12706 12706 + "description": "The account creation timestamp.", 12707 12707 + }, 12708 12708 + }, 12709 12709 + }, 12710 12710 + "config": { 12711 12711 + "type": "object", 12712 12712 + "description": "", 12713 12713 + "required": [ 12714 12714 + "regions", 12715 12715 + ], 12716 12716 + "properties": { 12717 12717 + "regions": { 12718 12718 + "type": "array", 12719 12719 + "description": "The per-region Age Assurance configuration.", 12720 12720 + "items": { 12721 12721 + "type": "ref", 12722 12722 + "ref": "lex:app.bsky.ageassurance.defs#configRegion", 12723 12723 + }, 12724 12724 + }, 12725 12725 + }, 12726 12726 + }, 12727 12727 + "configRegion": { 12728 12728 + "type": "object", 12729 12729 + "description": "The Age Assurance configuration for a specific region.", 12730 12730 + "required": [ 12731 12731 + "countryCode", 12732 12732 + "rules", 12733 12733 + ], 12734 12734 + "properties": { 12735 12735 + "countryCode": { 12736 12736 + "type": "string", 12737 12737 + "description": 12738 12738 + "The ISO 3166-1 alpha-2 country code this configuration applies to.", 12739 12739 + }, 12740 12740 + "regionCode": { 12741 12741 + "type": "string", 12742 12742 + "description": 12743 12743 + "The ISO 3166-2 region code this configuration applies to. If omitted, the configuration applies to the entire country.", 12744 12744 + }, 12745 12745 + "rules": { 12746 12746 + "type": "array", 12747 12747 + "description": 12748 12748 + "The ordered list of Age Assurance rules that apply to this region. Rules should be applied in order, and the first matching rule determines the access level granted. The rules array should always include a default rule as the last item.", 12749 12749 + "items": { 12750 12750 + "type": "union", 12751 12751 + "refs": [ 12752 12752 + "lex:app.bsky.ageassurance.defs#configRegionRuleDefault", 12753 12753 + "lex:app.bsky.ageassurance.defs#configRegionRuleIfDeclaredOverAge", 12754 12754 + "lex:app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge", 12755 12755 + "lex:app.bsky.ageassurance.defs#configRegionRuleIfAssuredOverAge", 12756 12756 + "lex:app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge", 12757 12757 + "lex:app.bsky.ageassurance.defs#configRegionRuleIfAccountNewerThan", 12758 12758 + "lex:app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan", 12759 12759 + ], 12760 12760 + }, 12761 12761 + }, 12762 12762 + }, 12763 12763 + }, 12764 12764 + "configRegionRuleDefault": { 12765 12765 + "type": "object", 12766 12766 + "description": "Age Assurance rule that applies by default.", 12767 12767 + "required": [ 12768 12768 + "access", 12769 12769 + ], 12770 12770 + "properties": { 12771 12771 + "access": { 12772 12772 + "type": "ref", 12773 12773 + "ref": "lex:app.bsky.ageassurance.defs#access", 12774 12774 + }, 12775 12775 + }, 12776 12776 + }, 12777 12777 + "configRegionRuleIfDeclaredOverAge": { 12778 12778 + "type": "object", 12779 12779 + "description": 12780 12780 + "Age Assurance rule that applies if the user has declared themselves equal-to or over a certain age.", 12781 12781 + "required": [ 12782 12782 + "age", 12783 12783 + "access", 12784 12784 + ], 12785 12785 + "properties": { 12786 12786 + "age": { 12787 12787 + "type": "integer", 12788 12788 + "description": "The age threshold as a whole integer.", 12789 12789 + }, 12790 12790 + "access": { 12791 12791 + "type": "ref", 12792 12792 + "ref": "lex:app.bsky.ageassurance.defs#access", 12793 12793 + }, 12794 12794 + }, 12795 12795 + }, 12796 12796 + "configRegionRuleIfDeclaredUnderAge": { 12797 12797 + "type": "object", 12798 12798 + "description": 12799 12799 + "Age Assurance rule that applies if the user has declared themselves under a certain age.", 12800 12800 + "required": [ 12801 12801 + "age", 12802 12802 + "access", 12803 12803 + ], 12804 12804 + "properties": { 12805 12805 + "age": { 12806 12806 + "type": "integer", 12807 12807 + "description": "The age threshold as a whole integer.", 12808 12808 + }, 12809 12809 + "access": { 12810 12810 + "type": "ref", 12811 12811 + "ref": "lex:app.bsky.ageassurance.defs#access", 12812 12812 + }, 12813 12813 + }, 12814 12814 + }, 12815 12815 + "configRegionRuleIfAssuredOverAge": { 12816 12816 + "type": "object", 12817 12817 + "description": 12818 12818 + "Age Assurance rule that applies if the user has been assured to be equal-to or over a certain age.", 12819 12819 + "required": [ 12820 12820 + "age", 12821 12821 + "access", 12822 12822 + ], 12823 12823 + "properties": { 12824 12824 + "age": { 12825 12825 + "type": "integer", 12826 12826 + "description": "The age threshold as a whole integer.", 12827 12827 + }, 12828 12828 + "access": { 12829 12829 + "type": "ref", 12830 12830 + "ref": "lex:app.bsky.ageassurance.defs#access", 12831 12831 + }, 12832 12832 + }, 12833 12833 + }, 12834 12834 + "configRegionRuleIfAssuredUnderAge": { 12835 12835 + "type": "object", 12836 12836 + "description": 12837 12837 + "Age Assurance rule that applies if the user has been assured to be under a certain age.", 12838 12838 + "required": [ 12839 12839 + "age", 12840 12840 + "access", 12841 12841 + ], 12842 12842 + "properties": { 12843 12843 + "age": { 12844 12844 + "type": "integer", 12845 12845 + "description": "The age threshold as a whole integer.", 12846 12846 + }, 12847 12847 + "access": { 12848 12848 + "type": "ref", 12849 12849 + "ref": "lex:app.bsky.ageassurance.defs#access", 12850 12850 + }, 12851 12851 + }, 12852 12852 + }, 12853 12853 + "configRegionRuleIfAccountNewerThan": { 12854 12854 + "type": "object", 12855 12855 + "description": 12856 12856 + "Age Assurance rule that applies if the account is equal-to or newer than a certain date.", 12857 12857 + "required": [ 12858 12858 + "date", 12859 12859 + "access", 12860 12860 + ], 12861 12861 + "properties": { 12862 12862 + "date": { 12863 12863 + "type": "string", 12864 12864 + "format": "datetime", 12865 12865 + "description": "The date threshold as a datetime string.", 12866 12866 + }, 12867 12867 + "access": { 12868 12868 + "type": "ref", 12869 12869 + "ref": "lex:app.bsky.ageassurance.defs#access", 12870 12870 + }, 12871 12871 + }, 12872 12872 + }, 12873 12873 + "configRegionRuleIfAccountOlderThan": { 12874 12874 + "type": "object", 12875 12875 + "description": 12876 12876 + "Age Assurance rule that applies if the account is older than a certain date.", 12877 12877 + "required": [ 12878 12878 + "date", 12879 12879 + "access", 12880 12880 + ], 12881 12881 + "properties": { 12882 12882 + "date": { 12883 12883 + "type": "string", 12884 12884 + "format": "datetime", 12885 12885 + "description": "The date threshold as a datetime string.", 12886 12886 + }, 12887 12887 + "access": { 12888 12888 + "type": "ref", 12889 12889 + "ref": "lex:app.bsky.ageassurance.defs#access", 12890 12890 + }, 12891 12891 + }, 12892 12892 + }, 12893 12893 + "event": { 12894 12894 + "type": "object", 12895 12895 + "description": "Object used to store Age Assurance data in stash.", 12896 12896 + "required": [ 12897 12897 + "createdAt", 12898 12898 + "status", 12899 12899 + "access", 12900 12900 + "attemptId", 12901 12901 + "countryCode", 12902 12902 + ], 12903 12903 + "properties": { 12904 12904 + "createdAt": { 12905 12905 + "type": "string", 12906 12906 + "format": "datetime", 12907 12907 + "description": "The date and time of this write operation.", 12908 12908 + }, 12909 12909 + "attemptId": { 12910 12910 + "type": "string", 12911 12911 + "description": 12912 12912 + "The unique identifier for this instance of the Age Assurance flow, in UUID format.", 12913 12913 + }, 12914 12914 + "status": { 12915 12915 + "type": "string", 12916 12916 + "description": "The status of the Age Assurance process.", 12917 12917 + "knownValues": [ 12918 12918 + "unknown", 12919 12919 + "pending", 12920 12920 + "assured", 12921 12921 + "blocked", 12922 12922 + ], 12923 12923 + }, 12924 12924 + "access": { 12925 12925 + "description": 12926 12926 + "The access level granted based on Age Assurance data we've processed.", 12927 12927 + "type": "string", 12928 12928 + "knownValues": [ 12929 12929 + "unknown", 12930 12930 + "none", 12931 12931 + "safe", 12932 12932 + "full", 12933 12933 + ], 12934 12934 + }, 12935 12935 + "countryCode": { 12936 12936 + "type": "string", 12937 12937 + "description": 12938 12938 + "The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow.", 12939 12939 + }, 12940 12940 + "regionCode": { 12941 12941 + "type": "string", 12942 12942 + "description": 12943 12943 + "The ISO 3166-2 region code provided when beginning the Age Assurance flow.", 12944 12944 + }, 12945 12945 + "email": { 12946 12946 + "type": "string", 12947 12947 + "description": "The email used for Age Assurance.", 12948 12948 + }, 12949 12949 + "initIp": { 12950 12950 + "type": "string", 12951 12951 + "description": 12952 12952 + "The IP address used when initiating the Age Assurance flow.", 12953 12953 + }, 12954 12954 + "initUa": { 12955 12955 + "type": "string", 12956 12956 + "description": 12957 12957 + "The user agent used when initiating the Age Assurance flow.", 12958 12958 + }, 12959 12959 + "completeIp": { 12960 12960 + "type": "string", 12961 12961 + "description": 12962 12962 + "The IP address used when completing the Age Assurance flow.", 12963 12963 + }, 12964 12964 + "completeUa": { 12965 12965 + "type": "string", 12966 12966 + "description": 12967 12967 + "The user agent used when completing the Age Assurance flow.", 12968 12968 + }, 12969 12969 + }, 12970 12970 + }, 12971 12971 + }, 12972 12972 + }, 12973 12973 + "AppBskyAgeassuranceGetState": { 12974 12974 + "lexicon": 1, 12975 12975 + "id": "app.bsky.ageassurance.getState", 12976 12976 + "defs": { 12977 12977 + "main": { 12978 12978 + "type": "query", 12979 12979 + "description": 12980 12980 + "Returns server-computed Age Assurance state, if available, and any additional metadata needed to compute Age Assurance state client-side.", 12981 12981 + "parameters": { 12982 12982 + "type": "params", 12983 12983 + "required": [ 12984 12984 + "countryCode", 12985 12985 + ], 12986 12986 + "properties": { 12987 12987 + "countryCode": { 12988 12988 + "type": "string", 12989 12989 + }, 12990 12990 + "regionCode": { 12991 12991 + "type": "string", 12992 12992 + }, 12993 12993 + }, 12994 12994 + }, 12995 12995 + "output": { 12996 12996 + "encoding": "application/json", 12997 12997 + "schema": { 12998 12998 + "type": "object", 12999 12999 + "required": [ 13000 13000 + "state", 13001 13001 + "metadata", 13002 13002 + ], 13003 13003 + "properties": { 13004 13004 + "state": { 13005 13005 + "type": "ref", 13006 13006 + "ref": "lex:app.bsky.ageassurance.defs#state", 13007 13007 + }, 13008 13008 + "metadata": { 13009 13009 + "type": "ref", 13010 13010 + "ref": "lex:app.bsky.ageassurance.defs#stateMetadata", 13011 13011 + }, 13012 13012 + }, 13013 13013 + }, 13014 13014 + }, 13015 13015 + }, 13016 13016 + }, 13017 13017 + }, 13018 13018 + "AppBskyAgeassuranceGetConfig": { 13019 13019 + "lexicon": 1, 13020 13020 + "id": "app.bsky.ageassurance.getConfig", 13021 13021 + "defs": { 13022 13022 + "main": { 13023 13023 + "type": "query", 13024 13024 + "description": 13025 13025 + "Returns Age Assurance configuration for use on the client.", 13026 13026 + "output": { 13027 13027 + "encoding": "application/json", 13028 13028 + "schema": { 13029 13029 + "type": "ref", 13030 13030 + "ref": "lex:app.bsky.ageassurance.defs#config", 13031 13031 + }, 13032 13032 + }, 13033 13033 + }, 13034 13034 + }, 13035 13035 + }, 8456 13036 "AppBskyActorSearchActorsTypeahead": { 8457 13037 "lexicon": 1, 8458 13038 "id": "app.bsky.actor.searchActorsTypeahead", ··· 8525 13105 "maxGraphemes": 64, 8526 13106 "maxLength": 640, 8527 13107 }, 13108 13108 + "pronouns": { 13109 13109 + "type": "string", 13110 13110 + }, 8528 13111 "avatar": { 8529 13112 "type": "string", 8530 13113 "format": "uri", ··· 8548 13131 "type": "string", 8549 13132 "format": "datetime", 8550 13133 }, 13134 13134 + "verification": { 13135 13135 + "type": "ref", 13136 13136 + "ref": "lex:app.bsky.actor.defs#verificationState", 13137 13137 + }, 13138 13138 + "status": { 13139 13139 + "type": "ref", 13140 13140 + "ref": "lex:app.bsky.actor.defs#statusView", 13141 13141 + }, 13142 13142 + "debug": { 13143 13143 + "type": "unknown", 13144 13144 + "description": "Debug information for internal development", 13145 13145 + }, 8551 13146 }, 8552 13147 }, 8553 13148 "profileView": { ··· 8569 13164 "type": "string", 8570 13165 "maxGraphemes": 64, 8571 13166 "maxLength": 640, 13167 13167 + }, 13168 13168 + "pronouns": { 13169 13169 + "type": "string", 8572 13170 }, 8573 13171 "description": { 8574 13172 "type": "string", ··· 8602 13200 "ref": "lex:com.atproto.label.defs#label", 8603 13201 }, 8604 13202 }, 13203 13203 + "verification": { 13204 13204 + "type": "ref", 13205 13205 + "ref": "lex:app.bsky.actor.defs#verificationState", 13206 13206 + }, 13207 13207 + "status": { 13208 13208 + "type": "ref", 13209 13209 + "ref": "lex:app.bsky.actor.defs#statusView", 13210 13210 + }, 13211 13211 + "debug": { 13212 13212 + "type": "unknown", 13213 13213 + "description": "Debug information for internal development", 13214 13214 + }, 8605 13215 }, 8606 13216 }, 8607 13217 "profileViewDetailed": { ··· 8629 13239 "maxGraphemes": 256, 8630 13240 "maxLength": 2560, 8631 13241 }, 13242 13242 + "pronouns": { 13243 13243 + "type": "string", 13244 13244 + }, 13245 13245 + "website": { 13246 13246 + "type": "string", 13247 13247 + "format": "uri", 13248 13248 + }, 8632 13249 "avatar": { 8633 13250 "type": "string", 8634 13251 "format": "uri", ··· 8677 13294 "type": "ref", 8678 13295 "ref": "lex:com.atproto.repo.strongRef", 8679 13296 }, 13297 13297 + "verification": { 13298 13298 + "type": "ref", 13299 13299 + "ref": "lex:app.bsky.actor.defs#verificationState", 13300 13300 + }, 13301 13301 + "status": { 13302 13302 + "type": "ref", 13303 13303 + "ref": "lex:app.bsky.actor.defs#statusView", 13304 13304 + }, 13305 13305 + "debug": { 13306 13306 + "type": "unknown", 13307 13307 + "description": "Debug information for internal development", 13308 13308 + }, 8680 13309 }, 8681 13310 }, 8682 13311 "profileAssociated": { ··· 8698 13327 "type": "ref", 8699 13328 "ref": "lex:app.bsky.actor.defs#profileAssociatedChat", 8700 13329 }, 13330 13330 + "activitySubscription": { 13331 13331 + "type": "ref", 13332 13332 + "ref": 13333 13333 + "lex:app.bsky.actor.defs#profileAssociatedActivitySubscription", 13334 13334 + }, 8701 13335 }, 8702 13336 }, 8703 13337 "profileAssociatedChat": { ··· 8712 13346 "all", 8713 13347 "none", 8714 13348 "following", 13349 13349 + ], 13350 13350 + }, 13351 13351 + }, 13352 13352 + }, 13353 13353 + "profileAssociatedActivitySubscription": { 13354 13354 + "type": "object", 13355 13355 + "required": [ 13356 13356 + "allowSubscriptions", 13357 13357 + ], 13358 13358 + "properties": { 13359 13359 + "allowSubscriptions": { 13360 13360 + "type": "string", 13361 13361 + "knownValues": [ 13362 13362 + "followers", 13363 13363 + "mutuals", 13364 13364 + "none", 8715 13365 ], 8716 13366 }, 8717 13367 }, ··· 8748 13398 "format": "at-uri", 8749 13399 }, 8750 13400 "knownFollowers": { 13401 13401 + "description": 13402 13402 + "This property is present only in selected cases, as an optimization.", 8751 13403 "type": "ref", 8752 13404 "ref": "lex:app.bsky.actor.defs#knownFollowers", 13405 13405 + }, 13406 13406 + "activitySubscription": { 13407 13407 + "description": 13408 13408 + "This property is present only in selected cases, as an optimization.", 13409 13409 + "type": "ref", 13410 13410 + "ref": "lex:app.bsky.notification.defs#activitySubscription", 8753 13411 }, 8754 13412 }, 8755 13413 }, ··· 8775 13433 }, 8776 13434 }, 8777 13435 }, 13436 13436 + "verificationState": { 13437 13437 + "type": "object", 13438 13438 + "description": 13439 13439 + "Represents the verification information about the user this object is attached to.", 13440 13440 + "required": [ 13441 13441 + "verifications", 13442 13442 + "verifiedStatus", 13443 13443 + "trustedVerifierStatus", 13444 13444 + ], 13445 13445 + "properties": { 13446 13446 + "verifications": { 13447 13447 + "type": "array", 13448 13448 + "description": 13449 13449 + "All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included.", 13450 13450 + "items": { 13451 13451 + "type": "ref", 13452 13452 + "ref": "lex:app.bsky.actor.defs#verificationView", 13453 13453 + }, 13454 13454 + }, 13455 13455 + "verifiedStatus": { 13456 13456 + "type": "string", 13457 13457 + "description": "The user's status as a verified account.", 13458 13458 + "knownValues": [ 13459 13459 + "valid", 13460 13460 + "invalid", 13461 13461 + "none", 13462 13462 + ], 13463 13463 + }, 13464 13464 + "trustedVerifierStatus": { 13465 13465 + "type": "string", 13466 13466 + "description": "The user's status as a trusted verifier.", 13467 13467 + "knownValues": [ 13468 13468 + "valid", 13469 13469 + "invalid", 13470 13470 + "none", 13471 13471 + ], 13472 13472 + }, 13473 13473 + }, 13474 13474 + }, 13475 13475 + "verificationView": { 13476 13476 + "type": "object", 13477 13477 + "description": "An individual verification for an associated subject.", 13478 13478 + "required": [ 13479 13479 + "issuer", 13480 13480 + "uri", 13481 13481 + "isValid", 13482 13482 + "createdAt", 13483 13483 + ], 13484 13484 + "properties": { 13485 13485 + "issuer": { 13486 13486 + "type": "string", 13487 13487 + "description": "The user who issued this verification.", 13488 13488 + "format": "did", 13489 13489 + }, 13490 13490 + "uri": { 13491 13491 + "type": "string", 13492 13492 + "description": "The AT-URI of the verification record.", 13493 13493 + "format": "at-uri", 13494 13494 + }, 13495 13495 + "isValid": { 13496 13496 + "type": "boolean", 13497 13497 + "description": 13498 13498 + "True if the verification passes validation, otherwise false.", 13499 13499 + }, 13500 13500 + "createdAt": { 13501 13501 + "type": "string", 13502 13502 + "description": "Timestamp when the verification was created.", 13503 13503 + "format": "datetime", 13504 13504 + }, 13505 13505 + }, 13506 13506 + }, 8778 13507 "preferences": { 8779 13508 "type": "array", 8780 13509 "items": { ··· 8793 13522 "lex:app.bsky.actor.defs#bskyAppStatePref", 8794 13523 "lex:app.bsky.actor.defs#labelersPref", 8795 13524 "lex:app.bsky.actor.defs#postInteractionSettingsPref", 13525 13525 + "lex:app.bsky.actor.defs#verificationPrefs", 8796 13526 ], 8797 13527 }, 8798 13528 }, ··· 9172 13902 }, 9173 13903 }, 9174 13904 }, 13905 13905 + "verificationPrefs": { 13906 13906 + "type": "object", 13907 13907 + "description": 13908 13908 + "Preferences for how verified accounts appear in the app.", 13909 13909 + "required": [], 13910 13910 + "properties": { 13911 13911 + "hideBadges": { 13912 13912 + "description": 13913 13913 + "Hide the blue check badges for verified accounts and trusted verifiers.", 13914 13914 + "type": "boolean", 13915 13915 + "default": false, 13916 13916 + }, 13917 13917 + }, 13918 13918 + }, 9175 13919 "postInteractionSettingsPref": { 9176 13920 "type": "object", 9177 13921 "description": ··· 9207 13951 }, 9208 13952 }, 9209 13953 }, 13954 13954 + "statusView": { 13955 13955 + "type": "object", 13956 13956 + "required": [ 13957 13957 + "status", 13958 13958 + "record", 13959 13959 + ], 13960 13960 + "properties": { 13961 13961 + "status": { 13962 13962 + "type": "string", 13963 13963 + "description": "The status for the account.", 13964 13964 + "knownValues": [ 13965 13965 + "app.bsky.actor.status#live", 13966 13966 + ], 13967 13967 + }, 13968 13968 + "record": { 13969 13969 + "type": "unknown", 13970 13970 + }, 13971 13971 + "embed": { 13972 13972 + "type": "union", 13973 13973 + "description": "An optional embed associated with the status.", 13974 13974 + "refs": [ 13975 13975 + "lex:app.bsky.embed.external#view", 13976 13976 + ], 13977 13977 + }, 13978 13978 + "expiresAt": { 13979 13979 + "type": "string", 13980 13980 + "description": 13981 13981 + "The date when this status will expire. The application might choose to no longer return the status after expiration.", 13982 13982 + "format": "datetime", 13983 13983 + }, 13984 13984 + "isActive": { 13985 13985 + "type": "boolean", 13986 13986 + "description": 13987 13987 + "True if the status is not expired, false if it is expired. Only present if expiration was set.", 13988 13988 + }, 13989 13989 + }, 13990 13990 + }, 9210 13991 }, 9211 13992 }, 9212 13993 "AppBskyActorPutPreferences": { ··· 9415 14196 }, 9416 14197 }, 9417 14198 }, 14199 14199 + "AppBskyActorStatus": { 14200 14200 + "lexicon": 1, 14201 14201 + "id": "app.bsky.actor.status", 14202 14202 + "defs": { 14203 14203 + "main": { 14204 14204 + "type": "record", 14205 14205 + "description": "A declaration of a Bluesky account status.", 14206 14206 + "key": "literal:self", 14207 14207 + "record": { 14208 14208 + "type": "object", 14209 14209 + "required": [ 14210 14210 + "status", 14211 14211 + "createdAt", 14212 14212 + ], 14213 14213 + "properties": { 14214 14214 + "status": { 14215 14215 + "type": "string", 14216 14216 + "description": "The status for the account.", 14217 14217 + "knownValues": [ 14218 14218 + "app.bsky.actor.status#live", 14219 14219 + ], 14220 14220 + }, 14221 14221 + "embed": { 14222 14222 + "type": "union", 14223 14223 + "description": "An optional embed associated with the status.", 14224 14224 + "refs": [ 14225 14225 + "lex:app.bsky.embed.external", 14226 14226 + ], 14227 14227 + }, 14228 14228 + "durationMinutes": { 14229 14229 + "type": "integer", 14230 14230 + "description": 14231 14231 + "The duration of the status in minutes. Applications can choose to impose minimum and maximum limits.", 14232 14232 + "minimum": 1, 14233 14233 + }, 14234 14234 + "createdAt": { 14235 14235 + "type": "string", 14236 14236 + "format": "datetime", 14237 14237 + }, 14238 14238 + }, 14239 14239 + }, 14240 14240 + }, 14241 14241 + "live": { 14242 14242 + "type": "token", 14243 14243 + "description": 14244 14244 + "Advertises an account as currently offering live content.", 14245 14245 + }, 14246 14246 + }, 14247 14247 + }, 9418 14248 "AppBskyActorGetPreferences": { 9419 14249 "lexicon": 1, 9420 14250 "id": "app.bsky.actor.getPreferences", ··· 9466 14296 "description": "Free-form profile description text.", 9467 14297 "maxGraphemes": 256, 9468 14298 "maxLength": 2560, 14299 14299 + }, 14300 14300 + "pronouns": { 14301 14301 + "type": "string", 14302 14302 + "description": "Free-form pronouns text.", 14303 14303 + "maxGraphemes": 20, 14304 14304 + "maxLength": 200, 14305 14305 + }, 14306 14306 + "website": { 14307 14307 + "type": "string", 14308 14308 + "format": "uri", 9469 14309 }, 9470 14310 "avatar": { 9471 14311 "type": "blob", ··· 9963 14803 "lex:app.bsky.embed.record#view", 9964 14804 ], 9965 14805 }, 14806 14806 + "reactions": { 14807 14807 + "type": "array", 14808 14808 + "description": 14809 14809 + "Reactions to this message, in ascending order of creation time.", 14810 14810 + "items": { 14811 14811 + "type": "ref", 14812 14812 + "ref": "lex:chat.bsky.convo.defs#reactionView", 14813 14813 + }, 14814 14814 + }, 9966 14815 "sender": { 9967 14816 "type": "ref", 9968 14817 "ref": "lex:chat.bsky.convo.defs#messageViewSender", ··· 10010 14859 }, 10011 14860 }, 10012 14861 }, 14862 14862 + "reactionView": { 14863 14863 + "type": "object", 14864 14864 + "required": [ 14865 14865 + "value", 14866 14866 + "sender", 14867 14867 + "createdAt", 14868 14868 + ], 14869 14869 + "properties": { 14870 14870 + "value": { 14871 14871 + "type": "string", 14872 14872 + }, 14873 14873 + "sender": { 14874 14874 + "type": "ref", 14875 14875 + "ref": "lex:chat.bsky.convo.defs#reactionViewSender", 14876 14876 + }, 14877 14877 + "createdAt": { 14878 14878 + "type": "string", 14879 14879 + "format": "datetime", 14880 14880 + }, 14881 14881 + }, 14882 14882 + }, 14883 14883 + "reactionViewSender": { 14884 14884 + "type": "object", 14885 14885 + "required": [ 14886 14886 + "did", 14887 14887 + ], 14888 14888 + "properties": { 14889 14889 + "did": { 14890 14890 + "type": "string", 14891 14891 + "format": "did", 14892 14892 + }, 14893 14893 + }, 14894 14894 + }, 14895 14895 + "messageAndReactionView": { 14896 14896 + "type": "object", 14897 14897 + "required": [ 14898 14898 + "message", 14899 14899 + "reaction", 14900 14900 + ], 14901 14901 + "properties": { 14902 14902 + "message": { 14903 14903 + "type": "ref", 14904 14904 + "ref": "lex:chat.bsky.convo.defs#messageView", 14905 14905 + }, 14906 14906 + "reaction": { 14907 14907 + "type": "ref", 14908 14908 + "ref": "lex:chat.bsky.convo.defs#reactionView", 14909 14909 + }, 14910 14910 + }, 14911 14911 + }, 10013 14912 "convoView": { 10014 14913 "type": "object", 10015 14914 "required": [ ··· 10038 14937 "refs": [ 10039 14938 "lex:chat.bsky.convo.defs#messageView", 10040 14939 "lex:chat.bsky.convo.defs#deletedMessageView", 14940 14940 + ], 14941 14941 + }, 14942 14942 + "lastReaction": { 14943 14943 + "type": "union", 14944 14944 + "refs": [ 14945 14945 + "lex:chat.bsky.convo.defs#messageAndReactionView", 10041 14946 ], 10042 14947 }, 10043 14948 "muted": { ··· 10199 15104 }, 10200 15105 }, 10201 15106 }, 15107 15107 + "logAddReaction": { 15108 15108 + "type": "object", 15109 15109 + "required": [ 15110 15110 + "rev", 15111 15111 + "convoId", 15112 15112 + "message", 15113 15113 + "reaction", 15114 15114 + ], 15115 15115 + "properties": { 15116 15116 + "rev": { 15117 15117 + "type": "string", 15118 15118 + }, 15119 15119 + "convoId": { 15120 15120 + "type": "string", 15121 15121 + }, 15122 15122 + "message": { 15123 15123 + "type": "union", 15124 15124 + "refs": [ 15125 15125 + "lex:chat.bsky.convo.defs#messageView", 15126 15126 + "lex:chat.bsky.convo.defs#deletedMessageView", 15127 15127 + ], 15128 15128 + }, 15129 15129 + "reaction": { 15130 15130 + "type": "ref", 15131 15131 + "ref": "lex:chat.bsky.convo.defs#reactionView", 15132 15132 + }, 15133 15133 + }, 15134 15134 + }, 15135 15135 + "logRemoveReaction": { 15136 15136 + "type": "object", 15137 15137 + "required": [ 15138 15138 + "rev", 15139 15139 + "convoId", 15140 15140 + "message", 15141 15141 + "reaction", 15142 15142 + ], 15143 15143 + "properties": { 15144 15144 + "rev": { 15145 15145 + "type": "string", 15146 15146 + }, 15147 15147 + "convoId": { 15148 15148 + "type": "string", 15149 15149 + }, 15150 15150 + "message": { 15151 15151 + "type": "union", 15152 15152 + "refs": [ 15153 15153 + "lex:chat.bsky.convo.defs#messageView", 15154 15154 + "lex:chat.bsky.convo.defs#deletedMessageView", 15155 15155 + ], 15156 15156 + }, 15157 15157 + "reaction": { 15158 15158 + "type": "ref", 15159 15159 + "ref": "lex:chat.bsky.convo.defs#reactionView", 15160 15160 + }, 15161 15161 + }, 15162 15162 + }, 10202 15163 }, 10203 15164 }, 10204 15165 "ChatBskyConvoGetConvoAvailability": { ··· 10281 15242 "lex:chat.bsky.convo.defs#logBeginConvo", 10282 15243 "lex:chat.bsky.convo.defs#logAcceptConvo", 10283 15244 "lex:chat.bsky.convo.defs#logLeaveConvo", 15245 15245 + "lex:chat.bsky.convo.defs#logMuteConvo", 15246 15246 + "lex:chat.bsky.convo.defs#logUnmuteConvo", 10284 15247 "lex:chat.bsky.convo.defs#logCreateMessage", 10285 15248 "lex:chat.bsky.convo.defs#logDeleteMessage", 15249 15249 + "lex:chat.bsky.convo.defs#logReadMessage", 15250 15250 + "lex:chat.bsky.convo.defs#logAddReaction", 15251 15251 + "lex:chat.bsky.convo.defs#logRemoveReaction", 10286 15252 ], 10287 15253 }, 10288 15254 }, ··· 10365 15331 }, 10366 15332 }, 10367 15333 }, 15334 15334 + }, 15335 15335 + }, 15336 15336 + }, 15337 15337 + "ChatBskyConvoAddReaction": { 15338 15338 + "lexicon": 1, 15339 15339 + "id": "chat.bsky.convo.addReaction", 15340 15340 + "defs": { 15341 15341 + "main": { 15342 15342 + "type": "procedure", 15343 15343 + "description": 15344 15344 + "Adds an emoji reaction to a message. Requires authentication. It is idempotent, so multiple calls from the same user with the same emoji result in a single reaction.", 15345 15345 + "input": { 15346 15346 + "encoding": "application/json", 15347 15347 + "schema": { 15348 15348 + "type": "object", 15349 15349 + "required": [ 15350 15350 + "convoId", 15351 15351 + "messageId", 15352 15352 + "value", 15353 15353 + ], 15354 15354 + "properties": { 15355 15355 + "convoId": { 15356 15356 + "type": "string", 15357 15357 + }, 15358 15358 + "messageId": { 15359 15359 + "type": "string", 15360 15360 + }, 15361 15361 + "value": { 15362 15362 + "type": "string", 15363 15363 + "minLength": 1, 15364 15364 + "maxLength": 64, 15365 15365 + "minGraphemes": 1, 15366 15366 + "maxGraphemes": 1, 15367 15367 + }, 15368 15368 + }, 15369 15369 + }, 15370 15370 + }, 15371 15371 + "output": { 15372 15372 + "encoding": "application/json", 15373 15373 + "schema": { 15374 15374 + "type": "object", 15375 15375 + "required": [ 15376 15376 + "message", 15377 15377 + ], 15378 15378 + "properties": { 15379 15379 + "message": { 15380 15380 + "type": "ref", 15381 15381 + "ref": "lex:chat.bsky.convo.defs#messageView", 15382 15382 + }, 15383 15383 + }, 15384 15384 + }, 15385 15385 + }, 15386 15386 + "errors": [ 15387 15387 + { 15388 15388 + "name": "ReactionMessageDeleted", 15389 15389 + "description": 15390 15390 + "Indicates that the message has been deleted and reactions can no longer be added/removed.", 15391 15391 + }, 15392 15392 + { 15393 15393 + "name": "ReactionLimitReached", 15394 15394 + "description": 15395 15395 + "Indicates that the message has the maximum number of reactions allowed for a single user, and the requested reaction wasn't yet present. If it was already present, the request will not fail since it is idempotent.", 15396 15396 + }, 15397 15397 + { 15398 15398 + "name": "ReactionInvalidValue", 15399 15399 + "description": 15400 15400 + "Indicates the value for the reaction is not acceptable. In general, this means it is not an emoji.", 15401 15401 + }, 15402 15402 + ], 10368 15403 }, 10369 15404 }, 10370 15405 }, ··· 10476 15511 }, 10477 15512 }, 10478 15513 }, 15514 15514 + "ChatBskyConvoRemoveReaction": { 15515 15515 + "lexicon": 1, 15516 15516 + "id": "chat.bsky.convo.removeReaction", 15517 15517 + "defs": { 15518 15518 + "main": { 15519 15519 + "type": "procedure", 15520 15520 + "description": 15521 15521 + "Removes an emoji reaction from a message. Requires authentication. It is idempotent, so multiple calls from the same user with the same emoji result in that reaction not being present, even if it already wasn't.", 15522 15522 + "input": { 15523 15523 + "encoding": "application/json", 15524 15524 + "schema": { 15525 15525 + "type": "object", 15526 15526 + "required": [ 15527 15527 + "convoId", 15528 15528 + "messageId", 15529 15529 + "value", 15530 15530 + ], 15531 15531 + "properties": { 15532 15532 + "convoId": { 15533 15533 + "type": "string", 15534 15534 + }, 15535 15535 + "messageId": { 15536 15536 + "type": "string", 15537 15537 + }, 15538 15538 + "value": { 15539 15539 + "type": "string", 15540 15540 + "minLength": 1, 15541 15541 + "maxLength": 64, 15542 15542 + "minGraphemes": 1, 15543 15543 + "maxGraphemes": 1, 15544 15544 + }, 15545 15545 + }, 15546 15546 + }, 15547 15547 + }, 15548 15548 + "output": { 15549 15549 + "encoding": "application/json", 15550 15550 + "schema": { 15551 15551 + "type": "object", 15552 15552 + "required": [ 15553 15553 + "message", 15554 15554 + ], 15555 15555 + "properties": { 15556 15556 + "message": { 15557 15557 + "type": "ref", 15558 15558 + "ref": "lex:chat.bsky.convo.defs#messageView", 15559 15559 + }, 15560 15560 + }, 15561 15561 + }, 15562 15562 + }, 15563 15563 + "errors": [ 15564 15564 + { 15565 15565 + "name": "ReactionMessageDeleted", 15566 15566 + "description": 15567 15567 + "Indicates that the message has been deleted and reactions can no longer be added/removed.", 15568 15568 + }, 15569 15569 + { 15570 15570 + "name": "ReactionInvalidValue", 15571 15571 + "description": 15572 15572 + "Indicates the value for the reaction is not acceptable. In general, this means it is not an emoji.", 15573 15573 + }, 15574 15574 + ], 15575 15575 + }, 15576 15576 + }, 15577 15577 + }, 10479 15578 "ChatBskyConvoUpdateRead": { 10480 15579 "lexicon": 1, 10481 15580 "id": "chat.bsky.convo.updateRead", ··· 10793 15892 "chatDisabled": { 10794 15893 "type": "boolean", 10795 15894 "description": 10796 10796 - "Set to true when the actor cannot actively participate in converations", 15895 15895 + "Set to true when the actor cannot actively participate in conversations", 15896 15896 + }, 15897 15897 + "verification": { 15898 15898 + "type": "ref", 15899 15899 + "ref": "lex:app.bsky.actor.defs#verificationState", 10797 15900 }, 10798 15901 }, 10799 15902 }, ··· 16026 21129 }, 16027 21130 }, 16028 21131 }, 21132 21132 + "ComAtprotoTempDereferenceScope": { 21133 21133 + "lexicon": 1, 21134 21134 + "id": "com.atproto.temp.dereferenceScope", 21135 21135 + "defs": { 21136 21136 + "main": { 21137 21137 + "type": "query", 21138 21138 + "description": 21139 21139 + "Allows finding the oauth permission scope from a reference", 21140 21140 + "parameters": { 21141 21141 + "type": "params", 21142 21142 + "required": [ 21143 21143 + "scope", 21144 21144 + ], 21145 21145 + "properties": { 21146 21146 + "scope": { 21147 21147 + "type": "string", 21148 21148 + "description": "The scope reference (starts with 'ref:')", 21149 21149 + }, 21150 21150 + }, 21151 21151 + }, 21152 21152 + "output": { 21153 21153 + "encoding": "application/json", 21154 21154 + "schema": { 21155 21155 + "type": "object", 21156 21156 + "required": [ 21157 21157 + "scope", 21158 21158 + ], 21159 21159 + "properties": { 21160 21160 + "scope": { 21161 21161 + "type": "string", 21162 21162 + "description": "The full oauth permission scope", 21163 21163 + }, 21164 21164 + }, 21165 21165 + }, 21166 21166 + }, 21167 21167 + "errors": [ 21168 21168 + { 21169 21169 + "name": "InvalidScopeReference", 21170 21170 + "description": "An invalid scope reference was provided.", 21171 21171 + }, 21172 21172 + ], 21173 21173 + }, 21174 21174 + }, 21175 21175 + }, 16029 21176 "ComAtprotoTempAddReservedHandle": { 16030 21177 "lexicon": 1, 16031 21178 "id": "com.atproto.temp.addReservedHandle", ··· 16087 21234 }, 16088 21235 }, 16089 21236 }, 21237 21237 + "ComAtprotoTempCheckHandleAvailability": { 21238 21238 + "lexicon": 1, 21239 21239 + "id": "com.atproto.temp.checkHandleAvailability", 21240 21240 + "defs": { 21241 21241 + "main": { 21242 21242 + "type": "query", 21243 21243 + "description": 21244 21244 + "Checks whether the provided handle is available. If the handle is not available, available suggestions will be returned. Optional inputs will be used to generate suggestions.", 21245 21245 + "parameters": { 21246 21246 + "type": "params", 21247 21247 + "required": [ 21248 21248 + "handle", 21249 21249 + ], 21250 21250 + "properties": { 21251 21251 + "handle": { 21252 21252 + "type": "string", 21253 21253 + "format": "handle", 21254 21254 + "description": 21255 21255 + "Tentative handle. Will be checked for availability or used to build handle suggestions.", 21256 21256 + }, 21257 21257 + "email": { 21258 21258 + "type": "string", 21259 21259 + "description": 21260 21260 + "User-provided email. Might be used to build handle suggestions.", 21261 21261 + }, 21262 21262 + "birthDate": { 21263 21263 + "type": "string", 21264 21264 + "format": "datetime", 21265 21265 + "description": 21266 21266 + "User-provided birth date. Might be used to build handle suggestions.", 21267 21267 + }, 21268 21268 + }, 21269 21269 + }, 21270 21270 + "output": { 21271 21271 + "encoding": "application/json", 21272 21272 + "schema": { 21273 21273 + "type": "object", 21274 21274 + "required": [ 21275 21275 + "handle", 21276 21276 + "result", 21277 21277 + ], 21278 21278 + "properties": { 21279 21279 + "handle": { 21280 21280 + "type": "string", 21281 21281 + "format": "handle", 21282 21282 + "description": "Echo of the input handle.", 21283 21283 + }, 21284 21284 + "result": { 21285 21285 + "type": "union", 21286 21286 + "refs": [ 21287 21287 + "lex:com.atproto.temp.checkHandleAvailability#resultAvailable", 21288 21288 + "lex:com.atproto.temp.checkHandleAvailability#resultUnavailable", 21289 21289 + ], 21290 21290 + }, 21291 21291 + }, 21292 21292 + }, 21293 21293 + }, 21294 21294 + "errors": [ 21295 21295 + { 21296 21296 + "name": "InvalidEmail", 21297 21297 + "description": "An invalid email was provided.", 21298 21298 + }, 21299 21299 + ], 21300 21300 + }, 21301 21301 + "resultAvailable": { 21302 21302 + "type": "object", 21303 21303 + "description": "Indicates the provided handle is available.", 21304 21304 + "properties": {}, 21305 21305 + }, 21306 21306 + "resultUnavailable": { 21307 21307 + "type": "object", 21308 21308 + "description": 21309 21309 + "Indicates the provided handle is unavailable and gives suggestions of available handles.", 21310 21310 + "required": [ 21311 21311 + "suggestions", 21312 21312 + ], 21313 21313 + "properties": { 21314 21314 + "suggestions": { 21315 21315 + "type": "array", 21316 21316 + "description": 21317 21317 + "List of suggested handles based on the provided inputs.", 21318 21318 + "items": { 21319 21319 + "type": "ref", 21320 21320 + "ref": "lex:com.atproto.temp.checkHandleAvailability#suggestion", 21321 21321 + }, 21322 21322 + }, 21323 21323 + }, 21324 21324 + }, 21325 21325 + "suggestion": { 21326 21326 + "type": "object", 21327 21327 + "required": [ 21328 21328 + "handle", 21329 21329 + "method", 21330 21330 + ], 21331 21331 + "properties": { 21332 21332 + "handle": { 21333 21333 + "type": "string", 21334 21334 + "format": "handle", 21335 21335 + }, 21336 21336 + "method": { 21337 21337 + "type": "string", 21338 21338 + "description": 21339 21339 + "Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics.", 21340 21340 + }, 21341 21341 + }, 21342 21342 + }, 21343 21343 + }, 21344 21344 + }, 16090 21345 "ComAtprotoTempRequestPhoneVerification": { 16091 21346 "lexicon": 1, 16092 21347 "id": "com.atproto.temp.requestPhoneVerification", ··· 16105 21360 "properties": { 16106 21361 "phoneNumber": { 16107 21362 "type": "string", 21363 21363 + }, 21364 21364 + }, 21365 21365 + }, 21366 21366 + }, 21367 21367 + }, 21368 21368 + }, 21369 21369 + }, 21370 21370 + "ComAtprotoTempRevokeAccountCredentials": { 21371 21371 + "lexicon": 1, 21372 21372 + "id": "com.atproto.temp.revokeAccountCredentials", 21373 21373 + "defs": { 21374 21374 + "main": { 21375 21375 + "type": "procedure", 21376 21376 + "description": 21377 21377 + "Revoke sessions, password, and app passwords associated with account. May be resolved by a password reset.", 21378 21378 + "input": { 21379 21379 + "encoding": "application/json", 21380 21380 + "schema": { 21381 21381 + "type": "object", 21382 21382 + "required": [ 21383 21383 + "account", 21384 21384 + ], 21385 21385 + "properties": { 21386 21386 + "account": { 21387 21387 + "type": "string", 21388 21388 + "format": "at-identifier", 16108 21389 }, 16109 21390 }, 16110 21391 }, ··· 16182 21463 }, 16183 21464 }, 16184 21465 }, 21466 21466 + "ComAtprotoIdentityDefs": { 21467 21467 + "lexicon": 1, 21468 21468 + "id": "com.atproto.identity.defs", 21469 21469 + "defs": { 21470 21470 + "identityInfo": { 21471 21471 + "type": "object", 21472 21472 + "required": [ 21473 21473 + "did", 21474 21474 + "handle", 21475 21475 + "didDoc", 21476 21476 + ], 21477 21477 + "properties": { 21478 21478 + "did": { 21479 21479 + "type": "string", 21480 21480 + "format": "did", 21481 21481 + }, 21482 21482 + "handle": { 21483 21483 + "type": "string", 21484 21484 + "format": "handle", 21485 21485 + "description": 21486 21486 + "The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document.", 21487 21487 + }, 21488 21488 + "didDoc": { 21489 21489 + "type": "unknown", 21490 21490 + "description": "The complete DID document for the identity.", 21491 21491 + }, 21492 21492 + }, 21493 21493 + }, 21494 21494 + }, 21495 21495 + }, 16185 21496 "ComAtprotoIdentitySignPlcOperation": { 16186 21497 "lexicon": 1, 16187 21498 "id": "com.atproto.identity.signPlcOperation", ··· 16264 21575 }, 16265 21576 }, 16266 21577 }, 21578 21578 + "ComAtprotoIdentityResolveIdentity": { 21579 21579 + "lexicon": 1, 21580 21580 + "id": "com.atproto.identity.resolveIdentity", 21581 21581 + "defs": { 21582 21582 + "main": { 21583 21583 + "type": "query", 21584 21584 + "description": 21585 21585 + "Resolves an identity (DID or Handle) to a full identity (DID document and verified handle).", 21586 21586 + "parameters": { 21587 21587 + "type": "params", 21588 21588 + "required": [ 21589 21589 + "identifier", 21590 21590 + ], 21591 21591 + "properties": { 21592 21592 + "identifier": { 21593 21593 + "type": "string", 21594 21594 + "format": "at-identifier", 21595 21595 + "description": "Handle or DID to resolve.", 21596 21596 + }, 21597 21597 + }, 21598 21598 + }, 21599 21599 + "output": { 21600 21600 + "encoding": "application/json", 21601 21601 + "schema": { 21602 21602 + "type": "ref", 21603 21603 + "ref": "lex:com.atproto.identity.defs#identityInfo", 21604 21604 + }, 21605 21605 + }, 21606 21606 + "errors": [ 21607 21607 + { 21608 21608 + "name": "HandleNotFound", 21609 21609 + "description": 21610 21610 + "The resolution process confirmed that the handle does not resolve to any DID.", 21611 21611 + }, 21612 21612 + { 21613 21613 + "name": "DidNotFound", 21614 21614 + "description": 21615 21615 + "The DID resolution process confirmed that there is no current DID.", 21616 21616 + }, 21617 21617 + { 21618 21618 + "name": "DidDeactivated", 21619 21619 + "description": 21620 21620 + "The DID previously existed, but has been deactivated.", 21621 21621 + }, 21622 21622 + ], 21623 21623 + }, 21624 21624 + }, 21625 21625 + }, 21626 21626 + "ComAtprotoIdentityRefreshIdentity": { 21627 21627 + "lexicon": 1, 21628 21628 + "id": "com.atproto.identity.refreshIdentity", 21629 21629 + "defs": { 21630 21630 + "main": { 21631 21631 + "type": "procedure", 21632 21632 + "description": 21633 21633 + "Request that the server re-resolve an identity (DID and handle). The server may ignore this request, or require authentication, depending on the role, implementation, and policy of the server.", 21634 21634 + "input": { 21635 21635 + "encoding": "application/json", 21636 21636 + "schema": { 21637 21637 + "type": "object", 21638 21638 + "required": [ 21639 21639 + "identifier", 21640 21640 + ], 21641 21641 + "properties": { 21642 21642 + "identifier": { 21643 21643 + "type": "string", 21644 21644 + "format": "at-identifier", 21645 21645 + }, 21646 21646 + }, 21647 21647 + }, 21648 21648 + }, 21649 21649 + "output": { 21650 21650 + "encoding": "application/json", 21651 21651 + "schema": { 21652 21652 + "type": "ref", 21653 21653 + "ref": "lex:com.atproto.identity.defs#identityInfo", 21654 21654 + }, 21655 21655 + }, 21656 21656 + "errors": [ 21657 21657 + { 21658 21658 + "name": "HandleNotFound", 21659 21659 + "description": 21660 21660 + "The resolution process confirmed that the handle does not resolve to any DID.", 21661 21661 + }, 21662 21662 + { 21663 21663 + "name": "DidNotFound", 21664 21664 + "description": 21665 21665 + "The DID resolution process confirmed that there is no current DID.", 21666 21666 + }, 21667 21667 + { 21668 21668 + "name": "DidDeactivated", 21669 21669 + "description": 21670 21670 + "The DID previously existed, but has been deactivated.", 21671 21671 + }, 21672 21672 + ], 21673 21673 + }, 21674 21674 + }, 21675 21675 + }, 16267 21676 "ComAtprotoIdentityResolveHandle": { 16268 21677 "lexicon": 1, 16269 21678 "id": "com.atproto.identity.resolveHandle", 16270 21679 "defs": { 16271 21680 "main": { 16272 21681 "type": "query", 16273 16273 - "description": "Resolves a handle (domain name) to a DID.", 21682 21682 + "description": 21683 21683 + "Resolves an atproto handle (hostname) to a DID. Does not necessarily bi-directionally verify against the the DID document.", 16274 21684 "parameters": { 16275 21685 "type": "params", 16276 21686 "required": [ ··· 16299 21709 }, 16300 21710 }, 16301 21711 }, 21712 21712 + "errors": [ 21713 21713 + { 21714 21714 + "name": "HandleNotFound", 21715 21715 + "description": 21716 21716 + "The resolution process confirmed that the handle does not resolve to any DID.", 21717 21717 + }, 21718 21718 + ], 16302 21719 }, 16303 21720 }, 16304 21721 }, ··· 16349 21766 }, 16350 21767 }, 16351 21768 }, 21769 21769 + }, 21770 21770 + }, 21771 21771 + }, 21772 21772 + "ComAtprotoIdentityResolveDid": { 21773 21773 + "lexicon": 1, 21774 21774 + "id": "com.atproto.identity.resolveDid", 21775 21775 + "defs": { 21776 21776 + "main": { 21777 21777 + "type": "query", 21778 21778 + "description": 21779 21779 + "Resolves DID to DID document. Does not bi-directionally verify handle.", 21780 21780 + "parameters": { 21781 21781 + "type": "params", 21782 21782 + "required": [ 21783 21783 + "did", 21784 21784 + ], 21785 21785 + "properties": { 21786 21786 + "did": { 21787 21787 + "type": "string", 21788 21788 + "format": "did", 21789 21789 + "description": "DID to resolve.", 21790 21790 + }, 21791 21791 + }, 21792 21792 + }, 21793 21793 + "output": { 21794 21794 + "encoding": "application/json", 21795 21795 + "schema": { 21796 21796 + "type": "object", 21797 21797 + "required": [ 21798 21798 + "didDoc", 21799 21799 + ], 21800 21800 + "properties": { 21801 21801 + "didDoc": { 21802 21802 + "type": "unknown", 21803 21803 + "description": "The complete DID document for the identity.", 21804 21804 + }, 21805 21805 + }, 21806 21806 + }, 21807 21807 + }, 21808 21808 + "errors": [ 21809 21809 + { 21810 21810 + "name": "DidNotFound", 21811 21811 + "description": 21812 21812 + "The DID resolution process confirmed that there is no current DID.", 21813 21813 + }, 21814 21814 + { 21815 21815 + "name": "DidDeactivated", 21816 21816 + "description": 21817 21817 + "The DID previously existed, but has been deactivated.", 21818 21818 + }, 21819 21819 + ], 16352 21820 }, 16353 21821 }, 16354 21822 }, ··· 16751 22219 "type": "ref", 16752 22220 "ref": "lex:com.atproto.server.defs#inviteCode", 16753 22221 }, 22222 22222 + }, 22223 22223 + }, 22224 22224 + }, 22225 22225 + }, 22226 22226 + }, 22227 22227 + }, 22228 22228 + }, 22229 22229 + "ComAtprotoAdminUpdateAccountSigningKey": { 22230 22230 + "lexicon": 1, 22231 22231 + "id": "com.atproto.admin.updateAccountSigningKey", 22232 22232 + "defs": { 22233 22233 + "main": { 22234 22234 + "type": "procedure", 22235 22235 + "description": 22236 22236 + "Administrative action to update an account's signing key in their Did document.", 22237 22237 + "input": { 22238 22238 + "encoding": "application/json", 22239 22239 + "schema": { 22240 22240 + "type": "object", 22241 22241 + "required": [ 22242 22242 + "did", 22243 22243 + "signingKey", 22244 22244 + ], 22245 22245 + "properties": { 22246 22246 + "did": { 22247 22247 + "type": "string", 22248 22248 + "format": "did", 22249 22249 + }, 22250 22250 + "signingKey": { 22251 22251 + "type": "string", 22252 22252 + "format": "did", 22253 22253 + "description": "Did-key formatted public key", 16754 22254 }, 16755 22255 }, 16756 22256 }, ··· 18591 24091 }, 18592 24092 }, 18593 24093 }, 24094 24094 + "ComAtprotoLexiconResolveLexicon": { 24095 24095 + "lexicon": 1, 24096 24096 + "id": "com.atproto.lexicon.resolveLexicon", 24097 24097 + "defs": { 24098 24098 + "main": { 24099 24099 + "type": "query", 24100 24100 + "description": "Resolves an atproto lexicon (NSID) to a schema.", 24101 24101 + "parameters": { 24102 24102 + "type": "params", 24103 24103 + "properties": { 24104 24104 + "nsid": { 24105 24105 + "format": "nsid", 24106 24106 + "type": "string", 24107 24107 + "description": "The lexicon NSID to resolve.", 24108 24108 + }, 24109 24109 + }, 24110 24110 + "required": [ 24111 24111 + "nsid", 24112 24112 + ], 24113 24113 + }, 24114 24114 + "output": { 24115 24115 + "encoding": "application/json", 24116 24116 + "schema": { 24117 24117 + "type": "object", 24118 24118 + "properties": { 24119 24119 + "cid": { 24120 24120 + "type": "string", 24121 24121 + "format": "cid", 24122 24122 + "description": "The CID of the lexicon schema record.", 24123 24123 + }, 24124 24124 + "schema": { 24125 24125 + "type": "ref", 24126 24126 + "ref": "lex:com.atproto.lexicon.schema#main", 24127 24127 + "description": "The resolved lexicon schema record.", 24128 24128 + }, 24129 24129 + "uri": { 24130 24130 + "type": "string", 24131 24131 + "format": "at-uri", 24132 24132 + "description": "The AT-URI of the lexicon schema record.", 24133 24133 + }, 24134 24134 + }, 24135 24135 + "required": [ 24136 24136 + "uri", 24137 24137 + "cid", 24138 24138 + "schema", 24139 24139 + ], 24140 24140 + }, 24141 24141 + }, 24142 24142 + "errors": [ 24143 24143 + { 24144 24144 + "description": "No lexicon was resolved for the NSID.", 24145 24145 + "name": "LexiconNotFound", 24146 24146 + }, 24147 24147 + ], 24148 24148 + }, 24149 24149 + }, 24150 24150 + }, 18594 24151 "ComAtprotoLexiconSchema": { 18595 24152 "lexicon": 1, 18596 24153 "id": "com.atproto.lexicon.schema", ··· 18731 24288 }, 18732 24289 "since": { 18733 24290 "type": "string", 24291 24291 + "format": "tid", 18734 24292 "description": 18735 24293 "The revision ('rev') of the repo to create a diff from.", 18736 24294 }, ··· 18763 24321 "main": { 18764 24322 "type": "procedure", 18765 24323 "description": 18766 18766 - "Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay.", 24324 24324 + "Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay. DEPRECATED: just use com.atproto.sync.requestCrawl", 18767 24325 "input": { 18768 24326 "encoding": "application/json", 18769 24327 "schema": { ··· 18783 24341 }, 18784 24342 }, 18785 24343 }, 24344 24344 + "ComAtprotoSyncDefs": { 24345 24345 + "lexicon": 1, 24346 24346 + "id": "com.atproto.sync.defs", 24347 24347 + "defs": { 24348 24348 + "hostStatus": { 24349 24349 + "type": "string", 24350 24350 + "knownValues": [ 24351 24351 + "active", 24352 24352 + "idle", 24353 24353 + "offline", 24354 24354 + "throttled", 24355 24355 + "banned", 24356 24356 + ], 24357 24357 + }, 24358 24358 + }, 24359 24359 + }, 18786 24360 "ComAtprotoSyncRequestCrawl": { 18787 24361 "lexicon": 1, 18788 24362 "id": "com.atproto.sync.requestCrawl", ··· 18807 24381 }, 18808 24382 }, 18809 24383 }, 24384 24384 + "errors": [ 24385 24385 + { 24386 24386 + "name": "HostBanned", 24387 24387 + }, 24388 24388 + ], 18810 24389 }, 18811 24390 }, 18812 24391 }, ··· 18831 24410 }, 18832 24411 "since": { 18833 24412 "type": "string", 24413 24413 + "format": "tid", 18834 24414 "description": 18835 24415 "Optional revision of the repo to list blobs since.", 18836 24416 }, ··· 18919 24499 }, 18920 24500 "rev": { 18921 24501 "type": "string", 24502 24502 + "format": "tid", 18922 24503 }, 18923 24504 }, 18924 24505 }, ··· 18963 24544 "type": "union", 18964 24545 "refs": [ 18965 24546 "lex:com.atproto.sync.subscribeRepos#commit", 24547 24547 + "lex:com.atproto.sync.subscribeRepos#sync", 18966 24548 "lex:com.atproto.sync.subscribeRepos#identity", 18967 24549 "lex:com.atproto.sync.subscribeRepos#account", 18968 18968 - "lex:com.atproto.sync.subscribeRepos#handle", 18969 18969 - "lex:com.atproto.sync.subscribeRepos#migrate", 18970 18970 - "lex:com.atproto.sync.subscribeRepos#tombstone", 18971 24550 "lex:com.atproto.sync.subscribeRepos#info", 18972 24551 ], 18973 24552 }, ··· 19001 24580 "time", 19002 24581 ], 19003 24582 "nullable": [ 19004 19004 - "prev", 19005 24583 "since", 19006 24584 ], 19007 24585 "properties": { ··· 19016 24594 "tooBig": { 19017 24595 "type": "boolean", 19018 24596 "description": 19019 19019 - "Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data.", 24597 24597 + "DEPRECATED -- replaced by #sync event and data limits. Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data.", 19020 24598 }, 19021 24599 "repo": { 19022 24600 "type": "string", 19023 24601 "format": "did", 19024 19024 - "description": "The repo this event comes from.", 24602 24602 + "description": 24603 24603 + "The repo this event comes from. Note that all other message types name this field 'did'.", 19025 24604 }, 19026 24605 "commit": { 19027 24606 "type": "cid-link", 19028 24607 "description": "Repo commit object CID.", 19029 24608 }, 19030 19030 - "prev": { 19031 19031 - "type": "cid-link", 19032 19032 - "description": 19033 19033 - "DEPRECATED -- unused. WARNING -- nullable and optional; stick with optional to ensure golang interoperability.", 19034 19034 - }, 19035 24609 "rev": { 19036 24610 "type": "string", 24611 24611 + "format": "tid", 19037 24612 "description": 19038 24613 "The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event.", 19039 24614 }, 19040 24615 "since": { 19041 24616 "type": "string", 24617 24617 + "format": "tid", 19042 24618 "description": 19043 24619 "The rev of the last emitted commit from this repo (if any).", 19044 24620 }, 19045 24621 "blocks": { 19046 24622 "type": "bytes", 19047 24623 "description": 19048 19048 - "CAR file containing relevant blocks, as a diff since the previous repo state.", 19049 19049 - "maxLength": 1000000, 24624 24624 + "CAR file containing relevant blocks, as a diff since the previous repo state. The commit must be included as a block, and the commit block CID must be the first entry in the CAR header 'roots' list.", 24625 24625 + "maxLength": 2000000, 19050 24626 }, 19051 24627 "ops": { 19052 24628 "type": "array", ··· 19063 24639 "items": { 19064 24640 "type": "cid-link", 19065 24641 "description": 19066 19066 - "List of new blobs (by CID) referenced by records in this commit.", 24642 24642 + "DEPRECATED -- will soon always be empty. List of new blobs (by CID) referenced by records in this commit.", 19067 24643 }, 19068 24644 }, 24645 24645 + "prevData": { 24646 24646 + "type": "cid-link", 24647 24647 + "description": 24648 24648 + "The root CID of the MST tree for the previous commit from this repo (indicated by the 'since' revision field in this message). Corresponds to the 'data' field in the repo commit object. NOTE: this field is effectively required for the 'inductive' version of firehose.", 24649 24649 + }, 19069 24650 "time": { 19070 24651 "type": "string", 19071 24652 "format": "datetime", ··· 19074 24655 }, 19075 24656 }, 19076 24657 }, 19077 19077 - "identity": { 24658 24658 + "sync": { 19078 24659 "type": "object", 19079 24660 "description": 19080 19080 - "Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.", 24661 24661 + "Updates the repo to a new state, without necessarily including that state on the firehose. Used to recover from broken commit streams, data loss incidents, or in situations where upstream host does not know recent state of the repository.", 19081 24662 "required": [ 19082 24663 "seq", 19083 24664 "did", 24665 24665 + "blocks", 24666 24666 + "rev", 19084 24667 "time", 19085 24668 ], 19086 24669 "properties": { 19087 24670 "seq": { 19088 24671 "type": "integer", 24672 24672 + "description": "The stream sequence number of this message.", 19089 24673 }, 19090 24674 "did": { 19091 24675 "type": "string", 19092 24676 "format": "did", 24677 24677 + "description": 24678 24678 + "The account this repo event corresponds to. Must match that in the commit object.", 24679 24679 + }, 24680 24680 + "blocks": { 24681 24681 + "type": "bytes", 24682 24682 + "description": 24683 24683 + "CAR file containing the commit, as a block. The CAR header must include the commit block CID as the first 'root'.", 24684 24684 + "maxLength": 10000, 24685 24685 + }, 24686 24686 + "rev": { 24687 24687 + "type": "string", 24688 24688 + "description": 24689 24689 + "The rev of the commit. This value must match that in the commit object.", 19093 24690 }, 19094 24691 "time": { 19095 24692 "type": "string", 19096 24693 "format": "datetime", 19097 19097 - }, 19098 19098 - "handle": { 19099 19099 - "type": "string", 19100 19100 - "format": "handle", 19101 24694 "description": 19102 19102 - "The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details.", 24695 24695 + "Timestamp of when this message was originally broadcast.", 19103 24696 }, 19104 24697 }, 19105 24698 }, 19106 19106 - "account": { 24699 24699 + "identity": { 19107 24700 "type": "object", 19108 24701 "description": 19109 19109 - "Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active.", 24702 24702 + "Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.", 19110 24703 "required": [ 19111 24704 "seq", 19112 24705 "did", 19113 24706 "time", 19114 19114 - "active", 19115 24707 ], 19116 24708 "properties": { 19117 24709 "seq": { ··· 19125 24717 "type": "string", 19126 24718 "format": "datetime", 19127 24719 }, 19128 19128 - "active": { 19129 19129 - "type": "boolean", 19130 19130 - "description": 19131 19131 - "Indicates that the account has a repository which can be fetched from the host that emitted this event.", 19132 19132 - }, 19133 19133 - "status": { 19134 19134 - "type": "string", 19135 19135 - "description": 19136 19136 - "If active=false, this optional field indicates a reason for why the account is not active.", 19137 19137 - "knownValues": [ 19138 19138 - "takendown", 19139 19139 - "suspended", 19140 19140 - "deleted", 19141 19141 - "deactivated", 19142 19142 - ], 19143 19143 - }, 19144 19144 - }, 19145 19145 - }, 19146 19146 - "handle": { 19147 19147 - "type": "object", 19148 19148 - "description": "DEPRECATED -- Use #identity event instead", 19149 19149 - "required": [ 19150 19150 - "seq", 19151 19151 - "did", 19152 19152 - "handle", 19153 19153 - "time", 19154 19154 - ], 19155 19155 - "properties": { 19156 19156 - "seq": { 19157 19157 - "type": "integer", 19158 19158 - }, 19159 19159 - "did": { 19160 19160 - "type": "string", 19161 19161 - "format": "did", 19162 19162 - }, 19163 24720 "handle": { 19164 24721 "type": "string", 19165 24722 "format": "handle", 19166 19166 - }, 19167 19167 - "time": { 19168 19168 - "type": "string", 19169 19169 - "format": "datetime", 24723 24723 + "description": 24724 24724 + "The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details.", 19170 24725 }, 19171 24726 }, 19172 24727 }, 19173 19173 - "migrate": { 24728 24728 + "account": { 19174 24729 "type": "object", 19175 19175 - "description": "DEPRECATED -- Use #account event instead", 24730 24730 + "description": 24731 24731 + "Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active.", 19176 24732 "required": [ 19177 24733 "seq", 19178 24734 "did", 19179 19179 - "migrateTo", 19180 24735 "time", 19181 19181 - ], 19182 19182 - "nullable": [ 19183 19183 - "migrateTo", 24736 24736 + "active", 19184 24737 ], 19185 24738 "properties": { 19186 24739 "seq": { ··· 19190 24743 "type": "string", 19191 24744 "format": "did", 19192 24745 }, 19193 19193 - "migrateTo": { 19194 19194 - "type": "string", 19195 19195 - }, 19196 24746 "time": { 19197 24747 "type": "string", 19198 24748 "format": "datetime", 19199 24749 }, 19200 19200 - }, 19201 19201 - }, 19202 19202 - "tombstone": { 19203 19203 - "type": "object", 19204 19204 - "description": "DEPRECATED -- Use #account event instead", 19205 19205 - "required": [ 19206 19206 - "seq", 19207 19207 - "did", 19208 19208 - "time", 19209 19209 - ], 19210 19210 - "properties": { 19211 19211 - "seq": { 19212 19212 - "type": "integer", 19213 19213 - }, 19214 19214 - "did": { 19215 19215 - "type": "string", 19216 19216 - "format": "did", 24750 24750 + "active": { 24751 24751 + "type": "boolean", 24752 24752 + "description": 24753 24753 + "Indicates that the account has a repository which can be fetched from the host that emitted this event.", 19217 24754 }, 19218 19218 - "time": { 24755 24755 + "status": { 19219 24756 "type": "string", 19220 19220 - "format": "datetime", 24757 24757 + "description": 24758 24758 + "If active=false, this optional field indicates a reason for why the account is not active.", 24759 24759 + "knownValues": [ 24760 24760 + "takendown", 24761 24761 + "suspended", 24762 24762 + "deleted", 24763 24763 + "deactivated", 24764 24764 + "desynchronized", 24765 24765 + "throttled", 24766 24766 + ], 19221 24767 }, 19222 24768 }, 19223 24769 }, ··· 19266 24812 "description": 19267 24813 "For creates and updates, the new record CID. For deletions, null.", 19268 24814 }, 24815 24815 + "prev": { 24816 24816 + "type": "cid-link", 24817 24817 + "description": 24818 24818 + "For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined.", 24819 24819 + }, 19269 24820 }, 19270 24821 }, 19271 24822 }, ··· 19314 24865 "knownValues": [ 19315 24866 "takendown", 19316 24867 "suspended", 24868 24868 + "deleted", 19317 24869 "deactivated", 24870 24870 + "desynchronized", 24871 24871 + "throttled", 19318 24872 ], 19319 24873 }, 19320 24874 "rev": { 19321 24875 "type": "string", 24876 24876 + "format": "tid", 19322 24877 "description": 19323 24878 "Optional field, the current rev of the repo, if active=true", 19324 24879 }, ··· 19361 24916 "rkey": { 19362 24917 "type": "string", 19363 24918 "description": "Record Key", 19364 19364 - }, 19365 19365 - "commit": { 19366 19366 - "type": "string", 19367 19367 - "format": "cid", 19368 19368 - "description": 19369 19369 - "DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit", 24919 24919 + "format": "record-key", 19370 24920 }, 19371 24921 }, 19372 24922 }, ··· 19393 24943 }, 19394 24944 }, 19395 24945 }, 24946 24946 + "ComAtprotoSyncListHosts": { 24947 24947 + "lexicon": 1, 24948 24948 + "id": "com.atproto.sync.listHosts", 24949 24949 + "defs": { 24950 24950 + "main": { 24951 24951 + "type": "query", 24952 24952 + "description": 24953 24953 + "Enumerates upstream hosts (eg, PDS or relay instances) that this service consumes from. Implemented by relays.", 24954 24954 + "parameters": { 24955 24955 + "type": "params", 24956 24956 + "properties": { 24957 24957 + "limit": { 24958 24958 + "type": "integer", 24959 24959 + "minimum": 1, 24960 24960 + "maximum": 1000, 24961 24961 + "default": 200, 24962 24962 + }, 24963 24963 + "cursor": { 24964 24964 + "type": "string", 24965 24965 + }, 24966 24966 + }, 24967 24967 + }, 24968 24968 + "output": { 24969 24969 + "encoding": "application/json", 24970 24970 + "schema": { 24971 24971 + "type": "object", 24972 24972 + "required": [ 24973 24973 + "hosts", 24974 24974 + ], 24975 24975 + "properties": { 24976 24976 + "cursor": { 24977 24977 + "type": "string", 24978 24978 + }, 24979 24979 + "hosts": { 24980 24980 + "type": "array", 24981 24981 + "items": { 24982 24982 + "type": "ref", 24983 24983 + "ref": "lex:com.atproto.sync.listHosts#host", 24984 24984 + }, 24985 24985 + "description": 24986 24986 + "Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first.", 24987 24987 + }, 24988 24988 + }, 24989 24989 + }, 24990 24990 + }, 24991 24991 + }, 24992 24992 + "host": { 24993 24993 + "type": "object", 24994 24994 + "required": [ 24995 24995 + "hostname", 24996 24996 + ], 24997 24997 + "properties": { 24998 24998 + "hostname": { 24999 24999 + "type": "string", 25000 25000 + "description": "hostname of server; not a URL (no scheme)", 25001 25001 + }, 25002 25002 + "seq": { 25003 25003 + "type": "integer", 25004 25004 + "description": 25005 25005 + "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).", 25006 25006 + }, 25007 25007 + "accountCount": { 25008 25008 + "type": "integer", 25009 25009 + }, 25010 25010 + "status": { 25011 25011 + "type": "ref", 25012 25012 + "ref": "lex:com.atproto.sync.defs#hostStatus", 25013 25013 + }, 25014 25014 + }, 25015 25015 + }, 25016 25016 + }, 25017 25017 + }, 19396 25018 "ComAtprotoSyncListRepos": { 19397 25019 "lexicon": 1, 19398 25020 "id": "com.atproto.sync.listRepos", ··· 19456 25078 }, 19457 25079 "rev": { 19458 25080 "type": "string", 25081 25081 + "format": "tid", 19459 25082 }, 19460 25083 "active": { 19461 25084 "type": "boolean", ··· 19467 25090 "knownValues": [ 19468 25091 "takendown", 19469 25092 "suspended", 25093 25093 + "deleted", 19470 25094 "deactivated", 25095 25095 + "desynchronized", 25096 25096 + "throttled", 19471 25097 ], 19472 25098 }, 19473 25099 }, 19474 25100 }, 19475 25101 }, 19476 25102 }, 25103 25103 + "ComAtprotoSyncGetHostStatus": { 25104 25104 + "lexicon": 1, 25105 25105 + "id": "com.atproto.sync.getHostStatus", 25106 25106 + "defs": { 25107 25107 + "main": { 25108 25108 + "type": "query", 25109 25109 + "description": 25110 25110 + "Returns information about a specified upstream host, as consumed by the server. Implemented by relays.", 25111 25111 + "parameters": { 25112 25112 + "type": "params", 25113 25113 + "required": [ 25114 25114 + "hostname", 25115 25115 + ], 25116 25116 + "properties": { 25117 25117 + "hostname": { 25118 25118 + "type": "string", 25119 25119 + "description": 25120 25120 + "Hostname of the host (eg, PDS or relay) being queried.", 25121 25121 + }, 25122 25122 + }, 25123 25123 + }, 25124 25124 + "output": { 25125 25125 + "encoding": "application/json", 25126 25126 + "schema": { 25127 25127 + "type": "object", 25128 25128 + "required": [ 25129 25129 + "hostname", 25130 25130 + ], 25131 25131 + "properties": { 25132 25132 + "hostname": { 25133 25133 + "type": "string", 25134 25134 + }, 25135 25135 + "seq": { 25136 25136 + "type": "integer", 25137 25137 + "description": 25138 25138 + "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).", 25139 25139 + }, 25140 25140 + "accountCount": { 25141 25141 + "type": "integer", 25142 25142 + "description": 25143 25143 + "Number of accounts on the server which are associated with the upstream host. Note that the upstream may actually have more accounts.", 25144 25144 + }, 25145 25145 + "status": { 25146 25146 + "type": "ref", 25147 25147 + "ref": "lex:com.atproto.sync.defs#hostStatus", 25148 25148 + }, 25149 25149 + }, 25150 25150 + }, 25151 25151 + }, 25152 25152 + "errors": [ 25153 25153 + { 25154 25154 + "name": "HostNotFound", 25155 25155 + }, 25156 25156 + ], 25157 25157 + }, 25158 25158 + }, 25159 25159 + }, 19477 25160 "ComAtprotoSyncGetBlocks": { 19478 25161 "lexicon": 1, 19479 25162 "id": "com.atproto.sync.getBlocks", ··· 19661 25344 }, 19662 25345 "rev": { 19663 25346 "type": "string", 25347 25347 + "format": "tid", 19664 25348 }, 19665 25349 }, 19666 25350 }, ··· 19760 25444 }, 19761 25445 "rkey": { 19762 25446 "type": "string", 25447 25447 + "format": "record-key", 19763 25448 "description": "The Record Key.", 19764 25449 "maxLength": 512, 19765 25450 }, ··· 19853 25538 }, 19854 25539 "rkey": { 19855 25540 "type": "string", 25541 25541 + "format": "record-key", 19856 25542 "description": "The Record Key.", 19857 25543 }, 19858 25544 "swapRecord": { ··· 19925 25611 }, 19926 25612 "rkey": { 19927 25613 "type": "string", 25614 25614 + "format": "record-key", 19928 25615 "description": "The Record Key.", 19929 25616 "maxLength": 512, 19930 25617 }, ··· 20265 25952 "rkey": { 20266 25953 "type": "string", 20267 25954 "maxLength": 512, 25955 25955 + "format": "record-key", 25956 25956 + "description": 25957 25957 + "NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility.", 20268 25958 }, 20269 25959 "value": { 20270 25960 "type": "unknown", ··· 20286 25976 }, 20287 25977 "rkey": { 20288 25978 "type": "string", 25979 25979 + "format": "record-key", 20289 25980 }, 20290 25981 "value": { 20291 25982 "type": "unknown", ··· 20306 25997 }, 20307 25998 "rkey": { 20308 25999 "type": "string", 26000 26000 + "format": "record-key", 20309 26001 }, 20310 26002 }, 20311 26003 }, ··· 20399 26091 "cursor": { 20400 26092 "type": "string", 20401 26093 }, 20402 20402 - "rkeyStart": { 20403 20403 - "type": "string", 20404 20404 - "description": 20405 20405 - "DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)", 20406 20406 - }, 20407 20407 - "rkeyEnd": { 20408 20408 - "type": "string", 20409 20409 - "description": 20410 20410 - "DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)", 20411 20411 - }, 20412 26094 "reverse": { 20413 26095 "type": "boolean", 20414 26096 "description": ··· 20475 26157 "com.atproto.moderation.defs#reasonRude", 20476 26158 "com.atproto.moderation.defs#reasonOther", 20477 26159 "com.atproto.moderation.defs#reasonAppeal", 26160 26160 + "tools.ozone.report.defs#reasonAppeal", 26161 26161 + "tools.ozone.report.defs#reasonOther", 26162 26162 + "tools.ozone.report.defs#reasonViolenceAnimal", 26163 26163 + "tools.ozone.report.defs#reasonViolenceThreats", 26164 26164 + "tools.ozone.report.defs#reasonViolenceGraphicContent", 26165 26165 + "tools.ozone.report.defs#reasonViolenceGlorification", 26166 26166 + "tools.ozone.report.defs#reasonViolenceExtremistContent", 26167 26167 + "tools.ozone.report.defs#reasonViolenceTrafficking", 26168 26168 + "tools.ozone.report.defs#reasonViolenceOther", 26169 26169 + "tools.ozone.report.defs#reasonSexualAbuseContent", 26170 26170 + "tools.ozone.report.defs#reasonSexualNCII", 26171 26171 + "tools.ozone.report.defs#reasonSexualDeepfake", 26172 26172 + "tools.ozone.report.defs#reasonSexualAnimal", 26173 26173 + "tools.ozone.report.defs#reasonSexualUnlabeled", 26174 26174 + "tools.ozone.report.defs#reasonSexualOther", 26175 26175 + "tools.ozone.report.defs#reasonChildSafetyCSAM", 26176 26176 + "tools.ozone.report.defs#reasonChildSafetyGroom", 26177 26177 + "tools.ozone.report.defs#reasonChildSafetyPrivacy", 26178 26178 + "tools.ozone.report.defs#reasonChildSafetyHarassment", 26179 26179 + "tools.ozone.report.defs#reasonChildSafetyOther", 26180 26180 + "tools.ozone.report.defs#reasonHarassmentTroll", 26181 26181 + "tools.ozone.report.defs#reasonHarassmentTargeted", 26182 26182 + "tools.ozone.report.defs#reasonHarassmentHateSpeech", 26183 26183 + "tools.ozone.report.defs#reasonHarassmentDoxxing", 26184 26184 + "tools.ozone.report.defs#reasonHarassmentOther", 26185 26185 + "tools.ozone.report.defs#reasonMisleadingBot", 26186 26186 + "tools.ozone.report.defs#reasonMisleadingImpersonation", 26187 26187 + "tools.ozone.report.defs#reasonMisleadingSpam", 26188 26188 + "tools.ozone.report.defs#reasonMisleadingScam", 26189 26189 + "tools.ozone.report.defs#reasonMisleadingElections", 26190 26190 + "tools.ozone.report.defs#reasonMisleadingOther", 26191 26191 + "tools.ozone.report.defs#reasonRuleSiteSecurity", 26192 26192 + "tools.ozone.report.defs#reasonRuleProhibitedSales", 26193 26193 + "tools.ozone.report.defs#reasonRuleBanEvasion", 26194 26194 + "tools.ozone.report.defs#reasonRuleOther", 26195 26195 + "tools.ozone.report.defs#reasonSelfHarmContent", 26196 26196 + "tools.ozone.report.defs#reasonSelfHarmED", 26197 26197 + "tools.ozone.report.defs#reasonSelfHarmStunts", 26198 26198 + "tools.ozone.report.defs#reasonSelfHarmSubstances", 26199 26199 + "tools.ozone.report.defs#reasonSelfHarmOther", 20478 26200 ], 20479 26201 }, 20480 26202 "reasonSpam": { 20481 26203 "type": "token", 20482 20482 - "description": "Spam: frequent unwanted promotion, replies, mentions", 26204 26204 + "description": 26205 26205 + "Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`.", 20483 26206 }, 20484 26207 "reasonViolation": { 20485 26208 "type": "token", 20486 26209 "description": 20487 20487 - "Direct violation of server rules, laws, terms of service", 26210 26210 + "Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`.", 20488 26211 }, 20489 26212 "reasonMisleading": { 20490 26213 "type": "token", 20491 20491 - "description": "Misleading identity, affiliation, or content", 26214 26214 + "description": 26215 26215 + "Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`.", 20492 26216 }, 20493 26217 "reasonSexual": { 20494 26218 "type": "token", 20495 20495 - "description": "Unwanted or mislabeled sexual content", 26219 26219 + "description": 26220 26220 + "Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`.", 20496 26221 }, 20497 26222 "reasonRude": { 20498 26223 "type": "token", 20499 26224 "description": 20500 20500 - "Rude, harassing, explicit, or otherwise unwelcoming behavior", 26225 26225 + "Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`.", 20501 26226 }, 20502 26227 "reasonOther": { 20503 26228 "type": "token", 20504 26229 "description": 20505 20505 - "Other: reports not falling under another report category", 26230 26230 + "Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`.", 20506 26231 }, 20507 26232 "reasonAppeal": { 20508 26233 "type": "token", 20509 20509 - "description": "Appeal: appeal a previously taken moderation action", 26234 26234 + "description": "Appeal a previously taken moderation action", 20510 26235 }, 20511 26236 "subjectType": { 20512 26237 "type": "string", ··· 20557 26282 "lex:com.atproto.repo.strongRef", 20558 26283 ], 20559 26284 }, 26285 26285 + "modTool": { 26286 26286 + "type": "ref", 26287 26287 + "ref": "lex:com.atproto.moderation.createReport#modTool", 26288 26288 + }, 20560 26289 }, 20561 26290 }, 20562 26291 }, ··· 20603 26332 }, 20604 26333 }, 20605 26334 }, 26335 26335 + "modTool": { 26336 26336 + "type": "object", 26337 26337 + "description": 26338 26338 + "Moderation tool information for tracing the source of the action", 26339 26339 + "required": [ 26340 26340 + "name", 26341 26341 + ], 26342 26342 + "properties": { 26343 26343 + "name": { 26344 26344 + "type": "string", 26345 26345 + "description": 26346 26346 + "Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome')", 26347 26347 + }, 26348 26348 + "meta": { 26349 26349 + "type": "unknown", 26350 26350 + "description": "Additional arbitrary metadata about the source", 26351 26351 + }, 26352 26352 + }, 26353 26353 + }, 20606 26354 }, 20607 26355 }, 20608 26356 } as Record<string, LexiconDoc>; ··· 20646 26394 ToolsOzoneSignatureFindRelatedAccounts: 20647 26395 "tools.ozone.signature.findRelatedAccounts", 20648 26396 ToolsOzoneServerGetConfig: "tools.ozone.server.getConfig", 26397 26397 + ToolsOzoneVerificationRevokeVerifications: 26398 26398 + "tools.ozone.verification.revokeVerifications", 26399 26399 + ToolsOzoneVerificationDefs: "tools.ozone.verification.defs", 26400 26400 + ToolsOzoneVerificationGrantVerifications: 26401 26401 + "tools.ozone.verification.grantVerifications", 26402 26402 + ToolsOzoneVerificationListVerifications: 26403 26403 + "tools.ozone.verification.listVerifications", 26404 26404 + ToolsOzoneSafelinkDefs: "tools.ozone.safelink.defs", 26405 26405 + ToolsOzoneSafelinkAddRule: "tools.ozone.safelink.addRule", 26406 26406 + ToolsOzoneSafelinkRemoveRule: "tools.ozone.safelink.removeRule", 26407 26407 + ToolsOzoneSafelinkUpdateRule: "tools.ozone.safelink.updateRule", 26408 26408 + ToolsOzoneSafelinkQueryEvents: "tools.ozone.safelink.queryEvents", 26409 26409 + ToolsOzoneSafelinkQueryRules: "tools.ozone.safelink.queryRules", 20649 26410 ToolsOzoneTeamListMembers: "tools.ozone.team.listMembers", 20650 26411 ToolsOzoneTeamDefs: "tools.ozone.team.defs", 20651 26412 ToolsOzoneTeamDeleteMember: "tools.ozone.team.deleteMember", 20652 26413 ToolsOzoneTeamUpdateMember: "tools.ozone.team.updateMember", 20653 26414 ToolsOzoneTeamAddMember: "tools.ozone.team.addMember", 26415 26415 + ToolsOzoneHostingGetAccountHistory: "tools.ozone.hosting.getAccountHistory", 26416 26416 + ToolsOzoneReportDefs: "tools.ozone.report.defs", 20654 26417 ToolsOzoneCommunicationDefs: "tools.ozone.communication.defs", 20655 26418 ToolsOzoneCommunicationUpdateTemplate: 20656 26419 "tools.ozone.communication.updateTemplate", ··· 20673 26436 ToolsOzoneSettingUpsertOption: "tools.ozone.setting.upsertOption", 20674 26437 ToolsOzoneModerationGetReporterStats: 20675 26438 "tools.ozone.moderation.getReporterStats", 26439 26439 + ToolsOzoneModerationCancelScheduledActions: 26440 26440 + "tools.ozone.moderation.cancelScheduledActions", 26441 26441 + ToolsOzoneModerationListScheduledActions: 26442 26442 + "tools.ozone.moderation.listScheduledActions", 20676 26443 ToolsOzoneModerationQueryStatuses: "tools.ozone.moderation.queryStatuses", 20677 26444 ToolsOzoneModerationGetRepo: "tools.ozone.moderation.getRepo", 20678 26445 ToolsOzoneModerationDefs: "tools.ozone.moderation.defs", 26446 26446 + ToolsOzoneModerationGetSubjects: "tools.ozone.moderation.getSubjects", 20679 26447 ToolsOzoneModerationGetRecords: "tools.ozone.moderation.getRecords", 26448 26448 + ToolsOzoneModerationScheduleAction: "tools.ozone.moderation.scheduleAction", 20680 26449 ToolsOzoneModerationGetEvent: "tools.ozone.moderation.getEvent", 20681 26450 ToolsOzoneModerationQueryEvents: "tools.ozone.moderation.queryEvents", 20682 26451 ToolsOzoneModerationGetRecord: "tools.ozone.moderation.getRecord", 20683 26452 ToolsOzoneModerationEmitEvent: "tools.ozone.moderation.emitEvent", 20684 26453 ToolsOzoneModerationSearchRepos: "tools.ozone.moderation.searchRepos", 26454 26454 + ToolsOzoneModerationGetAccountTimeline: 26455 26455 + "tools.ozone.moderation.getAccountTimeline", 20685 26456 ToolsOzoneModerationGetRepos: "tools.ozone.moderation.getRepos", 20686 26457 AppBskyVideoUploadVideo: "app.bsky.video.uploadVideo", 20687 26458 AppBskyVideoDefs: "app.bsky.video.defs", 20688 26459 AppBskyVideoGetJobStatus: "app.bsky.video.getJobStatus", 20689 26460 AppBskyVideoGetUploadLimits: "app.bsky.video.getUploadLimits", 26461 26461 + AppBskyBookmarkDefs: "app.bsky.bookmark.defs", 26462 26462 + AppBskyBookmarkDeleteBookmark: "app.bsky.bookmark.deleteBookmark", 26463 26463 + AppBskyBookmarkGetBookmarks: "app.bsky.bookmark.getBookmarks", 26464 26464 + AppBskyBookmarkCreateBookmark: "app.bsky.bookmark.createBookmark", 20690 26465 AppBskyEmbedDefs: "app.bsky.embed.defs", 20691 26466 AppBskyEmbedRecord: "app.bsky.embed.record", 20692 26467 AppBskyEmbedImages: "app.bsky.embed.images", 20693 26468 AppBskyEmbedRecordWithMedia: "app.bsky.embed.recordWithMedia", 20694 26469 AppBskyEmbedVideo: "app.bsky.embed.video", 20695 26470 AppBskyEmbedExternal: "app.bsky.embed.external", 26471 26471 + AppBskyNotificationDefs: "app.bsky.notification.defs", 20696 26472 AppBskyNotificationRegisterPush: "app.bsky.notification.registerPush", 20697 26473 AppBskyNotificationPutPreferences: "app.bsky.notification.putPreferences", 26474 26474 + AppBskyNotificationPutActivitySubscription: 26475 26475 + "app.bsky.notification.putActivitySubscription", 26476 26476 + AppBskyNotificationDeclaration: "app.bsky.notification.declaration", 26477 26477 + AppBskyNotificationPutPreferencesV2: "app.bsky.notification.putPreferencesV2", 20698 26478 AppBskyNotificationUpdateSeen: "app.bsky.notification.updateSeen", 26479 26479 + AppBskyNotificationListActivitySubscriptions: 26480 26480 + "app.bsky.notification.listActivitySubscriptions", 26481 26481 + AppBskyNotificationUnregisterPush: "app.bsky.notification.unregisterPush", 26482 26482 + AppBskyNotificationGetPreferences: "app.bsky.notification.getPreferences", 20699 26483 AppBskyNotificationListNotifications: 20700 26484 "app.bsky.notification.listNotifications", 20701 26485 AppBskyNotificationGetUnreadCount: "app.bsky.notification.getUnreadCount", 26486 26486 + AppBskyUnspeccedGetSuggestedFeedsSkeleton: 26487 26487 + "app.bsky.unspecced.getSuggestedFeedsSkeleton", 20702 26488 AppBskyUnspeccedSearchStarterPacksSkeleton: 20703 26489 "app.bsky.unspecced.searchStarterPacksSkeleton", 20704 26490 AppBskyUnspeccedDefs: "app.bsky.unspecced.defs", 26491 26491 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacksSkeleton: 26492 26492 + "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton", 26493 26493 + AppBskyUnspeccedGetSuggestedUsers: "app.bsky.unspecced.getSuggestedUsers", 26494 26494 + AppBskyUnspeccedGetPostThreadOtherV2: 26495 26495 + "app.bsky.unspecced.getPostThreadOtherV2", 26496 26496 + AppBskyUnspeccedGetSuggestedStarterPacks: 26497 26497 + "app.bsky.unspecced.getSuggestedStarterPacks", 26498 26498 + AppBskyUnspeccedGetSuggestedStarterPacksSkeleton: 26499 26499 + "app.bsky.unspecced.getSuggestedStarterPacksSkeleton", 26500 26500 + AppBskyUnspeccedGetOnboardingSuggestedStarterPacks: 26501 26501 + "app.bsky.unspecced.getOnboardingSuggestedStarterPacks", 26502 26502 + AppBskyUnspeccedGetSuggestedUsersSkeleton: 26503 26503 + "app.bsky.unspecced.getSuggestedUsersSkeleton", 26504 26504 + AppBskyUnspeccedGetPostThreadV2: "app.bsky.unspecced.getPostThreadV2", 26505 26505 + AppBskyUnspeccedGetTrends: "app.bsky.unspecced.getTrends", 20705 26506 AppBskyUnspeccedSearchActorsSkeleton: 20706 26507 "app.bsky.unspecced.searchActorsSkeleton", 20707 26508 AppBskyUnspeccedGetSuggestionsSkeleton: 20708 26509 "app.bsky.unspecced.getSuggestionsSkeleton", 20709 26510 AppBskyUnspeccedSearchPostsSkeleton: "app.bsky.unspecced.searchPostsSkeleton", 26511 26511 + AppBskyUnspeccedGetAgeAssuranceState: 26512 26512 + "app.bsky.unspecced.getAgeAssuranceState", 20710 26513 AppBskyUnspeccedGetPopularFeedGenerators: 20711 26514 "app.bsky.unspecced.getPopularFeedGenerators", 26515 26515 + AppBskyUnspeccedInitAgeAssurance: "app.bsky.unspecced.initAgeAssurance", 20712 26516 AppBskyUnspeccedGetTrendingTopics: "app.bsky.unspecced.getTrendingTopics", 20713 26517 AppBskyUnspeccedGetTaggedSuggestions: 20714 26518 "app.bsky.unspecced.getTaggedSuggestions", 26519 26519 + AppBskyUnspeccedGetSuggestedFeeds: "app.bsky.unspecced.getSuggestedFeeds", 26520 26520 + AppBskyUnspeccedGetTrendsSkeleton: "app.bsky.unspecced.getTrendsSkeleton", 20715 26521 AppBskyUnspeccedGetConfig: "app.bsky.unspecced.getConfig", 20716 26522 AppBskyGraphGetStarterPacks: "app.bsky.graph.getStarterPacks", 20717 26523 AppBskyGraphGetSuggestedFollowsByActor: 20718 26524 "app.bsky.graph.getSuggestedFollowsByActor", 20719 26525 AppBskyGraphBlock: "app.bsky.graph.block", 26526 26526 + AppBskyGraphGetStarterPacksWithMembership: 26527 26527 + "app.bsky.graph.getStarterPacksWithMembership", 20720 26528 AppBskyGraphFollow: "app.bsky.graph.follow", 20721 26529 AppBskyGraphDefs: "app.bsky.graph.defs", 26530 26530 + AppBskyGraphGetListsWithMembership: "app.bsky.graph.getListsWithMembership", 20722 26531 AppBskyGraphUnmuteActorList: "app.bsky.graph.unmuteActorList", 20723 26532 AppBskyGraphGetListBlocks: "app.bsky.graph.getListBlocks", 20724 26533 AppBskyGraphListblock: "app.bsky.graph.listblock", ··· 20736 26545 AppBskyGraphListitem: "app.bsky.graph.listitem", 20737 26546 AppBskyGraphList: "app.bsky.graph.list", 20738 26547 AppBskyGraphGetKnownFollowers: "app.bsky.graph.getKnownFollowers", 26548 26548 + AppBskyGraphVerification: "app.bsky.graph.verification", 20739 26549 AppBskyGraphGetListMutes: "app.bsky.graph.getListMutes", 20740 26550 AppBskyGraphGetFollows: "app.bsky.graph.getFollows", 20741 26551 AppBskyGraphGetBlocks: "app.bsky.graph.getBlocks", ··· 20768 26578 AppBskyFeedGetActorFeeds: "app.bsky.feed.getActorFeeds", 20769 26579 AppBskyFeedPost: "app.bsky.feed.post", 20770 26580 AppBskyRichtextFacet: "app.bsky.richtext.facet", 26581 26581 + AppBskyAgeassuranceBegin: "app.bsky.ageassurance.begin", 26582 26582 + AppBskyAgeassuranceDefs: "app.bsky.ageassurance.defs", 26583 26583 + AppBskyAgeassuranceGetState: "app.bsky.ageassurance.getState", 26584 26584 + AppBskyAgeassuranceGetConfig: "app.bsky.ageassurance.getConfig", 20771 26585 AppBskyActorSearchActorsTypeahead: "app.bsky.actor.searchActorsTypeahead", 20772 26586 AppBskyActorDefs: "app.bsky.actor.defs", 20773 26587 AppBskyActorPutPreferences: "app.bsky.actor.putPreferences", ··· 20775 26589 AppBskyActorGetSuggestions: "app.bsky.actor.getSuggestions", 20776 26590 AppBskyActorSearchActors: "app.bsky.actor.searchActors", 20777 26591 AppBskyActorGetProfiles: "app.bsky.actor.getProfiles", 26592 26592 + AppBskyActorStatus: "app.bsky.actor.status", 20778 26593 AppBskyActorGetPreferences: "app.bsky.actor.getPreferences", 20779 26594 AppBskyActorProfile: "app.bsky.actor.profile", 20780 26595 AppBskyLabelerDefs: "app.bsky.labeler.defs", ··· 20787 26602 ChatBskyConvoGetLog: "chat.bsky.convo.getLog", 20788 26603 ChatBskyConvoSendMessage: "chat.bsky.convo.sendMessage", 20789 26604 ChatBskyConvoLeaveConvo: "chat.bsky.convo.leaveConvo", 26605 26605 + ChatBskyConvoAddReaction: "chat.bsky.convo.addReaction", 20790 26606 ChatBskyConvoAcceptConvo: "chat.bsky.convo.acceptConvo", 20791 26607 ChatBskyConvoMuteConvo: "chat.bsky.convo.muteConvo", 20792 26608 ChatBskyConvoDeleteMessageForSelf: "chat.bsky.convo.deleteMessageForSelf", 26609 26609 + ChatBskyConvoRemoveReaction: "chat.bsky.convo.removeReaction", 20793 26610 ChatBskyConvoUpdateRead: "chat.bsky.convo.updateRead", 20794 26611 ChatBskyConvoUpdateAllRead: "chat.bsky.convo.updateAllRead", 20795 26612 ChatBskyConvoGetConvo: "chat.bsky.convo.getConvo", ··· 20878 26695 SoSprkMediaImages: "so.sprk.media.images", 20879 26696 SoSprkMediaVideo: "so.sprk.media.video", 20880 26697 SoSprkMediaImage: "so.sprk.media.image", 26698 26698 + ComAtprotoTempDereferenceScope: "com.atproto.temp.dereferenceScope", 20881 26699 ComAtprotoTempAddReservedHandle: "com.atproto.temp.addReservedHandle", 20882 26700 ComAtprotoTempCheckSignupQueue: "com.atproto.temp.checkSignupQueue", 26701 26701 + ComAtprotoTempCheckHandleAvailability: 26702 26702 + "com.atproto.temp.checkHandleAvailability", 20883 26703 ComAtprotoTempRequestPhoneVerification: 20884 26704 "com.atproto.temp.requestPhoneVerification", 26705 26705 + ComAtprotoTempRevokeAccountCredentials: 26706 26706 + "com.atproto.temp.revokeAccountCredentials", 20885 26707 ComAtprotoTempFetchLabels: "com.atproto.temp.fetchLabels", 20886 26708 ComAtprotoIdentityUpdateHandle: "com.atproto.identity.updateHandle", 26709 26709 + ComAtprotoIdentityDefs: "com.atproto.identity.defs", 20887 26710 ComAtprotoIdentitySignPlcOperation: "com.atproto.identity.signPlcOperation", 20888 26711 ComAtprotoIdentitySubmitPlcOperation: 20889 26712 "com.atproto.identity.submitPlcOperation", 26713 26713 + ComAtprotoIdentityResolveIdentity: "com.atproto.identity.resolveIdentity", 26714 26714 + ComAtprotoIdentityRefreshIdentity: "com.atproto.identity.refreshIdentity", 20890 26715 ComAtprotoIdentityResolveHandle: "com.atproto.identity.resolveHandle", 20891 26716 ComAtprotoIdentityRequestPlcOperationSignature: 20892 26717 "com.atproto.identity.requestPlcOperationSignature", 20893 26718 ComAtprotoIdentityGetRecommendedDidCredentials: 20894 26719 "com.atproto.identity.getRecommendedDidCredentials", 26720 26720 + ComAtprotoIdentityResolveDid: "com.atproto.identity.resolveDid", 20895 26721 ComAtprotoAdminUpdateAccountEmail: "com.atproto.admin.updateAccountEmail", 20896 26722 ComAtprotoAdminGetAccountInfo: "com.atproto.admin.getAccountInfo", 20897 26723 ComAtprotoAdminGetSubjectStatus: "com.atproto.admin.getSubjectStatus", ··· 20901 26727 "com.atproto.admin.updateAccountPassword", 20902 26728 ComAtprotoAdminUpdateAccountHandle: "com.atproto.admin.updateAccountHandle", 20903 26729 ComAtprotoAdminGetInviteCodes: "com.atproto.admin.getInviteCodes", 26730 26730 + ComAtprotoAdminUpdateAccountSigningKey: 26731 26731 + "com.atproto.admin.updateAccountSigningKey", 20904 26732 ComAtprotoAdminEnableAccountInvites: "com.atproto.admin.enableAccountInvites", 20905 26733 ComAtprotoAdminDisableAccountInvites: 20906 26734 "com.atproto.admin.disableAccountInvites", ··· 20942 26770 ComAtprotoServerCreateAccount: "com.atproto.server.createAccount", 20943 26771 ComAtprotoServerDeleteAccount: "com.atproto.server.deleteAccount", 20944 26772 ComAtprotoServerCreateInviteCode: "com.atproto.server.createInviteCode", 26773 26773 + ComAtprotoLexiconResolveLexicon: "com.atproto.lexicon.resolveLexicon", 20945 26774 ComAtprotoLexiconSchema: "com.atproto.lexicon.schema", 20946 26775 ComAtprotoSyncGetHead: "com.atproto.sync.getHead", 20947 26776 ComAtprotoSyncGetBlob: "com.atproto.sync.getBlob", 20948 26777 ComAtprotoSyncGetRepo: "com.atproto.sync.getRepo", 20949 26778 ComAtprotoSyncNotifyOfUpdate: "com.atproto.sync.notifyOfUpdate", 26779 26779 + ComAtprotoSyncDefs: "com.atproto.sync.defs", 20950 26780 ComAtprotoSyncRequestCrawl: "com.atproto.sync.requestCrawl", 20951 26781 ComAtprotoSyncListBlobs: "com.atproto.sync.listBlobs", 20952 26782 ComAtprotoSyncGetLatestCommit: "com.atproto.sync.getLatestCommit", 20953 26783 ComAtprotoSyncSubscribeRepos: "com.atproto.sync.subscribeRepos", 20954 26784 ComAtprotoSyncGetRepoStatus: "com.atproto.sync.getRepoStatus", 20955 26785 ComAtprotoSyncGetRecord: "com.atproto.sync.getRecord", 26786 26786 + ComAtprotoSyncListHosts: "com.atproto.sync.listHosts", 20956 26787 ComAtprotoSyncListRepos: "com.atproto.sync.listRepos", 26788 26788 + ComAtprotoSyncGetHostStatus: "com.atproto.sync.getHostStatus", 20957 26789 ComAtprotoSyncGetBlocks: "com.atproto.sync.getBlocks", 20958 26790 ComAtprotoSyncListReposByCollection: "com.atproto.sync.listReposByCollection", 20959 26791 ComAtprotoSyncGetCheckout: "com.atproto.sync.getCheckout",

+138

lex/types/app/bsky/actor/defs.ts

reviewed

··· 7 7 import type * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs.ts"; 8 8 import type * as AppBskyGraphDefs from "../graph/defs.ts"; 9 9 import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef.ts"; 10 10 + import type * as AppBskyNotificationDefs from "../notification/defs.ts"; 10 11 import type * as AppBskyFeedThreadgate from "../feed/threadgate.ts"; 11 12 import type * as AppBskyFeedPostgate from "../feed/postgate.ts"; 13 13 + import type * as AppBskyEmbedExternal from "../embed/external.ts"; 12 14 13 15 const is$typed = _is$typed, validate = _validate; 14 16 const id = "app.bsky.actor.defs"; ··· 18 20 did: string; 19 21 handle: string; 20 22 displayName?: string; 23 23 + pronouns?: string; 21 24 avatar?: string; 22 25 associated?: ProfileAssociated; 23 26 viewer?: ViewerState; 24 27 labels?: (ComAtprotoLabelDefs.Label)[]; 25 28 createdAt?: string; 29 29 + verification?: VerificationState; 30 30 + status?: StatusView; 31 31 + /** Debug information for internal development */ 32 32 + debug?: { [_ in string]: unknown }; 26 33 } 27 34 28 35 const hashProfileViewBasic = "profileViewBasic"; ··· 40 47 did: string; 41 48 handle: string; 42 49 displayName?: string; 50 50 + pronouns?: string; 43 51 description?: string; 44 52 avatar?: string; 45 53 associated?: ProfileAssociated; ··· 47 55 createdAt?: string; 48 56 viewer?: ViewerState; 49 57 labels?: (ComAtprotoLabelDefs.Label)[]; 58 58 + verification?: VerificationState; 59 59 + status?: StatusView; 60 60 + /** Debug information for internal development */ 61 61 + debug?: { [_ in string]: unknown }; 50 62 } 51 63 52 64 const hashProfileView = "profileView"; ··· 65 77 handle: string; 66 78 displayName?: string; 67 79 description?: string; 80 80 + pronouns?: string; 81 81 + website?: string; 68 82 avatar?: string; 69 83 banner?: string; 70 84 followersCount?: number; ··· 77 91 viewer?: ViewerState; 78 92 labels?: (ComAtprotoLabelDefs.Label)[]; 79 93 pinnedPost?: ComAtprotoRepoStrongRef.Main; 94 94 + verification?: VerificationState; 95 95 + status?: StatusView; 96 96 + /** Debug information for internal development */ 97 97 + debug?: { [_ in string]: unknown }; 80 98 } 81 99 82 100 const hashProfileViewDetailed = "profileViewDetailed"; ··· 96 114 starterPacks?: number; 97 115 labeler?: boolean; 98 116 chat?: ProfileAssociatedChat; 117 117 + activitySubscription?: ProfileAssociatedActivitySubscription; 99 118 } 100 119 101 120 const hashProfileAssociated = "profileAssociated"; ··· 127 146 return validate<ProfileAssociatedChat & V>(v, id, hashProfileAssociatedChat); 128 147 } 129 148 149 149 + export interface ProfileAssociatedActivitySubscription { 150 150 + $type?: "app.bsky.actor.defs#profileAssociatedActivitySubscription"; 151 151 + allowSubscriptions: 152 152 + | "followers" 153 153 + | "mutuals" 154 154 + | "none" 155 155 + | (string & globalThis.Record<PropertyKey, never>); 156 156 + } 157 157 + 158 158 + const hashProfileAssociatedActivitySubscription = 159 159 + "profileAssociatedActivitySubscription"; 160 160 + 161 161 + export function isProfileAssociatedActivitySubscription<V>(v: V) { 162 162 + return is$typed(v, id, hashProfileAssociatedActivitySubscription); 163 163 + } 164 164 + 165 165 + export function validateProfileAssociatedActivitySubscription<V>(v: V) { 166 166 + return validate<ProfileAssociatedActivitySubscription & V>( 167 167 + v, 168 168 + id, 169 169 + hashProfileAssociatedActivitySubscription, 170 170 + ); 171 171 + } 172 172 + 130 173 /** Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests. */ 131 174 export interface ViewerState { 132 175 $type?: "app.bsky.actor.defs#viewerState"; ··· 138 181 following?: string; 139 182 followedBy?: string; 140 183 knownFollowers?: KnownFollowers; 184 184 + activitySubscription?: AppBskyNotificationDefs.ActivitySubscription; 141 185 } 142 186 143 187 const hashViewerState = "viewerState"; ··· 167 211 return validate<KnownFollowers & V>(v, id, hashKnownFollowers); 168 212 } 169 213 214 214 + /** Represents the verification information about the user this object is attached to. */ 215 215 + export interface VerificationState { 216 216 + $type?: "app.bsky.actor.defs#verificationState"; 217 217 + /** All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included. */ 218 218 + verifications: (VerificationView)[]; 219 219 + /** The user's status as a verified account. */ 220 220 + verifiedStatus: 221 221 + | "valid" 222 222 + | "invalid" 223 223 + | "none" 224 224 + | (string & globalThis.Record<PropertyKey, never>); 225 225 + /** The user's status as a trusted verifier. */ 226 226 + trustedVerifierStatus: 227 227 + | "valid" 228 228 + | "invalid" 229 229 + | "none" 230 230 + | (string & globalThis.Record<PropertyKey, never>); 231 231 + } 232 232 + 233 233 + const hashVerificationState = "verificationState"; 234 234 + 235 235 + export function isVerificationState<V>(v: V) { 236 236 + return is$typed(v, id, hashVerificationState); 237 237 + } 238 238 + 239 239 + export function validateVerificationState<V>(v: V) { 240 240 + return validate<VerificationState & V>(v, id, hashVerificationState); 241 241 + } 242 242 + 243 243 + /** An individual verification for an associated subject. */ 244 244 + export interface VerificationView { 245 245 + $type?: "app.bsky.actor.defs#verificationView"; 246 246 + /** The user who issued this verification. */ 247 247 + issuer: string; 248 248 + /** The AT-URI of the verification record. */ 249 249 + uri: string; 250 250 + /** True if the verification passes validation, otherwise false. */ 251 251 + isValid: boolean; 252 252 + /** Timestamp when the verification was created. */ 253 253 + createdAt: string; 254 254 + } 255 255 + 256 256 + const hashVerificationView = "verificationView"; 257 257 + 258 258 + export function isVerificationView<V>(v: V) { 259 259 + return is$typed(v, id, hashVerificationView); 260 260 + } 261 261 + 262 262 + export function validateVerificationView<V>(v: V) { 263 263 + return validate<VerificationView & V>(v, id, hashVerificationView); 264 264 + } 265 265 + 170 266 export type Preferences = ( 171 267 | $Typed<AdultContentPref> 172 268 | $Typed<ContentLabelPref> ··· 181 277 | $Typed<BskyAppStatePref> 182 278 | $Typed<LabelersPref> 183 279 | $Typed<PostInteractionSettingsPref> 280 280 + | $Typed<VerificationPrefs> 184 281 | { $type: string } 185 282 )[]; 186 283 ··· 507 604 return validate<Nux & V>(v, id, hashNux); 508 605 } 509 606 607 607 + /** Preferences for how verified accounts appear in the app. */ 608 608 + export interface VerificationPrefs { 609 609 + $type?: "app.bsky.actor.defs#verificationPrefs"; 610 610 + /** Hide the blue check badges for verified accounts and trusted verifiers. */ 611 611 + hideBadges: boolean; 612 612 + } 613 613 + 614 614 + const hashVerificationPrefs = "verificationPrefs"; 615 615 + 616 616 + export function isVerificationPrefs<V>(v: V) { 617 617 + return is$typed(v, id, hashVerificationPrefs); 618 618 + } 619 619 + 620 620 + export function validateVerificationPrefs<V>(v: V) { 621 621 + return validate<VerificationPrefs & V>(v, id, hashVerificationPrefs); 622 622 + } 623 623 + 510 624 /** Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly. */ 511 625 export interface PostInteractionSettingsPref { 512 626 $type?: "app.bsky.actor.defs#postInteractionSettingsPref"; ··· 536 650 hashPostInteractionSettingsPref, 537 651 ); 538 652 } 653 653 + 654 654 + export interface StatusView { 655 655 + $type?: "app.bsky.actor.defs#statusView"; 656 656 + /** The status for the account. */ 657 657 + status: 658 658 + | "app.bsky.actor.status#live" 659 659 + | (string & globalThis.Record<PropertyKey, never>); 660 660 + record: { [_ in string]: unknown }; 661 661 + embed?: $Typed<AppBskyEmbedExternal.View> | { $type: string }; 662 662 + /** The date when this status will expire. The application might choose to no longer return the status after expiration. */ 663 663 + expiresAt?: string; 664 664 + /** True if the status is not expired, false if it is expired. Only present if expiration was set. */ 665 665 + isActive?: boolean; 666 666 + } 667 667 + 668 668 + const hashStatusView = "statusView"; 669 669 + 670 670 + export function isStatusView<V>(v: V) { 671 671 + return is$typed(v, id, hashStatusView); 672 672 + } 673 673 + 674 674 + export function validateStatusView<V>(v: V) { 675 675 + return validate<StatusView & V>(v, id, hashStatusView); 676 676 + }

+3

lex/types/app/bsky/actor/profile.ts

reviewed

··· 16 16 displayName?: string; 17 17 /** Free-form profile description text. */ 18 18 description?: string; 19 19 + /** Free-form pronouns text. */ 20 20 + pronouns?: string; 21 21 + website?: string; 19 22 /** Small image to be displayed next to posts from account. AKA, 'profile picture' */ 20 23 avatar?: BlobRef; 21 24 /** Larger horizontal image to display behind profile view. */

+36

lex/types/app/bsky/actor/status.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + import type * as AppBskyEmbedExternal from "../embed/external.ts"; 8 8 + 9 9 + const is$typed = _is$typed, validate = _validate; 10 10 + const id = "app.bsky.actor.status"; 11 11 + 12 12 + export interface Record { 13 13 + $type: "app.bsky.actor.status"; 14 14 + /** The status for the account. */ 15 15 + status: 16 16 + | "app.bsky.actor.status#live" 17 17 + | (string & globalThis.Record<PropertyKey, never>); 18 18 + embed?: $Typed<AppBskyEmbedExternal.Main> | { $type: string }; 19 19 + /** The duration of the status in minutes. Applications can choose to impose minimum and maximum limits. */ 20 20 + durationMinutes?: number; 21 21 + createdAt: string; 22 22 + [k: string]: unknown; 23 23 + } 24 24 + 25 25 + const hashRecord = "main"; 26 26 + 27 27 + export function isRecord<V>(v: V) { 28 28 + return is$typed(v, id, hashRecord); 29 29 + } 30 30 + 31 31 + export function validateRecord<V>(v: V) { 32 32 + return validate<Record & V>(v, id, hashRecord, true); 33 33 + } 34 34 + 35 35 + /** Advertises an account as currently offering live content. */ 36 36 + export const LIVE = `${id}#live`;

+42

lex/types/app/bsky/ageassurance/begin.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyAgeassuranceDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** The user's email address to receive Age Assurance instructions. */ 10 10 + email: string; 11 11 + /** The user's preferred language for communication during the Age Assurance process. */ 12 12 + language: string; 13 13 + /** An ISO 3166-1 alpha-2 code of the user's location. */ 14 14 + countryCode: string; 15 15 + /** An optional ISO 3166-2 code of the user's region or state within the country. */ 16 16 + regionCode?: string; 17 17 + } 18 18 + 19 19 + export type OutputSchema = AppBskyAgeassuranceDefs.State; 20 20 + 21 21 + export interface HandlerInput { 22 22 + encoding: "application/json"; 23 23 + body: InputSchema; 24 24 + } 25 25 + 26 26 + export interface HandlerSuccess { 27 27 + encoding: "application/json"; 28 28 + body: OutputSchema; 29 29 + headers?: { [key: string]: string }; 30 30 + } 31 31 + 32 32 + export interface HandlerError { 33 33 + status: number; 34 34 + message?: string; 35 35 + error?: 36 36 + | "InvalidEmail" 37 37 + | "DidTooLong" 38 38 + | "InvalidInitiation" 39 39 + | "RegionNotSupported"; 40 40 + } 41 41 + 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess;

+310

lex/types/app/bsky/ageassurance/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "app.bsky.ageassurance.defs"; 10 10 + 11 11 + /** The access level granted based on Age Assurance data we've processed. */ 12 12 + export type Access = 13 13 + | "unknown" 14 14 + | "none" 15 15 + | "safe" 16 16 + | "full" 17 17 + | (string & globalThis.Record<PropertyKey, never>); 18 18 + /** The status of the Age Assurance process. */ 19 19 + export type Status = 20 20 + | "unknown" 21 21 + | "pending" 22 22 + | "assured" 23 23 + | "blocked" 24 24 + | (string & globalThis.Record<PropertyKey, never>); 25 25 + 26 26 + /** The user's computed Age Assurance state. */ 27 27 + export interface State { 28 28 + $type?: "app.bsky.ageassurance.defs#state"; 29 29 + /** The timestamp when this state was last updated. */ 30 30 + lastInitiatedAt?: string; 31 31 + status: Status; 32 32 + access: Access; 33 33 + } 34 34 + 35 35 + const hashState = "state"; 36 36 + 37 37 + export function isState<V>(v: V) { 38 38 + return is$typed(v, id, hashState); 39 39 + } 40 40 + 41 41 + export function validateState<V>(v: V) { 42 42 + return validate<State & V>(v, id, hashState); 43 43 + } 44 44 + 45 45 + /** Additional metadata needed to compute Age Assurance state client-side. */ 46 46 + export interface StateMetadata { 47 47 + $type?: "app.bsky.ageassurance.defs#stateMetadata"; 48 48 + /** The account creation timestamp. */ 49 49 + accountCreatedAt?: string; 50 50 + } 51 51 + 52 52 + const hashStateMetadata = "stateMetadata"; 53 53 + 54 54 + export function isStateMetadata<V>(v: V) { 55 55 + return is$typed(v, id, hashStateMetadata); 56 56 + } 57 57 + 58 58 + export function validateStateMetadata<V>(v: V) { 59 59 + return validate<StateMetadata & V>(v, id, hashStateMetadata); 60 60 + } 61 61 + 62 62 + export interface Config { 63 63 + $type?: "app.bsky.ageassurance.defs#config"; 64 64 + /** The per-region Age Assurance configuration. */ 65 65 + regions: (ConfigRegion)[]; 66 66 + } 67 67 + 68 68 + const hashConfig = "config"; 69 69 + 70 70 + export function isConfig<V>(v: V) { 71 71 + return is$typed(v, id, hashConfig); 72 72 + } 73 73 + 74 74 + export function validateConfig<V>(v: V) { 75 75 + return validate<Config & V>(v, id, hashConfig); 76 76 + } 77 77 + 78 78 + /** The Age Assurance configuration for a specific region. */ 79 79 + export interface ConfigRegion { 80 80 + $type?: "app.bsky.ageassurance.defs#configRegion"; 81 81 + /** The ISO 3166-1 alpha-2 country code this configuration applies to. */ 82 82 + countryCode: string; 83 83 + /** The ISO 3166-2 region code this configuration applies to. If omitted, the configuration applies to the entire country. */ 84 84 + regionCode?: string; 85 85 + /** The ordered list of Age Assurance rules that apply to this region. Rules should be applied in order, and the first matching rule determines the access level granted. The rules array should always include a default rule as the last item. */ 86 86 + rules: ( 87 87 + | $Typed<ConfigRegionRuleDefault> 88 88 + | $Typed<ConfigRegionRuleIfDeclaredOverAge> 89 89 + | $Typed<ConfigRegionRuleIfDeclaredUnderAge> 90 90 + | $Typed<ConfigRegionRuleIfAssuredOverAge> 91 91 + | $Typed<ConfigRegionRuleIfAssuredUnderAge> 92 92 + | $Typed<ConfigRegionRuleIfAccountNewerThan> 93 93 + | $Typed<ConfigRegionRuleIfAccountOlderThan> 94 94 + | { $type: string } 95 95 + )[]; 96 96 + } 97 97 + 98 98 + const hashConfigRegion = "configRegion"; 99 99 + 100 100 + export function isConfigRegion<V>(v: V) { 101 101 + return is$typed(v, id, hashConfigRegion); 102 102 + } 103 103 + 104 104 + export function validateConfigRegion<V>(v: V) { 105 105 + return validate<ConfigRegion & V>(v, id, hashConfigRegion); 106 106 + } 107 107 + 108 108 + /** Age Assurance rule that applies by default. */ 109 109 + export interface ConfigRegionRuleDefault { 110 110 + $type?: "app.bsky.ageassurance.defs#configRegionRuleDefault"; 111 111 + access: Access; 112 112 + } 113 113 + 114 114 + const hashConfigRegionRuleDefault = "configRegionRuleDefault"; 115 115 + 116 116 + export function isConfigRegionRuleDefault<V>(v: V) { 117 117 + return is$typed(v, id, hashConfigRegionRuleDefault); 118 118 + } 119 119 + 120 120 + export function validateConfigRegionRuleDefault<V>(v: V) { 121 121 + return validate<ConfigRegionRuleDefault & V>( 122 122 + v, 123 123 + id, 124 124 + hashConfigRegionRuleDefault, 125 125 + ); 126 126 + } 127 127 + 128 128 + /** Age Assurance rule that applies if the user has declared themselves equal-to or over a certain age. */ 129 129 + export interface ConfigRegionRuleIfDeclaredOverAge { 130 130 + $type?: "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredOverAge"; 131 131 + /** The age threshold as a whole integer. */ 132 132 + age: number; 133 133 + access: Access; 134 134 + } 135 135 + 136 136 + const hashConfigRegionRuleIfDeclaredOverAge = 137 137 + "configRegionRuleIfDeclaredOverAge"; 138 138 + 139 139 + export function isConfigRegionRuleIfDeclaredOverAge<V>(v: V) { 140 140 + return is$typed(v, id, hashConfigRegionRuleIfDeclaredOverAge); 141 141 + } 142 142 + 143 143 + export function validateConfigRegionRuleIfDeclaredOverAge<V>(v: V) { 144 144 + return validate<ConfigRegionRuleIfDeclaredOverAge & V>( 145 145 + v, 146 146 + id, 147 147 + hashConfigRegionRuleIfDeclaredOverAge, 148 148 + ); 149 149 + } 150 150 + 151 151 + /** Age Assurance rule that applies if the user has declared themselves under a certain age. */ 152 152 + export interface ConfigRegionRuleIfDeclaredUnderAge { 153 153 + $type?: "app.bsky.ageassurance.defs#configRegionRuleIfDeclaredUnderAge"; 154 154 + /** The age threshold as a whole integer. */ 155 155 + age: number; 156 156 + access: Access; 157 157 + } 158 158 + 159 159 + const hashConfigRegionRuleIfDeclaredUnderAge = 160 160 + "configRegionRuleIfDeclaredUnderAge"; 161 161 + 162 162 + export function isConfigRegionRuleIfDeclaredUnderAge<V>(v: V) { 163 163 + return is$typed(v, id, hashConfigRegionRuleIfDeclaredUnderAge); 164 164 + } 165 165 + 166 166 + export function validateConfigRegionRuleIfDeclaredUnderAge<V>(v: V) { 167 167 + return validate<ConfigRegionRuleIfDeclaredUnderAge & V>( 168 168 + v, 169 169 + id, 170 170 + hashConfigRegionRuleIfDeclaredUnderAge, 171 171 + ); 172 172 + } 173 173 + 174 174 + /** Age Assurance rule that applies if the user has been assured to be equal-to or over a certain age. */ 175 175 + export interface ConfigRegionRuleIfAssuredOverAge { 176 176 + $type?: "app.bsky.ageassurance.defs#configRegionRuleIfAssuredOverAge"; 177 177 + /** The age threshold as a whole integer. */ 178 178 + age: number; 179 179 + access: Access; 180 180 + } 181 181 + 182 182 + const hashConfigRegionRuleIfAssuredOverAge = "configRegionRuleIfAssuredOverAge"; 183 183 + 184 184 + export function isConfigRegionRuleIfAssuredOverAge<V>(v: V) { 185 185 + return is$typed(v, id, hashConfigRegionRuleIfAssuredOverAge); 186 186 + } 187 187 + 188 188 + export function validateConfigRegionRuleIfAssuredOverAge<V>(v: V) { 189 189 + return validate<ConfigRegionRuleIfAssuredOverAge & V>( 190 190 + v, 191 191 + id, 192 192 + hashConfigRegionRuleIfAssuredOverAge, 193 193 + ); 194 194 + } 195 195 + 196 196 + /** Age Assurance rule that applies if the user has been assured to be under a certain age. */ 197 197 + export interface ConfigRegionRuleIfAssuredUnderAge { 198 198 + $type?: "app.bsky.ageassurance.defs#configRegionRuleIfAssuredUnderAge"; 199 199 + /** The age threshold as a whole integer. */ 200 200 + age: number; 201 201 + access: Access; 202 202 + } 203 203 + 204 204 + const hashConfigRegionRuleIfAssuredUnderAge = 205 205 + "configRegionRuleIfAssuredUnderAge"; 206 206 + 207 207 + export function isConfigRegionRuleIfAssuredUnderAge<V>(v: V) { 208 208 + return is$typed(v, id, hashConfigRegionRuleIfAssuredUnderAge); 209 209 + } 210 210 + 211 211 + export function validateConfigRegionRuleIfAssuredUnderAge<V>(v: V) { 212 212 + return validate<ConfigRegionRuleIfAssuredUnderAge & V>( 213 213 + v, 214 214 + id, 215 215 + hashConfigRegionRuleIfAssuredUnderAge, 216 216 + ); 217 217 + } 218 218 + 219 219 + /** Age Assurance rule that applies if the account is equal-to or newer than a certain date. */ 220 220 + export interface ConfigRegionRuleIfAccountNewerThan { 221 221 + $type?: "app.bsky.ageassurance.defs#configRegionRuleIfAccountNewerThan"; 222 222 + /** The date threshold as a datetime string. */ 223 223 + date: string; 224 224 + access: Access; 225 225 + } 226 226 + 227 227 + const hashConfigRegionRuleIfAccountNewerThan = 228 228 + "configRegionRuleIfAccountNewerThan"; 229 229 + 230 230 + export function isConfigRegionRuleIfAccountNewerThan<V>(v: V) { 231 231 + return is$typed(v, id, hashConfigRegionRuleIfAccountNewerThan); 232 232 + } 233 233 + 234 234 + export function validateConfigRegionRuleIfAccountNewerThan<V>(v: V) { 235 235 + return validate<ConfigRegionRuleIfAccountNewerThan & V>( 236 236 + v, 237 237 + id, 238 238 + hashConfigRegionRuleIfAccountNewerThan, 239 239 + ); 240 240 + } 241 241 + 242 242 + /** Age Assurance rule that applies if the account is older than a certain date. */ 243 243 + export interface ConfigRegionRuleIfAccountOlderThan { 244 244 + $type?: "app.bsky.ageassurance.defs#configRegionRuleIfAccountOlderThan"; 245 245 + /** The date threshold as a datetime string. */ 246 246 + date: string; 247 247 + access: Access; 248 248 + } 249 249 + 250 250 + const hashConfigRegionRuleIfAccountOlderThan = 251 251 + "configRegionRuleIfAccountOlderThan"; 252 252 + 253 253 + export function isConfigRegionRuleIfAccountOlderThan<V>(v: V) { 254 254 + return is$typed(v, id, hashConfigRegionRuleIfAccountOlderThan); 255 255 + } 256 256 + 257 257 + export function validateConfigRegionRuleIfAccountOlderThan<V>(v: V) { 258 258 + return validate<ConfigRegionRuleIfAccountOlderThan & V>( 259 259 + v, 260 260 + id, 261 261 + hashConfigRegionRuleIfAccountOlderThan, 262 262 + ); 263 263 + } 264 264 + 265 265 + /** Object used to store Age Assurance data in stash. */ 266 266 + export interface Event { 267 267 + $type?: "app.bsky.ageassurance.defs#event"; 268 268 + /** The date and time of this write operation. */ 269 269 + createdAt: string; 270 270 + /** The unique identifier for this instance of the Age Assurance flow, in UUID format. */ 271 271 + attemptId: string; 272 272 + /** The status of the Age Assurance process. */ 273 273 + status: 274 274 + | "unknown" 275 275 + | "pending" 276 276 + | "assured" 277 277 + | "blocked" 278 278 + | (string & globalThis.Record<PropertyKey, never>); 279 279 + /** The access level granted based on Age Assurance data we've processed. */ 280 280 + access: 281 281 + | "unknown" 282 282 + | "none" 283 283 + | "safe" 284 284 + | "full" 285 285 + | (string & globalThis.Record<PropertyKey, never>); 286 286 + /** The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow. */ 287 287 + countryCode: string; 288 288 + /** The ISO 3166-2 region code provided when beginning the Age Assurance flow. */ 289 289 + regionCode?: string; 290 290 + /** The email used for Age Assurance. */ 291 291 + email?: string; 292 292 + /** The IP address used when initiating the Age Assurance flow. */ 293 293 + initIp?: string; 294 294 + /** The user agent used when initiating the Age Assurance flow. */ 295 295 + initUa?: string; 296 296 + /** The IP address used when completing the Age Assurance flow. */ 297 297 + completeIp?: string; 298 298 + /** The user agent used when completing the Age Assurance flow. */ 299 299 + completeUa?: string; 300 300 + } 301 301 + 302 302 + const hashEvent = "event"; 303 303 + 304 304 + export function isEvent<V>(v: V) { 305 305 + return is$typed(v, id, hashEvent); 306 306 + } 307 307 + 308 308 + export function validateEvent<V>(v: V) { 309 309 + return validate<Event & V>(v, id, hashEvent); 310 310 + }

+22

lex/types/app/bsky/ageassurance/getConfig.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyAgeassuranceDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + export type InputSchema = undefined; 8 8 + export type OutputSchema = AppBskyAgeassuranceDefs.Config; 9 9 + export type HandlerInput = void; 10 10 + 11 11 + export interface HandlerSuccess { 12 12 + encoding: "application/json"; 13 13 + body: OutputSchema; 14 14 + headers?: { [key: string]: string }; 15 15 + } 16 16 + 17 17 + export interface HandlerError { 18 18 + status: number; 19 19 + message?: string; 20 20 + } 21 21 + 22 22 + export type HandlerOutput = HandlerError | HandlerSuccess;

+30

lex/types/app/bsky/ageassurance/getState.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyAgeassuranceDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + countryCode: string; 8 8 + regionCode?: string; 9 9 + }; 10 10 + export type InputSchema = undefined; 11 11 + 12 12 + export interface OutputSchema { 13 13 + state: AppBskyAgeassuranceDefs.State; 14 14 + metadata: AppBskyAgeassuranceDefs.StateMetadata; 15 15 + } 16 16 + 17 17 + export type HandlerInput = void; 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + } 29 29 + 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+22

lex/types/app/bsky/bookmark/createBookmark.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 5 5 + 6 6 + export interface InputSchema { 7 7 + uri: string; 8 8 + cid: string; 9 9 + } 10 10 + 11 11 + export interface HandlerInput { 12 12 + encoding: "application/json"; 13 13 + body: InputSchema; 14 14 + } 15 15 + 16 16 + export interface HandlerError { 17 17 + status: number; 18 18 + message?: string; 19 19 + error?: "UnsupportedCollection"; 20 20 + } 21 21 + 22 22 + export type HandlerOutput = HandlerError | void;

+48

lex/types/app/bsky/bookmark/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef.ts"; 8 8 + import type * as AppBskyFeedDefs from "../feed/defs.ts"; 9 9 + 10 10 + const is$typed = _is$typed, validate = _validate; 11 11 + const id = "app.bsky.bookmark.defs"; 12 12 + 13 13 + /** Object used to store bookmark data in stash. */ 14 14 + export interface Bookmark { 15 15 + $type?: "app.bsky.bookmark.defs#bookmark"; 16 16 + subject: ComAtprotoRepoStrongRef.Main; 17 17 + } 18 18 + 19 19 + const hashBookmark = "bookmark"; 20 20 + 21 21 + export function isBookmark<V>(v: V) { 22 22 + return is$typed(v, id, hashBookmark); 23 23 + } 24 24 + 25 25 + export function validateBookmark<V>(v: V) { 26 26 + return validate<Bookmark & V>(v, id, hashBookmark); 27 27 + } 28 28 + 29 29 + export interface BookmarkView { 30 30 + $type?: "app.bsky.bookmark.defs#bookmarkView"; 31 31 + subject: ComAtprotoRepoStrongRef.Main; 32 32 + createdAt?: string; 33 33 + item: 34 34 + | $Typed<AppBskyFeedDefs.BlockedPost> 35 35 + | $Typed<AppBskyFeedDefs.NotFoundPost> 36 36 + | $Typed<AppBskyFeedDefs.PostView> 37 37 + | { $type: string }; 38 38 + } 39 39 + 40 40 + const hashBookmarkView = "bookmarkView"; 41 41 + 42 42 + export function isBookmarkView<V>(v: V) { 43 43 + return is$typed(v, id, hashBookmarkView); 44 44 + } 45 45 + 46 46 + export function validateBookmarkView<V>(v: V) { 47 47 + return validate<BookmarkView & V>(v, id, hashBookmarkView); 48 48 + }

+21

lex/types/app/bsky/bookmark/deleteBookmark.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 5 5 + 6 6 + export interface InputSchema { 7 7 + uri: string; 8 8 + } 9 9 + 10 10 + export interface HandlerInput { 11 11 + encoding: "application/json"; 12 12 + body: InputSchema; 13 13 + } 14 14 + 15 15 + export interface HandlerError { 16 16 + status: number; 17 17 + message?: string; 18 18 + error?: "UnsupportedCollection"; 19 19 + } 20 20 + 21 21 + export type HandlerOutput = HandlerError | void;

+30

lex/types/app/bsky/bookmark/getBookmarks.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyBookmarkDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + limit: number; 8 8 + cursor?: string; 9 9 + }; 10 10 + export type InputSchema = undefined; 11 11 + 12 12 + export interface OutputSchema { 13 13 + cursor?: string; 14 14 + bookmarks: (AppBskyBookmarkDefs.BookmarkView)[]; 15 15 + } 16 16 + 17 17 + export type HandlerInput = void; 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + } 29 29 + 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1

lex/types/app/bsky/embed/video.ts

reviewed

··· 11 11 12 12 export interface Main { 13 13 $type?: "app.bsky.embed.video"; 14 14 + /** The mp4 video file. May be up to 100mb, formerly limited to 50mb. */ 14 15 video: BlobRef; 15 16 captions?: (Caption)[]; 16 17 /** Alt text description of the video, for accessibility. */

+10

lex/types/app/bsky/feed/defs.ts

reviewed

··· 30 30 | $Typed<AppBskyEmbedRecord.View> 31 31 | $Typed<AppBskyEmbedRecordWithMedia.View> 32 32 | { $type: string }; 33 33 + bookmarkCount?: number; 33 34 replyCount?: number; 34 35 repostCount?: number; 35 36 likeCount?: number; ··· 38 39 viewer?: ViewerState; 39 40 labels?: (ComAtprotoLabelDefs.Label)[]; 40 41 threadgate?: ThreadgateView; 42 42 + /** Debug information for internal development */ 43 43 + debug?: { [_ in string]: unknown }; 41 44 } 42 45 43 46 const hashPostView = "postView"; ··· 55 58 $type?: "app.bsky.feed.defs#viewerState"; 56 59 repost?: string; 57 60 like?: string; 61 61 + bookmarked?: boolean; 58 62 threadMuted?: boolean; 59 63 replyDisabled?: boolean; 60 64 embeddingDisabled?: boolean; ··· 94 98 reason?: $Typed<ReasonRepost> | $Typed<ReasonPin> | { $type: string }; 95 99 /** Context provided by feed generator that may be passed back alongside interactions. */ 96 100 feedContext?: string; 101 101 + /** Unique identifier per request that may be passed back alongside interactions. */ 102 102 + reqId?: string; 97 103 } 98 104 99 105 const hashFeedViewPost = "feedViewPost"; ··· 130 136 export interface ReasonRepost { 131 137 $type?: "app.bsky.feed.defs#reasonRepost"; 132 138 by: AppBskyActorDefs.ProfileViewBasic; 139 139 + uri?: string; 140 140 + cid?: string; 133 141 indexedAt: string; 134 142 } 135 143 ··· 363 371 | (string & globalThis.Record<PropertyKey, never>); 364 372 /** Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton. */ 365 373 feedContext?: string; 374 374 + /** Unique identifier per request that may be passed back alongside interactions. */ 375 375 + reqId?: string; 366 376 } 367 377 368 378 const hashInteraction = "interaction";

+2

lex/types/app/bsky/feed/getFeedSkeleton.ts

reviewed

··· 14 14 export interface OutputSchema { 15 15 cursor?: string; 16 16 feed: (AppBskyFeedDefs.SkeletonFeedPost)[]; 17 17 + /** Unique identifier per request that may be passed back alongside interactions. */ 18 18 + reqId?: string; 17 19 } 18 20 19 21 export type HandlerInput = void;

+2

lex/types/app/bsky/graph/follow.ts

reviewed

··· 3 3 */ 4 4 import { validate as _validate } from "../../../../lexicons.ts"; 5 5 import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef.ts"; 6 7 7 8 const is$typed = _is$typed, validate = _validate; 8 9 const id = "app.bsky.graph.follow"; ··· 11 12 $type: "app.bsky.graph.follow"; 12 13 subject: string; 13 14 createdAt: string; 15 15 + via?: ComAtprotoRepoStrongRef.Main; 14 16 [k: string]: unknown; 15 17 } 16 18

+5

lex/types/app/bsky/graph/getLists.ts

reviewed

··· 8 8 actor: string; 9 9 limit: number; 10 10 cursor?: string; 11 11 + /** Optional filter by list purpose. If not specified, all supported types are returned. */ 12 12 + purposes?: 13 13 + | "modlist" 14 14 + | "curatelist" 15 15 + | (string & globalThis.Record<PropertyKey, never>)[]; 11 16 }; 12 17 export type InputSchema = undefined; 13 18

+59

lex/types/app/bsky/graph/getListsWithMembership.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import type * as AppBskyGraphDefs from "./defs.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "app.bsky.graph.getListsWithMembership"; 10 10 + 11 11 + export type QueryParams = { 12 12 + /** The account (actor) to check for membership. */ 13 13 + actor: string; 14 14 + limit: number; 15 15 + cursor?: string; 16 16 + /** Optional filter by list purpose. If not specified, all supported types are returned. */ 17 17 + purposes?: 18 18 + | "modlist" 19 19 + | "curatelist" 20 20 + | (string & globalThis.Record<PropertyKey, never>)[]; 21 21 + }; 22 22 + export type InputSchema = undefined; 23 23 + 24 24 + export interface OutputSchema { 25 25 + cursor?: string; 26 26 + listsWithMembership: (ListWithMembership)[]; 27 27 + } 28 28 + 29 29 + export type HandlerInput = void; 30 30 + 31 31 + export interface HandlerSuccess { 32 32 + encoding: "application/json"; 33 33 + body: OutputSchema; 34 34 + headers?: { [key: string]: string }; 35 35 + } 36 36 + 37 37 + export interface HandlerError { 38 38 + status: number; 39 39 + message?: string; 40 40 + } 41 41 + 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess; 43 43 + 44 44 + /** A list and an optional list item indicating membership of a target user to that list. */ 45 45 + export interface ListWithMembership { 46 46 + $type?: "app.bsky.graph.getListsWithMembership#listWithMembership"; 47 47 + list: AppBskyGraphDefs.ListView; 48 48 + listItem?: AppBskyGraphDefs.ListItemView; 49 49 + } 50 50 + 51 51 + const hashListWithMembership = "listWithMembership"; 52 52 + 53 53 + export function isListWithMembership<V>(v: V) { 54 54 + return is$typed(v, id, hashListWithMembership); 55 55 + } 56 56 + 57 57 + export function validateListWithMembership<V>(v: V) { 58 58 + return validate<ListWithMembership & V>(v, id, hashListWithMembership); 59 59 + }

+59

lex/types/app/bsky/graph/getStarterPacksWithMembership.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import type * as AppBskyGraphDefs from "./defs.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "app.bsky.graph.getStarterPacksWithMembership"; 10 10 + 11 11 + export type QueryParams = { 12 12 + /** The account (actor) to check for membership. */ 13 13 + actor: string; 14 14 + limit: number; 15 15 + cursor?: string; 16 16 + }; 17 17 + export type InputSchema = undefined; 18 18 + 19 19 + export interface OutputSchema { 20 20 + cursor?: string; 21 21 + starterPacksWithMembership: (StarterPackWithMembership)[]; 22 22 + } 23 23 + 24 24 + export type HandlerInput = void; 25 25 + 26 26 + export interface HandlerSuccess { 27 27 + encoding: "application/json"; 28 28 + body: OutputSchema; 29 29 + headers?: { [key: string]: string }; 30 30 + } 31 31 + 32 32 + export interface HandlerError { 33 33 + status: number; 34 34 + message?: string; 35 35 + } 36 36 + 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess; 38 38 + 39 39 + /** A starter pack and an optional list item indicating membership of a target user to that starter pack. */ 40 40 + export interface StarterPackWithMembership { 41 41 + $type?: 42 42 + "app.bsky.graph.getStarterPacksWithMembership#starterPackWithMembership"; 43 43 + starterPack: AppBskyGraphDefs.StarterPackView; 44 44 + listItem?: AppBskyGraphDefs.ListItemView; 45 45 + } 46 46 + 47 47 + const hashStarterPackWithMembership = "starterPackWithMembership"; 48 48 + 49 49 + export function isStarterPackWithMembership<V>(v: V) { 50 50 + return is$typed(v, id, hashStarterPackWithMembership); 51 51 + } 52 52 + 53 53 + export function validateStarterPackWithMembership<V>(v: V) { 54 54 + return validate<StarterPackWithMembership & V>( 55 55 + v, 56 56 + id, 57 57 + hashStarterPackWithMembership, 58 58 + ); 59 59 + }

+31

lex/types/app/bsky/graph/verification.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "app.bsky.graph.verification"; 9 9 + 10 10 + export interface Record { 11 11 + $type: "app.bsky.graph.verification"; 12 12 + /** DID of the subject the verification applies to. */ 13 13 + subject: string; 14 14 + /** Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying. */ 15 15 + handle: string; 16 16 + /** Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying. */ 17 17 + displayName: string; 18 18 + /** Date of when the verification was created. */ 19 19 + createdAt: string; 20 20 + [k: string]: unknown; 21 21 + } 22 22 + 23 23 + const hashRecord = "main"; 24 24 + 25 25 + export function isRecord<V>(v: V) { 26 26 + return is$typed(v, id, hashRecord); 27 27 + } 28 28 + 29 29 + export function validateRecord<V>(v: V) { 30 30 + return validate<Record & V>(v, id, hashRecord, true); 31 31 + }

+29

lex/types/app/bsky/notification/declaration.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "app.bsky.notification.declaration"; 9 9 + 10 10 + export interface Record { 11 11 + $type: "app.bsky.notification.declaration"; 12 12 + /** A declaration of the user's preference for allowing activity subscriptions from other users. Absence of a record implies 'followers'. */ 13 13 + allowSubscriptions: 14 14 + | "followers" 15 15 + | "mutuals" 16 16 + | "none" 17 17 + | (string & globalThis.Record<PropertyKey, never>); 18 18 + [k: string]: unknown; 19 19 + } 20 20 + 21 21 + const hashRecord = "main"; 22 22 + 23 23 + export function isRecord<V>(v: V) { 24 24 + return is$typed(v, id, hashRecord); 25 25 + } 26 26 + 27 27 + export function validateRecord<V>(v: V) { 28 28 + return validate<Record & V>(v, id, hashRecord, true); 29 29 + }

+138

lex/types/app/bsky/notification/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "app.bsky.notification.defs"; 9 9 + 10 10 + export interface RecordDeleted { 11 11 + $type?: "app.bsky.notification.defs#recordDeleted"; 12 12 + } 13 13 + 14 14 + const hashRecordDeleted = "recordDeleted"; 15 15 + 16 16 + export function isRecordDeleted<V>(v: V) { 17 17 + return is$typed(v, id, hashRecordDeleted); 18 18 + } 19 19 + 20 20 + export function validateRecordDeleted<V>(v: V) { 21 21 + return validate<RecordDeleted & V>(v, id, hashRecordDeleted); 22 22 + } 23 23 + 24 24 + export interface ChatPreference { 25 25 + $type?: "app.bsky.notification.defs#chatPreference"; 26 26 + include: 27 27 + | "all" 28 28 + | "accepted" 29 29 + | (string & globalThis.Record<PropertyKey, never>); 30 30 + push: boolean; 31 31 + } 32 32 + 33 33 + const hashChatPreference = "chatPreference"; 34 34 + 35 35 + export function isChatPreference<V>(v: V) { 36 36 + return is$typed(v, id, hashChatPreference); 37 37 + } 38 38 + 39 39 + export function validateChatPreference<V>(v: V) { 40 40 + return validate<ChatPreference & V>(v, id, hashChatPreference); 41 41 + } 42 42 + 43 43 + export interface FilterablePreference { 44 44 + $type?: "app.bsky.notification.defs#filterablePreference"; 45 45 + include: "all" | "follows" | (string & globalThis.Record<PropertyKey, never>); 46 46 + list: boolean; 47 47 + push: boolean; 48 48 + } 49 49 + 50 50 + const hashFilterablePreference = "filterablePreference"; 51 51 + 52 52 + export function isFilterablePreference<V>(v: V) { 53 53 + return is$typed(v, id, hashFilterablePreference); 54 54 + } 55 55 + 56 56 + export function validateFilterablePreference<V>(v: V) { 57 57 + return validate<FilterablePreference & V>(v, id, hashFilterablePreference); 58 58 + } 59 59 + 60 60 + export interface Preference { 61 61 + $type?: "app.bsky.notification.defs#preference"; 62 62 + list: boolean; 63 63 + push: boolean; 64 64 + } 65 65 + 66 66 + const hashPreference = "preference"; 67 67 + 68 68 + export function isPreference<V>(v: V) { 69 69 + return is$typed(v, id, hashPreference); 70 70 + } 71 71 + 72 72 + export function validatePreference<V>(v: V) { 73 73 + return validate<Preference & V>(v, id, hashPreference); 74 74 + } 75 75 + 76 76 + export interface Preferences { 77 77 + $type?: "app.bsky.notification.defs#preferences"; 78 78 + chat: ChatPreference; 79 79 + follow: FilterablePreference; 80 80 + like: FilterablePreference; 81 81 + likeViaRepost: FilterablePreference; 82 82 + mention: FilterablePreference; 83 83 + quote: FilterablePreference; 84 84 + reply: FilterablePreference; 85 85 + repost: FilterablePreference; 86 86 + repostViaRepost: FilterablePreference; 87 87 + starterpackJoined: Preference; 88 88 + subscribedPost: Preference; 89 89 + unverified: Preference; 90 90 + verified: Preference; 91 91 + } 92 92 + 93 93 + const hashPreferences = "preferences"; 94 94 + 95 95 + export function isPreferences<V>(v: V) { 96 96 + return is$typed(v, id, hashPreferences); 97 97 + } 98 98 + 99 99 + export function validatePreferences<V>(v: V) { 100 100 + return validate<Preferences & V>(v, id, hashPreferences); 101 101 + } 102 102 + 103 103 + export interface ActivitySubscription { 104 104 + $type?: "app.bsky.notification.defs#activitySubscription"; 105 105 + post: boolean; 106 106 + reply: boolean; 107 107 + } 108 108 + 109 109 + const hashActivitySubscription = "activitySubscription"; 110 110 + 111 111 + export function isActivitySubscription<V>(v: V) { 112 112 + return is$typed(v, id, hashActivitySubscription); 113 113 + } 114 114 + 115 115 + export function validateActivitySubscription<V>(v: V) { 116 116 + return validate<ActivitySubscription & V>(v, id, hashActivitySubscription); 117 117 + } 118 118 + 119 119 + /** Object used to store activity subscription data in stash. */ 120 120 + export interface SubjectActivitySubscription { 121 121 + $type?: "app.bsky.notification.defs#subjectActivitySubscription"; 122 122 + subject: string; 123 123 + activitySubscription: ActivitySubscription; 124 124 + } 125 125 + 126 126 + const hashSubjectActivitySubscription = "subjectActivitySubscription"; 127 127 + 128 128 + export function isSubjectActivitySubscription<V>(v: V) { 129 129 + return is$typed(v, id, hashSubjectActivitySubscription); 130 130 + } 131 131 + 132 132 + export function validateSubjectActivitySubscription<V>(v: V) { 133 133 + return validate<SubjectActivitySubscription & V>( 134 134 + v, 135 135 + id, 136 136 + hashSubjectActivitySubscription, 137 137 + ); 138 138 + }

+26

lex/types/app/bsky/notification/getPreferences.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyNotificationDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + export type InputSchema = undefined; 8 8 + 9 9 + export interface OutputSchema { 10 10 + preferences: AppBskyNotificationDefs.Preferences; 11 11 + } 12 12 + 13 13 + export type HandlerInput = void; 14 14 + 15 15 + export interface HandlerSuccess { 16 16 + encoding: "application/json"; 17 17 + body: OutputSchema; 18 18 + headers?: { [key: string]: string }; 19 19 + } 20 20 + 21 21 + export interface HandlerError { 22 22 + status: number; 23 23 + message?: string; 24 24 + } 25 25 + 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+30

lex/types/app/bsky/notification/listActivitySubscriptions.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyActorDefs from "../actor/defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + limit: number; 8 8 + cursor?: string; 9 9 + }; 10 10 + export type InputSchema = undefined; 11 11 + 12 12 + export interface OutputSchema { 13 13 + cursor?: string; 14 14 + subscriptions: (AppBskyActorDefs.ProfileView)[]; 15 15 + } 16 16 + 17 17 + export type HandlerInput = void; 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + } 29 29 + 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+6 -1

lex/types/app/bsky/notification/listNotifications.ts

reviewed

··· 46 46 uri: string; 47 47 cid: string; 48 48 author: AppBskyActorDefs.ProfileView; 49 49 - /** Expected values are 'like', 'repost', 'follow', 'mention', 'reply', 'quote', and 'starterpack-joined'. */ 49 49 + /** The reason why this notification was delivered - e.g. your post was liked, or you received a new follower. */ 50 50 reason: 51 51 | "like" 52 52 | "repost" ··· 55 55 | "reply" 56 56 | "quote" 57 57 | "starterpack-joined" 58 58 + | "verified" 59 59 + | "unverified" 60 60 + | "like-via-repost" 61 61 + | "repost-via-repost" 62 62 + | "subscribed-post" 58 63 | (string & globalThis.Record<PropertyKey, never>); 59 64 reasonSubject?: string; 60 65 record: { [_ in string]: unknown };

+34

lex/types/app/bsky/notification/putActivitySubscription.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyNotificationDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + subject: string; 10 10 + activitySubscription: AppBskyNotificationDefs.ActivitySubscription; 11 11 + } 12 12 + 13 13 + export interface OutputSchema { 14 14 + subject: string; 15 15 + activitySubscription?: AppBskyNotificationDefs.ActivitySubscription; 16 16 + } 17 17 + 18 18 + export interface HandlerInput { 19 19 + encoding: "application/json"; 20 20 + body: InputSchema; 21 21 + } 22 22 + 23 23 + export interface HandlerSuccess { 24 24 + encoding: "application/json"; 25 25 + body: OutputSchema; 26 26 + headers?: { [key: string]: string }; 27 27 + } 28 28 + 29 29 + export interface HandlerError { 30 30 + status: number; 31 31 + message?: string; 32 32 + } 33 33 + 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+44

lex/types/app/bsky/notification/putPreferencesV2.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyNotificationDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + chat?: AppBskyNotificationDefs.ChatPreference; 10 10 + follow?: AppBskyNotificationDefs.FilterablePreference; 11 11 + like?: AppBskyNotificationDefs.FilterablePreference; 12 12 + likeViaRepost?: AppBskyNotificationDefs.FilterablePreference; 13 13 + mention?: AppBskyNotificationDefs.FilterablePreference; 14 14 + quote?: AppBskyNotificationDefs.FilterablePreference; 15 15 + reply?: AppBskyNotificationDefs.FilterablePreference; 16 16 + repost?: AppBskyNotificationDefs.FilterablePreference; 17 17 + repostViaRepost?: AppBskyNotificationDefs.FilterablePreference; 18 18 + starterpackJoined?: AppBskyNotificationDefs.Preference; 19 19 + subscribedPost?: AppBskyNotificationDefs.Preference; 20 20 + unverified?: AppBskyNotificationDefs.Preference; 21 21 + verified?: AppBskyNotificationDefs.Preference; 22 22 + } 23 23 + 24 24 + export interface OutputSchema { 25 25 + preferences: AppBskyNotificationDefs.Preferences; 26 26 + } 27 27 + 28 28 + export interface HandlerInput { 29 29 + encoding: "application/json"; 30 30 + body: InputSchema; 31 31 + } 32 32 + 33 33 + export interface HandlerSuccess { 34 34 + encoding: "application/json"; 35 35 + body: OutputSchema; 36 36 + headers?: { [key: string]: string }; 37 37 + } 38 38 + 39 39 + export interface HandlerError { 40 40 + status: number; 41 41 + message?: string; 42 42 + } 43 43 + 44 44 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2

lex/types/app/bsky/notification/registerPush.ts

reviewed

··· 12 12 | "web" 13 13 | (string & globalThis.Record<PropertyKey, never>); 14 14 appId: string; 15 15 + /** Set to true when the actor is age restricted */ 16 16 + ageRestricted?: boolean; 15 17 } 16 18 17 19 export interface HandlerInput {

+27

lex/types/app/bsky/notification/unregisterPush.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 5 5 + 6 6 + export interface InputSchema { 7 7 + serviceDid: string; 8 8 + token: string; 9 9 + platform: 10 10 + | "ios" 11 11 + | "android" 12 12 + | "web" 13 13 + | (string & globalThis.Record<PropertyKey, never>); 14 14 + appId: string; 15 15 + } 16 16 + 17 17 + export interface HandlerInput { 18 18 + encoding: "application/json"; 19 19 + body: InputSchema; 20 20 + } 21 21 + 22 22 + export interface HandlerError { 23 23 + status: number; 24 24 + message?: string; 25 25 + } 26 26 + 27 27 + export type HandlerOutput = HandlerError | void;

+177

lex/types/app/bsky/unspecced/defs.ts

reviewed

··· 3 3 */ 4 4 import { validate as _validate } from "../../../../lexicons.ts"; 5 5 import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import type * as AppBskyActorDefs from "../actor/defs.ts"; 7 7 + import type * as AppBskyFeedDefs from "../feed/defs.ts"; 6 8 7 9 const is$typed = _is$typed, validate = _validate; 8 10 const id = "app.bsky.unspecced.defs"; ··· 73 75 export function validateTrendingTopic<V>(v: V) { 74 76 return validate<TrendingTopic & V>(v, id, hashTrendingTopic); 75 77 } 78 78 + 79 79 + export interface SkeletonTrend { 80 80 + $type?: "app.bsky.unspecced.defs#skeletonTrend"; 81 81 + topic: string; 82 82 + displayName: string; 83 83 + link: string; 84 84 + startedAt: string; 85 85 + postCount: number; 86 86 + status?: "hot" | (string & globalThis.Record<PropertyKey, never>); 87 87 + category?: string; 88 88 + dids: (string)[]; 89 89 + } 90 90 + 91 91 + const hashSkeletonTrend = "skeletonTrend"; 92 92 + 93 93 + export function isSkeletonTrend<V>(v: V) { 94 94 + return is$typed(v, id, hashSkeletonTrend); 95 95 + } 96 96 + 97 97 + export function validateSkeletonTrend<V>(v: V) { 98 98 + return validate<SkeletonTrend & V>(v, id, hashSkeletonTrend); 99 99 + } 100 100 + 101 101 + export interface TrendView { 102 102 + $type?: "app.bsky.unspecced.defs#trendView"; 103 103 + topic: string; 104 104 + displayName: string; 105 105 + link: string; 106 106 + startedAt: string; 107 107 + postCount: number; 108 108 + status?: "hot" | (string & globalThis.Record<PropertyKey, never>); 109 109 + category?: string; 110 110 + actors: (AppBskyActorDefs.ProfileViewBasic)[]; 111 111 + } 112 112 + 113 113 + const hashTrendView = "trendView"; 114 114 + 115 115 + export function isTrendView<V>(v: V) { 116 116 + return is$typed(v, id, hashTrendView); 117 117 + } 118 118 + 119 119 + export function validateTrendView<V>(v: V) { 120 120 + return validate<TrendView & V>(v, id, hashTrendView); 121 121 + } 122 122 + 123 123 + export interface ThreadItemPost { 124 124 + $type?: "app.bsky.unspecced.defs#threadItemPost"; 125 125 + post: AppBskyFeedDefs.PostView; 126 126 + /** This post has more parents that were not present in the response. This is just a boolean, without the number of parents. */ 127 127 + moreParents: boolean; 128 128 + /** This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate. */ 129 129 + moreReplies: number; 130 130 + /** This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread. */ 131 131 + opThread: boolean; 132 132 + /** The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread. */ 133 133 + hiddenByThreadgate: boolean; 134 134 + /** This is by an account muted by the viewer requesting it. */ 135 135 + mutedByViewer: boolean; 136 136 + } 137 137 + 138 138 + const hashThreadItemPost = "threadItemPost"; 139 139 + 140 140 + export function isThreadItemPost<V>(v: V) { 141 141 + return is$typed(v, id, hashThreadItemPost); 142 142 + } 143 143 + 144 144 + export function validateThreadItemPost<V>(v: V) { 145 145 + return validate<ThreadItemPost & V>(v, id, hashThreadItemPost); 146 146 + } 147 147 + 148 148 + export interface ThreadItemNoUnauthenticated { 149 149 + $type?: "app.bsky.unspecced.defs#threadItemNoUnauthenticated"; 150 150 + } 151 151 + 152 152 + const hashThreadItemNoUnauthenticated = "threadItemNoUnauthenticated"; 153 153 + 154 154 + export function isThreadItemNoUnauthenticated<V>(v: V) { 155 155 + return is$typed(v, id, hashThreadItemNoUnauthenticated); 156 156 + } 157 157 + 158 158 + export function validateThreadItemNoUnauthenticated<V>(v: V) { 159 159 + return validate<ThreadItemNoUnauthenticated & V>( 160 160 + v, 161 161 + id, 162 162 + hashThreadItemNoUnauthenticated, 163 163 + ); 164 164 + } 165 165 + 166 166 + export interface ThreadItemNotFound { 167 167 + $type?: "app.bsky.unspecced.defs#threadItemNotFound"; 168 168 + } 169 169 + 170 170 + const hashThreadItemNotFound = "threadItemNotFound"; 171 171 + 172 172 + export function isThreadItemNotFound<V>(v: V) { 173 173 + return is$typed(v, id, hashThreadItemNotFound); 174 174 + } 175 175 + 176 176 + export function validateThreadItemNotFound<V>(v: V) { 177 177 + return validate<ThreadItemNotFound & V>(v, id, hashThreadItemNotFound); 178 178 + } 179 179 + 180 180 + export interface ThreadItemBlocked { 181 181 + $type?: "app.bsky.unspecced.defs#threadItemBlocked"; 182 182 + author: AppBskyFeedDefs.BlockedAuthor; 183 183 + } 184 184 + 185 185 + const hashThreadItemBlocked = "threadItemBlocked"; 186 186 + 187 187 + export function isThreadItemBlocked<V>(v: V) { 188 188 + return is$typed(v, id, hashThreadItemBlocked); 189 189 + } 190 190 + 191 191 + export function validateThreadItemBlocked<V>(v: V) { 192 192 + return validate<ThreadItemBlocked & V>(v, id, hashThreadItemBlocked); 193 193 + } 194 194 + 195 195 + /** The computed state of the age assurance process, returned to the user in question on certain authenticated requests. */ 196 196 + export interface AgeAssuranceState { 197 197 + $type?: "app.bsky.unspecced.defs#ageAssuranceState"; 198 198 + /** The timestamp when this state was last updated. */ 199 199 + lastInitiatedAt?: string; 200 200 + /** The status of the age assurance process. */ 201 201 + status: 202 202 + | "unknown" 203 203 + | "pending" 204 204 + | "assured" 205 205 + | "blocked" 206 206 + | (string & globalThis.Record<PropertyKey, never>); 207 207 + } 208 208 + 209 209 + const hashAgeAssuranceState = "ageAssuranceState"; 210 210 + 211 211 + export function isAgeAssuranceState<V>(v: V) { 212 212 + return is$typed(v, id, hashAgeAssuranceState); 213 213 + } 214 214 + 215 215 + export function validateAgeAssuranceState<V>(v: V) { 216 216 + return validate<AgeAssuranceState & V>(v, id, hashAgeAssuranceState); 217 217 + } 218 218 + 219 219 + /** Object used to store age assurance data in stash. */ 220 220 + export interface AgeAssuranceEvent { 221 221 + $type?: "app.bsky.unspecced.defs#ageAssuranceEvent"; 222 222 + /** The date and time of this write operation. */ 223 223 + createdAt: string; 224 224 + /** The status of the age assurance process. */ 225 225 + status: 226 226 + | "unknown" 227 227 + | "pending" 228 228 + | "assured" 229 229 + | (string & globalThis.Record<PropertyKey, never>); 230 230 + /** The unique identifier for this instance of the age assurance flow, in UUID format. */ 231 231 + attemptId: string; 232 232 + /** The email used for AA. */ 233 233 + email?: string; 234 234 + /** The IP address used when initiating the AA flow. */ 235 235 + initIp?: string; 236 236 + /** The user agent used when initiating the AA flow. */ 237 237 + initUa?: string; 238 238 + /** The IP address used when completing the AA flow. */ 239 239 + completeIp?: string; 240 240 + /** The user agent used when completing the AA flow. */ 241 241 + completeUa?: string; 242 242 + } 243 243 + 244 244 + const hashAgeAssuranceEvent = "ageAssuranceEvent"; 245 245 + 246 246 + export function isAgeAssuranceEvent<V>(v: V) { 247 247 + return is$typed(v, id, hashAgeAssuranceEvent); 248 248 + } 249 249 + 250 250 + export function validateAgeAssuranceEvent<V>(v: V) { 251 251 + return validate<AgeAssuranceEvent & V>(v, id, hashAgeAssuranceEvent); 252 252 + }

+22

lex/types/app/bsky/unspecced/getAgeAssuranceState.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyUnspeccedDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + export type InputSchema = undefined; 8 8 + export type OutputSchema = AppBskyUnspeccedDefs.AgeAssuranceState; 9 9 + export type HandlerInput = void; 10 10 + 11 11 + export interface HandlerSuccess { 12 12 + encoding: "application/json"; 13 13 + body: OutputSchema; 14 14 + headers?: { [key: string]: string }; 15 15 + } 16 16 + 17 17 + export interface HandlerError { 18 18 + status: number; 19 19 + message?: string; 20 20 + } 21 21 + 22 22 + export type HandlerOutput = HandlerError | HandlerSuccess;

+23

lex/types/app/bsky/unspecced/getConfig.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "app.bsky.unspecced.getConfig"; 9 9 + 4 10 export type QueryParams = globalThis.Record<PropertyKey, never>; 5 11 export type InputSchema = undefined; 6 12 7 13 export interface OutputSchema { 8 14 checkEmailConfirmed?: boolean; 15 15 + liveNow?: (LiveNowConfig)[]; 9 16 } 10 17 11 18 export type HandlerInput = void; ··· 22 29 } 23 30 24 31 export type HandlerOutput = HandlerError | HandlerSuccess; 32 32 + 33 33 + export interface LiveNowConfig { 34 34 + $type?: "app.bsky.unspecced.getConfig#liveNowConfig"; 35 35 + did: string; 36 36 + domains: (string)[]; 37 37 + } 38 38 + 39 39 + const hashLiveNowConfig = "liveNowConfig"; 40 40 + 41 41 + export function isLiveNowConfig<V>(v: V) { 42 42 + return is$typed(v, id, hashLiveNowConfig); 43 43 + } 44 44 + 45 45 + export function validateLiveNowConfig<V>(v: V) { 46 46 + return validate<LiveNowConfig & V>(v, id, hashLiveNowConfig); 47 47 + }

+28

lex/types/app/bsky/unspecced/getOnboardingSuggestedStarterPacks.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyGraphDefs from "../graph/defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + starterPacks: (AppBskyGraphDefs.StarterPackView)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+28

lex/types/app/bsky/unspecced/getOnboardingSuggestedStarterPacksSkeleton.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = { 5 5 + /** DID of the account making the request (not included for public/unauthenticated queries). */ 6 6 + viewer?: string; 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + starterPacks: (string)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+54

lex/types/app/bsky/unspecced/getPostThreadOtherV2.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + import type * as AppBskyUnspeccedDefs from "./defs.ts"; 8 8 + 9 9 + const is$typed = _is$typed, validate = _validate; 10 10 + const id = "app.bsky.unspecced.getPostThreadOtherV2"; 11 11 + 12 12 + export type QueryParams = { 13 13 + /** Reference (AT-URI) to post record. This is the anchor post. */ 14 14 + anchor: string; 15 15 + }; 16 16 + export type InputSchema = undefined; 17 17 + 18 18 + export interface OutputSchema { 19 19 + /** A flat list of other thread items. The depth of each item is indicated by the depth property inside the item. */ 20 20 + thread: (ThreadItem)[]; 21 21 + } 22 22 + 23 23 + export type HandlerInput = void; 24 24 + 25 25 + export interface HandlerSuccess { 26 26 + encoding: "application/json"; 27 27 + body: OutputSchema; 28 28 + headers?: { [key: string]: string }; 29 29 + } 30 30 + 31 31 + export interface HandlerError { 32 32 + status: number; 33 33 + message?: string; 34 34 + } 35 35 + 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess; 37 37 + 38 38 + export interface ThreadItem { 39 39 + $type?: "app.bsky.unspecced.getPostThreadOtherV2#threadItem"; 40 40 + uri: string; 41 41 + /** The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths. */ 42 42 + depth: number; 43 43 + value: $Typed<AppBskyUnspeccedDefs.ThreadItemPost> | { $type: string }; 44 44 + } 45 45 + 46 46 + const hashThreadItem = "threadItem"; 47 47 + 48 48 + export function isThreadItem<V>(v: V) { 49 49 + return is$typed(v, id, hashThreadItem); 50 50 + } 51 51 + 52 52 + export function validateThreadItem<V>(v: V) { 53 53 + return validate<ThreadItem & V>(v, id, hashThreadItem); 54 54 + }

+75

lex/types/app/bsky/unspecced/getPostThreadV2.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + import type * as AppBskyFeedDefs from "../feed/defs.ts"; 8 8 + import type * as AppBskyUnspeccedDefs from "./defs.ts"; 9 9 + 10 10 + const is$typed = _is$typed, validate = _validate; 11 11 + const id = "app.bsky.unspecced.getPostThreadV2"; 12 12 + 13 13 + export type QueryParams = { 14 14 + /** Reference (AT-URI) to post record. This is the anchor post, and the thread will be built around it. It can be any post in the tree, not necessarily a root post. */ 15 15 + anchor: string; 16 16 + /** Whether to include parents above the anchor. */ 17 17 + above: boolean; 18 18 + /** How many levels of replies to include below the anchor. */ 19 19 + below: number; 20 20 + /** Maximum of replies to include at each level of the thread, except for the direct replies to the anchor, which are (NOTE: currently, during unspecced phase) all returned (NOTE: later they might be paginated). */ 21 21 + branchingFactor: number; 22 22 + /** Sorting for the thread replies. */ 23 23 + sort: 24 24 + | "newest" 25 25 + | "oldest" 26 26 + | "top" 27 27 + | (string & globalThis.Record<PropertyKey, never>); 28 28 + }; 29 29 + export type InputSchema = undefined; 30 30 + 31 31 + export interface OutputSchema { 32 32 + /** A flat list of thread items. The depth of each item is indicated by the depth property inside the item. */ 33 33 + thread: (ThreadItem)[]; 34 34 + threadgate?: AppBskyFeedDefs.ThreadgateView; 35 35 + /** Whether this thread has additional replies. If true, a call can be made to the `getPostThreadOtherV2` endpoint to retrieve them. */ 36 36 + hasOtherReplies: boolean; 37 37 + } 38 38 + 39 39 + export type HandlerInput = void; 40 40 + 41 41 + export interface HandlerSuccess { 42 42 + encoding: "application/json"; 43 43 + body: OutputSchema; 44 44 + headers?: { [key: string]: string }; 45 45 + } 46 46 + 47 47 + export interface HandlerError { 48 48 + status: number; 49 49 + message?: string; 50 50 + } 51 51 + 52 52 + export type HandlerOutput = HandlerError | HandlerSuccess; 53 53 + 54 54 + export interface ThreadItem { 55 55 + $type?: "app.bsky.unspecced.getPostThreadV2#threadItem"; 56 56 + uri: string; 57 57 + /** The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths. */ 58 58 + depth: number; 59 59 + value: 60 60 + | $Typed<AppBskyUnspeccedDefs.ThreadItemPost> 61 61 + | $Typed<AppBskyUnspeccedDefs.ThreadItemNoUnauthenticated> 62 62 + | $Typed<AppBskyUnspeccedDefs.ThreadItemNotFound> 63 63 + | $Typed<AppBskyUnspeccedDefs.ThreadItemBlocked> 64 64 + | { $type: string }; 65 65 + } 66 66 + 67 67 + const hashThreadItem = "threadItem"; 68 68 + 69 69 + export function isThreadItem<V>(v: V) { 70 70 + return is$typed(v, id, hashThreadItem); 71 71 + } 72 72 + 73 73 + export function validateThreadItem<V>(v: V) { 74 74 + return validate<ThreadItem & V>(v, id, hashThreadItem); 75 75 + }

+28

lex/types/app/bsky/unspecced/getSuggestedFeeds.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyFeedDefs from "../feed/defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + feeds: (AppBskyFeedDefs.GeneratorView)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+28

lex/types/app/bsky/unspecced/getSuggestedFeedsSkeleton.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = { 5 5 + /** DID of the account making the request (not included for public/unauthenticated queries). */ 6 6 + viewer?: string; 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + feeds: (string)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+28

lex/types/app/bsky/unspecced/getSuggestedStarterPacks.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyGraphDefs from "../graph/defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + starterPacks: (AppBskyGraphDefs.StarterPackView)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+28

lex/types/app/bsky/unspecced/getSuggestedStarterPacksSkeleton.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = { 5 5 + /** DID of the account making the request (not included for public/unauthenticated queries). */ 6 6 + viewer?: string; 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + starterPacks: (string)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+30

lex/types/app/bsky/unspecced/getSuggestedUsers.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyActorDefs from "../actor/defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + /** Category of users to get suggestions for. */ 8 8 + category?: string; 9 9 + limit: number; 10 10 + }; 11 11 + export type InputSchema = undefined; 12 12 + 13 13 + export interface OutputSchema { 14 14 + actors: (AppBskyActorDefs.ProfileView)[]; 15 15 + } 16 16 + 17 17 + export type HandlerInput = void; 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + } 29 29 + 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+30

lex/types/app/bsky/unspecced/getSuggestedUsersSkeleton.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = { 5 5 + /** DID of the account making the request (not included for public/unauthenticated queries). */ 6 6 + viewer?: string; 7 7 + /** Category of users to get suggestions for. */ 8 8 + category?: string; 9 9 + limit: number; 10 10 + }; 11 11 + export type InputSchema = undefined; 12 12 + 13 13 + export interface OutputSchema { 14 14 + dids: (string)[]; 15 15 + } 16 16 + 17 17 + export type HandlerInput = void; 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + } 29 29 + 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+28

lex/types/app/bsky/unspecced/getTrends.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyUnspeccedDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + limit: number; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + trends: (AppBskyUnspeccedDefs.TrendView)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+30

lex/types/app/bsky/unspecced/getTrendsSkeleton.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyUnspeccedDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + /** DID of the account making the request (not included for public/unauthenticated queries). */ 8 8 + viewer?: string; 9 9 + limit: number; 10 10 + }; 11 11 + export type InputSchema = undefined; 12 12 + 13 13 + export interface OutputSchema { 14 14 + trends: (AppBskyUnspeccedDefs.SkeletonTrend)[]; 15 15 + } 16 16 + 17 17 + export type HandlerInput = void; 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + } 29 29 + 30 30 + export type HandlerOutput = HandlerError | HandlerSuccess;

+36

lex/types/app/bsky/unspecced/initAgeAssurance.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as AppBskyUnspeccedDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** The user's email address to receive assurance instructions. */ 10 10 + email: string; 11 11 + /** The user's preferred language for communication during the assurance process. */ 12 12 + language: string; 13 13 + /** An ISO 3166-1 alpha-2 code of the user's location. */ 14 14 + countryCode: string; 15 15 + } 16 16 + 17 17 + export type OutputSchema = AppBskyUnspeccedDefs.AgeAssuranceState; 18 18 + 19 19 + export interface HandlerInput { 20 20 + encoding: "application/json"; 21 21 + body: InputSchema; 22 22 + } 23 23 + 24 24 + export interface HandlerSuccess { 25 25 + encoding: "application/json"; 26 26 + body: OutputSchema; 27 27 + headers?: { [key: string]: string }; 28 28 + } 29 29 + 30 30 + export interface HandlerError { 31 31 + status: number; 32 32 + message?: string; 33 33 + error?: "InvalidEmail" | "DidTooLong" | "InvalidInitiation"; 34 34 + } 35 35 + 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess;

+2 -1

lex/types/chat/bsky/actor/defs.ts

reviewed

··· 18 18 associated?: AppBskyActorDefs.ProfileAssociated; 19 19 viewer?: AppBskyActorDefs.ViewerState; 20 20 labels?: (ComAtprotoLabelDefs.Label)[]; 21 21 - /** Set to true when the actor cannot actively participate in converations */ 21 21 + /** Set to true when the actor cannot actively participate in conversations */ 22 22 chatDisabled?: boolean; 23 23 + verification?: AppBskyActorDefs.VerificationState; 23 24 } 24 25 25 26 const hashProfileViewBasic = "profileViewBasic";

+38

lex/types/chat/bsky/convo/addReaction.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ChatBskyConvoDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + convoId: string; 10 10 + messageId: string; 11 11 + value: string; 12 12 + } 13 13 + 14 14 + export interface OutputSchema { 15 15 + message: ChatBskyConvoDefs.MessageView; 16 16 + } 17 17 + 18 18 + export interface HandlerInput { 19 19 + encoding: "application/json"; 20 20 + body: InputSchema; 21 21 + } 22 22 + 23 23 + export interface HandlerSuccess { 24 24 + encoding: "application/json"; 25 25 + body: OutputSchema; 26 26 + headers?: { [key: string]: string }; 27 27 + } 28 28 + 29 29 + export interface HandlerError { 30 30 + status: number; 31 31 + message?: string; 32 32 + error?: 33 33 + | "ReactionMessageDeleted" 34 34 + | "ReactionLimitReached" 35 35 + | "ReactionInvalidValue"; 36 36 + } 37 37 + 38 38 + export type HandlerOutput = HandlerError | HandlerSuccess;

+91

lex/types/chat/bsky/convo/defs.ts

reviewed

··· 54 54 /** Annotations of text (mentions, URLs, hashtags, etc) */ 55 55 facets?: (AppBskyRichtextFacet.Main)[]; 56 56 embed?: $Typed<AppBskyEmbedRecord.View> | { $type: string }; 57 57 + /** Reactions to this message, in ascending order of creation time. */ 58 58 + reactions?: (ReactionView)[]; 57 59 sender: MessageViewSender; 58 60 sentAt: string; 59 61 } ··· 101 103 return validate<MessageViewSender & V>(v, id, hashMessageViewSender); 102 104 } 103 105 106 106 + export interface ReactionView { 107 107 + $type?: "chat.bsky.convo.defs#reactionView"; 108 108 + value: string; 109 109 + sender: ReactionViewSender; 110 110 + createdAt: string; 111 111 + } 112 112 + 113 113 + const hashReactionView = "reactionView"; 114 114 + 115 115 + export function isReactionView<V>(v: V) { 116 116 + return is$typed(v, id, hashReactionView); 117 117 + } 118 118 + 119 119 + export function validateReactionView<V>(v: V) { 120 120 + return validate<ReactionView & V>(v, id, hashReactionView); 121 121 + } 122 122 + 123 123 + export interface ReactionViewSender { 124 124 + $type?: "chat.bsky.convo.defs#reactionViewSender"; 125 125 + did: string; 126 126 + } 127 127 + 128 128 + const hashReactionViewSender = "reactionViewSender"; 129 129 + 130 130 + export function isReactionViewSender<V>(v: V) { 131 131 + return is$typed(v, id, hashReactionViewSender); 132 132 + } 133 133 + 134 134 + export function validateReactionViewSender<V>(v: V) { 135 135 + return validate<ReactionViewSender & V>(v, id, hashReactionViewSender); 136 136 + } 137 137 + 138 138 + export interface MessageAndReactionView { 139 139 + $type?: "chat.bsky.convo.defs#messageAndReactionView"; 140 140 + message: MessageView; 141 141 + reaction: ReactionView; 142 142 + } 143 143 + 144 144 + const hashMessageAndReactionView = "messageAndReactionView"; 145 145 + 146 146 + export function isMessageAndReactionView<V>(v: V) { 147 147 + return is$typed(v, id, hashMessageAndReactionView); 148 148 + } 149 149 + 150 150 + export function validateMessageAndReactionView<V>(v: V) { 151 151 + return validate<MessageAndReactionView & V>( 152 152 + v, 153 153 + id, 154 154 + hashMessageAndReactionView, 155 155 + ); 156 156 + } 157 157 + 104 158 export interface ConvoView { 105 159 $type?: "chat.bsky.convo.defs#convoView"; 106 160 id: string; ··· 109 163 lastMessage?: $Typed<MessageView> | $Typed<DeletedMessageView> | { 110 164 $type: string; 111 165 }; 166 166 + lastReaction?: $Typed<MessageAndReactionView> | { $type: string }; 112 167 muted: boolean; 113 168 status?: 114 169 | "request" ··· 257 312 export function validateLogReadMessage<V>(v: V) { 258 313 return validate<LogReadMessage & V>(v, id, hashLogReadMessage); 259 314 } 315 315 + 316 316 + export interface LogAddReaction { 317 317 + $type?: "chat.bsky.convo.defs#logAddReaction"; 318 318 + rev: string; 319 319 + convoId: string; 320 320 + message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }; 321 321 + reaction: ReactionView; 322 322 + } 323 323 + 324 324 + const hashLogAddReaction = "logAddReaction"; 325 325 + 326 326 + export function isLogAddReaction<V>(v: V) { 327 327 + return is$typed(v, id, hashLogAddReaction); 328 328 + } 329 329 + 330 330 + export function validateLogAddReaction<V>(v: V) { 331 331 + return validate<LogAddReaction & V>(v, id, hashLogAddReaction); 332 332 + } 333 333 + 334 334 + export interface LogRemoveReaction { 335 335 + $type?: "chat.bsky.convo.defs#logRemoveReaction"; 336 336 + rev: string; 337 337 + convoId: string; 338 338 + message: $Typed<MessageView> | $Typed<DeletedMessageView> | { $type: string }; 339 339 + reaction: ReactionView; 340 340 + } 341 341 + 342 342 + const hashLogRemoveReaction = "logRemoveReaction"; 343 343 + 344 344 + export function isLogRemoveReaction<V>(v: V) { 345 345 + return is$typed(v, id, hashLogRemoveReaction); 346 346 + } 347 347 + 348 348 + export function validateLogRemoveReaction<V>(v: V) { 349 349 + return validate<LogRemoveReaction & V>(v, id, hashLogRemoveReaction); 350 350 + }

+5

lex/types/chat/bsky/convo/getLog.ts

reviewed

··· 15 15 | $Typed<ChatBskyConvoDefs.LogBeginConvo> 16 16 | $Typed<ChatBskyConvoDefs.LogAcceptConvo> 17 17 | $Typed<ChatBskyConvoDefs.LogLeaveConvo> 18 18 + | $Typed<ChatBskyConvoDefs.LogMuteConvo> 19 19 + | $Typed<ChatBskyConvoDefs.LogUnmuteConvo> 18 20 | $Typed<ChatBskyConvoDefs.LogCreateMessage> 19 21 | $Typed<ChatBskyConvoDefs.LogDeleteMessage> 22 22 + | $Typed<ChatBskyConvoDefs.LogReadMessage> 23 23 + | $Typed<ChatBskyConvoDefs.LogAddReaction> 24 24 + | $Typed<ChatBskyConvoDefs.LogRemoveReaction> 20 25 | { $type: string } 21 26 )[]; 22 27 }

+35

lex/types/chat/bsky/convo/removeReaction.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ChatBskyConvoDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + convoId: string; 10 10 + messageId: string; 11 11 + value: string; 12 12 + } 13 13 + 14 14 + export interface OutputSchema { 15 15 + message: ChatBskyConvoDefs.MessageView; 16 16 + } 17 17 + 18 18 + export interface HandlerInput { 19 19 + encoding: "application/json"; 20 20 + body: InputSchema; 21 21 + } 22 22 + 23 23 + export interface HandlerSuccess { 24 24 + encoding: "application/json"; 25 25 + body: OutputSchema; 26 26 + headers?: { [key: string]: string }; 27 27 + } 28 28 + 29 29 + export interface HandlerError { 30 30 + status: number; 31 31 + message?: string; 32 32 + error?: "ReactionMessageDeleted" | "ReactionInvalidValue"; 33 33 + } 34 34 + 35 35 + export type HandlerOutput = HandlerError | HandlerSuccess;

+22

lex/types/com/atproto/admin/updateAccountSigningKey.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 5 5 + 6 6 + export interface InputSchema { 7 7 + did: string; 8 8 + /** Did-key formatted public key */ 9 9 + signingKey: string; 10 10 + } 11 11 + 12 12 + export interface HandlerInput { 13 13 + encoding: "application/json"; 14 14 + body: InputSchema; 15 15 + } 16 16 + 17 17 + export interface HandlerError { 18 18 + status: number; 19 19 + message?: string; 20 20 + } 21 21 + 22 22 + export type HandlerOutput = HandlerError | void;

+27

lex/types/com/atproto/identity/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "com.atproto.identity.defs"; 9 9 + 10 10 + export interface IdentityInfo { 11 11 + $type?: "com.atproto.identity.defs#identityInfo"; 12 12 + did: string; 13 13 + /** The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document. */ 14 14 + handle: string; 15 15 + /** The complete DID document for the identity. */ 16 16 + didDoc: { [_ in string]: unknown }; 17 17 + } 18 18 + 19 19 + const hashIdentityInfo = "identityInfo"; 20 20 + 21 21 + export function isIdentityInfo<V>(v: V) { 22 22 + return is$typed(v, id, hashIdentityInfo); 23 23 + } 24 24 + 25 25 + export function validateIdentityInfo<V>(v: V) { 26 26 + return validate<IdentityInfo & V>(v, id, hashIdentityInfo); 27 27 + }

+31

lex/types/com/atproto/identity/refreshIdentity.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ComAtprotoIdentityDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + identifier: string; 10 10 + } 11 11 + 12 12 + export type OutputSchema = ComAtprotoIdentityDefs.IdentityInfo; 13 13 + 14 14 + export interface HandlerInput { 15 15 + encoding: "application/json"; 16 16 + body: InputSchema; 17 17 + } 18 18 + 19 19 + export interface HandlerSuccess { 20 20 + encoding: "application/json"; 21 21 + body: OutputSchema; 22 22 + headers?: { [key: string]: string }; 23 23 + } 24 24 + 25 25 + export interface HandlerError { 26 26 + status: number; 27 27 + message?: string; 28 28 + error?: "HandleNotFound" | "DidNotFound" | "DidDeactivated"; 29 29 + } 30 30 + 31 31 + export type HandlerOutput = HandlerError | HandlerSuccess;

+29

lex/types/com/atproto/identity/resolveDid.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = { 5 5 + /** DID to resolve. */ 6 6 + did: string; 7 7 + }; 8 8 + export type InputSchema = undefined; 9 9 + 10 10 + export interface OutputSchema { 11 11 + /** The complete DID document for the identity. */ 12 12 + didDoc: { [_ in string]: unknown }; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + error?: "DidNotFound" | "DidDeactivated"; 27 27 + } 28 28 + 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+1

lex/types/com/atproto/identity/resolveHandle.ts

reviewed

··· 22 22 export interface HandlerError { 23 23 status: number; 24 24 message?: string; 25 25 + error?: "HandleNotFound"; 25 26 } 26 27 27 28 export type HandlerOutput = HandlerError | HandlerSuccess;

+26

lex/types/com/atproto/identity/resolveIdentity.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ComAtprotoIdentityDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + /** Handle or DID to resolve. */ 8 8 + identifier: string; 9 9 + }; 10 10 + export type InputSchema = undefined; 11 11 + export type OutputSchema = ComAtprotoIdentityDefs.IdentityInfo; 12 12 + export type HandlerInput = void; 13 13 + 14 14 + export interface HandlerSuccess { 15 15 + encoding: "application/json"; 16 16 + body: OutputSchema; 17 17 + headers?: { [key: string]: string }; 18 18 + } 19 19 + 20 20 + export interface HandlerError { 21 21 + status: number; 22 22 + message?: string; 23 23 + error?: "HandleNotFound" | "DidNotFound" | "DidDeactivated"; 24 24 + } 25 25 + 26 26 + export type HandlerOutput = HandlerError | HandlerSuccess;

+34

lex/types/com/atproto/lexicon/resolveLexicon.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ComAtprotoLexiconSchema from "./schema.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + /** The lexicon NSID to resolve. */ 8 8 + nsid: string; 9 9 + }; 10 10 + export type InputSchema = undefined; 11 11 + 12 12 + export interface OutputSchema { 13 13 + /** The CID of the lexicon schema record. */ 14 14 + cid: string; 15 15 + schema: ComAtprotoLexiconSchema.Main; 16 16 + /** The AT-URI of the lexicon schema record. */ 17 17 + uri: string; 18 18 + } 19 19 + 20 20 + export type HandlerInput = void; 21 21 + 22 22 + export interface HandlerSuccess { 23 23 + encoding: "application/json"; 24 24 + body: OutputSchema; 25 25 + headers?: { [key: string]: string }; 26 26 + } 27 27 + 28 28 + export interface HandlerError { 29 29 + status: number; 30 30 + message?: string; 31 31 + error?: "LexiconNotFound"; 32 32 + } 33 33 + 34 34 + export type HandlerOutput = HandlerError | HandlerSuccess;

+25

lex/types/com/atproto/moderation/createReport.ts

reviewed

··· 1 1 /** 2 2 * GENERATED CODE - DO NOT MODIFY 3 3 */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 4 6 import { type $Typed } from "../../../../util.ts"; 5 7 import type * as ComAtprotoModerationDefs from "./defs.ts"; 6 8 import type * as ComAtprotoAdminDefs from "../admin/defs.ts"; 7 9 import type * as ComAtprotoRepoStrongRef from "../repo/strongRef.ts"; 10 10 + 11 11 + const is$typed = _is$typed, validate = _validate; 12 12 + const id = "com.atproto.moderation.createReport"; 8 13 9 14 export type QueryParams = globalThis.Record<PropertyKey, never>; 10 15 ··· 16 21 | $Typed<ComAtprotoAdminDefs.RepoRef> 17 22 | $Typed<ComAtprotoRepoStrongRef.Main> 18 23 | { $type: string }; 24 24 + modTool?: ModTool; 19 25 } 20 26 21 27 export interface OutputSchema { ··· 47 53 } 48 54 49 55 export type HandlerOutput = HandlerError | HandlerSuccess; 56 56 + 57 57 + /** Moderation tool information for tracing the source of the action */ 58 58 + export interface ModTool { 59 59 + $type?: "com.atproto.moderation.createReport#modTool"; 60 60 + /** Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome') */ 61 61 + name: string; 62 62 + /** Additional arbitrary metadata about the source */ 63 63 + meta?: { [_ in string]: unknown }; 64 64 + } 65 65 + 66 66 + const hashModTool = "modTool"; 67 67 + 68 68 + export function isModTool<V>(v: V) { 69 69 + return is$typed(v, id, hashModTool); 70 70 + } 71 71 + 72 72 + export function validateModTool<V>(v: V) { 73 73 + return validate<ModTool & V>(v, id, hashModTool); 74 74 + }

+47 -7

lex/types/com/atproto/moderation/defs.ts

reviewed

··· 11 11 | "com.atproto.moderation.defs#reasonRude" 12 12 | "com.atproto.moderation.defs#reasonOther" 13 13 | "com.atproto.moderation.defs#reasonAppeal" 14 14 + | "tools.ozone.report.defs#reasonAppeal" 15 15 + | "tools.ozone.report.defs#reasonOther" 16 16 + | "tools.ozone.report.defs#reasonViolenceAnimal" 17 17 + | "tools.ozone.report.defs#reasonViolenceThreats" 18 18 + | "tools.ozone.report.defs#reasonViolenceGraphicContent" 19 19 + | "tools.ozone.report.defs#reasonViolenceGlorification" 20 20 + | "tools.ozone.report.defs#reasonViolenceExtremistContent" 21 21 + | "tools.ozone.report.defs#reasonViolenceTrafficking" 22 22 + | "tools.ozone.report.defs#reasonViolenceOther" 23 23 + | "tools.ozone.report.defs#reasonSexualAbuseContent" 24 24 + | "tools.ozone.report.defs#reasonSexualNCII" 25 25 + | "tools.ozone.report.defs#reasonSexualDeepfake" 26 26 + | "tools.ozone.report.defs#reasonSexualAnimal" 27 27 + | "tools.ozone.report.defs#reasonSexualUnlabeled" 28 28 + | "tools.ozone.report.defs#reasonSexualOther" 29 29 + | "tools.ozone.report.defs#reasonChildSafetyCSAM" 30 30 + | "tools.ozone.report.defs#reasonChildSafetyGroom" 31 31 + | "tools.ozone.report.defs#reasonChildSafetyPrivacy" 32 32 + | "tools.ozone.report.defs#reasonChildSafetyHarassment" 33 33 + | "tools.ozone.report.defs#reasonChildSafetyOther" 34 34 + | "tools.ozone.report.defs#reasonHarassmentTroll" 35 35 + | "tools.ozone.report.defs#reasonHarassmentTargeted" 36 36 + | "tools.ozone.report.defs#reasonHarassmentHateSpeech" 37 37 + | "tools.ozone.report.defs#reasonHarassmentDoxxing" 38 38 + | "tools.ozone.report.defs#reasonHarassmentOther" 39 39 + | "tools.ozone.report.defs#reasonMisleadingBot" 40 40 + | "tools.ozone.report.defs#reasonMisleadingImpersonation" 41 41 + | "tools.ozone.report.defs#reasonMisleadingSpam" 42 42 + | "tools.ozone.report.defs#reasonMisleadingScam" 43 43 + | "tools.ozone.report.defs#reasonMisleadingElections" 44 44 + | "tools.ozone.report.defs#reasonMisleadingOther" 45 45 + | "tools.ozone.report.defs#reasonRuleSiteSecurity" 46 46 + | "tools.ozone.report.defs#reasonRuleProhibitedSales" 47 47 + | "tools.ozone.report.defs#reasonRuleBanEvasion" 48 48 + | "tools.ozone.report.defs#reasonRuleOther" 49 49 + | "tools.ozone.report.defs#reasonSelfHarmContent" 50 50 + | "tools.ozone.report.defs#reasonSelfHarmED" 51 51 + | "tools.ozone.report.defs#reasonSelfHarmStunts" 52 52 + | "tools.ozone.report.defs#reasonSelfHarmSubstances" 53 53 + | "tools.ozone.report.defs#reasonSelfHarmOther" 14 54 | (string & globalThis.Record<PropertyKey, never>); 15 55 16 16 - /** Spam: frequent unwanted promotion, replies, mentions */ 56 56 + /** Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`. */ 17 57 export const REASONSPAM = `${id}#reasonSpam`; 18 18 - /** Direct violation of server rules, laws, terms of service */ 58 58 + /** Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`. */ 19 59 export const REASONVIOLATION = `${id}#reasonViolation`; 20 20 - /** Misleading identity, affiliation, or content */ 60 60 + /** Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`. */ 21 61 export const REASONMISLEADING = `${id}#reasonMisleading`; 22 22 - /** Unwanted or mislabeled sexual content */ 62 62 + /** Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`. */ 23 63 export const REASONSEXUAL = `${id}#reasonSexual`; 24 24 - /** Rude, harassing, explicit, or otherwise unwelcoming behavior */ 64 64 + /** Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`. */ 25 65 export const REASONRUDE = `${id}#reasonRude`; 26 26 - /** Other: reports not falling under another report category */ 66 66 + /** Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`. */ 27 67 export const REASONOTHER = `${id}#reasonOther`; 28 28 - /** Appeal: appeal a previously taken moderation action */ 68 68 + /** Appeal a previously taken moderation action */ 29 69 export const REASONAPPEAL = `${id}#reasonAppeal`; 30 70 31 71 /** Tag describing a type of subject that might be reported. */

+1

lex/types/com/atproto/repo/applyWrites.ts

reviewed

··· 50 50 export interface Create { 51 51 $type?: "com.atproto.repo.applyWrites#create"; 52 52 collection: string; 53 53 + /** NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility. */ 53 54 rkey?: string; 54 55 value: { [_ in string]: unknown }; 55 56 }

-4

lex/types/com/atproto/repo/listRecords.ts

reviewed

··· 15 15 /** The number of records to return. */ 16 16 limit: number; 17 17 cursor?: string; 18 18 - /** DEPRECATED: The lowest sort-ordered rkey to start from (exclusive) */ 19 19 - rkeyStart?: string; 20 20 - /** DEPRECATED: The highest sort-ordered rkey to stop at (exclusive) */ 21 21 - rkeyEnd?: string; 22 18 /** Flag to reverse the order of the returned records. */ 23 19 reverse?: boolean; 24 20 };

+12

lex/types/com/atproto/sync/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + const id = "com.atproto.sync.defs"; 5 5 + 6 6 + export type HostStatus = 7 7 + | "active" 8 8 + | "idle" 9 9 + | "offline" 10 10 + | "throttled" 11 11 + | "banned" 12 12 + | (string & globalThis.Record<PropertyKey, never>);

+35

lex/types/com/atproto/sync/getHostStatus.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ComAtprotoSyncDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + /** Hostname of the host (eg, PDS or relay) being queried. */ 8 8 + hostname: string; 9 9 + }; 10 10 + export type InputSchema = undefined; 11 11 + 12 12 + export interface OutputSchema { 13 13 + hostname: string; 14 14 + /** Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor). */ 15 15 + seq?: number; 16 16 + /** Number of accounts on the server which are associated with the upstream host. Note that the upstream may actually have more accounts. */ 17 17 + accountCount?: number; 18 18 + status?: ComAtprotoSyncDefs.HostStatus; 19 19 + } 20 20 + 21 21 + export type HandlerInput = void; 22 22 + 23 23 + export interface HandlerSuccess { 24 24 + encoding: "application/json"; 25 25 + body: OutputSchema; 26 26 + headers?: { [key: string]: string }; 27 27 + } 28 28 + 29 29 + export interface HandlerError { 30 30 + status: number; 31 31 + message?: string; 32 32 + error?: "HostNotFound"; 33 33 + } 34 34 + 35 35 + export type HandlerOutput = HandlerError | HandlerSuccess;

-2

lex/types/com/atproto/sync/getRecord.ts

reviewed

··· 9 9 collection: string; 10 10 /** Record Key */ 11 11 rkey: string; 12 12 - /** DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit */ 13 13 - commit?: string; 14 12 }; 15 13 export type InputSchema = undefined; 16 14 export type HandlerInput = void;

+3

lex/types/com/atproto/sync/getRepoStatus.ts

reviewed

··· 14 14 status?: 15 15 | "takendown" 16 16 | "suspended" 17 17 + | "deleted" 17 18 | "deactivated" 19 19 + | "desynchronized" 20 20 + | "throttled" 18 21 | (string & globalThis.Record<PropertyKey, never>); 19 22 /** Optional field, the current rev of the repo, if active=true */ 20 23 rev?: string;

+56

lex/types/com/atproto/sync/listHosts.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import type * as ComAtprotoSyncDefs from "./defs.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "com.atproto.sync.listHosts"; 10 10 + 11 11 + export type QueryParams = { 12 12 + limit: number; 13 13 + cursor?: string; 14 14 + }; 15 15 + export type InputSchema = undefined; 16 16 + 17 17 + export interface OutputSchema { 18 18 + cursor?: string; 19 19 + /** Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first. */ 20 20 + hosts: (Host)[]; 21 21 + } 22 22 + 23 23 + export type HandlerInput = void; 24 24 + 25 25 + export interface HandlerSuccess { 26 26 + encoding: "application/json"; 27 27 + body: OutputSchema; 28 28 + headers?: { [key: string]: string }; 29 29 + } 30 30 + 31 31 + export interface HandlerError { 32 32 + status: number; 33 33 + message?: string; 34 34 + } 35 35 + 36 36 + export type HandlerOutput = HandlerError | HandlerSuccess; 37 37 + 38 38 + export interface Host { 39 39 + $type?: "com.atproto.sync.listHosts#host"; 40 40 + /** hostname of server; not a URL (no scheme) */ 41 41 + hostname: string; 42 42 + /** Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor). */ 43 43 + seq?: number; 44 44 + accountCount?: number; 45 45 + status?: ComAtprotoSyncDefs.HostStatus; 46 46 + } 47 47 + 48 48 + const hashHost = "host"; 49 49 + 50 50 + export function isHost<V>(v: V) { 51 51 + return is$typed(v, id, hashHost); 52 52 + } 53 53 + 54 54 + export function validateHost<V>(v: V) { 55 55 + return validate<Host & V>(v, id, hashHost); 56 56 + }

+3

lex/types/com/atproto/sync/listRepos.ts

reviewed

··· 44 44 status?: 45 45 | "takendown" 46 46 | "suspended" 47 47 + | "deleted" 47 48 | "deactivated" 49 49 + | "desynchronized" 50 50 + | "throttled" 48 51 | (string & globalThis.Record<PropertyKey, never>); 49 52 } 50 53

+1

lex/types/com/atproto/sync/requestCrawl.ts

reviewed

··· 16 16 export interface HandlerError { 17 17 status: number; 18 18 message?: string; 19 19 + error?: "HostBanned"; 19 20 } 20 21 21 22 export type HandlerOutput = HandlerError | void;

+35 -64

lex/types/com/atproto/sync/subscribeRepos.ts

reviewed

··· 16 16 }; 17 17 export type OutputSchema = 18 18 | $Typed<Commit> 19 19 + | $Typed<Sync> 19 20 | $Typed<Identity> 20 21 | $Typed<Account> 21 21 - | $Typed<Handle> 22 22 - | $Typed<Migrate> 23 23 - | $Typed<Tombstone> 24 22 | $Typed<Info> 25 23 | { $type: string }; 26 24 export type HandlerError = ErrorFrame<"FutureCursor" | "ConsumerTooSlow">; ··· 33 31 seq: number; 34 32 /** DEPRECATED -- unused */ 35 33 rebase: boolean; 36 36 - /** Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data. */ 34 34 + /** DEPRECATED -- replaced by #sync event and data limits. Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data. */ 37 35 tooBig: boolean; 38 38 - /** The repo this event comes from. */ 36 36 + /** The repo this event comes from. Note that all other message types name this field 'did'. */ 39 37 repo: string; 40 38 /** Repo commit object CID. */ 41 39 commit: CID; 42 42 - /** DEPRECATED -- unused. WARNING -- nullable and optional; stick with optional to ensure golang interoperability. */ 43 43 - prev?: CID | null; 44 40 /** The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event. */ 45 41 rev: string; 46 42 /** The rev of the last emitted commit from this repo (if any). */ 47 43 since: string | null; 48 48 - /** CAR file containing relevant blocks, as a diff since the previous repo state. */ 44 44 + /** CAR file containing relevant blocks, as a diff since the previous repo state. The commit must be included as a block, and the commit block CID must be the first entry in the CAR header 'roots' list. */ 49 45 blocks: Uint8Array; 50 46 ops: (RepoOp)[]; 51 47 blobs: (CID)[]; 48 48 + /** The root CID of the MST tree for the previous commit from this repo (indicated by the 'since' revision field in this message). Corresponds to the 'data' field in the repo commit object. NOTE: this field is effectively required for the 'inductive' version of firehose. */ 49 49 + prevData?: CID; 52 50 /** Timestamp of when this message was originally broadcast. */ 53 51 time: string; 54 52 } ··· 63 61 return validate<Commit & V>(v, id, hashCommit); 64 62 } 65 63 64 64 + /** Updates the repo to a new state, without necessarily including that state on the firehose. Used to recover from broken commit streams, data loss incidents, or in situations where upstream host does not know recent state of the repository. */ 65 65 + export interface Sync { 66 66 + $type?: "com.atproto.sync.subscribeRepos#sync"; 67 67 + /** The stream sequence number of this message. */ 68 68 + seq: number; 69 69 + /** The account this repo event corresponds to. Must match that in the commit object. */ 70 70 + did: string; 71 71 + /** CAR file containing the commit, as a block. The CAR header must include the commit block CID as the first 'root'. */ 72 72 + blocks: Uint8Array; 73 73 + /** The rev of the commit. This value must match that in the commit object. */ 74 74 + rev: string; 75 75 + /** Timestamp of when this message was originally broadcast. */ 76 76 + time: string; 77 77 + } 78 78 + 79 79 + const hashSync = "sync"; 80 80 + 81 81 + export function isSync<V>(v: V) { 82 82 + return is$typed(v, id, hashSync); 83 83 + } 84 84 + 85 85 + export function validateSync<V>(v: V) { 86 86 + return validate<Sync & V>(v, id, hashSync); 87 87 + } 88 88 + 66 89 /** Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache. */ 67 90 export interface Identity { 68 91 $type?: "com.atproto.sync.subscribeRepos#identity"; ··· 97 120 | "suspended" 98 121 | "deleted" 99 122 | "deactivated" 123 123 + | "desynchronized" 124 124 + | "throttled" 100 125 | (string & globalThis.Record<PropertyKey, never>); 101 126 } 102 127 ··· 110 135 return validate<Account & V>(v, id, hashAccount); 111 136 } 112 137 113 113 - /** DEPRECATED -- Use #identity event instead */ 114 114 - export interface Handle { 115 115 - $type?: "com.atproto.sync.subscribeRepos#handle"; 116 116 - seq: number; 117 117 - did: string; 118 118 - handle: string; 119 119 - time: string; 120 120 - } 121 121 - 122 122 - const hashHandle = "handle"; 123 123 - 124 124 - export function isHandle<V>(v: V) { 125 125 - return is$typed(v, id, hashHandle); 126 126 - } 127 127 - 128 128 - export function validateHandle<V>(v: V) { 129 129 - return validate<Handle & V>(v, id, hashHandle); 130 130 - } 131 131 - 132 132 - /** DEPRECATED -- Use #account event instead */ 133 133 - export interface Migrate { 134 134 - $type?: "com.atproto.sync.subscribeRepos#migrate"; 135 135 - seq: number; 136 136 - did: string; 137 137 - migrateTo: string | null; 138 138 - time: string; 139 139 - } 140 140 - 141 141 - const hashMigrate = "migrate"; 142 142 - 143 143 - export function isMigrate<V>(v: V) { 144 144 - return is$typed(v, id, hashMigrate); 145 145 - } 146 146 - 147 147 - export function validateMigrate<V>(v: V) { 148 148 - return validate<Migrate & V>(v, id, hashMigrate); 149 149 - } 150 150 - 151 151 - /** DEPRECATED -- Use #account event instead */ 152 152 - export interface Tombstone { 153 153 - $type?: "com.atproto.sync.subscribeRepos#tombstone"; 154 154 - seq: number; 155 155 - did: string; 156 156 - time: string; 157 157 - } 158 158 - 159 159 - const hashTombstone = "tombstone"; 160 160 - 161 161 - export function isTombstone<V>(v: V) { 162 162 - return is$typed(v, id, hashTombstone); 163 163 - } 164 164 - 165 165 - export function validateTombstone<V>(v: V) { 166 166 - return validate<Tombstone & V>(v, id, hashTombstone); 167 167 - } 168 168 - 169 138 export interface Info { 170 139 $type?: "com.atproto.sync.subscribeRepos#info"; 171 140 name: "OutdatedCursor" | (string & globalThis.Record<PropertyKey, never>); ··· 193 162 path: string; 194 163 /** For creates and updates, the new record CID. For deletions, null. */ 195 164 cid: CID | null; 165 165 + /** For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined. */ 166 166 + prev?: CID; 196 167 } 197 168 198 169 const hashRepoOp = "repoOp";

+92

lex/types/com/atproto/temp/checkHandleAvailability.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "com.atproto.temp.checkHandleAvailability"; 10 10 + 11 11 + export type QueryParams = { 12 12 + /** Tentative handle. Will be checked for availability or used to build handle suggestions. */ 13 13 + handle: string; 14 14 + /** User-provided email. Might be used to build handle suggestions. */ 15 15 + email?: string; 16 16 + /** User-provided birth date. Might be used to build handle suggestions. */ 17 17 + birthDate?: string; 18 18 + }; 19 19 + export type InputSchema = undefined; 20 20 + 21 21 + export interface OutputSchema { 22 22 + /** Echo of the input handle. */ 23 23 + handle: string; 24 24 + result: $Typed<ResultAvailable> | $Typed<ResultUnavailable> | { 25 25 + $type: string; 26 26 + }; 27 27 + } 28 28 + 29 29 + export type HandlerInput = void; 30 30 + 31 31 + export interface HandlerSuccess { 32 32 + encoding: "application/json"; 33 33 + body: OutputSchema; 34 34 + headers?: { [key: string]: string }; 35 35 + } 36 36 + 37 37 + export interface HandlerError { 38 38 + status: number; 39 39 + message?: string; 40 40 + error?: "InvalidEmail"; 41 41 + } 42 42 + 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess; 44 44 + 45 45 + /** Indicates the provided handle is available. */ 46 46 + export interface ResultAvailable { 47 47 + $type?: "com.atproto.temp.checkHandleAvailability#resultAvailable"; 48 48 + } 49 49 + 50 50 + const hashResultAvailable = "resultAvailable"; 51 51 + 52 52 + export function isResultAvailable<V>(v: V) { 53 53 + return is$typed(v, id, hashResultAvailable); 54 54 + } 55 55 + 56 56 + export function validateResultAvailable<V>(v: V) { 57 57 + return validate<ResultAvailable & V>(v, id, hashResultAvailable); 58 58 + } 59 59 + 60 60 + /** Indicates the provided handle is unavailable and gives suggestions of available handles. */ 61 61 + export interface ResultUnavailable { 62 62 + $type?: "com.atproto.temp.checkHandleAvailability#resultUnavailable"; 63 63 + /** List of suggested handles based on the provided inputs. */ 64 64 + suggestions: (Suggestion)[]; 65 65 + } 66 66 + 67 67 + const hashResultUnavailable = "resultUnavailable"; 68 68 + 69 69 + export function isResultUnavailable<V>(v: V) { 70 70 + return is$typed(v, id, hashResultUnavailable); 71 71 + } 72 72 + 73 73 + export function validateResultUnavailable<V>(v: V) { 74 74 + return validate<ResultUnavailable & V>(v, id, hashResultUnavailable); 75 75 + } 76 76 + 77 77 + export interface Suggestion { 78 78 + $type?: "com.atproto.temp.checkHandleAvailability#suggestion"; 79 79 + handle: string; 80 80 + /** Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics. */ 81 81 + method: string; 82 82 + } 83 83 + 84 84 + const hashSuggestion = "suggestion"; 85 85 + 86 86 + export function isSuggestion<V>(v: V) { 87 87 + return is$typed(v, id, hashSuggestion); 88 88 + } 89 89 + 90 90 + export function validateSuggestion<V>(v: V) { 91 91 + return validate<Suggestion & V>(v, id, hashSuggestion); 92 92 + }

+29

lex/types/com/atproto/temp/dereferenceScope.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = { 5 5 + /** The scope reference (starts with 'ref:') */ 6 6 + scope: string; 7 7 + }; 8 8 + export type InputSchema = undefined; 9 9 + 10 10 + export interface OutputSchema { 11 11 + /** The full oauth permission scope */ 12 12 + scope: string; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + error?: "InvalidScopeReference"; 27 27 + } 28 28 + 29 29 + export type HandlerOutput = HandlerError | HandlerSuccess;

+20

lex/types/com/atproto/temp/revokeAccountCredentials.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + export type QueryParams = globalThis.Record<PropertyKey, never>; 5 5 + 6 6 + export interface InputSchema { 7 7 + account: string; 8 8 + } 9 9 + 10 10 + export interface HandlerInput { 11 11 + encoding: "application/json"; 12 12 + body: InputSchema; 13 13 + } 14 14 + 15 15 + export interface HandlerError { 16 16 + status: number; 17 17 + message?: string; 18 18 + } 19 19 + 20 20 + export type HandlerOutput = HandlerError | void;

+141

lex/types/tools/ozone/hosting/getAccountHistory.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "tools.ozone.hosting.getAccountHistory"; 10 10 + 11 11 + export type QueryParams = { 12 12 + did: string; 13 13 + events?: 14 14 + | "accountCreated" 15 15 + | "emailUpdated" 16 16 + | "emailConfirmed" 17 17 + | "passwordUpdated" 18 18 + | "handleUpdated" 19 19 + | (string & globalThis.Record<PropertyKey, never>)[]; 20 20 + cursor?: string; 21 21 + limit: number; 22 22 + }; 23 23 + export type InputSchema = undefined; 24 24 + 25 25 + export interface OutputSchema { 26 26 + cursor?: string; 27 27 + events: (Event)[]; 28 28 + } 29 29 + 30 30 + export type HandlerInput = void; 31 31 + 32 32 + export interface HandlerSuccess { 33 33 + encoding: "application/json"; 34 34 + body: OutputSchema; 35 35 + headers?: { [key: string]: string }; 36 36 + } 37 37 + 38 38 + export interface HandlerError { 39 39 + status: number; 40 40 + message?: string; 41 41 + } 42 42 + 43 43 + export type HandlerOutput = HandlerError | HandlerSuccess; 44 44 + 45 45 + export interface Event { 46 46 + $type?: "tools.ozone.hosting.getAccountHistory#event"; 47 47 + details: 48 48 + | $Typed<AccountCreated> 49 49 + | $Typed<EmailUpdated> 50 50 + | $Typed<EmailConfirmed> 51 51 + | $Typed<PasswordUpdated> 52 52 + | $Typed<HandleUpdated> 53 53 + | { $type: string }; 54 54 + createdBy: string; 55 55 + createdAt: string; 56 56 + } 57 57 + 58 58 + const hashEvent = "event"; 59 59 + 60 60 + export function isEvent<V>(v: V) { 61 61 + return is$typed(v, id, hashEvent); 62 62 + } 63 63 + 64 64 + export function validateEvent<V>(v: V) { 65 65 + return validate<Event & V>(v, id, hashEvent); 66 66 + } 67 67 + 68 68 + export interface AccountCreated { 69 69 + $type?: "tools.ozone.hosting.getAccountHistory#accountCreated"; 70 70 + email?: string; 71 71 + handle?: string; 72 72 + } 73 73 + 74 74 + const hashAccountCreated = "accountCreated"; 75 75 + 76 76 + export function isAccountCreated<V>(v: V) { 77 77 + return is$typed(v, id, hashAccountCreated); 78 78 + } 79 79 + 80 80 + export function validateAccountCreated<V>(v: V) { 81 81 + return validate<AccountCreated & V>(v, id, hashAccountCreated); 82 82 + } 83 83 + 84 84 + export interface EmailUpdated { 85 85 + $type?: "tools.ozone.hosting.getAccountHistory#emailUpdated"; 86 86 + email: string; 87 87 + } 88 88 + 89 89 + const hashEmailUpdated = "emailUpdated"; 90 90 + 91 91 + export function isEmailUpdated<V>(v: V) { 92 92 + return is$typed(v, id, hashEmailUpdated); 93 93 + } 94 94 + 95 95 + export function validateEmailUpdated<V>(v: V) { 96 96 + return validate<EmailUpdated & V>(v, id, hashEmailUpdated); 97 97 + } 98 98 + 99 99 + export interface EmailConfirmed { 100 100 + $type?: "tools.ozone.hosting.getAccountHistory#emailConfirmed"; 101 101 + email: string; 102 102 + } 103 103 + 104 104 + const hashEmailConfirmed = "emailConfirmed"; 105 105 + 106 106 + export function isEmailConfirmed<V>(v: V) { 107 107 + return is$typed(v, id, hashEmailConfirmed); 108 108 + } 109 109 + 110 110 + export function validateEmailConfirmed<V>(v: V) { 111 111 + return validate<EmailConfirmed & V>(v, id, hashEmailConfirmed); 112 112 + } 113 113 + 114 114 + export interface PasswordUpdated { 115 115 + $type?: "tools.ozone.hosting.getAccountHistory#passwordUpdated"; 116 116 + } 117 117 + 118 118 + const hashPasswordUpdated = "passwordUpdated"; 119 119 + 120 120 + export function isPasswordUpdated<V>(v: V) { 121 121 + return is$typed(v, id, hashPasswordUpdated); 122 122 + } 123 123 + 124 124 + export function validatePasswordUpdated<V>(v: V) { 125 125 + return validate<PasswordUpdated & V>(v, id, hashPasswordUpdated); 126 126 + } 127 127 + 128 128 + export interface HandleUpdated { 129 129 + $type?: "tools.ozone.hosting.getAccountHistory#handleUpdated"; 130 130 + handle: string; 131 131 + } 132 132 + 133 133 + const hashHandleUpdated = "handleUpdated"; 134 134 + 135 135 + export function isHandleUpdated<V>(v: V) { 136 136 + return is$typed(v, id, hashHandleUpdated); 137 137 + } 138 138 + 139 139 + export function validateHandleUpdated<V>(v: V) { 140 140 + return validate<HandleUpdated & V>(v, id, hashHandleUpdated); 141 141 + }

+72

lex/types/tools/ozone/moderation/cancelScheduledActions.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "tools.ozone.moderation.cancelScheduledActions"; 9 9 + 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 11 11 + 12 12 + export interface InputSchema { 13 13 + /** Array of DID subjects to cancel scheduled actions for */ 14 14 + subjects: (string)[]; 15 15 + /** Optional comment describing the reason for cancellation */ 16 16 + comment?: string; 17 17 + } 18 18 + 19 19 + export type OutputSchema = CancellationResults; 20 20 + 21 21 + export interface HandlerInput { 22 22 + encoding: "application/json"; 23 23 + body: InputSchema; 24 24 + } 25 25 + 26 26 + export interface HandlerSuccess { 27 27 + encoding: "application/json"; 28 28 + body: OutputSchema; 29 29 + headers?: { [key: string]: string }; 30 30 + } 31 31 + 32 32 + export interface HandlerError { 33 33 + status: number; 34 34 + message?: string; 35 35 + } 36 36 + 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess; 38 38 + 39 39 + export interface CancellationResults { 40 40 + $type?: "tools.ozone.moderation.cancelScheduledActions#cancellationResults"; 41 41 + /** DIDs for which all pending scheduled actions were successfully cancelled */ 42 42 + succeeded: (string)[]; 43 43 + /** DIDs for which cancellation failed with error details */ 44 44 + failed: (FailedCancellation)[]; 45 45 + } 46 46 + 47 47 + const hashCancellationResults = "cancellationResults"; 48 48 + 49 49 + export function isCancellationResults<V>(v: V) { 50 50 + return is$typed(v, id, hashCancellationResults); 51 51 + } 52 52 + 53 53 + export function validateCancellationResults<V>(v: V) { 54 54 + return validate<CancellationResults & V>(v, id, hashCancellationResults); 55 55 + } 56 56 + 57 57 + export interface FailedCancellation { 58 58 + $type?: "tools.ozone.moderation.cancelScheduledActions#failedCancellation"; 59 59 + did: string; 60 60 + error: string; 61 61 + errorCode?: string; 62 62 + } 63 63 + 64 64 + const hashFailedCancellation = "failedCancellation"; 65 65 + 66 66 + export function isFailedCancellation<V>(v: V) { 67 67 + return is$typed(v, id, hashFailedCancellation); 68 68 + } 69 69 + 70 70 + export function validateFailedCancellation<V>(v: V) { 71 71 + return validate<FailedCancellation & V>(v, id, hashFailedCancellation); 72 72 + }

+303 -4

lex/types/tools/ozone/moderation/defs.ts

reviewed

··· 8 8 import type * as ComAtprotoRepoStrongRef from "../../../com/atproto/repo/strongRef.ts"; 9 9 import type * as ChatBskyConvoDefs from "../../../chat/bsky/convo/defs.ts"; 10 10 import type * as ComAtprotoModerationDefs from "../../../com/atproto/moderation/defs.ts"; 11 11 + import type * as AppBskyAgeassuranceDefs from "../../../app/bsky/ageassurance/defs.ts"; 11 12 import type * as ComAtprotoServerDefs from "../../../com/atproto/server/defs.ts"; 12 13 import type * as ComAtprotoLabelDefs from "../../../com/atproto/label/defs.ts"; 13 14 ··· 37 38 | $Typed<IdentityEvent> 38 39 | $Typed<RecordEvent> 39 40 | $Typed<ModEventPriorityScore> 41 41 + | $Typed<AgeAssuranceEvent> 42 42 + | $Typed<AgeAssuranceOverrideEvent> 43 43 + | $Typed<RevokeAccountCredentialsEvent> 44 44 + | $Typed<ScheduleTakedownEvent> 45 45 + | $Typed<CancelScheduledTakedownEvent> 40 46 | { $type: string }; 41 47 subject: 42 48 | $Typed<ComAtprotoAdminDefs.RepoRef> ··· 48 54 createdAt: string; 49 55 creatorHandle?: string; 50 56 subjectHandle?: string; 57 57 + modTool?: ModTool; 51 58 } 52 59 53 60 const hashModEventView = "modEventView"; ··· 83 90 | $Typed<IdentityEvent> 84 91 | $Typed<RecordEvent> 85 92 | $Typed<ModEventPriorityScore> 93 93 + | $Typed<AgeAssuranceEvent> 94 94 + | $Typed<AgeAssuranceOverrideEvent> 95 95 + | $Typed<RevokeAccountCredentialsEvent> 96 96 + | $Typed<ScheduleTakedownEvent> 97 97 + | $Typed<CancelScheduledTakedownEvent> 86 98 | { $type: string }; 87 99 subject: 88 100 | $Typed<RepoView> ··· 93 105 subjectBlobs: (BlobView)[]; 94 106 createdBy: string; 95 107 createdAt: string; 108 108 + modTool?: ModTool; 96 109 } 97 110 98 111 const hashModEventViewDetail = "modEventViewDetail"; ··· 111 124 subject: 112 125 | $Typed<ComAtprotoAdminDefs.RepoRef> 113 126 | $Typed<ComAtprotoRepoStrongRef.Main> 127 127 + | $Typed<ChatBskyConvoDefs.MessageRef> 114 128 | { $type: string }; 115 129 hosting?: $Typed<AccountHosting> | $Typed<RecordHosting> | { $type: string }; 116 130 subjectBlobCids?: (string)[]; ··· 138 152 tags?: (string)[]; 139 153 accountStats?: AccountStats; 140 154 recordsStats?: RecordsStats; 155 155 + accountStrike?: AccountStrike; 156 156 + /** Current age assurance state of the subject. */ 157 157 + ageAssuranceState?: 158 158 + | "pending" 159 159 + | "assured" 160 160 + | "unknown" 161 161 + | "reset" 162 162 + | "blocked" 163 163 + | (string & globalThis.Record<PropertyKey, never>); 164 164 + /** Whether or not the last successful update to age assurance was made by the user or admin. */ 165 165 + ageAssuranceUpdatedBy?: 166 166 + | "admin" 167 167 + | "user" 168 168 + | (string & globalThis.Record<PropertyKey, never>); 141 169 } 142 170 143 171 const hashSubjectStatusView = "subjectStatusView"; ··· 150 178 return validate<SubjectStatusView & V>(v, id, hashSubjectStatusView); 151 179 } 152 180 181 181 + /** Detailed view of a subject. For record subjects, the author's repo and profile will be returned. */ 182 182 + export interface SubjectView { 183 183 + $type?: "tools.ozone.moderation.defs#subjectView"; 184 184 + type: ComAtprotoModerationDefs.SubjectType; 185 185 + subject: string; 186 186 + status?: SubjectStatusView; 187 187 + repo?: RepoViewDetail; 188 188 + profile?: { $type: string }; 189 189 + record?: RecordViewDetail; 190 190 + } 191 191 + 192 192 + const hashSubjectView = "subjectView"; 193 193 + 194 194 + export function isSubjectView<V>(v: V) { 195 195 + return is$typed(v, id, hashSubjectView); 196 196 + } 197 197 + 198 198 + export function validateSubjectView<V>(v: V) { 199 199 + return validate<SubjectView & V>(v, id, hashSubjectView); 200 200 + } 201 201 + 153 202 /** Statistics about a particular account subject */ 154 203 export interface AccountStats { 155 204 $type?: "tools.ozone.moderation.defs#accountStats"; ··· 206 255 return validate<RecordsStats & V>(v, id, hashRecordsStats); 207 256 } 208 257 258 258 + /** Strike information for an account */ 259 259 + export interface AccountStrike { 260 260 + $type?: "tools.ozone.moderation.defs#accountStrike"; 261 261 + /** Current number of active strikes (excluding expired strikes) */ 262 262 + activeStrikeCount?: number; 263 263 + /** Total number of strikes ever received (including expired strikes) */ 264 264 + totalStrikeCount?: number; 265 265 + /** Timestamp of the first strike received */ 266 266 + firstStrikeAt?: string; 267 267 + /** Timestamp of the most recent strike received */ 268 268 + lastStrikeAt?: string; 269 269 + } 270 270 + 271 271 + const hashAccountStrike = "accountStrike"; 272 272 + 273 273 + export function isAccountStrike<V>(v: V) { 274 274 + return is$typed(v, id, hashAccountStrike); 275 275 + } 276 276 + 277 277 + export function validateAccountStrike<V>(v: V) { 278 278 + return validate<AccountStrike & V>(v, id, hashAccountStrike); 279 279 + } 280 280 + 209 281 export type SubjectReviewState = 210 210 - | "lex:tools.ozone.moderation.defs#reviewOpen" 211 211 - | "lex:tools.ozone.moderation.defs#reviewEscalated" 212 212 - | "lex:tools.ozone.moderation.defs#reviewClosed" 213 213 - | "lex:tools.ozone.moderation.defs#reviewNone" 282 282 + | "tools.ozone.moderation.defs#reviewOpen" 283 283 + | "tools.ozone.moderation.defs#reviewEscalated" 284 284 + | "tools.ozone.moderation.defs#reviewClosed" 285 285 + | "tools.ozone.moderation.defs#reviewNone" 214 286 | (string & globalThis.Record<PropertyKey, never>); 215 287 216 288 /** Moderator review status of a subject: Open. Indicates that the subject needs to be reviewed by a moderator */ ··· 232 304 acknowledgeAccountSubjects?: boolean; 233 305 /** Names/Keywords of the policies that drove the decision. */ 234 306 policies?: (string)[]; 307 307 + /** Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.). */ 308 308 + severityLevel?: string; 309 309 + /** List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services. */ 310 310 + targetServices?: 311 311 + ("appview" | "pds" | (string & globalThis.Record<PropertyKey, never>))[]; 312 312 + /** Number of strikes to assign to the user for this violation. */ 313 313 + strikeCount?: number; 314 314 + /** When the strike should expire. If not provided, the strike never expires. */ 315 315 + strikeExpiresAt?: string; 235 316 } 236 317 237 318 const hashModEventTakedown = "modEventTakedown"; ··· 249 330 $type?: "tools.ozone.moderation.defs#modEventReverseTakedown"; 250 331 /** Describe reasoning behind the reversal. */ 251 332 comment?: string; 333 333 + /** Names/Keywords of the policy infraction for which takedown is being reversed. */ 334 334 + policies?: (string)[]; 335 335 + /** Severity level of the violation. Usually set from the last policy infraction's severity. */ 336 336 + severityLevel?: string; 337 337 + /** Number of strikes to subtract from the user's strike count. Usually set from the last policy infraction's severity. */ 338 338 + strikeCount?: number; 252 339 } 253 340 254 341 const hashModEventReverseTakedown = "modEventReverseTakedown"; ··· 356 443 return validate<ModEventPriorityScore & V>(v, id, hashModEventPriorityScore); 357 444 } 358 445 446 446 + /** Age assurance info coming directly from users. Only works on DID subjects. */ 447 447 + export interface AgeAssuranceEvent { 448 448 + $type?: "tools.ozone.moderation.defs#ageAssuranceEvent"; 449 449 + /** The date and time of this write operation. */ 450 450 + createdAt: string; 451 451 + /** The unique identifier for this instance of the age assurance flow, in UUID format. */ 452 452 + attemptId: string; 453 453 + /** The status of the Age Assurance process. */ 454 454 + status: 455 455 + | "unknown" 456 456 + | "pending" 457 457 + | "assured" 458 458 + | (string & globalThis.Record<PropertyKey, never>); 459 459 + access?: AppBskyAgeassuranceDefs.Access; 460 460 + /** The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow. */ 461 461 + countryCode?: string; 462 462 + /** The ISO 3166-2 region code provided when beginning the Age Assurance flow. */ 463 463 + regionCode?: string; 464 464 + /** The IP address used when initiating the AA flow. */ 465 465 + initIp?: string; 466 466 + /** The user agent used when initiating the AA flow. */ 467 467 + initUa?: string; 468 468 + /** The IP address used when completing the AA flow. */ 469 469 + completeIp?: string; 470 470 + /** The user agent used when completing the AA flow. */ 471 471 + completeUa?: string; 472 472 + } 473 473 + 474 474 + const hashAgeAssuranceEvent = "ageAssuranceEvent"; 475 475 + 476 476 + export function isAgeAssuranceEvent<V>(v: V) { 477 477 + return is$typed(v, id, hashAgeAssuranceEvent); 478 478 + } 479 479 + 480 480 + export function validateAgeAssuranceEvent<V>(v: V) { 481 481 + return validate<AgeAssuranceEvent & V>(v, id, hashAgeAssuranceEvent); 482 482 + } 483 483 + 484 484 + /** Age assurance status override by moderators. Only works on DID subjects. */ 485 485 + export interface AgeAssuranceOverrideEvent { 486 486 + $type?: "tools.ozone.moderation.defs#ageAssuranceOverrideEvent"; 487 487 + /** The status to be set for the user decided by a moderator, overriding whatever value the user had previously. Use reset to default to original state. */ 488 488 + status: 489 489 + | "assured" 490 490 + | "reset" 491 491 + | "blocked" 492 492 + | (string & globalThis.Record<PropertyKey, never>); 493 493 + access?: AppBskyAgeassuranceDefs.Access; 494 494 + /** Comment describing the reason for the override. */ 495 495 + comment: string; 496 496 + } 497 497 + 498 498 + const hashAgeAssuranceOverrideEvent = "ageAssuranceOverrideEvent"; 499 499 + 500 500 + export function isAgeAssuranceOverrideEvent<V>(v: V) { 501 501 + return is$typed(v, id, hashAgeAssuranceOverrideEvent); 502 502 + } 503 503 + 504 504 + export function validateAgeAssuranceOverrideEvent<V>(v: V) { 505 505 + return validate<AgeAssuranceOverrideEvent & V>( 506 506 + v, 507 507 + id, 508 508 + hashAgeAssuranceOverrideEvent, 509 509 + ); 510 510 + } 511 511 + 512 512 + /** Account credentials revocation by moderators. Only works on DID subjects. */ 513 513 + export interface RevokeAccountCredentialsEvent { 514 514 + $type?: "tools.ozone.moderation.defs#revokeAccountCredentialsEvent"; 515 515 + /** Comment describing the reason for the revocation. */ 516 516 + comment: string; 517 517 + } 518 518 + 519 519 + const hashRevokeAccountCredentialsEvent = "revokeAccountCredentialsEvent"; 520 520 + 521 521 + export function isRevokeAccountCredentialsEvent<V>(v: V) { 522 522 + return is$typed(v, id, hashRevokeAccountCredentialsEvent); 523 523 + } 524 524 + 525 525 + export function validateRevokeAccountCredentialsEvent<V>(v: V) { 526 526 + return validate<RevokeAccountCredentialsEvent & V>( 527 527 + v, 528 528 + id, 529 529 + hashRevokeAccountCredentialsEvent, 530 530 + ); 531 531 + } 532 532 + 359 533 export interface ModEventAcknowledge { 360 534 $type?: "tools.ozone.moderation.defs#modEventAcknowledge"; 361 535 comment?: string; ··· 471 645 content?: string; 472 646 /** Additional comment about the outgoing comm. */ 473 647 comment?: string; 648 648 + /** Names/Keywords of the policies that necessitated the email. */ 649 649 + policies?: (string)[]; 650 650 + /** Severity level of the violation. Normally 'sev-1' that adds strike on repeat offense */ 651 651 + severityLevel?: string; 652 652 + /** Number of strikes to assign to the user for this violation. Normally 0 as an indicator of a warning and only added as a strike on a repeat offense. */ 653 653 + strikeCount?: number; 654 654 + /** When the strike should expire. If not provided, the strike never expires. */ 655 655 + strikeExpiresAt?: string; 656 656 + /** Indicates whether the email was successfully delivered to the user's inbox. */ 657 657 + isDelivered?: boolean; 474 658 } 475 659 476 660 const hashModEventEmail = "modEventEmail"; ··· 588 772 589 773 export function validateRecordEvent<V>(v: V) { 590 774 return validate<RecordEvent & V>(v, id, hashRecordEvent); 775 775 + } 776 776 + 777 777 + /** Logs a scheduled takedown action for an account. */ 778 778 + export interface ScheduleTakedownEvent { 779 779 + $type?: "tools.ozone.moderation.defs#scheduleTakedownEvent"; 780 780 + comment?: string; 781 781 + executeAt?: string; 782 782 + executeAfter?: string; 783 783 + executeUntil?: string; 784 784 + } 785 785 + 786 786 + const hashScheduleTakedownEvent = "scheduleTakedownEvent"; 787 787 + 788 788 + export function isScheduleTakedownEvent<V>(v: V) { 789 789 + return is$typed(v, id, hashScheduleTakedownEvent); 790 790 + } 791 791 + 792 792 + export function validateScheduleTakedownEvent<V>(v: V) { 793 793 + return validate<ScheduleTakedownEvent & V>(v, id, hashScheduleTakedownEvent); 794 794 + } 795 795 + 796 796 + /** Logs cancellation of a scheduled takedown action for an account. */ 797 797 + export interface CancelScheduledTakedownEvent { 798 798 + $type?: "tools.ozone.moderation.defs#cancelScheduledTakedownEvent"; 799 799 + comment?: string; 800 800 + } 801 801 + 802 802 + const hashCancelScheduledTakedownEvent = "cancelScheduledTakedownEvent"; 803 803 + 804 804 + export function isCancelScheduledTakedownEvent<V>(v: V) { 805 805 + return is$typed(v, id, hashCancelScheduledTakedownEvent); 806 806 + } 807 807 + 808 808 + export function validateCancelScheduledTakedownEvent<V>(v: V) { 809 809 + return validate<CancelScheduledTakedownEvent & V>( 810 810 + v, 811 811 + id, 812 812 + hashCancelScheduledTakedownEvent, 813 813 + ); 591 814 } 592 815 593 816 export interface RepoView { ··· 876 1099 export function validateReporterStats<V>(v: V) { 877 1100 return validate<ReporterStats & V>(v, id, hashReporterStats); 878 1101 } 1102 1102 + 1103 1103 + /** Moderation tool information for tracing the source of the action */ 1104 1104 + export interface ModTool { 1105 1105 + $type?: "tools.ozone.moderation.defs#modTool"; 1106 1106 + /** Name/identifier of the source (e.g., 'automod', 'ozone/workspace') */ 1107 1107 + name: string; 1108 1108 + /** Additional arbitrary metadata about the source */ 1109 1109 + meta?: { [_ in string]: unknown }; 1110 1110 + } 1111 1111 + 1112 1112 + const hashModTool = "modTool"; 1113 1113 + 1114 1114 + export function isModTool<V>(v: V) { 1115 1115 + return is$typed(v, id, hashModTool); 1116 1116 + } 1117 1117 + 1118 1118 + export function validateModTool<V>(v: V) { 1119 1119 + return validate<ModTool & V>(v, id, hashModTool); 1120 1120 + } 1121 1121 + 1122 1122 + /** Moderation event timeline event for a PLC create operation */ 1123 1123 + export const TIMELINEEVENTPLCCREATE = `${id}#timelineEventPlcCreate`; 1124 1124 + /** Moderation event timeline event for generic PLC operation */ 1125 1125 + export const TIMELINEEVENTPLCOPERATION = `${id}#timelineEventPlcOperation`; 1126 1126 + /** Moderation event timeline event for a PLC tombstone operation */ 1127 1127 + export const TIMELINEEVENTPLCTOMBSTONE = `${id}#timelineEventPlcTombstone`; 1128 1128 + 1129 1129 + /** View of a scheduled moderation action */ 1130 1130 + export interface ScheduledActionView { 1131 1131 + $type?: "tools.ozone.moderation.defs#scheduledActionView"; 1132 1132 + /** Auto-incrementing row ID */ 1133 1133 + id: number; 1134 1134 + /** Type of action to be executed */ 1135 1135 + action: "takedown" | (string & globalThis.Record<PropertyKey, never>); 1136 1136 + /** Serialized event object that will be propagated to the event when performed */ 1137 1137 + eventData?: { [_ in string]: unknown }; 1138 1138 + /** Subject DID for the action */ 1139 1139 + did: string; 1140 1140 + /** Exact time to execute the action */ 1141 1141 + executeAt?: string; 1142 1142 + /** Earliest time to execute the action (for randomized scheduling) */ 1143 1143 + executeAfter?: string; 1144 1144 + /** Latest time to execute the action (for randomized scheduling) */ 1145 1145 + executeUntil?: string; 1146 1146 + /** Whether execution time should be randomized within the specified range */ 1147 1147 + randomizeExecution?: boolean; 1148 1148 + /** DID of the user who created this scheduled action */ 1149 1149 + createdBy: string; 1150 1150 + /** When the scheduled action was created */ 1151 1151 + createdAt: string; 1152 1152 + /** When the scheduled action was last updated */ 1153 1153 + updatedAt?: string; 1154 1154 + /** Current status of the scheduled action */ 1155 1155 + status: 1156 1156 + | "pending" 1157 1157 + | "executed" 1158 1158 + | "cancelled" 1159 1159 + | "failed" 1160 1160 + | (string & globalThis.Record<PropertyKey, never>); 1161 1161 + /** When the action was last attempted to be executed */ 1162 1162 + lastExecutedAt?: string; 1163 1163 + /** Reason for the last execution failure */ 1164 1164 + lastFailureReason?: string; 1165 1165 + /** ID of the moderation event created when action was successfully executed */ 1166 1166 + executionEventId?: number; 1167 1167 + } 1168 1168 + 1169 1169 + const hashScheduledActionView = "scheduledActionView"; 1170 1170 + 1171 1171 + export function isScheduledActionView<V>(v: V) { 1172 1172 + return is$typed(v, id, hashScheduledActionView); 1173 1173 + } 1174 1174 + 1175 1175 + export function validateScheduledActionView<V>(v: V) { 1176 1176 + return validate<ScheduledActionView & V>(v, id, hashScheduledActionView); 1177 1177 + }

+9 -1

lex/types/tools/ozone/moderation/emitEvent.ts

reviewed

··· 29 29 | $Typed<ToolsOzoneModerationDefs.IdentityEvent> 30 30 | $Typed<ToolsOzoneModerationDefs.RecordEvent> 31 31 | $Typed<ToolsOzoneModerationDefs.ModEventPriorityScore> 32 32 + | $Typed<ToolsOzoneModerationDefs.AgeAssuranceEvent> 33 33 + | $Typed<ToolsOzoneModerationDefs.AgeAssuranceOverrideEvent> 34 34 + | $Typed<ToolsOzoneModerationDefs.RevokeAccountCredentialsEvent> 35 35 + | $Typed<ToolsOzoneModerationDefs.ScheduleTakedownEvent> 36 36 + | $Typed<ToolsOzoneModerationDefs.CancelScheduledTakedownEvent> 32 37 | { $type: string }; 33 38 subject: 34 39 | $Typed<ComAtprotoAdminDefs.RepoRef> ··· 36 41 | { $type: string }; 37 42 subjectBlobCids?: (string)[]; 38 43 createdBy: string; 44 44 + modTool?: ToolsOzoneModerationDefs.ModTool; 45 45 + /** An optional external ID for the event, used to deduplicate events from external systems. Fails when an event of same type with the same external ID exists for the same subject. */ 46 46 + externalId?: string; 39 47 } 40 48 41 49 export type OutputSchema = ToolsOzoneModerationDefs.ModEventView; ··· 54 62 export interface HandlerError { 55 63 status: number; 56 64 message?: string; 57 57 - error?: "SubjectHasAction"; 65 65 + error?: "SubjectHasAction" | "DuplicateExternalId"; 58 66 } 59 67 60 68 export type HandlerOutput = HandlerError | HandlerSuccess;

+102

lex/types/tools/ozone/moderation/getAccountTimeline.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "tools.ozone.moderation.getAccountTimeline"; 9 9 + 10 10 + export type QueryParams = { 11 11 + did: string; 12 12 + }; 13 13 + export type InputSchema = undefined; 14 14 + 15 15 + export interface OutputSchema { 16 16 + timeline: (TimelineItem)[]; 17 17 + } 18 18 + 19 19 + export type HandlerInput = void; 20 20 + 21 21 + export interface HandlerSuccess { 22 22 + encoding: "application/json"; 23 23 + body: OutputSchema; 24 24 + headers?: { [key: string]: string }; 25 25 + } 26 26 + 27 27 + export interface HandlerError { 28 28 + status: number; 29 29 + message?: string; 30 30 + error?: "RepoNotFound"; 31 31 + } 32 32 + 33 33 + export type HandlerOutput = HandlerError | HandlerSuccess; 34 34 + 35 35 + export interface TimelineItem { 36 36 + $type?: "tools.ozone.moderation.getAccountTimeline#timelineItem"; 37 37 + day: string; 38 38 + summary: (TimelineItemSummary)[]; 39 39 + } 40 40 + 41 41 + const hashTimelineItem = "timelineItem"; 42 42 + 43 43 + export function isTimelineItem<V>(v: V) { 44 44 + return is$typed(v, id, hashTimelineItem); 45 45 + } 46 46 + 47 47 + export function validateTimelineItem<V>(v: V) { 48 48 + return validate<TimelineItem & V>(v, id, hashTimelineItem); 49 49 + } 50 50 + 51 51 + export interface TimelineItemSummary { 52 52 + $type?: "tools.ozone.moderation.getAccountTimeline#timelineItemSummary"; 53 53 + eventSubjectType: 54 54 + | "account" 55 55 + | "record" 56 56 + | "chat" 57 57 + | (string & globalThis.Record<PropertyKey, never>); 58 58 + eventType: 59 59 + | "tools.ozone.moderation.defs#modEventTakedown" 60 60 + | "tools.ozone.moderation.defs#modEventReverseTakedown" 61 61 + | "tools.ozone.moderation.defs#modEventComment" 62 62 + | "tools.ozone.moderation.defs#modEventReport" 63 63 + | "tools.ozone.moderation.defs#modEventLabel" 64 64 + | "tools.ozone.moderation.defs#modEventAcknowledge" 65 65 + | "tools.ozone.moderation.defs#modEventEscalate" 66 66 + | "tools.ozone.moderation.defs#modEventMute" 67 67 + | "tools.ozone.moderation.defs#modEventUnmute" 68 68 + | "tools.ozone.moderation.defs#modEventMuteReporter" 69 69 + | "tools.ozone.moderation.defs#modEventUnmuteReporter" 70 70 + | "tools.ozone.moderation.defs#modEventEmail" 71 71 + | "tools.ozone.moderation.defs#modEventResolveAppeal" 72 72 + | "tools.ozone.moderation.defs#modEventDivert" 73 73 + | "tools.ozone.moderation.defs#modEventTag" 74 74 + | "tools.ozone.moderation.defs#accountEvent" 75 75 + | "tools.ozone.moderation.defs#identityEvent" 76 76 + | "tools.ozone.moderation.defs#recordEvent" 77 77 + | "tools.ozone.moderation.defs#modEventPriorityScore" 78 78 + | "tools.ozone.moderation.defs#revokeAccountCredentialsEvent" 79 79 + | "tools.ozone.moderation.defs#ageAssuranceEvent" 80 80 + | "tools.ozone.moderation.defs#ageAssuranceOverrideEvent" 81 81 + | "tools.ozone.moderation.defs#timelineEventPlcCreate" 82 82 + | "tools.ozone.moderation.defs#timelineEventPlcOperation" 83 83 + | "tools.ozone.moderation.defs#timelineEventPlcTombstone" 84 84 + | "tools.ozone.hosting.getAccountHistory#accountCreated" 85 85 + | "tools.ozone.hosting.getAccountHistory#emailConfirmed" 86 86 + | "tools.ozone.hosting.getAccountHistory#passwordUpdated" 87 87 + | "tools.ozone.hosting.getAccountHistory#handleUpdated" 88 88 + | "tools.ozone.moderation.defs#scheduleTakedownEvent" 89 89 + | "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" 90 90 + | (string & globalThis.Record<PropertyKey, never>); 91 91 + count: number; 92 92 + } 93 93 + 94 94 + const hashTimelineItemSummary = "timelineItemSummary"; 95 95 + 96 96 + export function isTimelineItemSummary<V>(v: V) { 97 97 + return is$typed(v, id, hashTimelineItemSummary); 98 98 + } 99 99 + 100 100 + export function validateTimelineItemSummary<V>(v: V) { 101 101 + return validate<TimelineItemSummary & V>(v, id, hashTimelineItemSummary); 102 102 + }

+28

lex/types/tools/ozone/moderation/getSubjects.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneModerationDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + subjects: string[]; 8 8 + }; 9 9 + export type InputSchema = undefined; 10 10 + 11 11 + export interface OutputSchema { 12 12 + subjects: (ToolsOzoneModerationDefs.SubjectView)[]; 13 13 + } 14 14 + 15 15 + export type HandlerInput = void; 16 16 + 17 17 + export interface HandlerSuccess { 18 18 + encoding: "application/json"; 19 19 + body: OutputSchema; 20 20 + headers?: { [key: string]: string }; 21 21 + } 22 22 + 23 23 + export interface HandlerError { 24 24 + status: number; 25 25 + message?: string; 26 26 + } 27 27 + 28 28 + export type HandlerOutput = HandlerError | HandlerSuccess;

+51

lex/types/tools/ozone/moderation/listScheduledActions.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneModerationDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** Filter actions scheduled to execute after this time */ 10 10 + startsAfter?: string; 11 11 + /** Filter actions scheduled to execute before this time */ 12 12 + endsBefore?: string; 13 13 + /** Filter actions for specific DID subjects */ 14 14 + subjects?: (string)[]; 15 15 + /** Filter actions by status */ 16 16 + statuses: ( 17 17 + | "pending" 18 18 + | "executed" 19 19 + | "cancelled" 20 20 + | "failed" 21 21 + | (string & globalThis.Record<PropertyKey, never>) 22 22 + )[]; 23 23 + /** Maximum number of results to return */ 24 24 + limit: number; 25 25 + /** Cursor for pagination */ 26 26 + cursor?: string; 27 27 + } 28 28 + 29 29 + export interface OutputSchema { 30 30 + actions: (ToolsOzoneModerationDefs.ScheduledActionView)[]; 31 31 + /** Cursor for next page of results */ 32 32 + cursor?: string; 33 33 + } 34 34 + 35 35 + export interface HandlerInput { 36 36 + encoding: "application/json"; 37 37 + body: InputSchema; 38 38 + } 39 39 + 40 40 + export interface HandlerSuccess { 41 41 + encoding: "application/json"; 42 42 + body: OutputSchema; 43 43 + headers?: { [key: string]: string }; 44 44 + } 45 45 + 46 46 + export interface HandlerError { 47 47 + status: number; 48 48 + message?: string; 49 49 + } 50 50 + 51 51 + export type HandlerOutput = HandlerError | HandlerSuccess;

+14

lex/types/tools/ozone/moderation/queryEvents.ts

reviewed

··· 38 38 removedTags?: string[]; 39 39 reportTypes?: string[]; 40 40 policies?: string[]; 41 41 + /** If specified, only events where the modTool name matches any of the given values are returned */ 42 42 + modTool?: string[]; 43 43 + /** If specified, only events where the batchId matches the given value are returned */ 44 44 + batchId?: string; 45 45 + /** If specified, only events where the age assurance state matches the given value are returned */ 46 46 + ageAssuranceState?: 47 47 + | "pending" 48 48 + | "assured" 49 49 + | "unknown" 50 50 + | "reset" 51 51 + | "blocked" 52 52 + | (string & globalThis.Record<PropertyKey, never>); 53 53 + /** If specified, only events where strikeCount value is set are returned. */ 54 54 + withStrike?: boolean; 41 55 cursor?: string; 42 56 }; 43 57 export type InputSchema = undefined;

+16 -1

lex/types/tools/ozone/moderation/queryStatuses.ts

reviewed

··· 39 39 /** When set to true, only muted subjects and reporters will be returned. */ 40 40 onlyMuted?: boolean; 41 41 /** Specify when fetching subjects in a certain state */ 42 42 - reviewState?: string; 42 42 + reviewState?: 43 43 + | "tools.ozone.moderation.defs#reviewOpen" 44 44 + | "tools.ozone.moderation.defs#reviewClosed" 45 45 + | "tools.ozone.moderation.defs#reviewEscalated" 46 46 + | "tools.ozone.moderation.defs#reviewNone" 47 47 + | (string & globalThis.Record<PropertyKey, never>); 43 48 ignoreSubjects?: string[]; 44 49 /** Get all subject statuses that were reviewed by a specific moderator */ 45 50 lastReviewedBy?: string; ··· 73 78 minTakendownRecordsCount?: number; 74 79 /** If specified, only subjects that have priority score value above the given value will be returned. */ 75 80 minPriorityScore?: number; 81 81 + /** If specified, only subjects that belong to an account that has at least this many active strikes will be returned. */ 82 82 + minStrikeCount?: number; 83 83 + /** If specified, only subjects with the given age assurance state will be returned. */ 84 84 + ageAssuranceState?: 85 85 + | "pending" 86 86 + | "assured" 87 87 + | "unknown" 88 88 + | "reset" 89 89 + | "blocked" 90 90 + | (string & globalThis.Record<PropertyKey, never>); 76 91 }; 77 92 export type InputSchema = undefined; 78 93

+131

lex/types/tools/ozone/moderation/scheduleAction.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + import type * as ToolsOzoneModerationDefs from "./defs.ts"; 8 8 + 9 9 + const is$typed = _is$typed, validate = _validate; 10 10 + const id = "tools.ozone.moderation.scheduleAction"; 11 11 + 12 12 + export type QueryParams = globalThis.Record<PropertyKey, never>; 13 13 + 14 14 + export interface InputSchema { 15 15 + action: $Typed<Takedown> | { $type: string }; 16 16 + /** Array of DID subjects to schedule the action for */ 17 17 + subjects: (string)[]; 18 18 + createdBy: string; 19 19 + scheduling: SchedulingConfig; 20 20 + modTool?: ToolsOzoneModerationDefs.ModTool; 21 21 + } 22 22 + 23 23 + export type OutputSchema = ScheduledActionResults; 24 24 + 25 25 + export interface HandlerInput { 26 26 + encoding: "application/json"; 27 27 + body: InputSchema; 28 28 + } 29 29 + 30 30 + export interface HandlerSuccess { 31 31 + encoding: "application/json"; 32 32 + body: OutputSchema; 33 33 + headers?: { [key: string]: string }; 34 34 + } 35 35 + 36 36 + export interface HandlerError { 37 37 + status: number; 38 38 + message?: string; 39 39 + } 40 40 + 41 41 + export type HandlerOutput = HandlerError | HandlerSuccess; 42 42 + 43 43 + /** Schedule a takedown action */ 44 44 + export interface Takedown { 45 45 + $type?: "tools.ozone.moderation.scheduleAction#takedown"; 46 46 + comment?: string; 47 47 + /** Indicates how long the takedown should be in effect before automatically expiring. */ 48 48 + durationInHours?: number; 49 49 + /** If true, all other reports on content authored by this account will be resolved (acknowledged). */ 50 50 + acknowledgeAccountSubjects?: boolean; 51 51 + /** Names/Keywords of the policies that drove the decision. */ 52 52 + policies?: (string)[]; 53 53 + /** Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.). */ 54 54 + severityLevel?: string; 55 55 + /** Number of strikes to assign to the user when takedown is applied. */ 56 56 + strikeCount?: number; 57 57 + /** When the strike should expire. If not provided, the strike never expires. */ 58 58 + strikeExpiresAt?: string; 59 59 + /** Email content to be sent to the user upon takedown. */ 60 60 + emailContent?: string; 61 61 + /** Subject of the email to be sent to the user upon takedown. */ 62 62 + emailSubject?: string; 63 63 + } 64 64 + 65 65 + const hashTakedown = "takedown"; 66 66 + 67 67 + export function isTakedown<V>(v: V) { 68 68 + return is$typed(v, id, hashTakedown); 69 69 + } 70 70 + 71 71 + export function validateTakedown<V>(v: V) { 72 72 + return validate<Takedown & V>(v, id, hashTakedown); 73 73 + } 74 74 + 75 75 + /** Configuration for when the action should be executed */ 76 76 + export interface SchedulingConfig { 77 77 + $type?: "tools.ozone.moderation.scheduleAction#schedulingConfig"; 78 78 + /** Exact time to execute the action */ 79 79 + executeAt?: string; 80 80 + /** Earliest time to execute the action (for randomized scheduling) */ 81 81 + executeAfter?: string; 82 82 + /** Latest time to execute the action (for randomized scheduling) */ 83 83 + executeUntil?: string; 84 84 + } 85 85 + 86 86 + const hashSchedulingConfig = "schedulingConfig"; 87 87 + 88 88 + export function isSchedulingConfig<V>(v: V) { 89 89 + return is$typed(v, id, hashSchedulingConfig); 90 90 + } 91 91 + 92 92 + export function validateSchedulingConfig<V>(v: V) { 93 93 + return validate<SchedulingConfig & V>(v, id, hashSchedulingConfig); 94 94 + } 95 95 + 96 96 + export interface ScheduledActionResults { 97 97 + $type?: "tools.ozone.moderation.scheduleAction#scheduledActionResults"; 98 98 + succeeded: (string)[]; 99 99 + failed: (FailedScheduling)[]; 100 100 + } 101 101 + 102 102 + const hashScheduledActionResults = "scheduledActionResults"; 103 103 + 104 104 + export function isScheduledActionResults<V>(v: V) { 105 105 + return is$typed(v, id, hashScheduledActionResults); 106 106 + } 107 107 + 108 108 + export function validateScheduledActionResults<V>(v: V) { 109 109 + return validate<ScheduledActionResults & V>( 110 110 + v, 111 111 + id, 112 112 + hashScheduledActionResults, 113 113 + ); 114 114 + } 115 115 + 116 116 + export interface FailedScheduling { 117 117 + $type?: "tools.ozone.moderation.scheduleAction#failedScheduling"; 118 118 + subject: string; 119 119 + error: string; 120 120 + errorCode?: string; 121 121 + } 122 122 + 123 123 + const hashFailedScheduling = "failedScheduling"; 124 124 + 125 125 + export function isFailedScheduling<V>(v: V) { 126 126 + return is$typed(v, id, hashFailedScheduling); 127 127 + } 128 128 + 129 129 + export function validateFailedScheduling<V>(v: V) { 130 130 + return validate<FailedScheduling & V>(v, id, hashFailedScheduling); 131 131 + }

+131

lex/types/tools/ozone/report/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + const id = "tools.ozone.report.defs"; 5 5 + 6 6 + export type ReasonType = 7 7 + | "tools.ozone.report.defs#reasonAppeal" 8 8 + | "tools.ozone.report.defs#reasonOther" 9 9 + | "tools.ozone.report.defs#reasonViolenceAnimal" 10 10 + | "tools.ozone.report.defs#reasonViolenceThreats" 11 11 + | "tools.ozone.report.defs#reasonViolenceGraphicContent" 12 12 + | "tools.ozone.report.defs#reasonViolenceGlorification" 13 13 + | "tools.ozone.report.defs#reasonViolenceExtremistContent" 14 14 + | "tools.ozone.report.defs#reasonViolenceTrafficking" 15 15 + | "tools.ozone.report.defs#reasonViolenceOther" 16 16 + | "tools.ozone.report.defs#reasonSexualAbuseContent" 17 17 + | "tools.ozone.report.defs#reasonSexualNCII" 18 18 + | "tools.ozone.report.defs#reasonSexualDeepfake" 19 19 + | "tools.ozone.report.defs#reasonSexualAnimal" 20 20 + | "tools.ozone.report.defs#reasonSexualUnlabeled" 21 21 + | "tools.ozone.report.defs#reasonSexualOther" 22 22 + | "tools.ozone.report.defs#reasonChildSafetyCSAM" 23 23 + | "tools.ozone.report.defs#reasonChildSafetyGroom" 24 24 + | "tools.ozone.report.defs#reasonChildSafetyPrivacy" 25 25 + | "tools.ozone.report.defs#reasonChildSafetyHarassment" 26 26 + | "tools.ozone.report.defs#reasonChildSafetyOther" 27 27 + | "tools.ozone.report.defs#reasonHarassmentTroll" 28 28 + | "tools.ozone.report.defs#reasonHarassmentTargeted" 29 29 + | "tools.ozone.report.defs#reasonHarassmentHateSpeech" 30 30 + | "tools.ozone.report.defs#reasonHarassmentDoxxing" 31 31 + | "tools.ozone.report.defs#reasonHarassmentOther" 32 32 + | "tools.ozone.report.defs#reasonMisleadingBot" 33 33 + | "tools.ozone.report.defs#reasonMisleadingImpersonation" 34 34 + | "tools.ozone.report.defs#reasonMisleadingSpam" 35 35 + | "tools.ozone.report.defs#reasonMisleadingScam" 36 36 + | "tools.ozone.report.defs#reasonMisleadingElections" 37 37 + | "tools.ozone.report.defs#reasonMisleadingOther" 38 38 + | "tools.ozone.report.defs#reasonRuleSiteSecurity" 39 39 + | "tools.ozone.report.defs#reasonRuleProhibitedSales" 40 40 + | "tools.ozone.report.defs#reasonRuleBanEvasion" 41 41 + | "tools.ozone.report.defs#reasonRuleOther" 42 42 + | "tools.ozone.report.defs#reasonSelfHarmContent" 43 43 + | "tools.ozone.report.defs#reasonSelfHarmED" 44 44 + | "tools.ozone.report.defs#reasonSelfHarmStunts" 45 45 + | "tools.ozone.report.defs#reasonSelfHarmSubstances" 46 46 + | "tools.ozone.report.defs#reasonSelfHarmOther" 47 47 + | (string & globalThis.Record<PropertyKey, never>); 48 48 + 49 49 + /** Appeal a previously taken moderation action */ 50 50 + export const REASONAPPEAL = `${id}#reasonAppeal`; 51 51 + /** An issue not included in these options */ 52 52 + export const REASONOTHER = `${id}#reasonOther`; 53 53 + /** Animal welfare violations */ 54 54 + export const REASONVIOLENCEANIMAL = `${id}#reasonViolenceAnimal`; 55 55 + /** Threats or incitement */ 56 56 + export const REASONVIOLENCETHREATS = `${id}#reasonViolenceThreats`; 57 57 + /** Graphic violent content */ 58 58 + export const REASONVIOLENCEGRAPHICCONTENT = 59 59 + `${id}#reasonViolenceGraphicContent`; 60 60 + /** Glorification of violence */ 61 61 + export const REASONVIOLENCEGLORIFICATION = `${id}#reasonViolenceGlorification`; 62 62 + /** Extremist content. These reports will be sent only be sent to the application's Moderation Authority. */ 63 63 + export const REASONVIOLENCEEXTREMISTCONTENT = 64 64 + `${id}#reasonViolenceExtremistContent`; 65 65 + /** Human trafficking */ 66 66 + export const REASONVIOLENCETRAFFICKING = `${id}#reasonViolenceTrafficking`; 67 67 + /** Other violent content */ 68 68 + export const REASONVIOLENCEOTHER = `${id}#reasonViolenceOther`; 69 69 + /** Adult sexual abuse content */ 70 70 + export const REASONSEXUALABUSECONTENT = `${id}#reasonSexualAbuseContent`; 71 71 + /** Non-consensual intimate imagery */ 72 72 + export const REASONSEXUALNCII = `${id}#reasonSexualNCII`; 73 73 + /** Deepfake adult content */ 74 74 + export const REASONSEXUALDEEPFAKE = `${id}#reasonSexualDeepfake`; 75 75 + /** Animal sexual abuse */ 76 76 + export const REASONSEXUALANIMAL = `${id}#reasonSexualAnimal`; 77 77 + /** Unlabelled adult content */ 78 78 + export const REASONSEXUALUNLABELED = `${id}#reasonSexualUnlabeled`; 79 79 + /** Other sexual violence content */ 80 80 + export const REASONSEXUALOTHER = `${id}#reasonSexualOther`; 81 81 + /** Child sexual abuse material (CSAM). These reports will be sent only be sent to the application's Moderation Authority. */ 82 82 + export const REASONCHILDSAFETYCSAM = `${id}#reasonChildSafetyCSAM`; 83 83 + /** Grooming or predatory behavior. These reports will be sent only be sent to the application's Moderation Authority. */ 84 84 + export const REASONCHILDSAFETYGROOM = `${id}#reasonChildSafetyGroom`; 85 85 + /** Privacy violation involving a minor */ 86 86 + export const REASONCHILDSAFETYPRIVACY = `${id}#reasonChildSafetyPrivacy`; 87 87 + /** Harassment or bullying of minors */ 88 88 + export const REASONCHILDSAFETYHARASSMENT = `${id}#reasonChildSafetyHarassment`; 89 89 + /** Other child safety. These reports will be sent only be sent to the application's Moderation Authority. */ 90 90 + export const REASONCHILDSAFETYOTHER = `${id}#reasonChildSafetyOther`; 91 91 + /** Trolling */ 92 92 + export const REASONHARASSMENTTROLL = `${id}#reasonHarassmentTroll`; 93 93 + /** Targeted harassment */ 94 94 + export const REASONHARASSMENTTARGETED = `${id}#reasonHarassmentTargeted`; 95 95 + /** Hate speech */ 96 96 + export const REASONHARASSMENTHATESPEECH = `${id}#reasonHarassmentHateSpeech`; 97 97 + /** Doxxing */ 98 98 + export const REASONHARASSMENTDOXXING = `${id}#reasonHarassmentDoxxing`; 99 99 + /** Other harassing or hateful content */ 100 100 + export const REASONHARASSMENTOTHER = `${id}#reasonHarassmentOther`; 101 101 + /** Fake account or bot */ 102 102 + export const REASONMISLEADINGBOT = `${id}#reasonMisleadingBot`; 103 103 + /** Impersonation */ 104 104 + export const REASONMISLEADINGIMPERSONATION = 105 105 + `${id}#reasonMisleadingImpersonation`; 106 106 + /** Spam */ 107 107 + export const REASONMISLEADINGSPAM = `${id}#reasonMisleadingSpam`; 108 108 + /** Scam */ 109 109 + export const REASONMISLEADINGSCAM = `${id}#reasonMisleadingScam`; 110 110 + /** False information about elections */ 111 111 + export const REASONMISLEADINGELECTIONS = `${id}#reasonMisleadingElections`; 112 112 + /** Other misleading content */ 113 113 + export const REASONMISLEADINGOTHER = `${id}#reasonMisleadingOther`; 114 114 + /** Hacking or system attacks */ 115 115 + export const REASONRULESITESECURITY = `${id}#reasonRuleSiteSecurity`; 116 116 + /** Promoting or selling prohibited items or services */ 117 117 + export const REASONRULEPROHIBITEDSALES = `${id}#reasonRuleProhibitedSales`; 118 118 + /** Banned user returning */ 119 119 + export const REASONRULEBANEVASION = `${id}#reasonRuleBanEvasion`; 120 120 + /** Other */ 121 121 + export const REASONRULEOTHER = `${id}#reasonRuleOther`; 122 122 + /** Content promoting or depicting self-harm */ 123 123 + export const REASONSELFHARMCONTENT = `${id}#reasonSelfHarmContent`; 124 124 + /** Eating disorders */ 125 125 + export const REASONSELFHARMED = `${id}#reasonSelfHarmED`; 126 126 + /** Dangerous challenges or activities */ 127 127 + export const REASONSELFHARMSTUNTS = `${id}#reasonSelfHarmStunts`; 128 128 + /** Dangerous substances or drug abuse */ 129 129 + export const REASONSELFHARMSUBSTANCES = `${id}#reasonSelfHarmSubstances`; 130 130 + /** Other dangerous content */ 131 131 + export const REASONSELFHARMOTHER = `${id}#reasonSelfHarmOther`;

+39

lex/types/tools/ozone/safelink/addRule.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneSafelinkDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** The URL or domain to apply the rule to */ 10 10 + url: string; 11 11 + pattern: ToolsOzoneSafelinkDefs.PatternType; 12 12 + action: ToolsOzoneSafelinkDefs.ActionType; 13 13 + reason: ToolsOzoneSafelinkDefs.ReasonType; 14 14 + /** Optional comment about the decision */ 15 15 + comment?: string; 16 16 + /** Author DID. Only respected when using admin auth */ 17 17 + createdBy?: string; 18 18 + } 19 19 + 20 20 + export type OutputSchema = ToolsOzoneSafelinkDefs.Event; 21 21 + 22 22 + export interface HandlerInput { 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 + } 26 26 + 27 27 + export interface HandlerSuccess { 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 + } 32 32 + 33 33 + export interface HandlerError { 34 34 + status: number; 35 35 + message?: string; 36 36 + error?: "InvalidUrl" | "RuleAlreadyExists"; 37 37 + } 38 38 + 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess;

+85

lex/types/tools/ozone/safelink/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "tools.ozone.safelink.defs"; 9 9 + 10 10 + /** An event for URL safety decisions */ 11 11 + export interface Event { 12 12 + $type?: "tools.ozone.safelink.defs#event"; 13 13 + /** Auto-incrementing row ID */ 14 14 + id: number; 15 15 + eventType: EventType; 16 16 + /** The URL that this rule applies to */ 17 17 + url: string; 18 18 + pattern: PatternType; 19 19 + action: ActionType; 20 20 + reason: ReasonType; 21 21 + /** DID of the user who created this rule */ 22 22 + createdBy: string; 23 23 + createdAt: string; 24 24 + /** Optional comment about the decision */ 25 25 + comment?: string; 26 26 + } 27 27 + 28 28 + const hashEvent = "event"; 29 29 + 30 30 + export function isEvent<V>(v: V) { 31 31 + return is$typed(v, id, hashEvent); 32 32 + } 33 33 + 34 34 + export function validateEvent<V>(v: V) { 35 35 + return validate<Event & V>(v, id, hashEvent); 36 36 + } 37 37 + 38 38 + export type EventType = 39 39 + | "addRule" 40 40 + | "updateRule" 41 41 + | "removeRule" 42 42 + | (string & globalThis.Record<PropertyKey, never>); 43 43 + export type PatternType = 44 44 + | "domain" 45 45 + | "url" 46 46 + | (string & globalThis.Record<PropertyKey, never>); 47 47 + export type ActionType = 48 48 + | "block" 49 49 + | "warn" 50 50 + | "whitelist" 51 51 + | (string & globalThis.Record<PropertyKey, never>); 52 52 + export type ReasonType = 53 53 + | "csam" 54 54 + | "spam" 55 55 + | "phishing" 56 56 + | "none" 57 57 + | (string & globalThis.Record<PropertyKey, never>); 58 58 + 59 59 + /** Input for creating a URL safety rule */ 60 60 + export interface UrlRule { 61 61 + $type?: "tools.ozone.safelink.defs#urlRule"; 62 62 + /** The URL or domain to apply the rule to */ 63 63 + url: string; 64 64 + pattern: PatternType; 65 65 + action: ActionType; 66 66 + reason: ReasonType; 67 67 + /** Optional comment about the decision */ 68 68 + comment?: string; 69 69 + /** DID of the user added the rule. */ 70 70 + createdBy: string; 71 71 + /** Timestamp when the rule was created */ 72 72 + createdAt: string; 73 73 + /** Timestamp when the rule was last updated */ 74 74 + updatedAt: string; 75 75 + } 76 76 + 77 77 + const hashUrlRule = "urlRule"; 78 78 + 79 79 + export function isUrlRule<V>(v: V) { 80 80 + return is$typed(v, id, hashUrlRule); 81 81 + } 82 82 + 83 83 + export function validateUrlRule<V>(v: V) { 84 84 + return validate<UrlRule & V>(v, id, hashUrlRule); 85 85 + }

+46

lex/types/tools/ozone/safelink/queryEvents.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneSafelinkDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** Cursor for pagination */ 10 10 + cursor?: string; 11 11 + /** Maximum number of results to return */ 12 12 + limit: number; 13 13 + /** Filter by specific URLs or domains */ 14 14 + urls?: (string)[]; 15 15 + /** Filter by pattern type */ 16 16 + patternType?: string; 17 17 + /** Sort direction */ 18 18 + sortDirection: 19 19 + | "asc" 20 20 + | "desc" 21 21 + | (string & globalThis.Record<PropertyKey, never>); 22 22 + } 23 23 + 24 24 + export interface OutputSchema { 25 25 + /** Next cursor for pagination. Only present if there are more results. */ 26 26 + cursor?: string; 27 27 + events: (ToolsOzoneSafelinkDefs.Event)[]; 28 28 + } 29 29 + 30 30 + export interface HandlerInput { 31 31 + encoding: "application/json"; 32 32 + body: InputSchema; 33 33 + } 34 34 + 35 35 + export interface HandlerSuccess { 36 36 + encoding: "application/json"; 37 37 + body: OutputSchema; 38 38 + headers?: { [key: string]: string }; 39 39 + } 40 40 + 41 41 + export interface HandlerError { 42 42 + status: number; 43 43 + message?: string; 44 44 + } 45 45 + 46 46 + export type HandlerOutput = HandlerError | HandlerSuccess;

+52

lex/types/tools/ozone/safelink/queryRules.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneSafelinkDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** Cursor for pagination */ 10 10 + cursor?: string; 11 11 + /** Maximum number of results to return */ 12 12 + limit: number; 13 13 + /** Filter by specific URLs or domains */ 14 14 + urls?: (string)[]; 15 15 + /** Filter by pattern type */ 16 16 + patternType?: string; 17 17 + /** Filter by action types */ 18 18 + actions?: (string)[]; 19 19 + /** Filter by reason type */ 20 20 + reason?: string; 21 21 + /** Filter by rule creator */ 22 22 + createdBy?: string; 23 23 + /** Sort direction */ 24 24 + sortDirection: 25 25 + | "asc" 26 26 + | "desc" 27 27 + | (string & globalThis.Record<PropertyKey, never>); 28 28 + } 29 29 + 30 30 + export interface OutputSchema { 31 31 + /** Next cursor for pagination. Only present if there are more results. */ 32 32 + cursor?: string; 33 33 + rules: (ToolsOzoneSafelinkDefs.UrlRule)[]; 34 34 + } 35 35 + 36 36 + export interface HandlerInput { 37 37 + encoding: "application/json"; 38 38 + body: InputSchema; 39 39 + } 40 40 + 41 41 + export interface HandlerSuccess { 42 42 + encoding: "application/json"; 43 43 + body: OutputSchema; 44 44 + headers?: { [key: string]: string }; 45 45 + } 46 46 + 47 47 + export interface HandlerError { 48 48 + status: number; 49 49 + message?: string; 50 50 + } 51 51 + 52 52 + export type HandlerOutput = HandlerError | HandlerSuccess;

+37

lex/types/tools/ozone/safelink/removeRule.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneSafelinkDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** The URL or domain to remove the rule for */ 10 10 + url: string; 11 11 + pattern: ToolsOzoneSafelinkDefs.PatternType; 12 12 + /** Optional comment about why the rule is being removed */ 13 13 + comment?: string; 14 14 + /** Optional DID of the user. Only respected when using admin auth. */ 15 15 + createdBy?: string; 16 16 + } 17 17 + 18 18 + export type OutputSchema = ToolsOzoneSafelinkDefs.Event; 19 19 + 20 20 + export interface HandlerInput { 21 21 + encoding: "application/json"; 22 22 + body: InputSchema; 23 23 + } 24 24 + 25 25 + export interface HandlerSuccess { 26 26 + encoding: "application/json"; 27 27 + body: OutputSchema; 28 28 + headers?: { [key: string]: string }; 29 29 + } 30 30 + 31 31 + export interface HandlerError { 32 32 + status: number; 33 33 + message?: string; 34 34 + error?: "RuleNotFound"; 35 35 + } 36 36 + 37 37 + export type HandlerOutput = HandlerError | HandlerSuccess;

+39

lex/types/tools/ozone/safelink/updateRule.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneSafelinkDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = globalThis.Record<PropertyKey, never>; 7 7 + 8 8 + export interface InputSchema { 9 9 + /** The URL or domain to update the rule for */ 10 10 + url: string; 11 11 + pattern: ToolsOzoneSafelinkDefs.PatternType; 12 12 + action: ToolsOzoneSafelinkDefs.ActionType; 13 13 + reason: ToolsOzoneSafelinkDefs.ReasonType; 14 14 + /** Optional comment about the update */ 15 15 + comment?: string; 16 16 + /** Optional DID to credit as the creator. Only respected for admin_token authentication. */ 17 17 + createdBy?: string; 18 18 + } 19 19 + 20 20 + export type OutputSchema = ToolsOzoneSafelinkDefs.Event; 21 21 + 22 22 + export interface HandlerInput { 23 23 + encoding: "application/json"; 24 24 + body: InputSchema; 25 25 + } 26 26 + 27 27 + export interface HandlerSuccess { 28 28 + encoding: "application/json"; 29 29 + body: OutputSchema; 30 30 + headers?: { [key: string]: string }; 31 31 + } 32 32 + 33 33 + export interface HandlerError { 34 34 + status: number; 35 35 + message?: string; 36 36 + error?: "RuleNotFound"; 37 37 + } 38 38 + 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess;

+3

lex/types/tools/ozone/server/getConfig.ts

reviewed

··· 16 16 blobDivert?: ServiceConfig; 17 17 chat?: ServiceConfig; 18 18 viewer?: ViewerConfig; 19 19 + /** The did of the verifier used for verification. */ 20 20 + verifierDid?: string; 19 21 } 20 22 21 23 export type HandlerInput = void; ··· 54 56 | "tools.ozone.team.defs#roleAdmin" 55 57 | "tools.ozone.team.defs#roleModerator" 56 58 | "tools.ozone.team.defs#roleTriage" 59 59 + | "tools.ozone.team.defs#roleVerifier" 57 60 | (string & globalThis.Record<PropertyKey, never>); 58 61 } 59 62

+1

lex/types/tools/ozone/setting/defs.ts

reviewed

··· 19 19 | "tools.ozone.team.defs#roleModerator" 20 20 | "tools.ozone.team.defs#roleTriage" 21 21 | "tools.ozone.team.defs#roleAdmin" 22 22 + | "tools.ozone.team.defs#roleVerifier" 22 23 | (string & globalThis.Record<PropertyKey, never>); 23 24 scope: 24 25 | "instance"

+1

lex/types/tools/ozone/setting/upsertOption.ts

reviewed

··· 16 16 managerRole?: 17 17 | "tools.ozone.team.defs#roleModerator" 18 18 | "tools.ozone.team.defs#roleTriage" 19 19 + | "tools.ozone.team.defs#roleVerifier" 19 20 | "tools.ozone.team.defs#roleAdmin" 20 21 | (string & globalThis.Record<PropertyKey, never>); 21 22 }

+1

lex/types/tools/ozone/team/addMember.ts

reviewed

··· 10 10 role: 11 11 | "tools.ozone.team.defs#roleAdmin" 12 12 | "tools.ozone.team.defs#roleModerator" 13 13 + | "tools.ozone.team.defs#roleVerifier" 13 14 | "tools.ozone.team.defs#roleTriage" 14 15 | (string & globalThis.Record<PropertyKey, never>); 15 16 }

+6 -3

lex/types/tools/ozone/team/defs.ts

reviewed

··· 17 17 updatedAt?: string; 18 18 lastUpdatedBy?: string; 19 19 role: 20 20 - | "lex:tools.ozone.team.defs#roleAdmin" 21 21 - | "lex:tools.ozone.team.defs#roleModerator" 22 22 - | "lex:tools.ozone.team.defs#roleTriage" 20 20 + | "tools.ozone.team.defs#roleAdmin" 21 21 + | "tools.ozone.team.defs#roleModerator" 22 22 + | "tools.ozone.team.defs#roleTriage" 23 23 + | "tools.ozone.team.defs#roleVerifier" 23 24 | (string & globalThis.Record<PropertyKey, never>); 24 25 } 25 26 ··· 39 40 export const ROLEMODERATOR = `${id}#roleModerator`; 40 41 /** Triage role. Mostly intended for monitoring and escalating issues. */ 41 42 export const ROLETRIAGE = `${id}#roleTriage`; 43 43 + /** Verifier role. Only allowed to issue verifications. */ 44 44 + export const ROLEVERIFIER = `${id}#roleVerifier`;

+1

lex/types/tools/ozone/team/listMembers.ts

reviewed

··· 4 4 import type * as ToolsOzoneTeamDefs from "./defs.ts"; 5 5 6 6 export type QueryParams = { 7 7 + q?: string; 7 8 disabled?: boolean; 8 9 roles?: string[]; 9 10 limit: number;

+1

lex/types/tools/ozone/team/updateMember.ts

reviewed

··· 11 11 role?: 12 12 | "tools.ozone.team.defs#roleAdmin" 13 13 | "tools.ozone.team.defs#roleModerator" 14 14 + | "tools.ozone.team.defs#roleVerifier" 14 15 | "tools.ozone.team.defs#roleTriage" 15 16 | (string & globalThis.Record<PropertyKey, never>); 16 17 }

+53

lex/types/tools/ozone/verification/defs.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import { type $Typed } from "../../../../util.ts"; 7 7 + import type * as ToolsOzoneModerationDefs from "../moderation/defs.ts"; 8 8 + 9 9 + const is$typed = _is$typed, validate = _validate; 10 10 + const id = "tools.ozone.verification.defs"; 11 11 + 12 12 + /** Verification data for the associated subject. */ 13 13 + export interface VerificationView { 14 14 + $type?: "tools.ozone.verification.defs#verificationView"; 15 15 + /** The user who issued this verification. */ 16 16 + issuer: string; 17 17 + /** The AT-URI of the verification record. */ 18 18 + uri: string; 19 19 + /** The subject of the verification. */ 20 20 + subject: string; 21 21 + /** Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying. */ 22 22 + handle: string; 23 23 + /** Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying. */ 24 24 + displayName: string; 25 25 + /** Timestamp when the verification was created. */ 26 26 + createdAt: string; 27 27 + /** Describes the reason for revocation, also indicating that the verification is no longer valid. */ 28 28 + revokeReason?: string; 29 29 + /** Timestamp when the verification was revoked. */ 30 30 + revokedAt?: string; 31 31 + /** The user who revoked this verification. */ 32 32 + revokedBy?: string; 33 33 + subjectProfile?: { $type: string }; 34 34 + issuerProfile?: { $type: string }; 35 35 + subjectRepo?: 36 36 + | $Typed<ToolsOzoneModerationDefs.RepoViewDetail> 37 37 + | $Typed<ToolsOzoneModerationDefs.RepoViewNotFound> 38 38 + | { $type: string }; 39 39 + issuerRepo?: 40 40 + | $Typed<ToolsOzoneModerationDefs.RepoViewDetail> 41 41 + | $Typed<ToolsOzoneModerationDefs.RepoViewNotFound> 42 42 + | { $type: string }; 43 43 + } 44 44 + 45 45 + const hashVerificationView = "verificationView"; 46 46 + 47 47 + export function isVerificationView<V>(v: V) { 48 48 + return is$typed(v, id, hashVerificationView); 49 49 + } 50 50 + 51 51 + export function validateVerificationView<V>(v: V) { 52 52 + return validate<VerificationView & V>(v, id, hashVerificationView); 53 53 + }

+80

lex/types/tools/ozone/verification/grantVerifications.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + import type * as ToolsOzoneVerificationDefs from "./defs.ts"; 7 7 + 8 8 + const is$typed = _is$typed, validate = _validate; 9 9 + const id = "tools.ozone.verification.grantVerifications"; 10 10 + 11 11 + export type QueryParams = globalThis.Record<PropertyKey, never>; 12 12 + 13 13 + export interface InputSchema { 14 14 + /** Array of verification requests to process */ 15 15 + verifications: (VerificationInput)[]; 16 16 + } 17 17 + 18 18 + export interface OutputSchema { 19 19 + verifications: (ToolsOzoneVerificationDefs.VerificationView)[]; 20 20 + failedVerifications: (GrantError)[]; 21 21 + } 22 22 + 23 23 + export interface HandlerInput { 24 24 + encoding: "application/json"; 25 25 + body: InputSchema; 26 26 + } 27 27 + 28 28 + export interface HandlerSuccess { 29 29 + encoding: "application/json"; 30 30 + body: OutputSchema; 31 31 + headers?: { [key: string]: string }; 32 32 + } 33 33 + 34 34 + export interface HandlerError { 35 35 + status: number; 36 36 + message?: string; 37 37 + } 38 38 + 39 39 + export type HandlerOutput = HandlerError | HandlerSuccess; 40 40 + 41 41 + export interface VerificationInput { 42 42 + $type?: "tools.ozone.verification.grantVerifications#verificationInput"; 43 43 + /** The did of the subject being verified */ 44 44 + subject: string; 45 45 + /** Handle of the subject the verification applies to at the moment of verifying. */ 46 46 + handle: string; 47 47 + /** Display name of the subject the verification applies to at the moment of verifying. */ 48 48 + displayName: string; 49 49 + /** Timestamp for verification record. Defaults to current time when not specified. */ 50 50 + createdAt?: string; 51 51 + } 52 52 + 53 53 + const hashVerificationInput = "verificationInput"; 54 54 + 55 55 + export function isVerificationInput<V>(v: V) { 56 56 + return is$typed(v, id, hashVerificationInput); 57 57 + } 58 58 + 59 59 + export function validateVerificationInput<V>(v: V) { 60 60 + return validate<VerificationInput & V>(v, id, hashVerificationInput); 61 61 + } 62 62 + 63 63 + /** Error object for failed verifications. */ 64 64 + export interface GrantError { 65 65 + $type?: "tools.ozone.verification.grantVerifications#grantError"; 66 66 + /** Error message describing the reason for failure. */ 67 67 + error: string; 68 68 + /** The did of the subject being verified */ 69 69 + subject: string; 70 70 + } 71 71 + 72 72 + const hashGrantError = "grantError"; 73 73 + 74 74 + export function isGrantError<V>(v: V) { 75 75 + return is$typed(v, id, hashGrantError); 76 76 + } 77 77 + 78 78 + export function validateGrantError<V>(v: V) { 79 79 + return validate<GrantError & V>(v, id, hashGrantError); 80 80 + }

+44

lex/types/tools/ozone/verification/listVerifications.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import type * as ToolsOzoneVerificationDefs from "./defs.ts"; 5 5 + 6 6 + export type QueryParams = { 7 7 + /** Pagination cursor */ 8 8 + cursor?: string; 9 9 + /** Maximum number of results to return */ 10 10 + limit: number; 11 11 + /** Filter to verifications created after this timestamp */ 12 12 + createdAfter?: string; 13 13 + /** Filter to verifications created before this timestamp */ 14 14 + createdBefore?: string; 15 15 + /** Filter to verifications from specific issuers */ 16 16 + issuers?: string[]; 17 17 + /** Filter to specific verified DIDs */ 18 18 + subjects?: string[]; 19 19 + /** Sort direction for creation date */ 20 20 + sortDirection: "asc" | "desc"; 21 21 + /** Filter to verifications that are revoked or not. By default, includes both. */ 22 22 + isRevoked?: boolean; 23 23 + }; 24 24 + export type InputSchema = undefined; 25 25 + 26 26 + export interface OutputSchema { 27 27 + cursor?: string; 28 28 + verifications: (ToolsOzoneVerificationDefs.VerificationView)[]; 29 29 + } 30 30 + 31 31 + export type HandlerInput = void; 32 32 + 33 33 + export interface HandlerSuccess { 34 34 + encoding: "application/json"; 35 35 + body: OutputSchema; 36 36 + headers?: { [key: string]: string }; 37 37 + } 38 38 + 39 39 + export interface HandlerError { 40 40 + status: number; 41 41 + message?: string; 42 42 + } 43 43 + 44 44 + export type HandlerOutput = HandlerError | HandlerSuccess;

+61

lex/types/tools/ozone/verification/revokeVerifications.ts

reviewed

··· 1 1 + /** 2 2 + * GENERATED CODE - DO NOT MODIFY 3 3 + */ 4 4 + import { validate as _validate } from "../../../../lexicons.ts"; 5 5 + import { is$typed as _is$typed } from "../../../../util.ts"; 6 6 + 7 7 + const is$typed = _is$typed, validate = _validate; 8 8 + const id = "tools.ozone.verification.revokeVerifications"; 9 9 + 10 10 + export type QueryParams = globalThis.Record<PropertyKey, never>; 11 11 + 12 12 + export interface InputSchema { 13 13 + /** Array of verification record uris to revoke */ 14 14 + uris: (string)[]; 15 15 + /** Reason for revoking the verification. This is optional and can be omitted if not needed. */ 16 16 + revokeReason?: string; 17 17 + } 18 18 + 19 19 + export interface OutputSchema { 20 20 + /** List of verification uris successfully revoked */ 21 21 + revokedVerifications: (string)[]; 22 22 + /** List of verification uris that couldn't be revoked, including failure reasons */ 23 23 + failedRevocations: (RevokeError)[]; 24 24 + } 25 25 + 26 26 + export interface HandlerInput { 27 27 + encoding: "application/json"; 28 28 + body: InputSchema; 29 29 + } 30 30 + 31 31 + export interface HandlerSuccess { 32 32 + encoding: "application/json"; 33 33 + body: OutputSchema; 34 34 + headers?: { [key: string]: string }; 35 35 + } 36 36 + 37 37 + export interface HandlerError { 38 38 + status: number; 39 39 + message?: string; 40 40 + } 41 41 + 42 42 + export type HandlerOutput = HandlerError | HandlerSuccess; 43 43 + 44 44 + /** Error object for failed revocations */ 45 45 + export interface RevokeError { 46 46 + $type?: "tools.ozone.verification.revokeVerifications#revokeError"; 47 47 + /** The AT-URI of the verification record that failed to revoke. */ 48 48 + uri: string; 49 49 + /** Description of the error that occurred during revocation. */ 50 50 + error: string; 51 51 + } 52 52 + 53 53 + const hashRevokeError = "revokeError"; 54 54 + 55 55 + export function isRevokeError<V>(v: V) { 56 56 + return is$typed(v, id, hashRevokeError); 57 57 + } 58 58 + 59 59 + export function validateRevokeError<V>(v: V) { 60 60 + return validate<RevokeError & V>(v, id, hashRevokeError); 61 61 + }

+150 -3

lexicons/app/bsky/actor/defs.json

reviewed

··· 13 13 "maxGraphemes": 64, 14 14 "maxLength": 640 15 15 }, 16 16 + "pronouns": { "type": "string" }, 16 17 "avatar": { "type": "string", "format": "uri" }, 17 18 "associated": { 18 19 "type": "ref", ··· 23 24 "type": "array", 24 25 "items": { "type": "ref", "ref": "com.atproto.label.defs#label" } 25 26 }, 26 26 - "createdAt": { "type": "string", "format": "datetime" } 27 27 + "createdAt": { "type": "string", "format": "datetime" }, 28 28 + "verification": { 29 29 + "type": "ref", 30 30 + "ref": "#verificationState" 31 31 + }, 32 32 + "status": { 33 33 + "type": "ref", 34 34 + "ref": "#statusView" 35 35 + }, 36 36 + "debug": { 37 37 + "type": "unknown", 38 38 + "description": "Debug information for internal development" 39 39 + } 27 40 } 28 41 }, 29 42 "profileView": { ··· 37 50 "maxGraphemes": 64, 38 51 "maxLength": 640 39 52 }, 53 53 + "pronouns": { "type": "string" }, 40 54 "description": { 41 55 "type": "string", 42 56 "maxGraphemes": 256, ··· 53 67 "labels": { 54 68 "type": "array", 55 69 "items": { "type": "ref", "ref": "com.atproto.label.defs#label" } 70 70 + }, 71 71 + "verification": { 72 72 + "type": "ref", 73 73 + "ref": "#verificationState" 74 74 + }, 75 75 + "status": { 76 76 + "type": "ref", 77 77 + "ref": "#statusView" 78 78 + }, 79 79 + "debug": { 80 80 + "type": "unknown", 81 81 + "description": "Debug information for internal development" 56 82 } 57 83 } 58 84 }, ··· 72 98 "maxGraphemes": 256, 73 99 "maxLength": 2560 74 100 }, 101 101 + "pronouns": { "type": "string" }, 102 102 + "website": { "type": "string", "format": "uri" }, 75 103 "avatar": { "type": "string", "format": "uri" }, 76 104 "banner": { "type": "string", "format": "uri" }, 77 105 "followersCount": { "type": "integer" }, ··· 95 123 "pinnedPost": { 96 124 "type": "ref", 97 125 "ref": "com.atproto.repo.strongRef" 126 126 + }, 127 127 + "verification": { 128 128 + "type": "ref", 129 129 + "ref": "#verificationState" 130 130 + }, 131 131 + "status": { 132 132 + "type": "ref", 133 133 + "ref": "#statusView" 134 134 + }, 135 135 + "debug": { 136 136 + "type": "unknown", 137 137 + "description": "Debug information for internal development" 98 138 } 99 139 } 100 140 }, ··· 105 145 "feedgens": { "type": "integer" }, 106 146 "starterPacks": { "type": "integer" }, 107 147 "labeler": { "type": "boolean" }, 108 108 - "chat": { "type": "ref", "ref": "#profileAssociatedChat" } 148 148 + "chat": { "type": "ref", "ref": "#profileAssociatedChat" }, 149 149 + "activitySubscription": { 150 150 + "type": "ref", 151 151 + "ref": "#profileAssociatedActivitySubscription" 152 152 + } 109 153 } 110 154 }, 111 155 "profileAssociatedChat": { ··· 115 159 "allowIncoming": { 116 160 "type": "string", 117 161 "knownValues": ["all", "none", "following"] 162 162 + } 163 163 + } 164 164 + }, 165 165 + "profileAssociatedActivitySubscription": { 166 166 + "type": "object", 167 167 + "required": ["allowSubscriptions"], 168 168 + "properties": { 169 169 + "allowSubscriptions": { 170 170 + "type": "string", 171 171 + "knownValues": ["followers", "mutuals", "none"] 118 172 } 119 173 } 120 174 }, ··· 136 190 "following": { "type": "string", "format": "at-uri" }, 137 191 "followedBy": { "type": "string", "format": "at-uri" }, 138 192 "knownFollowers": { 193 193 + "description": "This property is present only in selected cases, as an optimization.", 139 194 "type": "ref", 140 195 "ref": "#knownFollowers" 196 196 + }, 197 197 + "activitySubscription": { 198 198 + "description": "This property is present only in selected cases, as an optimization.", 199 199 + "type": "ref", 200 200 + "ref": "app.bsky.notification.defs#activitySubscription" 141 201 } 142 202 } 143 203 }, ··· 158 218 } 159 219 } 160 220 }, 221 221 + "verificationState": { 222 222 + "type": "object", 223 223 + "description": "Represents the verification information about the user this object is attached to.", 224 224 + "required": ["verifications", "verifiedStatus", "trustedVerifierStatus"], 225 225 + "properties": { 226 226 + "verifications": { 227 227 + "type": "array", 228 228 + "description": "All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included.", 229 229 + "items": { "type": "ref", "ref": "#verificationView" } 230 230 + }, 231 231 + "verifiedStatus": { 232 232 + "type": "string", 233 233 + "description": "The user's status as a verified account.", 234 234 + "knownValues": ["valid", "invalid", "none"] 235 235 + }, 236 236 + "trustedVerifierStatus": { 237 237 + "type": "string", 238 238 + "description": "The user's status as a trusted verifier.", 239 239 + "knownValues": ["valid", "invalid", "none"] 240 240 + } 241 241 + } 242 242 + }, 243 243 + "verificationView": { 244 244 + "type": "object", 245 245 + "description": "An individual verification for an associated subject.", 246 246 + "required": ["issuer", "uri", "isValid", "createdAt"], 247 247 + "properties": { 248 248 + "issuer": { 249 249 + "type": "string", 250 250 + "description": "The user who issued this verification.", 251 251 + "format": "did" 252 252 + }, 253 253 + "uri": { 254 254 + "type": "string", 255 255 + "description": "The AT-URI of the verification record.", 256 256 + "format": "at-uri" 257 257 + }, 258 258 + "isValid": { 259 259 + "type": "boolean", 260 260 + "description": "True if the verification passes validation, otherwise false." 261 261 + }, 262 262 + "createdAt": { 263 263 + "type": "string", 264 264 + "description": "Timestamp when the verification was created.", 265 265 + "format": "datetime" 266 266 + } 267 267 + } 268 268 + }, 161 269 "preferences": { 162 270 "type": "array", 163 271 "items": { ··· 175 283 "#hiddenPostsPref", 176 284 "#bskyAppStatePref", 177 285 "#labelersPref", 178 178 - "#postInteractionSettingsPref" 286 286 + "#postInteractionSettingsPref", 287 287 + "#verificationPrefs" 179 288 ] 180 289 } 181 290 }, ··· 466 575 } 467 576 } 468 577 }, 578 578 + "verificationPrefs": { 579 579 + "type": "object", 580 580 + "description": "Preferences for how verified accounts appear in the app.", 581 581 + "required": [], 582 582 + "properties": { 583 583 + "hideBadges": { 584 584 + "description": "Hide the blue check badges for verified accounts and trusted verifiers.", 585 585 + "type": "boolean", 586 586 + "default": false 587 587 + } 588 588 + } 589 589 + }, 469 590 "postInteractionSettingsPref": { 470 591 "type": "object", 471 592 "description": "Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly.", ··· 493 614 "type": "union", 494 615 "refs": ["app.bsky.feed.postgate#disableRule"] 495 616 } 617 617 + } 618 618 + } 619 619 + }, 620 620 + "statusView": { 621 621 + "type": "object", 622 622 + "required": ["status", "record"], 623 623 + "properties": { 624 624 + "status": { 625 625 + "type": "string", 626 626 + "description": "The status for the account.", 627 627 + "knownValues": ["app.bsky.actor.status#live"] 628 628 + }, 629 629 + "record": { "type": "unknown" }, 630 630 + "embed": { 631 631 + "type": "union", 632 632 + "description": "An optional embed associated with the status.", 633 633 + "refs": ["app.bsky.embed.external#view"] 634 634 + }, 635 635 + "expiresAt": { 636 636 + "type": "string", 637 637 + "description": "The date when this status will expire. The application might choose to no longer return the status after expiration.", 638 638 + "format": "datetime" 639 639 + }, 640 640 + "isActive": { 641 641 + "type": "boolean", 642 642 + "description": "True if the status is not expired, false if it is expired. Only present if expiration was set." 496 643 } 497 644 } 498 645 }

+7

lexicons/app/bsky/actor/profile.json

reviewed

··· 20 20 "maxGraphemes": 256, 21 21 "maxLength": 2560 22 22 }, 23 23 + "pronouns": { 24 24 + "type": "string", 25 25 + "description": "Free-form pronouns text.", 26 26 + "maxGraphemes": 20, 27 27 + "maxLength": 200 28 28 + }, 29 29 + "website": { "type": "string", "format": "uri" }, 23 30 "avatar": { 24 31 "type": "blob", 25 32 "description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",

+37

lexicons/app/bsky/actor/status.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.actor.status", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "A declaration of a Bluesky account status.", 8 8 + "key": "literal:self", 9 9 + "record": { 10 10 + "type": "object", 11 11 + "required": ["status", "createdAt"], 12 12 + "properties": { 13 13 + "status": { 14 14 + "type": "string", 15 15 + "description": "The status for the account.", 16 16 + "knownValues": ["app.bsky.actor.status#live"] 17 17 + }, 18 18 + "embed": { 19 19 + "type": "union", 20 20 + "description": "An optional embed associated with the status.", 21 21 + "refs": ["app.bsky.embed.external"] 22 22 + }, 23 23 + "durationMinutes": { 24 24 + "type": "integer", 25 25 + "description": "The duration of the status in minutes. Applications can choose to impose minimum and maximum limits.", 26 26 + "minimum": 1 27 27 + }, 28 28 + "createdAt": { "type": "string", "format": "datetime" } 29 29 + } 30 30 + } 31 31 + }, 32 32 + "live": { 33 33 + "type": "token", 34 34 + "description": "Advertises an account as currently offering live content." 35 35 + } 36 36 + } 37 37 + }

+48

lexicons/app/bsky/ageassurance/begin.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.ageassurance.begin", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Initiate Age Assurance for an account.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["email", "language", "countryCode"], 13 13 + "properties": { 14 14 + "email": { 15 15 + "type": "string", 16 16 + "description": "The user's email address to receive Age Assurance instructions." 17 17 + }, 18 18 + "language": { 19 19 + "type": "string", 20 20 + "description": "The user's preferred language for communication during the Age Assurance process." 21 21 + }, 22 22 + "countryCode": { 23 23 + "type": "string", 24 24 + "description": "An ISO 3166-1 alpha-2 code of the user's location." 25 25 + }, 26 26 + "regionCode": { 27 27 + "type": "string", 28 28 + "description": "An optional ISO 3166-2 code of the user's region or state within the country." 29 29 + } 30 30 + } 31 31 + } 32 32 + }, 33 33 + "output": { 34 34 + "encoding": "application/json", 35 35 + "schema": { 36 36 + "type": "ref", 37 37 + "ref": "app.bsky.ageassurance.defs#state" 38 38 + } 39 39 + }, 40 40 + "errors": [ 41 41 + { "name": "InvalidEmail" }, 42 42 + { "name": "DidTooLong" }, 43 43 + { "name": "InvalidInitiation" }, 44 44 + { "name": "RegionNotSupported" } 45 45 + ] 46 46 + } 47 47 + } 48 48 + }

+251

lexicons/app/bsky/ageassurance/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.ageassurance.defs", 4 4 + "defs": { 5 5 + "access": { 6 6 + "description": "The access level granted based on Age Assurance data we've processed.", 7 7 + "type": "string", 8 8 + "knownValues": ["unknown", "none", "safe", "full"] 9 9 + }, 10 10 + "status": { 11 11 + "type": "string", 12 12 + "description": "The status of the Age Assurance process.", 13 13 + "knownValues": ["unknown", "pending", "assured", "blocked"] 14 14 + }, 15 15 + "state": { 16 16 + "type": "object", 17 17 + "description": "The user's computed Age Assurance state.", 18 18 + "required": ["status", "access"], 19 19 + "properties": { 20 20 + "lastInitiatedAt": { 21 21 + "type": "string", 22 22 + "format": "datetime", 23 23 + "description": "The timestamp when this state was last updated." 24 24 + }, 25 25 + "status": { 26 26 + "type": "ref", 27 27 + "ref": "app.bsky.ageassurance.defs#status" 28 28 + }, 29 29 + "access": { 30 30 + "type": "ref", 31 31 + "ref": "app.bsky.ageassurance.defs#access" 32 32 + } 33 33 + } 34 34 + }, 35 35 + "stateMetadata": { 36 36 + "type": "object", 37 37 + "description": "Additional metadata needed to compute Age Assurance state client-side.", 38 38 + "required": [], 39 39 + "properties": { 40 40 + "accountCreatedAt": { 41 41 + "type": "string", 42 42 + "format": "datetime", 43 43 + "description": "The account creation timestamp." 44 44 + } 45 45 + } 46 46 + }, 47 47 + "config": { 48 48 + "type": "object", 49 49 + "description": "", 50 50 + "required": ["regions"], 51 51 + "properties": { 52 52 + "regions": { 53 53 + "type": "array", 54 54 + "description": "The per-region Age Assurance configuration.", 55 55 + "items": { 56 56 + "type": "ref", 57 57 + "ref": "app.bsky.ageassurance.defs#configRegion" 58 58 + } 59 59 + } 60 60 + } 61 61 + }, 62 62 + "configRegion": { 63 63 + "type": "object", 64 64 + "description": "The Age Assurance configuration for a specific region.", 65 65 + "required": ["countryCode", "rules"], 66 66 + "properties": { 67 67 + "countryCode": { 68 68 + "type": "string", 69 69 + "description": "The ISO 3166-1 alpha-2 country code this configuration applies to." 70 70 + }, 71 71 + "regionCode": { 72 72 + "type": "string", 73 73 + "description": "The ISO 3166-2 region code this configuration applies to. If omitted, the configuration applies to the entire country." 74 74 + }, 75 75 + "rules": { 76 76 + "type": "array", 77 77 + "description": "The ordered list of Age Assurance rules that apply to this region. Rules should be applied in order, and the first matching rule determines the access level granted. The rules array should always include a default rule as the last item.", 78 78 + "items": { 79 79 + "type": "union", 80 80 + "refs": [ 81 81 + "#configRegionRuleDefault", 82 82 + "#configRegionRuleIfDeclaredOverAge", 83 83 + "#configRegionRuleIfDeclaredUnderAge", 84 84 + "#configRegionRuleIfAssuredOverAge", 85 85 + "#configRegionRuleIfAssuredUnderAge", 86 86 + "#configRegionRuleIfAccountNewerThan", 87 87 + "#configRegionRuleIfAccountOlderThan" 88 88 + ] 89 89 + } 90 90 + } 91 91 + } 92 92 + }, 93 93 + "configRegionRuleDefault": { 94 94 + "type": "object", 95 95 + "description": "Age Assurance rule that applies by default.", 96 96 + "required": ["access"], 97 97 + "properties": { 98 98 + "access": { 99 99 + "type": "ref", 100 100 + "ref": "app.bsky.ageassurance.defs#access" 101 101 + } 102 102 + } 103 103 + }, 104 104 + "configRegionRuleIfDeclaredOverAge": { 105 105 + "type": "object", 106 106 + "description": "Age Assurance rule that applies if the user has declared themselves equal-to or over a certain age.", 107 107 + "required": ["age", "access"], 108 108 + "properties": { 109 109 + "age": { 110 110 + "type": "integer", 111 111 + "description": "The age threshold as a whole integer." 112 112 + }, 113 113 + "access": { 114 114 + "type": "ref", 115 115 + "ref": "app.bsky.ageassurance.defs#access" 116 116 + } 117 117 + } 118 118 + }, 119 119 + "configRegionRuleIfDeclaredUnderAge": { 120 120 + "type": "object", 121 121 + "description": "Age Assurance rule that applies if the user has declared themselves under a certain age.", 122 122 + "required": ["age", "access"], 123 123 + "properties": { 124 124 + "age": { 125 125 + "type": "integer", 126 126 + "description": "The age threshold as a whole integer." 127 127 + }, 128 128 + "access": { 129 129 + "type": "ref", 130 130 + "ref": "app.bsky.ageassurance.defs#access" 131 131 + } 132 132 + } 133 133 + }, 134 134 + "configRegionRuleIfAssuredOverAge": { 135 135 + "type": "object", 136 136 + "description": "Age Assurance rule that applies if the user has been assured to be equal-to or over a certain age.", 137 137 + "required": ["age", "access"], 138 138 + "properties": { 139 139 + "age": { 140 140 + "type": "integer", 141 141 + "description": "The age threshold as a whole integer." 142 142 + }, 143 143 + "access": { 144 144 + "type": "ref", 145 145 + "ref": "app.bsky.ageassurance.defs#access" 146 146 + } 147 147 + } 148 148 + }, 149 149 + "configRegionRuleIfAssuredUnderAge": { 150 150 + "type": "object", 151 151 + "description": "Age Assurance rule that applies if the user has been assured to be under a certain age.", 152 152 + "required": ["age", "access"], 153 153 + "properties": { 154 154 + "age": { 155 155 + "type": "integer", 156 156 + "description": "The age threshold as a whole integer." 157 157 + }, 158 158 + "access": { 159 159 + "type": "ref", 160 160 + "ref": "app.bsky.ageassurance.defs#access" 161 161 + } 162 162 + } 163 163 + }, 164 164 + "configRegionRuleIfAccountNewerThan": { 165 165 + "type": "object", 166 166 + "description": "Age Assurance rule that applies if the account is equal-to or newer than a certain date.", 167 167 + "required": ["date", "access"], 168 168 + "properties": { 169 169 + "date": { 170 170 + "type": "string", 171 171 + "format": "datetime", 172 172 + "description": "The date threshold as a datetime string." 173 173 + }, 174 174 + "access": { 175 175 + "type": "ref", 176 176 + "ref": "app.bsky.ageassurance.defs#access" 177 177 + } 178 178 + } 179 179 + }, 180 180 + "configRegionRuleIfAccountOlderThan": { 181 181 + "type": "object", 182 182 + "description": "Age Assurance rule that applies if the account is older than a certain date.", 183 183 + "required": ["date", "access"], 184 184 + "properties": { 185 185 + "date": { 186 186 + "type": "string", 187 187 + "format": "datetime", 188 188 + "description": "The date threshold as a datetime string." 189 189 + }, 190 190 + "access": { 191 191 + "type": "ref", 192 192 + "ref": "app.bsky.ageassurance.defs#access" 193 193 + } 194 194 + } 195 195 + }, 196 196 + "event": { 197 197 + "type": "object", 198 198 + "description": "Object used to store Age Assurance data in stash.", 199 199 + "required": ["createdAt", "status", "access", "attemptId", "countryCode"], 200 200 + "properties": { 201 201 + "createdAt": { 202 202 + "type": "string", 203 203 + "format": "datetime", 204 204 + "description": "The date and time of this write operation." 205 205 + }, 206 206 + "attemptId": { 207 207 + "type": "string", 208 208 + "description": "The unique identifier for this instance of the Age Assurance flow, in UUID format." 209 209 + }, 210 210 + "status": { 211 211 + "type": "string", 212 212 + "description": "The status of the Age Assurance process.", 213 213 + "knownValues": ["unknown", "pending", "assured", "blocked"] 214 214 + }, 215 215 + "access": { 216 216 + "description": "The access level granted based on Age Assurance data we've processed.", 217 217 + "type": "string", 218 218 + "knownValues": ["unknown", "none", "safe", "full"] 219 219 + }, 220 220 + "countryCode": { 221 221 + "type": "string", 222 222 + "description": "The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow." 223 223 + }, 224 224 + "regionCode": { 225 225 + "type": "string", 226 226 + "description": "The ISO 3166-2 region code provided when beginning the Age Assurance flow." 227 227 + }, 228 228 + "email": { 229 229 + "type": "string", 230 230 + "description": "The email used for Age Assurance." 231 231 + }, 232 232 + "initIp": { 233 233 + "type": "string", 234 234 + "description": "The IP address used when initiating the Age Assurance flow." 235 235 + }, 236 236 + "initUa": { 237 237 + "type": "string", 238 238 + "description": "The user agent used when initiating the Age Assurance flow." 239 239 + }, 240 240 + "completeIp": { 241 241 + "type": "string", 242 242 + "description": "The IP address used when completing the Age Assurance flow." 243 243 + }, 244 244 + "completeUa": { 245 245 + "type": "string", 246 246 + "description": "The user agent used when completing the Age Assurance flow." 247 247 + } 248 248 + } 249 249 + } 250 250 + } 251 251 + }

+17

lexicons/app/bsky/ageassurance/getConfig.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.ageassurance.getConfig", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Returns Age Assurance configuration for use on the client.", 8 8 + "output": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "ref", 12 12 + "ref": "app.bsky.ageassurance.defs#config" 13 13 + } 14 14 + } 15 15 + } 16 16 + } 17 17 + }

+35

lexicons/app/bsky/ageassurance/getState.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.ageassurance.getState", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Returns server-computed Age Assurance state, if available, and any additional metadata needed to compute Age Assurance state client-side.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["countryCode"], 11 11 + "properties": { 12 12 + "countryCode": { "type": "string" }, 13 13 + "regionCode": { "type": "string" } 14 14 + } 15 15 + }, 16 16 + "output": { 17 17 + "encoding": "application/json", 18 18 + "schema": { 19 19 + "type": "object", 20 20 + "required": ["state", "metadata"], 21 21 + "properties": { 22 22 + "state": { 23 23 + "type": "ref", 24 24 + "ref": "app.bsky.ageassurance.defs#state" 25 25 + }, 26 26 + "metadata": { 27 27 + "type": "ref", 28 28 + "ref": "app.bsky.ageassurance.defs#stateMetadata" 29 29 + } 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + }

+27

lexicons/app/bsky/bookmark/createBookmark.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.bookmark.createBookmark", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Creates a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["uri", "cid"], 13 13 + "properties": { 14 14 + "uri": { "type": "string", "format": "at-uri" }, 15 15 + "cid": { "type": "string", "format": "cid" } 16 16 + } 17 17 + } 18 18 + }, 19 19 + "errors": [ 20 20 + { 21 21 + "name": "UnsupportedCollection", 22 22 + "description": "The URI to be bookmarked is for an unsupported collection." 23 23 + } 24 24 + ] 25 25 + } 26 26 + } 27 27 + }

+38

lexicons/app/bsky/bookmark/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.bookmark.defs", 4 4 + "defs": { 5 5 + "bookmark": { 6 6 + "description": "Object used to store bookmark data in stash.", 7 7 + "type": "object", 8 8 + "required": ["subject"], 9 9 + "properties": { 10 10 + "subject": { 11 11 + "description": "A strong ref to the record to be bookmarked. Currently, only `app.bsky.feed.post` records are supported.", 12 12 + "type": "ref", 13 13 + "ref": "com.atproto.repo.strongRef" 14 14 + } 15 15 + } 16 16 + }, 17 17 + "bookmarkView": { 18 18 + "type": "object", 19 19 + "required": ["subject", "item"], 20 20 + "properties": { 21 21 + "subject": { 22 22 + "description": "A strong ref to the bookmarked record.", 23 23 + "type": "ref", 24 24 + "ref": "com.atproto.repo.strongRef" 25 25 + }, 26 26 + "createdAt": { "type": "string", "format": "datetime" }, 27 27 + "item": { 28 28 + "type": "union", 29 29 + "refs": [ 30 30 + "app.bsky.feed.defs#blockedPost", 31 31 + "app.bsky.feed.defs#notFoundPost", 32 32 + "app.bsky.feed.defs#postView" 33 33 + ] 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + }

+26

lexicons/app/bsky/bookmark/deleteBookmark.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.bookmark.deleteBookmark", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Deletes a private bookmark for the specified record. Currently, only `app.bsky.feed.post` records are supported. Requires authentication.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["uri"], 13 13 + "properties": { 14 14 + "uri": { "type": "string", "format": "at-uri" } 15 15 + } 16 16 + } 17 17 + }, 18 18 + "errors": [ 19 19 + { 20 20 + "name": "UnsupportedCollection", 21 21 + "description": "The URI to be bookmarked is for an unsupported collection." 22 22 + } 23 23 + ] 24 24 + } 25 25 + } 26 26 + }

+39

lexicons/app/bsky/bookmark/getBookmarks.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.bookmark.getBookmarks", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Gets views of records bookmarked by the authenticated user. Requires authentication.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 100, 15 15 + "default": 50 16 16 + }, 17 17 + "cursor": { "type": "string" } 18 18 + } 19 19 + }, 20 20 + "output": { 21 21 + "encoding": "application/json", 22 22 + "schema": { 23 23 + "type": "object", 24 24 + "required": ["bookmarks"], 25 25 + "properties": { 26 26 + "cursor": { "type": "string" }, 27 27 + "bookmarks": { 28 28 + "type": "array", 29 29 + "items": { 30 30 + "type": "ref", 31 31 + "ref": "app.bsky.bookmark.defs#bookmarkView" 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + }

+2 -1

lexicons/app/bsky/embed/video.json

reviewed

··· 9 9 "properties": { 10 10 "video": { 11 11 "type": "blob", 12 12 + "description": "The mp4 video file. May be up to 100mb, formerly limited to 50mb.", 12 13 "accept": ["video/mp4"], 13 13 - "maxSize": 50000000 14 14 + "maxSize": 100000000 14 15 }, 15 16 "captions": { 16 17 "type": "array",

+19 -1

lexicons/app/bsky/feed/defs.json

reviewed

··· 23 23 "app.bsky.embed.recordWithMedia#view" 24 24 ] 25 25 }, 26 26 + "bookmarkCount": { "type": "integer" }, 26 27 "replyCount": { "type": "integer" }, 27 28 "repostCount": { "type": "integer" }, 28 29 "likeCount": { "type": "integer" }, ··· 33 34 "type": "array", 34 35 "items": { "type": "ref", "ref": "com.atproto.label.defs#label" } 35 36 }, 36 36 - "threadgate": { "type": "ref", "ref": "#threadgateView" } 37 37 + "threadgate": { "type": "ref", "ref": "#threadgateView" }, 38 38 + "debug": { 39 39 + "type": "unknown", 40 40 + "description": "Debug information for internal development" 41 41 + } 37 42 } 38 43 }, 39 44 "viewerState": { ··· 42 47 "properties": { 43 48 "repost": { "type": "string", "format": "at-uri" }, 44 49 "like": { "type": "string", "format": "at-uri" }, 50 50 + "bookmarked": { "type": "boolean" }, 45 51 "threadMuted": { "type": "boolean" }, 46 52 "replyDisabled": { "type": "boolean" }, 47 53 "embeddingDisabled": { "type": "boolean" }, ··· 66 72 "type": "string", 67 73 "description": "Context provided by feed generator that may be passed back alongside interactions.", 68 74 "maxLength": 2000 75 75 + }, 76 76 + "reqId": { 77 77 + "type": "string", 78 78 + "description": "Unique identifier per request that may be passed back alongside interactions.", 79 79 + "maxLength": 100 69 80 } 70 81 } 71 82 }, ··· 93 104 "required": ["by", "indexedAt"], 94 105 "properties": { 95 106 "by": { "type": "ref", "ref": "app.bsky.actor.defs#profileViewBasic" }, 107 107 + "uri": { "type": "string", "format": "at-uri" }, 108 108 + "cid": { "type": "string", "format": "cid" }, 96 109 "indexedAt": { "type": "string", "format": "datetime" } 97 110 } 98 111 }, ··· 250 263 "type": "string", 251 264 "description": "Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton.", 252 265 "maxLength": 2000 266 266 + }, 267 267 + "reqId": { 268 268 + "type": "string", 269 269 + "description": "Unique identifier per request that may be passed back alongside interactions.", 270 270 + "maxLength": 100 253 271 } 254 272 } 255 273 },

+5

lexicons/app/bsky/feed/getFeedSkeleton.json

reviewed

··· 36 36 "type": "ref", 37 37 "ref": "app.bsky.feed.defs#skeletonFeedPost" 38 38 } 39 39 + }, 40 40 + "reqId": { 41 41 + "type": "string", 42 42 + "description": "Unique identifier per request that may be passed back alongside interactions.", 43 43 + "maxLength": 100 39 44 } 40 45 } 41 46 }

+1 -1

lexicons/app/bsky/feed/searchPosts.json

reviewed

··· 4 4 "defs": { 5 5 "main": { 6 6 "type": "query", 7 7 - "description": "Find posts matching search criteria, returning views of those posts.", 7 7 + "description": "Find posts matching search criteria, returning views of those posts. Note that this API endpoint may require authentication (eg, not public) for some service providers and implementations.", 8 8 "parameters": { 9 9 "type": "params", 10 10 "required": ["q"],

+1 -1

lexicons/app/bsky/feed/threadgate.json

reviewed

··· 32 32 "createdAt": { "type": "string", "format": "datetime" }, 33 33 "hiddenReplies": { 34 34 "type": "array", 35 35 - "maxLength": 50, 35 35 + "maxLength": 300, 36 36 "items": { 37 37 "type": "string", 38 38 "format": "at-uri"

+2 -1

lexicons/app/bsky/graph/follow.json

reviewed

··· 11 11 "required": ["subject", "createdAt"], 12 12 "properties": { 13 13 "subject": { "type": "string", "format": "did" }, 14 14 - "createdAt": { "type": "string", "format": "datetime" } 14 14 + "createdAt": { "type": "string", "format": "datetime" }, 15 15 + "via": { "type": "ref", "ref": "com.atproto.repo.strongRef" } 15 16 } 16 17 } 17 18 }

+9 -1

lexicons/app/bsky/graph/getLists.json

reviewed

··· 20 20 "maximum": 100, 21 21 "default": 50 22 22 }, 23 23 - "cursor": { "type": "string" } 23 23 + "cursor": { "type": "string" }, 24 24 + "purposes": { 25 25 + "type": "array", 26 26 + "description": "Optional filter by list purpose. If not specified, all supported types are returned.", 27 27 + "items": { 28 28 + "type": "string", 29 29 + "knownValues": ["modlist", "curatelist"] 30 30 + } 31 31 + } 24 32 } 25 33 }, 26 34 "output": {

+65

lexicons/app/bsky/graph/getListsWithMembership.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.graph.getListsWithMembership", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Enumerates the lists created by the session user, and includes membership information about `actor` in those lists. Only supports curation and moderation lists (no reference lists, used in starter packs). Requires auth.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["actor"], 11 11 + "properties": { 12 12 + "actor": { 13 13 + "type": "string", 14 14 + "format": "at-identifier", 15 15 + "description": "The account (actor) to check for membership." 16 16 + }, 17 17 + "limit": { 18 18 + "type": "integer", 19 19 + "minimum": 1, 20 20 + "maximum": 100, 21 21 + "default": 50 22 22 + }, 23 23 + "cursor": { "type": "string" }, 24 24 + "purposes": { 25 25 + "type": "array", 26 26 + "description": "Optional filter by list purpose. If not specified, all supported types are returned.", 27 27 + "items": { 28 28 + "type": "string", 29 29 + "knownValues": ["modlist", "curatelist"] 30 30 + } 31 31 + } 32 32 + } 33 33 + }, 34 34 + "output": { 35 35 + "encoding": "application/json", 36 36 + "schema": { 37 37 + "type": "object", 38 38 + "required": ["listsWithMembership"], 39 39 + "properties": { 40 40 + "cursor": { "type": "string" }, 41 41 + "listsWithMembership": { 42 42 + "type": "array", 43 43 + "items": { "type": "ref", "ref": "#listWithMembership" } 44 44 + } 45 45 + } 46 46 + } 47 47 + } 48 48 + }, 49 49 + "listWithMembership": { 50 50 + "description": "A list and an optional list item indicating membership of a target user to that list.", 51 51 + "type": "object", 52 52 + "required": ["list"], 53 53 + "properties": { 54 54 + "list": { 55 55 + "type": "ref", 56 56 + "ref": "app.bsky.graph.defs#listView" 57 57 + }, 58 58 + "listItem": { 59 59 + "type": "ref", 60 60 + "ref": "app.bsky.graph.defs#listItemView" 61 61 + } 62 62 + } 63 63 + } 64 64 + } 65 65 + }

+57

lexicons/app/bsky/graph/getStarterPacksWithMembership.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.graph.getStarterPacksWithMembership", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Enumerates the starter packs created by the session user, and includes membership information about `actor` in those starter packs. Requires auth.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["actor"], 11 11 + "properties": { 12 12 + "actor": { 13 13 + "type": "string", 14 14 + "format": "at-identifier", 15 15 + "description": "The account (actor) to check for membership." 16 16 + }, 17 17 + "limit": { 18 18 + "type": "integer", 19 19 + "minimum": 1, 20 20 + "maximum": 100, 21 21 + "default": 50 22 22 + }, 23 23 + "cursor": { "type": "string" } 24 24 + } 25 25 + }, 26 26 + "output": { 27 27 + "encoding": "application/json", 28 28 + "schema": { 29 29 + "type": "object", 30 30 + "required": ["starterPacksWithMembership"], 31 31 + "properties": { 32 32 + "cursor": { "type": "string" }, 33 33 + "starterPacksWithMembership": { 34 34 + "type": "array", 35 35 + "items": { "type": "ref", "ref": "#starterPackWithMembership" } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + }, 41 41 + "starterPackWithMembership": { 42 42 + "description": "A starter pack and an optional list item indicating membership of a target user to that starter pack.", 43 43 + "type": "object", 44 44 + "required": ["starterPack"], 45 45 + "properties": { 46 46 + "starterPack": { 47 47 + "type": "ref", 48 48 + "ref": "app.bsky.graph.defs#starterPackView" 49 49 + }, 50 50 + "listItem": { 51 51 + "type": "ref", 52 52 + "ref": "app.bsky.graph.defs#listItemView" 53 53 + } 54 54 + } 55 55 + } 56 56 + } 57 57 + }

+36

lexicons/app/bsky/graph/verification.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.graph.verification", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "Record declaring a verification relationship between two accounts. Verifications are only considered valid by an app if issued by an account the app considers trusted.", 8 8 + "key": "tid", 9 9 + "record": { 10 10 + "type": "object", 11 11 + "required": ["subject", "handle", "displayName", "createdAt"], 12 12 + "properties": { 13 13 + "subject": { 14 14 + "description": "DID of the subject the verification applies to.", 15 15 + "type": "string", 16 16 + "format": "did" 17 17 + }, 18 18 + "handle": { 19 19 + "description": "Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.", 20 20 + "type": "string", 21 21 + "format": "handle" 22 22 + }, 23 23 + "displayName": { 24 24 + "description": "Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying.", 25 25 + "type": "string" 26 26 + }, 27 27 + "createdAt": { 28 28 + "description": "Date of when the verification was created.", 29 29 + "type": "string", 30 30 + "format": "datetime" 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + }

+22

lexicons/app/bsky/notification/declaration.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.declaration", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "record", 7 7 + "description": "A declaration of the user's choices related to notifications that can be produced by them.", 8 8 + "key": "literal:self", 9 9 + "record": { 10 10 + "type": "object", 11 11 + "required": ["allowSubscriptions"], 12 12 + "properties": { 13 13 + "allowSubscriptions": { 14 14 + "type": "string", 15 15 + "description": "A declaration of the user's preference for allowing activity subscriptions from other users. Absence of a record implies 'followers'.", 16 16 + "knownValues": ["followers", "mutuals", "none"] 17 17 + } 18 18 + } 19 19 + } 20 20 + } 21 21 + } 22 22 + }

+88

lexicons/app/bsky/notification/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.defs", 4 4 + "defs": { 5 5 + "recordDeleted": { 6 6 + "type": "object", 7 7 + "properties": {} 8 8 + }, 9 9 + "chatPreference": { 10 10 + "type": "object", 11 11 + "required": ["include", "push"], 12 12 + "properties": { 13 13 + "include": { "type": "string", "knownValues": ["all", "accepted"] }, 14 14 + "push": { "type": "boolean" } 15 15 + } 16 16 + }, 17 17 + "filterablePreference": { 18 18 + "type": "object", 19 19 + "required": ["include", "list", "push"], 20 20 + "properties": { 21 21 + "include": { "type": "string", "knownValues": ["all", "follows"] }, 22 22 + "list": { "type": "boolean" }, 23 23 + "push": { "type": "boolean" } 24 24 + } 25 25 + }, 26 26 + "preference": { 27 27 + "type": "object", 28 28 + "required": ["list", "push"], 29 29 + "properties": { 30 30 + "list": { "type": "boolean" }, 31 31 + "push": { "type": "boolean" } 32 32 + } 33 33 + }, 34 34 + "preferences": { 35 35 + "type": "object", 36 36 + "required": [ 37 37 + "chat", 38 38 + "follow", 39 39 + "like", 40 40 + "likeViaRepost", 41 41 + "mention", 42 42 + "quote", 43 43 + "reply", 44 44 + "repost", 45 45 + "repostViaRepost", 46 46 + "starterpackJoined", 47 47 + "subscribedPost", 48 48 + "unverified", 49 49 + "verified" 50 50 + ], 51 51 + "properties": { 52 52 + "chat": { "type": "ref", "ref": "#chatPreference" }, 53 53 + "follow": { "type": "ref", "ref": "#filterablePreference" }, 54 54 + "like": { "type": "ref", "ref": "#filterablePreference" }, 55 55 + "likeViaRepost": { "type": "ref", "ref": "#filterablePreference" }, 56 56 + "mention": { "type": "ref", "ref": "#filterablePreference" }, 57 57 + "quote": { "type": "ref", "ref": "#filterablePreference" }, 58 58 + "reply": { "type": "ref", "ref": "#filterablePreference" }, 59 59 + "repost": { "type": "ref", "ref": "#filterablePreference" }, 60 60 + "repostViaRepost": { "type": "ref", "ref": "#filterablePreference" }, 61 61 + "starterpackJoined": { "type": "ref", "ref": "#preference" }, 62 62 + "subscribedPost": { "type": "ref", "ref": "#preference" }, 63 63 + "unverified": { "type": "ref", "ref": "#preference" }, 64 64 + "verified": { "type": "ref", "ref": "#preference" } 65 65 + } 66 66 + }, 67 67 + "activitySubscription": { 68 68 + "type": "object", 69 69 + "required": ["post", "reply"], 70 70 + "properties": { 71 71 + "post": { "type": "boolean" }, 72 72 + "reply": { "type": "boolean" } 73 73 + } 74 74 + }, 75 75 + "subjectActivitySubscription": { 76 76 + "description": "Object used to store activity subscription data in stash.", 77 77 + "type": "object", 78 78 + "required": ["subject", "activitySubscription"], 79 79 + "properties": { 80 80 + "subject": { "type": "string", "format": "did" }, 81 81 + "activitySubscription": { 82 82 + "type": "ref", 83 83 + "ref": "#activitySubscription" 84 84 + } 85 85 + } 86 86 + } 87 87 + } 88 88 + }

+27

lexicons/app/bsky/notification/getPreferences.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.getPreferences", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get notification-related preferences for an account. Requires auth.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": {} 11 11 + }, 12 12 + "output": { 13 13 + "encoding": "application/json", 14 14 + "schema": { 15 15 + "type": "object", 16 16 + "required": ["preferences"], 17 17 + "properties": { 18 18 + "preferences": { 19 19 + "type": "ref", 20 20 + "ref": "app.bsky.notification.defs#preferences" 21 21 + } 22 22 + } 23 23 + } 24 24 + } 25 25 + } 26 26 + } 27 27 + }

+39

lexicons/app/bsky/notification/listActivitySubscriptions.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.listActivitySubscriptions", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Enumerate all accounts to which the requesting account is subscribed to receive notifications for. Requires auth.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 100, 15 15 + "default": 50 16 16 + }, 17 17 + "cursor": { "type": "string" } 18 18 + } 19 19 + }, 20 20 + "output": { 21 21 + "encoding": "application/json", 22 22 + "schema": { 23 23 + "type": "object", 24 24 + "required": ["subscriptions"], 25 25 + "properties": { 26 26 + "cursor": { "type": "string" }, 27 27 + "subscriptions": { 28 28 + "type": "array", 29 29 + "items": { 30 30 + "type": "ref", 31 31 + "ref": "app.bsky.actor.defs#profileView" 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + }

+7 -2

lexicons/app/bsky/notification/listNotifications.json

reviewed

··· 61 61 "author": { "type": "ref", "ref": "app.bsky.actor.defs#profileView" }, 62 62 "reason": { 63 63 "type": "string", 64 64 - "description": "Expected values are 'like', 'repost', 'follow', 'mention', 'reply', 'quote', and 'starterpack-joined'.", 64 64 + "description": "The reason why this notification was delivered - e.g. your post was liked, or you received a new follower.", 65 65 "knownValues": [ 66 66 "like", 67 67 "repost", ··· 69 69 "mention", 70 70 "reply", 71 71 "quote", 72 72 - "starterpack-joined" 72 72 + "starterpack-joined", 73 73 + "verified", 74 74 + "unverified", 75 75 + "like-via-repost", 76 76 + "repost-via-repost", 77 77 + "subscribed-post" 73 78 ] 74 79 }, 75 80 "reasonSubject": { "type": "string", "format": "at-uri" },

+38

lexicons/app/bsky/notification/putActivitySubscription.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.putActivitySubscription", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Puts an activity subscription entry. The key should be omitted for creation and provided for updates. Requires auth.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["subject", "activitySubscription"], 13 13 + "properties": { 14 14 + "subject": { "type": "string", "format": "did" }, 15 15 + "activitySubscription": { 16 16 + "type": "ref", 17 17 + "ref": "app.bsky.notification.defs#activitySubscription" 18 18 + } 19 19 + } 20 20 + } 21 21 + }, 22 22 + "output": { 23 23 + "encoding": "application/json", 24 24 + "schema": { 25 25 + "type": "object", 26 26 + "required": ["subject"], 27 27 + "properties": { 28 28 + "subject": { "type": "string", "format": "did" }, 29 29 + "activitySubscription": { 30 30 + "type": "ref", 31 31 + "ref": "app.bsky.notification.defs#activitySubscription" 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + }

+83

lexicons/app/bsky/notification/putPreferencesV2.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.putPreferencesV2", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Set notification-related preferences for an account. Requires auth.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "properties": { 13 13 + "chat": { 14 14 + "type": "ref", 15 15 + "ref": "app.bsky.notification.defs#chatPreference" 16 16 + }, 17 17 + "follow": { 18 18 + "type": "ref", 19 19 + "ref": "app.bsky.notification.defs#filterablePreference" 20 20 + }, 21 21 + "like": { 22 22 + "type": "ref", 23 23 + "ref": "app.bsky.notification.defs#filterablePreference" 24 24 + }, 25 25 + "likeViaRepost": { 26 26 + "type": "ref", 27 27 + "ref": "app.bsky.notification.defs#filterablePreference" 28 28 + }, 29 29 + "mention": { 30 30 + "type": "ref", 31 31 + "ref": "app.bsky.notification.defs#filterablePreference" 32 32 + }, 33 33 + "quote": { 34 34 + "type": "ref", 35 35 + "ref": "app.bsky.notification.defs#filterablePreference" 36 36 + }, 37 37 + "reply": { 38 38 + "type": "ref", 39 39 + "ref": "app.bsky.notification.defs#filterablePreference" 40 40 + }, 41 41 + "repost": { 42 42 + "type": "ref", 43 43 + "ref": "app.bsky.notification.defs#filterablePreference" 44 44 + }, 45 45 + "repostViaRepost": { 46 46 + "type": "ref", 47 47 + "ref": "app.bsky.notification.defs#filterablePreference" 48 48 + }, 49 49 + "starterpackJoined": { 50 50 + "type": "ref", 51 51 + "ref": "app.bsky.notification.defs#preference" 52 52 + }, 53 53 + "subscribedPost": { 54 54 + "type": "ref", 55 55 + "ref": "app.bsky.notification.defs#preference" 56 56 + }, 57 57 + "unverified": { 58 58 + "type": "ref", 59 59 + "ref": "app.bsky.notification.defs#preference" 60 60 + }, 61 61 + "verified": { 62 62 + "type": "ref", 63 63 + "ref": "app.bsky.notification.defs#preference" 64 64 + } 65 65 + } 66 66 + } 67 67 + }, 68 68 + "output": { 69 69 + "encoding": "application/json", 70 70 + "schema": { 71 71 + "type": "object", 72 72 + "required": ["preferences"], 73 73 + "properties": { 74 74 + "preferences": { 75 75 + "type": "ref", 76 76 + "ref": "app.bsky.notification.defs#preferences" 77 77 + } 78 78 + } 79 79 + } 80 80 + } 81 81 + } 82 82 + } 83 83 + }

+5 -1

lexicons/app/bsky/notification/registerPush.json

reviewed

··· 17 17 "type": "string", 18 18 "knownValues": ["ios", "android", "web"] 19 19 }, 20 20 - "appId": { "type": "string" } 20 20 + "appId": { "type": "string" }, 21 21 + "ageRestricted": { 22 22 + "type": "boolean", 23 23 + "description": "Set to true when the actor is age restricted" 24 24 + } 21 25 } 22 26 } 23 27 }

+26

lexicons/app/bsky/notification/unregisterPush.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.notification.unregisterPush", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "The inverse of registerPush - inform a specified service that push notifications should no longer be sent to the given token for the requesting account. Requires auth.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["serviceDid", "token", "platform", "appId"], 13 13 + "properties": { 14 14 + "serviceDid": { "type": "string", "format": "did" }, 15 15 + "token": { "type": "string" }, 16 16 + "platform": { 17 17 + "type": "string", 18 18 + "knownValues": ["ios", "android", "web"] 19 19 + }, 20 20 + "appId": { "type": "string" } 21 21 + } 22 22 + } 23 23 + } 24 24 + } 25 25 + } 26 26 + }

+161

lexicons/app/bsky/unspecced/defs.json

reviewed

··· 32 32 "description": { "type": "string" }, 33 33 "link": { "type": "string" } 34 34 } 35 35 + }, 36 36 + "skeletonTrend": { 37 37 + "type": "object", 38 38 + "required": [ 39 39 + "topic", 40 40 + "displayName", 41 41 + "link", 42 42 + "startedAt", 43 43 + "postCount", 44 44 + "dids" 45 45 + ], 46 46 + "properties": { 47 47 + "topic": { "type": "string" }, 48 48 + "displayName": { "type": "string" }, 49 49 + "link": { "type": "string" }, 50 50 + "startedAt": { "type": "string", "format": "datetime" }, 51 51 + "postCount": { "type": "integer" }, 52 52 + "status": { "type": "string", "knownValues": ["hot"] }, 53 53 + "category": { "type": "string" }, 54 54 + "dids": { 55 55 + "type": "array", 56 56 + "items": { 57 57 + "type": "string", 58 58 + "format": "did" 59 59 + } 60 60 + } 61 61 + } 62 62 + }, 63 63 + "trendView": { 64 64 + "type": "object", 65 65 + "required": [ 66 66 + "topic", 67 67 + "displayName", 68 68 + "link", 69 69 + "startedAt", 70 70 + "postCount", 71 71 + "actors" 72 72 + ], 73 73 + "properties": { 74 74 + "topic": { "type": "string" }, 75 75 + "displayName": { "type": "string" }, 76 76 + "link": { "type": "string" }, 77 77 + "startedAt": { "type": "string", "format": "datetime" }, 78 78 + "postCount": { "type": "integer" }, 79 79 + "status": { "type": "string", "knownValues": ["hot"] }, 80 80 + "category": { "type": "string" }, 81 81 + "actors": { 82 82 + "type": "array", 83 83 + "items": { 84 84 + "type": "ref", 85 85 + "ref": "app.bsky.actor.defs#profileViewBasic" 86 86 + } 87 87 + } 88 88 + } 89 89 + }, 90 90 + "threadItemPost": { 91 91 + "type": "object", 92 92 + "required": [ 93 93 + "post", 94 94 + "moreParents", 95 95 + "moreReplies", 96 96 + "opThread", 97 97 + "hiddenByThreadgate", 98 98 + "mutedByViewer" 99 99 + ], 100 100 + "properties": { 101 101 + "post": { "type": "ref", "ref": "app.bsky.feed.defs#postView" }, 102 102 + "moreParents": { 103 103 + "type": "boolean", 104 104 + "description": "This post has more parents that were not present in the response. This is just a boolean, without the number of parents." 105 105 + }, 106 106 + "moreReplies": { 107 107 + "type": "integer", 108 108 + "description": "This post has more replies that were not present in the response. This is a numeric value, which is best-effort and might not be accurate." 109 109 + }, 110 110 + "opThread": { 111 111 + "type": "boolean", 112 112 + "description": "This post is part of a contiguous thread by the OP from the thread root. Many different OP threads can happen in the same thread." 113 113 + }, 114 114 + "hiddenByThreadgate": { 115 115 + "type": "boolean", 116 116 + "description": "The threadgate created by the author indicates this post as a reply to be hidden for everyone consuming the thread." 117 117 + }, 118 118 + "mutedByViewer": { 119 119 + "type": "boolean", 120 120 + "description": "This is by an account muted by the viewer requesting it." 121 121 + } 122 122 + } 123 123 + }, 124 124 + "threadItemNoUnauthenticated": { 125 125 + "type": "object", 126 126 + "properties": {} 127 127 + }, 128 128 + "threadItemNotFound": { 129 129 + "type": "object", 130 130 + "properties": {} 131 131 + }, 132 132 + "threadItemBlocked": { 133 133 + "type": "object", 134 134 + "required": ["author"], 135 135 + "properties": { 136 136 + "author": { "type": "ref", "ref": "app.bsky.feed.defs#blockedAuthor" } 137 137 + } 138 138 + }, 139 139 + "ageAssuranceState": { 140 140 + "type": "object", 141 141 + "description": "The computed state of the age assurance process, returned to the user in question on certain authenticated requests.", 142 142 + "required": ["status"], 143 143 + "properties": { 144 144 + "lastInitiatedAt": { 145 145 + "type": "string", 146 146 + "format": "datetime", 147 147 + "description": "The timestamp when this state was last updated." 148 148 + }, 149 149 + "status": { 150 150 + "type": "string", 151 151 + "description": "The status of the age assurance process.", 152 152 + "knownValues": ["unknown", "pending", "assured", "blocked"] 153 153 + } 154 154 + } 155 155 + }, 156 156 + "ageAssuranceEvent": { 157 157 + "type": "object", 158 158 + "description": "Object used to store age assurance data in stash.", 159 159 + "required": ["createdAt", "status", "attemptId"], 160 160 + "properties": { 161 161 + "createdAt": { 162 162 + "type": "string", 163 163 + "format": "datetime", 164 164 + "description": "The date and time of this write operation." 165 165 + }, 166 166 + "status": { 167 167 + "type": "string", 168 168 + "description": "The status of the age assurance process.", 169 169 + "knownValues": ["unknown", "pending", "assured"] 170 170 + }, 171 171 + "attemptId": { 172 172 + "type": "string", 173 173 + "description": "The unique identifier for this instance of the age assurance flow, in UUID format." 174 174 + }, 175 175 + "email": { 176 176 + "type": "string", 177 177 + "description": "The email used for AA." 178 178 + }, 179 179 + "initIp": { 180 180 + "type": "string", 181 181 + "description": "The IP address used when initiating the AA flow." 182 182 + }, 183 183 + "initUa": { 184 184 + "type": "string", 185 185 + "description": "The user agent used when initiating the AA flow." 186 186 + }, 187 187 + "completeIp": { 188 188 + "type": "string", 189 189 + "description": "The IP address used when completing the AA flow." 190 190 + }, 191 191 + "completeUa": { 192 192 + "type": "string", 193 193 + "description": "The user agent used when completing the AA flow." 194 194 + } 195 195 + } 35 196 } 36 197 } 37 198 }

+17

lexicons/app/bsky/unspecced/getAgeAssuranceState.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getAgeAssuranceState", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Returns the current state of the age assurance process for an account. This is used to check if the user has completed age assurance or if further action is required.", 8 8 + "output": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "ref", 12 12 + "ref": "app.bsky.unspecced.defs#ageAssuranceState" 13 13 + } 14 14 + } 15 15 + } 16 16 + } 17 17 + }

+18 -1

lexicons/app/bsky/unspecced/getConfig.json

reviewed

··· 11 11 "type": "object", 12 12 "required": [], 13 13 "properties": { 14 14 - "checkEmailConfirmed": { "type": "boolean" } 14 14 + "checkEmailConfirmed": { "type": "boolean" }, 15 15 + "liveNow": { 16 16 + "type": "array", 17 17 + "items": { "type": "ref", "ref": "#liveNowConfig" } 18 18 + } 19 19 + } 20 20 + } 21 21 + } 22 22 + }, 23 23 + "liveNowConfig": { 24 24 + "type": "object", 25 25 + "required": ["did", "domains"], 26 26 + "properties": { 27 27 + "did": { "type": "string", "format": "did" }, 28 28 + "domains": { 29 29 + "type": "array", 30 30 + "items": { 31 31 + "type": "string" 15 32 } 16 33 } 17 34 }

+37

lexicons/app/bsky/unspecced/getOnboardingSuggestedStarterPacks.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getOnboardingSuggestedStarterPacks", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a list of suggested starterpacks for onboarding", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 25, 15 15 + "default": 10 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "required": ["starterPacks"], 24 24 + "properties": { 25 25 + "starterPacks": { 26 26 + "type": "array", 27 27 + "items": { 28 28 + "type": "ref", 29 29 + "ref": "app.bsky.graph.defs#starterPackView" 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + }

+42

lexicons/app/bsky/unspecced/getOnboardingSuggestedStarterPacksSkeleton.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getOnboardingSuggestedStarterPacksSkeleton", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a skeleton of suggested starterpacks for onboarding. Intended to be called and hydrated by app.bsky.unspecced.getOnboardingSuggestedStarterPacks", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "viewer": { 12 12 + "type": "string", 13 13 + "format": "did", 14 14 + "description": "DID of the account making the request (not included for public/unauthenticated queries)." 15 15 + }, 16 16 + "limit": { 17 17 + "type": "integer", 18 18 + "minimum": 1, 19 19 + "maximum": 25, 20 20 + "default": 10 21 21 + } 22 22 + } 23 23 + }, 24 24 + "output": { 25 25 + "encoding": "application/json", 26 26 + "schema": { 27 27 + "type": "object", 28 28 + "required": ["starterPacks"], 29 29 + "properties": { 30 30 + "starterPacks": { 31 31 + "type": "array", 32 32 + "items": { 33 33 + "type": "string", 34 34 + "format": "at-uri" 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + } 41 41 + } 42 42 + }

+56

lexicons/app/bsky/unspecced/getPostThreadOtherV2.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getPostThreadOtherV2", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "(NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get additional posts under a thread e.g. replies hidden by threadgate. Based on an anchor post at any depth of the tree, returns top-level replies below that anchor. It does not include ancestors nor the anchor itself. This should be called after exhausting `app.bsky.unspecced.getPostThreadV2`. Does not require auth, but additional metadata and filtering will be applied for authed requests.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["anchor"], 11 11 + "properties": { 12 12 + "anchor": { 13 13 + "type": "string", 14 14 + "format": "at-uri", 15 15 + "description": "Reference (AT-URI) to post record. This is the anchor post." 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "required": ["thread"], 24 24 + "properties": { 25 25 + "thread": { 26 26 + "type": "array", 27 27 + "description": "A flat list of other thread items. The depth of each item is indicated by the depth property inside the item.", 28 28 + "items": { 29 29 + "type": "ref", 30 30 + "ref": "#threadItem" 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + }, 37 37 + "threadItem": { 38 38 + "type": "object", 39 39 + "required": ["uri", "depth", "value"], 40 40 + "properties": { 41 41 + "uri": { 42 42 + "type": "string", 43 43 + "format": "at-uri" 44 44 + }, 45 45 + "depth": { 46 46 + "type": "integer", 47 47 + "description": "The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths." 48 48 + }, 49 49 + "value": { 50 50 + "type": "union", 51 51 + "refs": ["app.bsky.unspecced.defs#threadItemPost"] 52 52 + } 53 53 + } 54 54 + } 55 55 + } 56 56 + }

+94

lexicons/app/bsky/unspecced/getPostThreadV2.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getPostThreadV2", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "(NOTE: this endpoint is under development and WILL change without notice. Don't use it until it is moved out of `unspecced` or your application WILL break) Get posts in a thread. It is based in an anchor post at any depth of the tree, and returns posts above it (recursively resolving the parent, without further branching to their replies) and below it (recursive replies, with branching to their replies). Does not require auth, but additional metadata and filtering will be applied for authed requests.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["anchor"], 11 11 + "properties": { 12 12 + "anchor": { 13 13 + "type": "string", 14 14 + "format": "at-uri", 15 15 + "description": "Reference (AT-URI) to post record. This is the anchor post, and the thread will be built around it. It can be any post in the tree, not necessarily a root post." 16 16 + }, 17 17 + "above": { 18 18 + "type": "boolean", 19 19 + "description": "Whether to include parents above the anchor.", 20 20 + "default": true 21 21 + }, 22 22 + "below": { 23 23 + "type": "integer", 24 24 + "description": "How many levels of replies to include below the anchor.", 25 25 + "default": 6, 26 26 + "minimum": 0, 27 27 + "maximum": 20 28 28 + }, 29 29 + "branchingFactor": { 30 30 + "type": "integer", 31 31 + "description": "Maximum of replies to include at each level of the thread, except for the direct replies to the anchor, which are (NOTE: currently, during unspecced phase) all returned (NOTE: later they might be paginated).", 32 32 + "default": 10, 33 33 + "minimum": 0, 34 34 + "maximum": 100 35 35 + }, 36 36 + "sort": { 37 37 + "type": "string", 38 38 + "description": "Sorting for the thread replies.", 39 39 + "knownValues": ["newest", "oldest", "top"], 40 40 + "default": "oldest" 41 41 + } 42 42 + } 43 43 + }, 44 44 + "output": { 45 45 + "encoding": "application/json", 46 46 + "schema": { 47 47 + "type": "object", 48 48 + "required": ["thread", "hasOtherReplies"], 49 49 + "properties": { 50 50 + "thread": { 51 51 + "type": "array", 52 52 + "description": "A flat list of thread items. The depth of each item is indicated by the depth property inside the item.", 53 53 + "items": { 54 54 + "type": "ref", 55 55 + "ref": "#threadItem" 56 56 + } 57 57 + }, 58 58 + "threadgate": { 59 59 + "type": "ref", 60 60 + "ref": "app.bsky.feed.defs#threadgateView" 61 61 + }, 62 62 + "hasOtherReplies": { 63 63 + "type": "boolean", 64 64 + "description": "Whether this thread has additional replies. If true, a call can be made to the `getPostThreadOtherV2` endpoint to retrieve them." 65 65 + } 66 66 + } 67 67 + } 68 68 + } 69 69 + }, 70 70 + "threadItem": { 71 71 + "type": "object", 72 72 + "required": ["uri", "depth", "value"], 73 73 + "properties": { 74 74 + "uri": { 75 75 + "type": "string", 76 76 + "format": "at-uri" 77 77 + }, 78 78 + "depth": { 79 79 + "type": "integer", 80 80 + "description": "The nesting level of this item in the thread. Depth 0 means the anchor item. Items above have negative depths, items below have positive depths." 81 81 + }, 82 82 + "value": { 83 83 + "type": "union", 84 84 + "refs": [ 85 85 + "app.bsky.unspecced.defs#threadItemPost", 86 86 + "app.bsky.unspecced.defs#threadItemNoUnauthenticated", 87 87 + "app.bsky.unspecced.defs#threadItemNotFound", 88 88 + "app.bsky.unspecced.defs#threadItemBlocked" 89 89 + ] 90 90 + } 91 91 + } 92 92 + } 93 93 + } 94 94 + }

+37

lexicons/app/bsky/unspecced/getSuggestedFeeds.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getSuggestedFeeds", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a list of suggested feeds", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 25, 15 15 + "default": 10 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "required": ["feeds"], 24 24 + "properties": { 25 25 + "feeds": { 26 26 + "type": "array", 27 27 + "items": { 28 28 + "type": "ref", 29 29 + "ref": "app.bsky.feed.defs#generatorView" 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + }

+42

lexicons/app/bsky/unspecced/getSuggestedFeedsSkeleton.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getSuggestedFeedsSkeleton", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a skeleton of suggested feeds. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedFeeds", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "viewer": { 12 12 + "type": "string", 13 13 + "format": "did", 14 14 + "description": "DID of the account making the request (not included for public/unauthenticated queries)." 15 15 + }, 16 16 + "limit": { 17 17 + "type": "integer", 18 18 + "minimum": 1, 19 19 + "maximum": 25, 20 20 + "default": 10 21 21 + } 22 22 + } 23 23 + }, 24 24 + "output": { 25 25 + "encoding": "application/json", 26 26 + "schema": { 27 27 + "type": "object", 28 28 + "required": ["feeds"], 29 29 + "properties": { 30 30 + "feeds": { 31 31 + "type": "array", 32 32 + "items": { 33 33 + "type": "string", 34 34 + "format": "at-uri" 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + } 41 41 + } 42 42 + }

+37

lexicons/app/bsky/unspecced/getSuggestedStarterPacks.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getSuggestedStarterPacks", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a list of suggested starterpacks", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 25, 15 15 + "default": 10 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "required": ["starterPacks"], 24 24 + "properties": { 25 25 + "starterPacks": { 26 26 + "type": "array", 27 27 + "items": { 28 28 + "type": "ref", 29 29 + "ref": "app.bsky.graph.defs#starterPackView" 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + }

+42

lexicons/app/bsky/unspecced/getSuggestedStarterPacksSkeleton.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getSuggestedStarterPacksSkeleton", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a skeleton of suggested starterpacks. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedStarterpacks", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "viewer": { 12 12 + "type": "string", 13 13 + "format": "did", 14 14 + "description": "DID of the account making the request (not included for public/unauthenticated queries)." 15 15 + }, 16 16 + "limit": { 17 17 + "type": "integer", 18 18 + "minimum": 1, 19 19 + "maximum": 25, 20 20 + "default": 10 21 21 + } 22 22 + } 23 23 + }, 24 24 + "output": { 25 25 + "encoding": "application/json", 26 26 + "schema": { 27 27 + "type": "object", 28 28 + "required": ["starterPacks"], 29 29 + "properties": { 30 30 + "starterPacks": { 31 31 + "type": "array", 32 32 + "items": { 33 33 + "type": "string", 34 34 + "format": "at-uri" 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + } 41 41 + } 42 42 + }

+41

lexicons/app/bsky/unspecced/getSuggestedUsers.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getSuggestedUsers", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a list of suggested users", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "category": { 12 12 + "type": "string", 13 13 + "description": "Category of users to get suggestions for." 14 14 + }, 15 15 + "limit": { 16 16 + "type": "integer", 17 17 + "minimum": 1, 18 18 + "maximum": 50, 19 19 + "default": 25 20 20 + } 21 21 + } 22 22 + }, 23 23 + "output": { 24 24 + "encoding": "application/json", 25 25 + "schema": { 26 26 + "type": "object", 27 27 + "required": ["actors"], 28 28 + "properties": { 29 29 + "actors": { 30 30 + "type": "array", 31 31 + "items": { 32 32 + "type": "ref", 33 33 + "ref": "app.bsky.actor.defs#profileView" 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + } 41 41 + }

+46

lexicons/app/bsky/unspecced/getSuggestedUsersSkeleton.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getSuggestedUsersSkeleton", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get a skeleton of suggested users. Intended to be called and hydrated by app.bsky.unspecced.getSuggestedUsers", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "viewer": { 12 12 + "type": "string", 13 13 + "format": "did", 14 14 + "description": "DID of the account making the request (not included for public/unauthenticated queries)." 15 15 + }, 16 16 + "category": { 17 17 + "type": "string", 18 18 + "description": "Category of users to get suggestions for." 19 19 + }, 20 20 + "limit": { 21 21 + "type": "integer", 22 22 + "minimum": 1, 23 23 + "maximum": 50, 24 24 + "default": 25 25 25 + } 26 26 + } 27 27 + }, 28 28 + "output": { 29 29 + "encoding": "application/json", 30 30 + "schema": { 31 31 + "type": "object", 32 32 + "required": ["dids"], 33 33 + "properties": { 34 34 + "dids": { 35 35 + "type": "array", 36 36 + "items": { 37 37 + "type": "string", 38 38 + "format": "did" 39 39 + } 40 40 + } 41 41 + } 42 42 + } 43 43 + } 44 44 + } 45 45 + } 46 46 + }

+37

lexicons/app/bsky/unspecced/getTrends.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getTrends", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get the current trends on the network", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 25, 15 15 + "default": 10 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "required": ["trends"], 24 24 + "properties": { 25 25 + "trends": { 26 26 + "type": "array", 27 27 + "items": { 28 28 + "type": "ref", 29 29 + "ref": "app.bsky.unspecced.defs#trendView" 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + }

+42

lexicons/app/bsky/unspecced/getTrendsSkeleton.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.getTrendsSkeleton", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get the skeleton of trends on the network. Intended to be called and then hydrated through app.bsky.unspecced.getTrends", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "viewer": { 12 12 + "type": "string", 13 13 + "format": "did", 14 14 + "description": "DID of the account making the request (not included for public/unauthenticated queries)." 15 15 + }, 16 16 + "limit": { 17 17 + "type": "integer", 18 18 + "minimum": 1, 19 19 + "maximum": 25, 20 20 + "default": 10 21 21 + } 22 22 + } 23 23 + }, 24 24 + "output": { 25 25 + "encoding": "application/json", 26 26 + "schema": { 27 27 + "type": "object", 28 28 + "required": ["trends"], 29 29 + "properties": { 30 30 + "trends": { 31 31 + "type": "array", 32 32 + "items": { 33 33 + "type": "ref", 34 34 + "ref": "app.bsky.unspecced.defs#skeletonTrend" 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + } 41 41 + } 42 42 + }

+43

lexicons/app/bsky/unspecced/initAgeAssurance.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "app.bsky.unspecced.initAgeAssurance", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Initiate age assurance for an account. This is a one-time action that will start the process of verifying the user's age.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["email", "language", "countryCode"], 13 13 + "properties": { 14 14 + "email": { 15 15 + "type": "string", 16 16 + "description": "The user's email address to receive assurance instructions." 17 17 + }, 18 18 + "language": { 19 19 + "type": "string", 20 20 + "description": "The user's preferred language for communication during the assurance process." 21 21 + }, 22 22 + "countryCode": { 23 23 + "type": "string", 24 24 + "description": "An ISO 3166-1 alpha-2 code of the user's location." 25 25 + } 26 26 + } 27 27 + } 28 28 + }, 29 29 + "output": { 30 30 + "encoding": "application/json", 31 31 + "schema": { 32 32 + "type": "ref", 33 33 + "ref": "app.bsky.unspecced.defs#ageAssuranceState" 34 34 + } 35 35 + }, 36 36 + "errors": [ 37 37 + { "name": "InvalidEmail" }, 38 38 + { "name": "DidTooLong" }, 39 39 + { "name": "InvalidInitiation" } 40 40 + ] 41 41 + } 42 42 + } 43 43 + }

+5 -1

lexicons/chat/bsky/actor/defs.json

reviewed

··· 25 25 }, 26 26 "chatDisabled": { 27 27 "type": "boolean", 28 28 - "description": "Set to true when the actor cannot actively participate in converations" 28 28 + "description": "Set to true when the actor cannot actively participate in conversations" 29 29 + }, 30 30 + "verification": { 31 31 + "type": "ref", 32 32 + "ref": "app.bsky.actor.defs#verificationState" 29 33 } 30 34 } 31 35 }

+55

lexicons/chat/bsky/convo/addReaction.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "chat.bsky.convo.addReaction", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Adds an emoji reaction to a message. Requires authentication. It is idempotent, so multiple calls from the same user with the same emoji result in a single reaction.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["convoId", "messageId", "value"], 13 13 + "properties": { 14 14 + "convoId": { "type": "string" }, 15 15 + "messageId": { "type": "string" }, 16 16 + "value": { 17 17 + "type": "string", 18 18 + "minLength": 1, 19 19 + "maxLength": 64, 20 20 + "minGraphemes": 1, 21 21 + "maxGraphemes": 1 22 22 + } 23 23 + } 24 24 + } 25 25 + }, 26 26 + "output": { 27 27 + "encoding": "application/json", 28 28 + "schema": { 29 29 + "type": "object", 30 30 + "required": ["message"], 31 31 + "properties": { 32 32 + "message": { 33 33 + "type": "ref", 34 34 + "ref": "chat.bsky.convo.defs#messageView" 35 35 + } 36 36 + } 37 37 + } 38 38 + }, 39 39 + "errors": [ 40 40 + { 41 41 + "name": "ReactionMessageDeleted", 42 42 + "description": "Indicates that the message has been deleted and reactions can no longer be added/removed." 43 43 + }, 44 44 + { 45 45 + "name": "ReactionLimitReached", 46 46 + "description": "Indicates that the message has the maximum number of reactions allowed for a single user, and the requested reaction wasn't yet present. If it was already present, the request will not fail since it is idempotent." 47 47 + }, 48 48 + { 49 49 + "name": "ReactionInvalidValue", 50 50 + "description": "Indicates the value for the reaction is not acceptable. In general, this means it is not an emoji." 51 51 + } 52 52 + ] 53 53 + } 54 54 + } 55 55 + }

+59

lexicons/chat/bsky/convo/defs.json

reviewed

··· 51 51 "type": "union", 52 52 "refs": ["app.bsky.embed.record#view"] 53 53 }, 54 54 + "reactions": { 55 55 + "type": "array", 56 56 + "description": "Reactions to this message, in ascending order of creation time.", 57 57 + "items": { "type": "ref", "ref": "#reactionView" } 58 58 + }, 54 59 "sender": { "type": "ref", "ref": "#messageViewSender" }, 55 60 "sentAt": { "type": "string", "format": "datetime" } 56 61 } ··· 72 77 "did": { "type": "string", "format": "did" } 73 78 } 74 79 }, 80 80 + "reactionView": { 81 81 + "type": "object", 82 82 + "required": ["value", "sender", "createdAt"], 83 83 + "properties": { 84 84 + "value": { "type": "string" }, 85 85 + "sender": { "type": "ref", "ref": "#reactionViewSender" }, 86 86 + "createdAt": { "type": "string", "format": "datetime" } 87 87 + } 88 88 + }, 89 89 + "reactionViewSender": { 90 90 + "type": "object", 91 91 + "required": ["did"], 92 92 + "properties": { 93 93 + "did": { "type": "string", "format": "did" } 94 94 + } 95 95 + }, 96 96 + "messageAndReactionView": { 97 97 + "type": "object", 98 98 + "required": ["message", "reaction"], 99 99 + "properties": { 100 100 + "message": { "type": "ref", "ref": "#messageView" }, 101 101 + "reaction": { "type": "ref", "ref": "#reactionView" } 102 102 + } 103 103 + }, 75 104 "convoView": { 76 105 "type": "object", 77 106 "required": ["id", "rev", "members", "muted", "unreadCount"], ··· 89 118 "type": "union", 90 119 "refs": ["#messageView", "#deletedMessageView"] 91 120 }, 121 121 + "lastReaction": { 122 122 + "type": "union", 123 123 + "refs": ["#messageAndReactionView"] 124 124 + }, 92 125 "muted": { "type": "boolean" }, 93 126 "status": { 94 127 "type": "string", ··· 171 204 "type": "union", 172 205 "refs": ["#messageView", "#deletedMessageView"] 173 206 } 207 207 + } 208 208 + }, 209 209 + "logAddReaction": { 210 210 + "type": "object", 211 211 + "required": ["rev", "convoId", "message", "reaction"], 212 212 + "properties": { 213 213 + "rev": { "type": "string" }, 214 214 + "convoId": { "type": "string" }, 215 215 + "message": { 216 216 + "type": "union", 217 217 + "refs": ["#messageView", "#deletedMessageView"] 218 218 + }, 219 219 + "reaction": { "type": "ref", "ref": "#reactionView" } 220 220 + } 221 221 + }, 222 222 + "logRemoveReaction": { 223 223 + "type": "object", 224 224 + "required": ["rev", "convoId", "message", "reaction"], 225 225 + "properties": { 226 226 + "rev": { "type": "string" }, 227 227 + "convoId": { "type": "string" }, 228 228 + "message": { 229 229 + "type": "union", 230 230 + "refs": ["#messageView", "#deletedMessageView"] 231 231 + }, 232 232 + "reaction": { "type": "ref", "ref": "#reactionView" } 174 233 } 175 234 } 176 235 }

+6 -1

lexicons/chat/bsky/convo/getLog.json

reviewed

··· 26 26 "chat.bsky.convo.defs#logBeginConvo", 27 27 "chat.bsky.convo.defs#logAcceptConvo", 28 28 "chat.bsky.convo.defs#logLeaveConvo", 29 29 + "chat.bsky.convo.defs#logMuteConvo", 30 30 + "chat.bsky.convo.defs#logUnmuteConvo", 29 31 "chat.bsky.convo.defs#logCreateMessage", 30 30 - "chat.bsky.convo.defs#logDeleteMessage" 32 32 + "chat.bsky.convo.defs#logDeleteMessage", 33 33 + "chat.bsky.convo.defs#logReadMessage", 34 34 + "chat.bsky.convo.defs#logAddReaction", 35 35 + "chat.bsky.convo.defs#logRemoveReaction" 31 36 ] 32 37 } 33 38 }

+51

lexicons/chat/bsky/convo/removeReaction.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "chat.bsky.convo.removeReaction", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Removes an emoji reaction from a message. Requires authentication. It is idempotent, so multiple calls from the same user with the same emoji result in that reaction not being present, even if it already wasn't.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["convoId", "messageId", "value"], 13 13 + "properties": { 14 14 + "convoId": { "type": "string" }, 15 15 + "messageId": { "type": "string" }, 16 16 + "value": { 17 17 + "type": "string", 18 18 + "minLength": 1, 19 19 + "maxLength": 64, 20 20 + "minGraphemes": 1, 21 21 + "maxGraphemes": 1 22 22 + } 23 23 + } 24 24 + } 25 25 + }, 26 26 + "output": { 27 27 + "encoding": "application/json", 28 28 + "schema": { 29 29 + "type": "object", 30 30 + "required": ["message"], 31 31 + "properties": { 32 32 + "message": { 33 33 + "type": "ref", 34 34 + "ref": "chat.bsky.convo.defs#messageView" 35 35 + } 36 36 + } 37 37 + } 38 38 + }, 39 39 + "errors": [ 40 40 + { 41 41 + "name": "ReactionMessageDeleted", 42 42 + "description": "Indicates that the message has been deleted and reactions can no longer be added/removed." 43 43 + }, 44 44 + { 45 45 + "name": "ReactionInvalidValue", 46 46 + "description": "Indicates the value for the reaction is not acceptable. In general, this means it is not an emoji." 47 47 + } 48 48 + ] 49 49 + } 50 50 + } 51 51 + }

+25

lexicons/com/atproto/admin/updateAccountSigningKey.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.admin.updateAccountSigningKey", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Administrative action to update an account's signing key in their Did document.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["did", "signingKey"], 13 13 + "properties": { 14 14 + "did": { "type": "string", "format": "did" }, 15 15 + "signingKey": { 16 16 + "type": "string", 17 17 + "format": "did", 18 18 + "description": "Did-key formatted public key" 19 19 + } 20 20 + } 21 21 + } 22 22 + } 23 23 + } 24 24 + } 25 25 + }

+22

lexicons/com/atproto/identity/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.identity.defs", 4 4 + "defs": { 5 5 + "identityInfo": { 6 6 + "type": "object", 7 7 + "required": ["did", "handle", "didDoc"], 8 8 + "properties": { 9 9 + "did": { "type": "string", "format": "did" }, 10 10 + "handle": { 11 11 + "type": "string", 12 12 + "format": "handle", 13 13 + "description": "The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document." 14 14 + }, 15 15 + "didDoc": { 16 16 + "type": "unknown", 17 17 + "description": "The complete DID document for the identity." 18 18 + } 19 19 + } 20 20 + } 21 21 + } 22 22 + }

+44

lexicons/com/atproto/identity/refreshIdentity.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.identity.refreshIdentity", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Request that the server re-resolve an identity (DID and handle). The server may ignore this request, or require authentication, depending on the role, implementation, and policy of the server.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["identifier"], 13 13 + "properties": { 14 14 + "identifier": { 15 15 + "type": "string", 16 16 + "format": "at-identifier" 17 17 + } 18 18 + } 19 19 + } 20 20 + }, 21 21 + "output": { 22 22 + "encoding": "application/json", 23 23 + "schema": { 24 24 + "type": "ref", 25 25 + "ref": "com.atproto.identity.defs#identityInfo" 26 26 + } 27 27 + }, 28 28 + "errors": [ 29 29 + { 30 30 + "name": "HandleNotFound", 31 31 + "description": "The resolution process confirmed that the handle does not resolve to any DID." 32 32 + }, 33 33 + { 34 34 + "name": "DidNotFound", 35 35 + "description": "The DID resolution process confirmed that there is no current DID." 36 36 + }, 37 37 + { 38 38 + "name": "DidDeactivated", 39 39 + "description": "The DID previously existed, but has been deactivated." 40 40 + } 41 41 + ] 42 42 + } 43 43 + } 44 44 + }

+44

lexicons/com/atproto/identity/resolveDid.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.identity.resolveDid", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Resolves DID to DID document. Does not bi-directionally verify handle.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["did"], 11 11 + "properties": { 12 12 + "did": { 13 13 + "type": "string", 14 14 + "format": "did", 15 15 + "description": "DID to resolve." 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "required": ["didDoc"], 24 24 + "properties": { 25 25 + "didDoc": { 26 26 + "type": "unknown", 27 27 + "description": "The complete DID document for the identity." 28 28 + } 29 29 + } 30 30 + } 31 31 + }, 32 32 + "errors": [ 33 33 + { 34 34 + "name": "DidNotFound", 35 35 + "description": "The DID resolution process confirmed that there is no current DID." 36 36 + }, 37 37 + { 38 38 + "name": "DidDeactivated", 39 39 + "description": "The DID previously existed, but has been deactivated." 40 40 + } 41 41 + ] 42 42 + } 43 43 + } 44 44 + }

+8 -2

lexicons/com/atproto/identity/resolveHandle.json

reviewed

··· 4 4 "defs": { 5 5 "main": { 6 6 "type": "query", 7 7 - "description": "Resolves a handle (domain name) to a DID.", 7 7 + "description": "Resolves an atproto handle (hostname) to a DID. Does not necessarily bi-directionally verify against the the DID document.", 8 8 "parameters": { 9 9 "type": "params", 10 10 "required": ["handle"], ··· 25 25 "did": { "type": "string", "format": "did" } 26 26 } 27 27 } 28 28 - } 28 28 + }, 29 29 + "errors": [ 30 30 + { 31 31 + "name": "HandleNotFound", 32 32 + "description": "The resolution process confirmed that the handle does not resolve to any DID." 33 33 + } 34 34 + ] 29 35 } 30 36 } 31 37 }

+42

lexicons/com/atproto/identity/resolveIdentity.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.identity.resolveIdentity", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Resolves an identity (DID or Handle) to a full identity (DID document and verified handle).", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["identifier"], 11 11 + "properties": { 12 12 + "identifier": { 13 13 + "type": "string", 14 14 + "format": "at-identifier", 15 15 + "description": "Handle or DID to resolve." 16 16 + } 17 17 + } 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "ref", 23 23 + "ref": "com.atproto.identity.defs#identityInfo" 24 24 + } 25 25 + }, 26 26 + "errors": [ 27 27 + { 28 28 + "name": "HandleNotFound", 29 29 + "description": "The resolution process confirmed that the handle does not resolve to any DID." 30 30 + }, 31 31 + { 32 32 + "name": "DidNotFound", 33 33 + "description": "The DID resolution process confirmed that there is no current DID." 34 34 + }, 35 35 + { 36 36 + "name": "DidDeactivated", 37 37 + "description": "The DID previously existed, but has been deactivated." 38 38 + } 39 39 + ] 40 40 + } 41 41 + } 42 42 + }

+51

lexicons/com/atproto/lexicon/resolveLexicon.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.lexicon.resolveLexicon", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Resolves an atproto lexicon (NSID) to a schema.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "nsid": { 12 12 + "format": "nsid", 13 13 + "type": "string", 14 14 + "description": "The lexicon NSID to resolve." 15 15 + } 16 16 + }, 17 17 + "required": ["nsid"] 18 18 + }, 19 19 + "output": { 20 20 + "encoding": "application/json", 21 21 + "schema": { 22 22 + "type": "object", 23 23 + "properties": { 24 24 + "cid": { 25 25 + "type": "string", 26 26 + "format": "cid", 27 27 + "description": "The CID of the lexicon schema record." 28 28 + }, 29 29 + "schema": { 30 30 + "type": "ref", 31 31 + "ref": "com.atproto.lexicon.schema#main", 32 32 + "description": "The resolved lexicon schema record." 33 33 + }, 34 34 + "uri": { 35 35 + "type": "string", 36 36 + "format": "at-uri", 37 37 + "description": "The AT-URI of the lexicon schema record." 38 38 + } 39 39 + }, 40 40 + "required": ["uri", "cid", "schema"] 41 41 + } 42 42 + }, 43 43 + "errors": [ 44 44 + { 45 45 + "description": "No lexicon was resolved for the NSID.", 46 46 + "name": "LexiconNotFound" 47 47 + } 48 48 + ] 49 49 + } 50 50 + } 51 51 + }

+19

lexicons/com/atproto/moderation/createReport.json

reviewed

··· 28 28 "com.atproto.admin.defs#repoRef", 29 29 "com.atproto.repo.strongRef" 30 30 ] 31 31 + }, 32 32 + "modTool": { 33 33 + "type": "ref", 34 34 + "ref": "#modTool" 31 35 } 32 36 } 33 37 } ··· 64 68 "reportedBy": { "type": "string", "format": "did" }, 65 69 "createdAt": { "type": "string", "format": "datetime" } 66 70 } 71 71 + } 72 72 + } 73 73 + }, 74 74 + "modTool": { 75 75 + "type": "object", 76 76 + "description": "Moderation tool information for tracing the source of the action", 77 77 + "required": ["name"], 78 78 + "properties": { 79 79 + "name": { 80 80 + "type": "string", 81 81 + "description": "Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome')" 82 82 + }, 83 83 + "meta": { 84 84 + "type": "unknown", 85 85 + "description": "Additional arbitrary metadata about the source" 67 86 } 68 87 } 69 88 }

+56 -8

lexicons/com/atproto/moderation/defs.json

reviewed

··· 11 11 "com.atproto.moderation.defs#reasonSexual", 12 12 "com.atproto.moderation.defs#reasonRude", 13 13 "com.atproto.moderation.defs#reasonOther", 14 14 - "com.atproto.moderation.defs#reasonAppeal" 14 14 + "com.atproto.moderation.defs#reasonAppeal", 15 15 + 16 16 + "tools.ozone.report.defs#reasonAppeal", 17 17 + "tools.ozone.report.defs#reasonOther", 18 18 + 19 19 + "tools.ozone.report.defs#reasonViolenceAnimal", 20 20 + "tools.ozone.report.defs#reasonViolenceThreats", 21 21 + "tools.ozone.report.defs#reasonViolenceGraphicContent", 22 22 + "tools.ozone.report.defs#reasonViolenceGlorification", 23 23 + "tools.ozone.report.defs#reasonViolenceExtremistContent", 24 24 + "tools.ozone.report.defs#reasonViolenceTrafficking", 25 25 + "tools.ozone.report.defs#reasonViolenceOther", 26 26 + 27 27 + "tools.ozone.report.defs#reasonSexualAbuseContent", 28 28 + "tools.ozone.report.defs#reasonSexualNCII", 29 29 + "tools.ozone.report.defs#reasonSexualDeepfake", 30 30 + "tools.ozone.report.defs#reasonSexualAnimal", 31 31 + "tools.ozone.report.defs#reasonSexualUnlabeled", 32 32 + "tools.ozone.report.defs#reasonSexualOther", 33 33 + 34 34 + "tools.ozone.report.defs#reasonChildSafetyCSAM", 35 35 + "tools.ozone.report.defs#reasonChildSafetyGroom", 36 36 + "tools.ozone.report.defs#reasonChildSafetyPrivacy", 37 37 + "tools.ozone.report.defs#reasonChildSafetyHarassment", 38 38 + "tools.ozone.report.defs#reasonChildSafetyOther", 39 39 + 40 40 + "tools.ozone.report.defs#reasonHarassmentTroll", 41 41 + "tools.ozone.report.defs#reasonHarassmentTargeted", 42 42 + "tools.ozone.report.defs#reasonHarassmentHateSpeech", 43 43 + "tools.ozone.report.defs#reasonHarassmentDoxxing", 44 44 + "tools.ozone.report.defs#reasonHarassmentOther", 45 45 + 46 46 + "tools.ozone.report.defs#reasonMisleadingBot", 47 47 + "tools.ozone.report.defs#reasonMisleadingImpersonation", 48 48 + "tools.ozone.report.defs#reasonMisleadingSpam", 49 49 + "tools.ozone.report.defs#reasonMisleadingScam", 50 50 + "tools.ozone.report.defs#reasonMisleadingElections", 51 51 + "tools.ozone.report.defs#reasonMisleadingOther", 52 52 + 53 53 + "tools.ozone.report.defs#reasonRuleSiteSecurity", 54 54 + "tools.ozone.report.defs#reasonRuleProhibitedSales", 55 55 + "tools.ozone.report.defs#reasonRuleBanEvasion", 56 56 + "tools.ozone.report.defs#reasonRuleOther", 57 57 + 58 58 + "tools.ozone.report.defs#reasonSelfHarmContent", 59 59 + "tools.ozone.report.defs#reasonSelfHarmED", 60 60 + "tools.ozone.report.defs#reasonSelfHarmStunts", 61 61 + "tools.ozone.report.defs#reasonSelfHarmSubstances", 62 62 + "tools.ozone.report.defs#reasonSelfHarmOther" 15 63 ] 16 64 }, 17 65 "reasonSpam": { 18 66 "type": "token", 19 19 - "description": "Spam: frequent unwanted promotion, replies, mentions" 67 67 + "description": "Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`." 20 68 }, 21 69 "reasonViolation": { 22 70 "type": "token", 23 23 - "description": "Direct violation of server rules, laws, terms of service" 71 71 + "description": "Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`." 24 72 }, 25 73 "reasonMisleading": { 26 74 "type": "token", 27 27 - "description": "Misleading identity, affiliation, or content" 75 75 + "description": "Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`." 28 76 }, 29 77 "reasonSexual": { 30 78 "type": "token", 31 31 - "description": "Unwanted or mislabeled sexual content" 79 79 + "description": "Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`." 32 80 }, 33 81 "reasonRude": { 34 82 "type": "token", 35 35 - "description": "Rude, harassing, explicit, or otherwise unwelcoming behavior" 83 83 + "description": "Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`." 36 84 }, 37 85 "reasonOther": { 38 86 "type": "token", 39 39 - "description": "Other: reports not falling under another report category" 87 87 + "description": "Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`." 40 88 }, 41 89 "reasonAppeal": { 42 90 "type": "token", 43 43 - "description": "Appeal: appeal a previously taken moderation action" 91 91 + "description": "Appeal a previously taken moderation action" 44 92 }, 45 93 "subjectType": { 46 94 "type": "string",

+8 -3

lexicons/com/atproto/repo/applyWrites.json

reviewed

··· 70 70 "required": ["collection", "value"], 71 71 "properties": { 72 72 "collection": { "type": "string", "format": "nsid" }, 73 73 - "rkey": { "type": "string", "maxLength": 512 }, 73 73 + "rkey": { 74 74 + "type": "string", 75 75 + "maxLength": 512, 76 76 + "format": "record-key", 77 77 + "description": "NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility." 78 78 + }, 74 79 "value": { "type": "unknown" } 75 80 } 76 81 }, ··· 80 85 "required": ["collection", "rkey", "value"], 81 86 "properties": { 82 87 "collection": { "type": "string", "format": "nsid" }, 83 83 - "rkey": { "type": "string" }, 88 88 + "rkey": { "type": "string", "format": "record-key" }, 84 89 "value": { "type": "unknown" } 85 90 } 86 91 }, ··· 90 95 "required": ["collection", "rkey"], 91 96 "properties": { 92 97 "collection": { "type": "string", "format": "nsid" }, 93 93 - "rkey": { "type": "string" } 98 98 + "rkey": { "type": "string", "format": "record-key" } 94 99 } 95 100 }, 96 101 "createResult": {

+1

lexicons/com/atproto/repo/createRecord.json

reviewed

··· 23 23 }, 24 24 "rkey": { 25 25 "type": "string", 26 26 + "format": "record-key", 26 27 "description": "The Record Key.", 27 28 "maxLength": 512 28 29 },

+1 -1

lexicons/com/atproto/repo/defs.json

reviewed

··· 7 7 "required": ["cid", "rev"], 8 8 "properties": { 9 9 "cid": { "type": "string", "format": "cid" }, 10 10 - "rev": { "type": "string" } 10 10 + "rev": { "type": "string", "format": "tid" } 11 11 } 12 12 } 13 13 }

+1

lexicons/com/atproto/repo/deleteRecord.json

reviewed

··· 23 23 }, 24 24 "rkey": { 25 25 "type": "string", 26 26 + "format": "record-key", 26 27 "description": "The Record Key." 27 28 }, 28 29 "swapRecord": {

-8

lexicons/com/atproto/repo/listRecords.json

reviewed

··· 27 27 "description": "The number of records to return." 28 28 }, 29 29 "cursor": { "type": "string" }, 30 30 - "rkeyStart": { 31 31 - "type": "string", 32 32 - "description": "DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)" 33 33 - }, 34 34 - "rkeyEnd": { 35 35 - "type": "string", 36 36 - "description": "DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)" 37 37 - }, 38 30 "reverse": { 39 31 "type": "boolean", 40 32 "description": "Flag to reverse the order of the returned records."

+1

lexicons/com/atproto/repo/putRecord.json

reviewed

··· 24 24 }, 25 25 "rkey": { 26 26 "type": "string", 27 27 + "format": "record-key", 27 28 "description": "The Record Key.", 28 29 "maxLength": 512 29 30 },

+10

lexicons/com/atproto/sync/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.sync.defs", 4 4 + "defs": { 5 5 + "hostStatus": { 6 6 + "type": "string", 7 7 + "knownValues": ["active", "idle", "offline", "throttled", "banned"] 8 8 + } 9 9 + } 10 10 + }

+43

lexicons/com/atproto/sync/getHostStatus.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.sync.getHostStatus", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Returns information about a specified upstream host, as consumed by the server. Implemented by relays.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["hostname"], 11 11 + "properties": { 12 12 + "hostname": { 13 13 + "type": "string", 14 14 + "description": "Hostname of the host (eg, PDS or relay) being queried." 15 15 + } 16 16 + } 17 17 + }, 18 18 + "output": { 19 19 + "encoding": "application/json", 20 20 + "schema": { 21 21 + "type": "object", 22 22 + "required": ["hostname"], 23 23 + "properties": { 24 24 + "hostname": { "type": "string" }, 25 25 + "seq": { 26 26 + "type": "integer", 27 27 + "description": "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor)." 28 28 + }, 29 29 + "accountCount": { 30 30 + "type": "integer", 31 31 + "description": "Number of accounts on the server which are associated with the upstream host. Note that the upstream may actually have more accounts." 32 32 + }, 33 33 + "status": { 34 34 + "type": "ref", 35 35 + "ref": "com.atproto.sync.defs#hostStatus" 36 36 + } 37 37 + } 38 38 + } 39 39 + }, 40 40 + "errors": [{ "name": "HostNotFound" }] 41 41 + } 42 42 + } 43 43 + }

+1 -1

lexicons/com/atproto/sync/getLatestCommit.json

reviewed

··· 23 23 "required": ["cid", "rev"], 24 24 "properties": { 25 25 "cid": { "type": "string", "format": "cid" }, 26 26 - "rev": { "type": "string" } 26 26 + "rev": { "type": "string", "format": "tid" } 27 27 } 28 28 } 29 29 },

+3 -4

lexicons/com/atproto/sync/getRecord.json

reviewed

··· 15 15 "description": "The DID of the repo." 16 16 }, 17 17 "collection": { "type": "string", "format": "nsid" }, 18 18 - "rkey": { "type": "string", "description": "Record Key" }, 19 19 - "commit": { 18 18 + "rkey": { 20 19 "type": "string", 21 21 - "format": "cid", 22 22 - "description": "DEPRECATED: referenced a repo commit by CID, and retrieved record as of that commit" 20 20 + "description": "Record Key", 21 21 + "format": "record-key" 23 22 } 24 23 } 25 24 },

+1

lexicons/com/atproto/sync/getRepo.json

reviewed

··· 16 16 }, 17 17 "since": { 18 18 "type": "string", 19 19 + "format": "tid", 19 20 "description": "The revision ('rev') of the repo to create a diff from." 20 21 } 21 22 }

+9 -1

lexicons/com/atproto/sync/getRepoStatus.json

reviewed

··· 27 27 "status": { 28 28 "type": "string", 29 29 "description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.", 30 30 - "knownValues": ["takendown", "suspended", "deactivated"] 30 30 + "knownValues": [ 31 31 + "takendown", 32 32 + "suspended", 33 33 + "deleted", 34 34 + "deactivated", 35 35 + "desynchronized", 36 36 + "throttled" 37 37 + ] 31 38 }, 32 39 "rev": { 33 40 "type": "string", 41 41 + "format": "tid", 34 42 "description": "Optional field, the current rev of the repo, if active=true" 35 43 } 36 44 }

+1

lexicons/com/atproto/sync/listBlobs.json

reviewed

··· 16 16 }, 17 17 "since": { 18 18 "type": "string", 19 19 + "format": "tid", 19 20 "description": "Optional revision of the repo to list blobs since." 20 21 }, 21 22 "limit": {

+56

lexicons/com/atproto/sync/listHosts.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.sync.listHosts", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Enumerates upstream hosts (eg, PDS or relay instances) that this service consumes from. Implemented by relays.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "limit": { 12 12 + "type": "integer", 13 13 + "minimum": 1, 14 14 + "maximum": 1000, 15 15 + "default": 200 16 16 + }, 17 17 + "cursor": { "type": "string" } 18 18 + } 19 19 + }, 20 20 + "output": { 21 21 + "encoding": "application/json", 22 22 + "schema": { 23 23 + "type": "object", 24 24 + "required": ["hosts"], 25 25 + "properties": { 26 26 + "cursor": { "type": "string" }, 27 27 + "hosts": { 28 28 + "type": "array", 29 29 + "items": { "type": "ref", "ref": "#host" }, 30 30 + "description": "Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first." 31 31 + } 32 32 + } 33 33 + } 34 34 + } 35 35 + }, 36 36 + "host": { 37 37 + "type": "object", 38 38 + "required": ["hostname"], 39 39 + "properties": { 40 40 + "hostname": { 41 41 + "type": "string", 42 42 + "description": "hostname of server; not a URL (no scheme)" 43 43 + }, 44 44 + "seq": { 45 45 + "type": "integer", 46 46 + "description": "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor)." 47 47 + }, 48 48 + "accountCount": { "type": "integer" }, 49 49 + "status": { 50 50 + "type": "ref", 51 51 + "ref": "com.atproto.sync.defs#hostStatus" 52 52 + } 53 53 + } 54 54 + } 55 55 + } 56 56 + }

+9 -2

lexicons/com/atproto/sync/listRepos.json

reviewed

··· 42 42 "format": "cid", 43 43 "description": "Current repo commit CID" 44 44 }, 45 45 - "rev": { "type": "string" }, 45 45 + "rev": { "type": "string", "format": "tid" }, 46 46 "active": { "type": "boolean" }, 47 47 "status": { 48 48 "type": "string", 49 49 "description": "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.", 50 50 - "knownValues": ["takendown", "suspended", "deactivated"] 50 50 + "knownValues": [ 51 51 + "takendown", 52 52 + "suspended", 53 53 + "deleted", 54 54 + "deactivated", 55 55 + "desynchronized", 56 56 + "throttled" 57 57 + ] 51 58 } 52 59 } 53 60 }

+1 -1

lexicons/com/atproto/sync/notifyOfUpdate.json

reviewed

··· 4 4 "defs": { 5 5 "main": { 6 6 "type": "procedure", 7 7 - "description": "Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay.", 7 7 + "description": "Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay. DEPRECATED: just use com.atproto.sync.requestCrawl", 8 8 "input": { 9 9 "encoding": "application/json", 10 10 "schema": {

+2 -1

lexicons/com/atproto/sync/requestCrawl.json

reviewed

··· 17 17 } 18 18 } 19 19 } 20 20 - } 20 20 + }, 21 21 + "errors": [{ "name": "HostBanned" }] 21 22 } 22 23 } 23 24 }

+55 -53

lexicons/com/atproto/sync/subscribeRepos.json

reviewed

··· 17 17 "message": { 18 18 "schema": { 19 19 "type": "union", 20 20 - "refs": [ 21 21 - "#commit", 22 22 - "#identity", 23 23 - "#account", 24 24 - "#handle", 25 25 - "#migrate", 26 26 - "#tombstone", 27 27 - "#info" 28 28 - ] 20 20 + "refs": ["#commit", "#sync", "#identity", "#account", "#info"] 29 21 } 30 22 }, 31 23 "errors": [ ··· 52 44 "blobs", 53 45 "time" 54 46 ], 55 55 - "nullable": ["prev", "since"], 47 47 + "nullable": ["since"], 56 48 "properties": { 57 49 "seq": { 58 50 "type": "integer", ··· 61 53 "rebase": { "type": "boolean", "description": "DEPRECATED -- unused" }, 62 54 "tooBig": { 63 55 "type": "boolean", 64 64 - "description": "Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data." 56 56 + "description": "DEPRECATED -- replaced by #sync event and data limits. Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data." 65 57 }, 66 58 "repo": { 67 59 "type": "string", 68 60 "format": "did", 69 69 - "description": "The repo this event comes from." 61 61 + "description": "The repo this event comes from. Note that all other message types name this field 'did'." 70 62 }, 71 63 "commit": { 72 64 "type": "cid-link", 73 65 "description": "Repo commit object CID." 74 66 }, 75 75 - "prev": { 76 76 - "type": "cid-link", 77 77 - "description": "DEPRECATED -- unused. WARNING -- nullable and optional; stick with optional to ensure golang interoperability." 78 78 - }, 79 67 "rev": { 80 68 "type": "string", 69 69 + "format": "tid", 81 70 "description": "The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event." 82 71 }, 83 72 "since": { 84 73 "type": "string", 74 74 + "format": "tid", 85 75 "description": "The rev of the last emitted commit from this repo (if any)." 86 76 }, 87 77 "blocks": { 88 78 "type": "bytes", 89 89 - "description": "CAR file containing relevant blocks, as a diff since the previous repo state.", 90 90 - "maxLength": 1000000 79 79 + "description": "CAR file containing relevant blocks, as a diff since the previous repo state. The commit must be included as a block, and the commit block CID must be the first entry in the CAR header 'roots' list.", 80 80 + "maxLength": 2000000 91 81 }, 92 82 "ops": { 93 83 "type": "array", ··· 102 92 "type": "array", 103 93 "items": { 104 94 "type": "cid-link", 105 105 - "description": "List of new blobs (by CID) referenced by records in this commit." 95 95 + "description": "DEPRECATED -- will soon always be empty. List of new blobs (by CID) referenced by records in this commit." 106 96 } 97 97 + }, 98 98 + "prevData": { 99 99 + "type": "cid-link", 100 100 + "description": "The root CID of the MST tree for the previous commit from this repo (indicated by the 'since' revision field in this message). Corresponds to the 'data' field in the repo commit object. NOTE: this field is effectively required for the 'inductive' version of firehose." 101 101 + }, 102 102 + "time": { 103 103 + "type": "string", 104 104 + "format": "datetime", 105 105 + "description": "Timestamp of when this message was originally broadcast." 106 106 + } 107 107 + } 108 108 + }, 109 109 + "sync": { 110 110 + "type": "object", 111 111 + "description": "Updates the repo to a new state, without necessarily including that state on the firehose. Used to recover from broken commit streams, data loss incidents, or in situations where upstream host does not know recent state of the repository.", 112 112 + "required": ["seq", "did", "blocks", "rev", "time"], 113 113 + "properties": { 114 114 + "seq": { 115 115 + "type": "integer", 116 116 + "description": "The stream sequence number of this message." 117 117 + }, 118 118 + "did": { 119 119 + "type": "string", 120 120 + "format": "did", 121 121 + "description": "The account this repo event corresponds to. Must match that in the commit object." 122 122 + }, 123 123 + "blocks": { 124 124 + "type": "bytes", 125 125 + "description": "CAR file containing the commit, as a block. The CAR header must include the commit block CID as the first 'root'.", 126 126 + "maxLength": 10000 127 127 + }, 128 128 + "rev": { 129 129 + "type": "string", 130 130 + "description": "The rev of the commit. This value must match that in the commit object." 107 131 }, 108 132 "time": { 109 133 "type": "string", ··· 142 166 "status": { 143 167 "type": "string", 144 168 "description": "If active=false, this optional field indicates a reason for why the account is not active.", 145 145 - "knownValues": ["takendown", "suspended", "deleted", "deactivated"] 169 169 + "knownValues": [ 170 170 + "takendown", 171 171 + "suspended", 172 172 + "deleted", 173 173 + "deactivated", 174 174 + "desynchronized", 175 175 + "throttled" 176 176 + ] 146 177 } 147 178 } 148 179 }, 149 149 - "handle": { 150 150 - "type": "object", 151 151 - "description": "DEPRECATED -- Use #identity event instead", 152 152 - "required": ["seq", "did", "handle", "time"], 153 153 - "properties": { 154 154 - "seq": { "type": "integer" }, 155 155 - "did": { "type": "string", "format": "did" }, 156 156 - "handle": { "type": "string", "format": "handle" }, 157 157 - "time": { "type": "string", "format": "datetime" } 158 158 - } 159 159 - }, 160 160 - "migrate": { 161 161 - "type": "object", 162 162 - "description": "DEPRECATED -- Use #account event instead", 163 163 - "required": ["seq", "did", "migrateTo", "time"], 164 164 - "nullable": ["migrateTo"], 165 165 - "properties": { 166 166 - "seq": { "type": "integer" }, 167 167 - "did": { "type": "string", "format": "did" }, 168 168 - "migrateTo": { "type": "string" }, 169 169 - "time": { "type": "string", "format": "datetime" } 170 170 - } 171 171 - }, 172 172 - "tombstone": { 173 173 - "type": "object", 174 174 - "description": "DEPRECATED -- Use #account event instead", 175 175 - "required": ["seq", "did", "time"], 176 176 - "properties": { 177 177 - "seq": { "type": "integer" }, 178 178 - "did": { "type": "string", "format": "did" }, 179 179 - "time": { "type": "string", "format": "datetime" } 180 180 - } 181 181 - }, 182 180 "info": { 183 181 "type": "object", 184 182 "required": ["name"], ··· 206 204 "cid": { 207 205 "type": "cid-link", 208 206 "description": "For creates and updates, the new record CID. For deletions, null." 207 207 + }, 208 208 + "prev": { 209 209 + "type": "cid-link", 210 210 + "description": "For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined." 209 211 } 210 212 } 211 213 }

+88

lexicons/com/atproto/temp/checkHandleAvailability.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.temp.checkHandleAvailability", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Checks whether the provided handle is available. If the handle is not available, available suggestions will be returned. Optional inputs will be used to generate suggestions.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["handle"], 11 11 + "properties": { 12 12 + "handle": { 13 13 + "type": "string", 14 14 + "format": "handle", 15 15 + "description": "Tentative handle. Will be checked for availability or used to build handle suggestions." 16 16 + }, 17 17 + "email": { 18 18 + "type": "string", 19 19 + "description": "User-provided email. Might be used to build handle suggestions." 20 20 + }, 21 21 + "birthDate": { 22 22 + "type": "string", 23 23 + "format": "datetime", 24 24 + "description": "User-provided birth date. Might be used to build handle suggestions." 25 25 + } 26 26 + } 27 27 + }, 28 28 + "output": { 29 29 + "encoding": "application/json", 30 30 + "schema": { 31 31 + "type": "object", 32 32 + "required": ["handle", "result"], 33 33 + "properties": { 34 34 + "handle": { 35 35 + "type": "string", 36 36 + "format": "handle", 37 37 + "description": "Echo of the input handle." 38 38 + }, 39 39 + "result": { 40 40 + "type": "union", 41 41 + "refs": ["#resultAvailable", "#resultUnavailable"] 42 42 + } 43 43 + } 44 44 + } 45 45 + }, 46 46 + "errors": [ 47 47 + { 48 48 + "name": "InvalidEmail", 49 49 + "description": "An invalid email was provided." 50 50 + } 51 51 + ] 52 52 + }, 53 53 + "resultAvailable": { 54 54 + "type": "object", 55 55 + "description": "Indicates the provided handle is available.", 56 56 + "properties": {} 57 57 + }, 58 58 + "resultUnavailable": { 59 59 + "type": "object", 60 60 + "description": "Indicates the provided handle is unavailable and gives suggestions of available handles.", 61 61 + "required": ["suggestions"], 62 62 + "properties": { 63 63 + "suggestions": { 64 64 + "type": "array", 65 65 + "description": "List of suggested handles based on the provided inputs.", 66 66 + "items": { 67 67 + "type": "ref", 68 68 + "ref": "#suggestion" 69 69 + } 70 70 + } 71 71 + } 72 72 + }, 73 73 + "suggestion": { 74 74 + "type": "object", 75 75 + "required": ["handle", "method"], 76 76 + "properties": { 77 77 + "handle": { 78 78 + "type": "string", 79 79 + "format": "handle" 80 80 + }, 81 81 + "method": { 82 82 + "type": "string", 83 83 + "description": "Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics." 84 84 + } 85 85 + } 86 86 + } 87 87 + } 88 88 + }

+39

lexicons/com/atproto/temp/dereferenceScope.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.temp.dereferenceScope", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Allows finding the oauth permission scope from a reference", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["scope"], 11 11 + "properties": { 12 12 + "scope": { 13 13 + "type": "string", 14 14 + "description": "The scope reference (starts with 'ref:')" 15 15 + } 16 16 + } 17 17 + }, 18 18 + "output": { 19 19 + "encoding": "application/json", 20 20 + "schema": { 21 21 + "type": "object", 22 22 + "required": ["scope"], 23 23 + "properties": { 24 24 + "scope": { 25 25 + "type": "string", 26 26 + "description": "The full oauth permission scope" 27 27 + } 28 28 + } 29 29 + } 30 30 + }, 31 31 + "errors": [ 32 32 + { 33 33 + "name": "InvalidScopeReference", 34 34 + "description": "An invalid scope reference was provided." 35 35 + } 36 36 + ] 37 37 + } 38 38 + } 39 39 + }

+23

lexicons/com/atproto/temp/revokeAccountCredentials.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "com.atproto.temp.revokeAccountCredentials", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Revoke sessions, password, and app passwords associated with account. May be resolved by a password reset.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["account"], 13 13 + "properties": { 14 14 + "account": { 15 15 + "type": "string", 16 16 + "format": "at-identifier" 17 17 + } 18 18 + } 19 19 + } 20 20 + } 21 21 + } 22 22 + } 23 23 + }

+106

lexicons/tools/ozone/hosting/getAccountHistory.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.hosting.getAccountHistory", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get account history, e.g. log of updated email addresses or other identity information.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["did"], 11 11 + "properties": { 12 12 + "did": { "type": "string", "format": "did" }, 13 13 + "events": { 14 14 + "type": "array", 15 15 + "items": { 16 16 + "type": "string", 17 17 + "knownValues": [ 18 18 + "accountCreated", 19 19 + "emailUpdated", 20 20 + "emailConfirmed", 21 21 + "passwordUpdated", 22 22 + "handleUpdated" 23 23 + ] 24 24 + } 25 25 + }, 26 26 + "cursor": { "type": "string" }, 27 27 + "limit": { 28 28 + "type": "integer", 29 29 + "minimum": 1, 30 30 + "maximum": 100, 31 31 + "default": 50 32 32 + } 33 33 + } 34 34 + }, 35 35 + "output": { 36 36 + "encoding": "application/json", 37 37 + "schema": { 38 38 + "type": "object", 39 39 + "required": ["events"], 40 40 + "properties": { 41 41 + "cursor": { "type": "string" }, 42 42 + "events": { 43 43 + "type": "array", 44 44 + "items": { 45 45 + "type": "ref", 46 46 + "ref": "#event" 47 47 + } 48 48 + } 49 49 + } 50 50 + } 51 51 + } 52 52 + }, 53 53 + "event": { 54 54 + "type": "object", 55 55 + "required": ["details", "createdBy", "createdAt"], 56 56 + "properties": { 57 57 + "details": { 58 58 + "type": "union", 59 59 + "refs": [ 60 60 + "#accountCreated", 61 61 + "#emailUpdated", 62 62 + "#emailConfirmed", 63 63 + "#passwordUpdated", 64 64 + "#handleUpdated" 65 65 + ] 66 66 + }, 67 67 + "createdBy": { "type": "string" }, 68 68 + "createdAt": { "type": "string", "format": "datetime" } 69 69 + } 70 70 + }, 71 71 + "accountCreated": { 72 72 + "type": "object", 73 73 + "required": [], 74 74 + "properties": { 75 75 + "email": { "type": "string" }, 76 76 + "handle": { "type": "string", "format": "handle" } 77 77 + } 78 78 + }, 79 79 + "emailUpdated": { 80 80 + "type": "object", 81 81 + "required": ["email"], 82 82 + "properties": { 83 83 + "email": { "type": "string" } 84 84 + } 85 85 + }, 86 86 + "emailConfirmed": { 87 87 + "type": "object", 88 88 + "required": ["email"], 89 89 + "properties": { 90 90 + "email": { "type": "string" } 91 91 + } 92 92 + }, 93 93 + "passwordUpdated": { 94 94 + "type": "object", 95 95 + "required": [], 96 96 + "properties": {} 97 97 + }, 98 98 + "handleUpdated": { 99 99 + "type": "object", 100 100 + "required": ["handle"], 101 101 + "properties": { 102 102 + "handle": { "type": "string", "format": "handle" } 103 103 + } 104 104 + } 105 105 + } 106 106 + }

+64

lexicons/tools/ozone/moderation/cancelScheduledActions.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.moderation.cancelScheduledActions", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Cancel all pending scheduled moderation actions for specified subjects", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["subjects"], 13 13 + "properties": { 14 14 + "subjects": { 15 15 + "type": "array", 16 16 + "maxLength": 100, 17 17 + "items": { 18 18 + "type": "string", 19 19 + "format": "did" 20 20 + }, 21 21 + "description": "Array of DID subjects to cancel scheduled actions for" 22 22 + }, 23 23 + "comment": { 24 24 + "type": "string", 25 25 + "description": "Optional comment describing the reason for cancellation" 26 26 + } 27 27 + } 28 28 + } 29 29 + }, 30 30 + "output": { 31 31 + "encoding": "application/json", 32 32 + "schema": { 33 33 + "type": "ref", 34 34 + "ref": "#cancellationResults" 35 35 + } 36 36 + } 37 37 + }, 38 38 + "cancellationResults": { 39 39 + "type": "object", 40 40 + "required": ["succeeded", "failed"], 41 41 + "properties": { 42 42 + "succeeded": { 43 43 + "type": "array", 44 44 + "items": { "type": "string", "format": "did" }, 45 45 + "description": "DIDs for which all pending scheduled actions were successfully cancelled" 46 46 + }, 47 47 + "failed": { 48 48 + "type": "array", 49 49 + "items": { "type": "ref", "ref": "#failedCancellation" }, 50 50 + "description": "DIDs for which cancellation failed with error details" 51 51 + } 52 52 + } 53 53 + }, 54 54 + "failedCancellation": { 55 55 + "type": "object", 56 56 + "required": ["did", "error"], 57 57 + "properties": { 58 58 + "did": { "type": "string", "format": "did" }, 59 59 + "error": { "type": "string" }, 60 60 + "errorCode": { "type": "string" } 61 61 + } 62 62 + } 63 63 + } 64 64 + }

+347 -9

lexicons/tools/ozone/moderation/defs.json

reviewed

··· 35 35 "#accountEvent", 36 36 "#identityEvent", 37 37 "#recordEvent", 38 38 - "#modEventPriorityScore" 38 38 + "#modEventPriorityScore", 39 39 + "#ageAssuranceEvent", 40 40 + "#ageAssuranceOverrideEvent", 41 41 + "#revokeAccountCredentialsEvent", 42 42 + "#scheduleTakedownEvent", 43 43 + "#cancelScheduledTakedownEvent" 39 44 ] 40 45 }, 41 46 "subject": { ··· 50 55 "createdBy": { "type": "string", "format": "did" }, 51 56 "createdAt": { "type": "string", "format": "datetime" }, 52 57 "creatorHandle": { "type": "string" }, 53 53 - "subjectHandle": { "type": "string" } 58 58 + "subjectHandle": { "type": "string" }, 59 59 + "modTool": { "type": "ref", "ref": "#modTool" } 54 60 } 55 61 }, 56 62 "modEventViewDetail": { ··· 86 92 "#accountEvent", 87 93 "#identityEvent", 88 94 "#recordEvent", 89 89 - "#modEventPriorityScore" 95 95 + "#modEventPriorityScore", 96 96 + "#ageAssuranceEvent", 97 97 + "#ageAssuranceOverrideEvent", 98 98 + "#revokeAccountCredentialsEvent", 99 99 + "#scheduleTakedownEvent", 100 100 + "#cancelScheduledTakedownEvent" 90 101 ] 91 102 }, 92 103 "subject": { ··· 103 114 "items": { "type": "ref", "ref": "#blobView" } 104 115 }, 105 116 "createdBy": { "type": "string", "format": "did" }, 106 106 - "createdAt": { "type": "string", "format": "datetime" } 117 117 + "createdAt": { "type": "string", "format": "datetime" }, 118 118 + "modTool": { "type": "ref", "ref": "#modTool" } 107 119 } 108 120 }, 109 121 "subjectStatusView": { ··· 115 127 "type": "union", 116 128 "refs": [ 117 129 "com.atproto.admin.defs#repoRef", 118 118 - "com.atproto.repo.strongRef" 130 130 + "com.atproto.repo.strongRef", 131 131 + "chat.bsky.convo.defs#messageRef" 119 132 ] 120 133 }, 121 134 "hosting": { ··· 200 213 "description": "Statistics related to the record subjects authored by the subject's account", 201 214 "type": "ref", 202 215 "ref": "#recordsStats" 216 216 + }, 217 217 + "accountStrike": { 218 218 + "description": "Strike information for the account (account-level only)", 219 219 + "type": "ref", 220 220 + "ref": "#accountStrike" 221 221 + }, 222 222 + "ageAssuranceState": { 223 223 + "type": "string", 224 224 + "description": "Current age assurance state of the subject.", 225 225 + "knownValues": ["pending", "assured", "unknown", "reset", "blocked"] 226 226 + }, 227 227 + "ageAssuranceUpdatedBy": { 228 228 + "type": "string", 229 229 + "description": "Whether or not the last successful update to age assurance was made by the user or admin.", 230 230 + "knownValues": ["admin", "user"] 231 231 + } 232 232 + } 233 233 + }, 234 234 + "subjectView": { 235 235 + "description": "Detailed view of a subject. For record subjects, the author's repo and profile will be returned.", 236 236 + "type": "object", 237 237 + "required": ["type", "subject"], 238 238 + "properties": { 239 239 + "type": { 240 240 + "type": "ref", 241 241 + "ref": "com.atproto.moderation.defs#subjectType" 242 242 + }, 243 243 + "subject": { 244 244 + "type": "string" 245 245 + }, 246 246 + "status": { 247 247 + "type": "ref", 248 248 + "ref": "#subjectStatusView" 249 249 + }, 250 250 + "repo": { 251 251 + "type": "ref", 252 252 + "ref": "#repoViewDetail" 253 253 + }, 254 254 + "profile": { 255 255 + "type": "union", 256 256 + "refs": [] 257 257 + }, 258 258 + "record": { 259 259 + "type": "ref", 260 260 + "ref": "#recordViewDetail" 203 261 } 204 262 } 205 263 }, ··· 267 325 } 268 326 } 269 327 }, 328 328 + "accountStrike": { 329 329 + "description": "Strike information for an account", 330 330 + "type": "object", 331 331 + "properties": { 332 332 + "activeStrikeCount": { 333 333 + "description": "Current number of active strikes (excluding expired strikes)", 334 334 + "type": "integer" 335 335 + }, 336 336 + "totalStrikeCount": { 337 337 + "description": "Total number of strikes ever received (including expired strikes)", 338 338 + "type": "integer" 339 339 + }, 340 340 + "firstStrikeAt": { 341 341 + "description": "Timestamp of the first strike received", 342 342 + "type": "string", 343 343 + "format": "datetime" 344 344 + }, 345 345 + "lastStrikeAt": { 346 346 + "description": "Timestamp of the most recent strike received", 347 347 + "type": "string", 348 348 + "format": "datetime" 349 349 + } 350 350 + } 351 351 + }, 270 352 "subjectReviewState": { 271 353 "type": "string", 272 354 "knownValues": [ 273 273 - "#reviewOpen", 274 274 - "#reviewEscalated", 275 275 - "#reviewClosed", 276 276 - "#reviewNone" 355 355 + "tools.ozone.moderation.defs#reviewOpen", 356 356 + "tools.ozone.moderation.defs#reviewEscalated", 357 357 + "tools.ozone.moderation.defs#reviewClosed", 358 358 + "tools.ozone.moderation.defs#reviewNone" 277 359 ] 278 360 }, 279 361 "reviewOpen": { ··· 312 394 "maxLength": 5, 313 395 "items": { "type": "string" }, 314 396 "description": "Names/Keywords of the policies that drove the decision." 397 397 + }, 398 398 + "severityLevel": { 399 399 + "type": "string", 400 400 + "description": "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.)." 401 401 + }, 402 402 + "targetServices": { 403 403 + "type": "array", 404 404 + "items": { "type": "string", "knownValues": ["appview", "pds"] }, 405 405 + "description": "List of services where the takedown should be applied. If empty or not provided, takedown is applied on all configured services." 406 406 + }, 407 407 + "strikeCount": { 408 408 + "type": "integer", 409 409 + "description": "Number of strikes to assign to the user for this violation." 410 410 + }, 411 411 + "strikeExpiresAt": { 412 412 + "type": "string", 413 413 + "format": "datetime", 414 414 + "description": "When the strike should expire. If not provided, the strike never expires." 315 415 } 316 416 } 317 417 }, ··· 322 422 "comment": { 323 423 "type": "string", 324 424 "description": "Describe reasoning behind the reversal." 425 425 + }, 426 426 + "policies": { 427 427 + "type": "array", 428 428 + "maxLength": 5, 429 429 + "items": { "type": "string" }, 430 430 + "description": "Names/Keywords of the policy infraction for which takedown is being reversed." 431 431 + }, 432 432 + "severityLevel": { 433 433 + "type": "string", 434 434 + "description": "Severity level of the violation. Usually set from the last policy infraction's severity." 435 435 + }, 436 436 + "strikeCount": { 437 437 + "type": "integer", 438 438 + "description": "Number of strikes to subtract from the user's strike count. Usually set from the last policy infraction's severity." 325 439 } 326 440 } 327 441 }, ··· 403 517 } 404 518 } 405 519 }, 520 520 + "ageAssuranceEvent": { 521 521 + "type": "object", 522 522 + "description": "Age assurance info coming directly from users. Only works on DID subjects.", 523 523 + "required": ["createdAt", "status", "attemptId"], 524 524 + "properties": { 525 525 + "createdAt": { 526 526 + "type": "string", 527 527 + "format": "datetime", 528 528 + "description": "The date and time of this write operation." 529 529 + }, 530 530 + "attemptId": { 531 531 + "type": "string", 532 532 + "description": "The unique identifier for this instance of the age assurance flow, in UUID format." 533 533 + }, 534 534 + "status": { 535 535 + "type": "string", 536 536 + "description": "The status of the Age Assurance process.", 537 537 + "knownValues": ["unknown", "pending", "assured"] 538 538 + }, 539 539 + "access": { 540 540 + "type": "ref", 541 541 + "ref": "app.bsky.ageassurance.defs#access" 542 542 + }, 543 543 + "countryCode": { 544 544 + "type": "string", 545 545 + "description": "The ISO 3166-1 alpha-2 country code provided when beginning the Age Assurance flow." 546 546 + }, 547 547 + "regionCode": { 548 548 + "type": "string", 549 549 + "description": "The ISO 3166-2 region code provided when beginning the Age Assurance flow." 550 550 + }, 551 551 + "initIp": { 552 552 + "type": "string", 553 553 + "description": "The IP address used when initiating the AA flow." 554 554 + }, 555 555 + "initUa": { 556 556 + "type": "string", 557 557 + "description": "The user agent used when initiating the AA flow." 558 558 + }, 559 559 + "completeIp": { 560 560 + "type": "string", 561 561 + "description": "The IP address used when completing the AA flow." 562 562 + }, 563 563 + "completeUa": { 564 564 + "type": "string", 565 565 + "description": "The user agent used when completing the AA flow." 566 566 + } 567 567 + } 568 568 + }, 569 569 + "ageAssuranceOverrideEvent": { 570 570 + "type": "object", 571 571 + "description": "Age assurance status override by moderators. Only works on DID subjects.", 572 572 + "required": ["comment", "status"], 573 573 + "properties": { 574 574 + "status": { 575 575 + "type": "string", 576 576 + "description": "The status to be set for the user decided by a moderator, overriding whatever value the user had previously. Use reset to default to original state.", 577 577 + "knownValues": ["assured", "reset", "blocked"] 578 578 + }, 579 579 + "access": { 580 580 + "type": "ref", 581 581 + "ref": "app.bsky.ageassurance.defs#access" 582 582 + }, 583 583 + "comment": { 584 584 + "type": "string", 585 585 + "description": "Comment describing the reason for the override." 586 586 + } 587 587 + } 588 588 + }, 589 589 + "revokeAccountCredentialsEvent": { 590 590 + "type": "object", 591 591 + "description": "Account credentials revocation by moderators. Only works on DID subjects.", 592 592 + "required": ["comment"], 593 593 + "properties": { 594 594 + "comment": { 595 595 + "type": "string", 596 596 + "description": "Comment describing the reason for the revocation." 597 597 + } 598 598 + } 599 599 + }, 406 600 "modEventAcknowledge": { 407 601 "type": "object", 408 602 "properties": { ··· 478 672 "comment": { 479 673 "type": "string", 480 674 "description": "Additional comment about the outgoing comm." 675 675 + }, 676 676 + "policies": { 677 677 + "type": "array", 678 678 + "maxLength": 5, 679 679 + "items": { "type": "string" }, 680 680 + "description": "Names/Keywords of the policies that necessitated the email." 681 681 + }, 682 682 + "severityLevel": { 683 683 + "type": "string", 684 684 + "description": "Severity level of the violation. Normally 'sev-1' that adds strike on repeat offense" 685 685 + }, 686 686 + "strikeCount": { 687 687 + "type": "integer", 688 688 + "description": "Number of strikes to assign to the user for this violation. Normally 0 as an indicator of a warning and only added as a strike on a repeat offense." 689 689 + }, 690 690 + "strikeExpiresAt": { 691 691 + "type": "string", 692 692 + "format": "datetime", 693 693 + "description": "When the strike should expire. If not provided, the strike never expires." 694 694 + }, 695 695 + "isDelivered": { 696 696 + "type": "boolean", 697 697 + "description": "Indicates whether the email was successfully delivered to the user's inbox." 481 698 } 482 699 } 483 700 }, ··· 563 780 }, 564 781 "cid": { "type": "string", "format": "cid" }, 565 782 "timestamp": { "type": "string", "format": "datetime" } 783 783 + } 784 784 + }, 785 785 + "scheduleTakedownEvent": { 786 786 + "type": "object", 787 787 + "description": "Logs a scheduled takedown action for an account.", 788 788 + "properties": { 789 789 + "comment": { "type": "string" }, 790 790 + "executeAt": { "type": "string", "format": "datetime" }, 791 791 + "executeAfter": { "type": "string", "format": "datetime" }, 792 792 + "executeUntil": { "type": "string", "format": "datetime" } 793 793 + } 794 794 + }, 795 795 + "cancelScheduledTakedownEvent": { 796 796 + "type": "object", 797 797 + "description": "Logs cancellation of a scheduled takedown action for an account.", 798 798 + "properties": { 799 799 + "comment": { "type": "string" } 566 800 } 567 801 }, 568 802 "repoView": { ··· 861 1095 "labeledRecordCount": { 862 1096 "type": "integer", 863 1097 "description": "The total number of records labeled as a result of the user's reports." 1098 1098 + } 1099 1099 + } 1100 1100 + }, 1101 1101 + "modTool": { 1102 1102 + "type": "object", 1103 1103 + "description": "Moderation tool information for tracing the source of the action", 1104 1104 + "required": ["name"], 1105 1105 + "properties": { 1106 1106 + "name": { 1107 1107 + "type": "string", 1108 1108 + "description": "Name/identifier of the source (e.g., 'automod', 'ozone/workspace')" 1109 1109 + }, 1110 1110 + "meta": { 1111 1111 + "type": "unknown", 1112 1112 + "description": "Additional arbitrary metadata about the source" 1113 1113 + } 1114 1114 + } 1115 1115 + }, 1116 1116 + "timelineEventPlcCreate": { 1117 1117 + "type": "token", 1118 1118 + "description": "Moderation event timeline event for a PLC create operation" 1119 1119 + }, 1120 1120 + "timelineEventPlcOperation": { 1121 1121 + "type": "token", 1122 1122 + "description": "Moderation event timeline event for generic PLC operation" 1123 1123 + }, 1124 1124 + "timelineEventPlcTombstone": { 1125 1125 + "type": "token", 1126 1126 + "description": "Moderation event timeline event for a PLC tombstone operation" 1127 1127 + }, 1128 1128 + "scheduledActionView": { 1129 1129 + "type": "object", 1130 1130 + "description": "View of a scheduled moderation action", 1131 1131 + "required": ["id", "action", "did", "createdBy", "createdAt", "status"], 1132 1132 + "properties": { 1133 1133 + "id": { 1134 1134 + "type": "integer", 1135 1135 + "description": "Auto-incrementing row ID" 1136 1136 + }, 1137 1137 + "action": { 1138 1138 + "type": "string", 1139 1139 + "knownValues": ["takedown"], 1140 1140 + "description": "Type of action to be executed" 1141 1141 + }, 1142 1142 + "eventData": { 1143 1143 + "type": "unknown", 1144 1144 + "description": "Serialized event object that will be propagated to the event when performed" 1145 1145 + }, 1146 1146 + "did": { 1147 1147 + "type": "string", 1148 1148 + "format": "did", 1149 1149 + "description": "Subject DID for the action" 1150 1150 + }, 1151 1151 + "executeAt": { 1152 1152 + "type": "string", 1153 1153 + "format": "datetime", 1154 1154 + "description": "Exact time to execute the action" 1155 1155 + }, 1156 1156 + "executeAfter": { 1157 1157 + "type": "string", 1158 1158 + "format": "datetime", 1159 1159 + "description": "Earliest time to execute the action (for randomized scheduling)" 1160 1160 + }, 1161 1161 + "executeUntil": { 1162 1162 + "type": "string", 1163 1163 + "format": "datetime", 1164 1164 + "description": "Latest time to execute the action (for randomized scheduling)" 1165 1165 + }, 1166 1166 + "randomizeExecution": { 1167 1167 + "type": "boolean", 1168 1168 + "description": "Whether execution time should be randomized within the specified range" 1169 1169 + }, 1170 1170 + "createdBy": { 1171 1171 + "type": "string", 1172 1172 + "format": "did", 1173 1173 + "description": "DID of the user who created this scheduled action" 1174 1174 + }, 1175 1175 + "createdAt": { 1176 1176 + "type": "string", 1177 1177 + "format": "datetime", 1178 1178 + "description": "When the scheduled action was created" 1179 1179 + }, 1180 1180 + "updatedAt": { 1181 1181 + "type": "string", 1182 1182 + "format": "datetime", 1183 1183 + "description": "When the scheduled action was last updated" 1184 1184 + }, 1185 1185 + "status": { 1186 1186 + "type": "string", 1187 1187 + "knownValues": ["pending", "executed", "cancelled", "failed"], 1188 1188 + "description": "Current status of the scheduled action" 1189 1189 + }, 1190 1190 + "lastExecutedAt": { 1191 1191 + "type": "string", 1192 1192 + "format": "datetime", 1193 1193 + "description": "When the action was last attempted to be executed" 1194 1194 + }, 1195 1195 + "lastFailureReason": { 1196 1196 + "type": "string", 1197 1197 + "description": "Reason for the last execution failure" 1198 1198 + }, 1199 1199 + "executionEventId": { 1200 1200 + "type": "integer", 1201 1201 + "description": "ID of the moderation event created when action was successfully executed" 864 1202 } 865 1203 } 866 1204 }

+31 -4

lexicons/tools/ozone/moderation/emitEvent.json

reviewed

··· 32 32 "tools.ozone.moderation.defs#accountEvent", 33 33 "tools.ozone.moderation.defs#identityEvent", 34 34 "tools.ozone.moderation.defs#recordEvent", 35 35 - "tools.ozone.moderation.defs#modEventPriorityScore" 35 35 + "tools.ozone.moderation.defs#modEventPriorityScore", 36 36 + "tools.ozone.moderation.defs#ageAssuranceEvent", 37 37 + "tools.ozone.moderation.defs#ageAssuranceOverrideEvent", 38 38 + "tools.ozone.moderation.defs#revokeAccountCredentialsEvent", 39 39 + "tools.ozone.moderation.defs#scheduleTakedownEvent", 40 40 + "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" 36 41 ] 37 42 }, 38 43 "subject": { ··· 44 49 }, 45 50 "subjectBlobCids": { 46 51 "type": "array", 47 47 - "items": { "type": "string", "format": "cid" } 52 52 + "items": { 53 53 + "type": "string", 54 54 + "format": "cid" 55 55 + } 56 56 + }, 57 57 + "createdBy": { 58 58 + "type": "string", 59 59 + "format": "did" 60 60 + }, 61 61 + "modTool": { 62 62 + "type": "ref", 63 63 + "ref": "tools.ozone.moderation.defs#modTool" 48 64 }, 49 49 - "createdBy": { "type": "string", "format": "did" } 65 65 + "externalId": { 66 66 + "type": "string", 67 67 + "description": "An optional external ID for the event, used to deduplicate events from external systems. Fails when an event of same type with the same external ID exists for the same subject." 68 68 + } 50 69 } 51 70 } 52 71 }, ··· 57 76 "ref": "tools.ozone.moderation.defs#modEventView" 58 77 } 59 78 }, 60 60 - "errors": [{ "name": "SubjectHasAction" }] 79 79 + "errors": [ 80 80 + { 81 81 + "name": "SubjectHasAction" 82 82 + }, 83 83 + { 84 84 + "name": "DuplicateExternalId", 85 85 + "description": "An event with the same external ID already exists for the subject." 86 86 + } 87 87 + ] 61 88 } 62 89 } 63 90 }

+106

lexicons/tools/ozone/moderation/getAccountTimeline.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.moderation.getAccountTimeline", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get timeline of all available events of an account. This includes moderation events, account history and did history.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["did"], 11 11 + "properties": { 12 12 + "did": { 13 13 + "type": "string", 14 14 + "format": "did" 15 15 + } 16 16 + } 17 17 + }, 18 18 + "output": { 19 19 + "encoding": "application/json", 20 20 + "schema": { 21 21 + "type": "object", 22 22 + "required": ["timeline"], 23 23 + "properties": { 24 24 + "timeline": { 25 25 + "type": "array", 26 26 + "items": { 27 27 + "type": "ref", 28 28 + "ref": "#timelineItem" 29 29 + } 30 30 + } 31 31 + } 32 32 + } 33 33 + }, 34 34 + "errors": [ 35 35 + { 36 36 + "name": "RepoNotFound" 37 37 + } 38 38 + ] 39 39 + }, 40 40 + "timelineItem": { 41 41 + "type": "object", 42 42 + "required": ["day", "summary"], 43 43 + "properties": { 44 44 + "day": { 45 45 + "type": "string" 46 46 + }, 47 47 + "summary": { 48 48 + "type": "array", 49 49 + "items": { 50 50 + "type": "ref", 51 51 + "ref": "#timelineItemSummary" 52 52 + } 53 53 + } 54 54 + } 55 55 + }, 56 56 + "timelineItemSummary": { 57 57 + "type": "object", 58 58 + "required": ["eventSubjectType", "eventType", "count"], 59 59 + "properties": { 60 60 + "eventSubjectType": { 61 61 + "type": "string", 62 62 + "knownValues": ["account", "record", "chat"] 63 63 + }, 64 64 + "eventType": { 65 65 + "type": "string", 66 66 + "knownValues": [ 67 67 + "tools.ozone.moderation.defs#modEventTakedown", 68 68 + "tools.ozone.moderation.defs#modEventReverseTakedown", 69 69 + "tools.ozone.moderation.defs#modEventComment", 70 70 + "tools.ozone.moderation.defs#modEventReport", 71 71 + "tools.ozone.moderation.defs#modEventLabel", 72 72 + "tools.ozone.moderation.defs#modEventAcknowledge", 73 73 + "tools.ozone.moderation.defs#modEventEscalate", 74 74 + "tools.ozone.moderation.defs#modEventMute", 75 75 + "tools.ozone.moderation.defs#modEventUnmute", 76 76 + "tools.ozone.moderation.defs#modEventMuteReporter", 77 77 + "tools.ozone.moderation.defs#modEventUnmuteReporter", 78 78 + "tools.ozone.moderation.defs#modEventEmail", 79 79 + "tools.ozone.moderation.defs#modEventResolveAppeal", 80 80 + "tools.ozone.moderation.defs#modEventDivert", 81 81 + "tools.ozone.moderation.defs#modEventTag", 82 82 + "tools.ozone.moderation.defs#accountEvent", 83 83 + "tools.ozone.moderation.defs#identityEvent", 84 84 + "tools.ozone.moderation.defs#recordEvent", 85 85 + "tools.ozone.moderation.defs#modEventPriorityScore", 86 86 + "tools.ozone.moderation.defs#revokeAccountCredentialsEvent", 87 87 + "tools.ozone.moderation.defs#ageAssuranceEvent", 88 88 + "tools.ozone.moderation.defs#ageAssuranceOverrideEvent", 89 89 + "tools.ozone.moderation.defs#timelineEventPlcCreate", 90 90 + "tools.ozone.moderation.defs#timelineEventPlcOperation", 91 91 + "tools.ozone.moderation.defs#timelineEventPlcTombstone", 92 92 + "tools.ozone.hosting.getAccountHistory#accountCreated", 93 93 + "tools.ozone.hosting.getAccountHistory#emailConfirmed", 94 94 + "tools.ozone.hosting.getAccountHistory#passwordUpdated", 95 95 + "tools.ozone.hosting.getAccountHistory#handleUpdated", 96 96 + "tools.ozone.moderation.defs#scheduleTakedownEvent", 97 97 + "tools.ozone.moderation.defs#cancelScheduledTakedownEvent" 98 98 + ] 99 99 + }, 100 100 + "count": { 101 101 + "type": "integer" 102 102 + } 103 103 + } 104 104 + } 105 105 + } 106 106 + }

+40

lexicons/tools/ozone/moderation/getSubjects.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.moderation.getSubjects", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get details about subjects.", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["subjects"], 11 11 + "properties": { 12 12 + "subjects": { 13 13 + "type": "array", 14 14 + "maxLength": 100, 15 15 + "minLength": 1, 16 16 + "items": { 17 17 + "type": "string" 18 18 + } 19 19 + } 20 20 + } 21 21 + }, 22 22 + "output": { 23 23 + "encoding": "application/json", 24 24 + "schema": { 25 25 + "type": "object", 26 26 + "required": ["subjects"], 27 27 + "properties": { 28 28 + "subjects": { 29 29 + "type": "array", 30 30 + "items": { 31 31 + "type": "ref", 32 32 + "ref": "tools.ozone.moderation.defs#subjectView" 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + } 39 39 + } 40 40 + }

+78

lexicons/tools/ozone/moderation/listScheduledActions.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.moderation.listScheduledActions", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "List scheduled moderation actions with optional filtering", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["statuses"], 13 13 + "properties": { 14 14 + "startsAfter": { 15 15 + "type": "string", 16 16 + "format": "datetime", 17 17 + "description": "Filter actions scheduled to execute after this time" 18 18 + }, 19 19 + "endsBefore": { 20 20 + "type": "string", 21 21 + "format": "datetime", 22 22 + "description": "Filter actions scheduled to execute before this time" 23 23 + }, 24 24 + "subjects": { 25 25 + "type": "array", 26 26 + "maxLength": 100, 27 27 + "items": { 28 28 + "type": "string", 29 29 + "format": "did" 30 30 + }, 31 31 + "description": "Filter actions for specific DID subjects" 32 32 + }, 33 33 + "statuses": { 34 34 + "type": "array", 35 35 + "minLength": 1, 36 36 + "items": { 37 37 + "type": "string", 38 38 + "knownValues": ["pending", "executed", "cancelled", "failed"] 39 39 + }, 40 40 + "description": "Filter actions by status" 41 41 + }, 42 42 + "limit": { 43 43 + "type": "integer", 44 44 + "minimum": 1, 45 45 + "maximum": 100, 46 46 + "default": 50, 47 47 + "description": "Maximum number of results to return" 48 48 + }, 49 49 + "cursor": { 50 50 + "type": "string", 51 51 + "description": "Cursor for pagination" 52 52 + } 53 53 + } 54 54 + } 55 55 + }, 56 56 + "output": { 57 57 + "encoding": "application/json", 58 58 + "schema": { 59 59 + "type": "object", 60 60 + "required": ["actions"], 61 61 + "properties": { 62 62 + "actions": { 63 63 + "type": "array", 64 64 + "items": { 65 65 + "type": "ref", 66 66 + "ref": "tools.ozone.moderation.defs#scheduledActionView" 67 67 + } 68 68 + }, 69 69 + "cursor": { 70 70 + "type": "string", 71 71 + "description": "Cursor for next page of results" 72 72 + } 73 73 + } 74 74 + } 75 75 + } 76 76 + } 77 77 + } 78 78 + }

+20

lexicons/tools/ozone/moderation/queryEvents.json

reviewed

··· 113 113 "description": "If specified, only events where the action policies match any of the given policies are returned" 114 114 } 115 115 }, 116 116 + "modTool": { 117 117 + "type": "array", 118 118 + "items": { 119 119 + "type": "string" 120 120 + }, 121 121 + "description": "If specified, only events where the modTool name matches any of the given values are returned" 122 122 + }, 123 123 + "batchId": { 124 124 + "type": "string", 125 125 + "description": "If specified, only events where the batchId matches the given value are returned" 126 126 + }, 127 127 + "ageAssuranceState": { 128 128 + "type": "string", 129 129 + "description": "If specified, only events where the age assurance state matches the given value are returned", 130 130 + "knownValues": ["pending", "assured", "unknown", "reset", "blocked"] 131 131 + }, 132 132 + "withStrike": { 133 133 + "type": "boolean", 134 134 + "description": "If specified, only events where strikeCount value is set are returned." 135 135 + }, 116 136 "cursor": { 117 137 "type": "string" 118 138 }

+17 -1

lexicons/tools/ozone/moderation/queryStatuses.json

reviewed

··· 90 90 }, 91 91 "reviewState": { 92 92 "type": "string", 93 93 - "description": "Specify when fetching subjects in a certain state" 93 93 + "description": "Specify when fetching subjects in a certain state", 94 94 + "knownValues": [ 95 95 + "tools.ozone.moderation.defs#reviewOpen", 96 96 + "tools.ozone.moderation.defs#reviewClosed", 97 97 + "tools.ozone.moderation.defs#reviewEscalated", 98 98 + "tools.ozone.moderation.defs#reviewNone" 99 99 + ] 94 100 }, 95 101 "ignoreSubjects": { 96 102 "type": "array", ··· 182 188 "maximum": 100, 183 189 "type": "integer", 184 190 "description": "If specified, only subjects that have priority score value above the given value will be returned." 191 191 + }, 192 192 + "minStrikeCount": { 193 193 + "type": "integer", 194 194 + "minimum": 1, 195 195 + "description": "If specified, only subjects that belong to an account that has at least this many active strikes will be returned." 196 196 + }, 197 197 + "ageAssuranceState": { 198 198 + "type": "string", 199 199 + "description": "If specified, only subjects with the given age assurance state will be returned.", 200 200 + "knownValues": ["pending", "assured", "unknown", "reset", "blocked"] 185 201 } 186 202 } 187 203 },

+155

lexicons/tools/ozone/moderation/scheduleAction.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.moderation.scheduleAction", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Schedule a moderation action to be executed at a future time", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["action", "subjects", "createdBy", "scheduling"], 13 13 + "properties": { 14 14 + "action": { 15 15 + "type": "union", 16 16 + "refs": ["#takedown"] 17 17 + }, 18 18 + "subjects": { 19 19 + "type": "array", 20 20 + "maxLength": 100, 21 21 + "items": { 22 22 + "type": "string", 23 23 + "format": "did" 24 24 + }, 25 25 + "description": "Array of DID subjects to schedule the action for" 26 26 + }, 27 27 + "createdBy": { 28 28 + "type": "string", 29 29 + "format": "did" 30 30 + }, 31 31 + "scheduling": { 32 32 + "type": "ref", 33 33 + "ref": "#schedulingConfig" 34 34 + }, 35 35 + "modTool": { 36 36 + "type": "ref", 37 37 + "ref": "tools.ozone.moderation.defs#modTool", 38 38 + "description": "This will be propagated to the moderation event when it is applied" 39 39 + } 40 40 + } 41 41 + } 42 42 + }, 43 43 + "output": { 44 44 + "encoding": "application/json", 45 45 + "schema": { 46 46 + "type": "ref", 47 47 + "ref": "#scheduledActionResults" 48 48 + } 49 49 + } 50 50 + }, 51 51 + "takedown": { 52 52 + "type": "object", 53 53 + "description": "Schedule a takedown action", 54 54 + "properties": { 55 55 + "comment": { 56 56 + "type": "string" 57 57 + }, 58 58 + "durationInHours": { 59 59 + "type": "integer", 60 60 + "description": "Indicates how long the takedown should be in effect before automatically expiring." 61 61 + }, 62 62 + "acknowledgeAccountSubjects": { 63 63 + "type": "boolean", 64 64 + "description": "If true, all other reports on content authored by this account will be resolved (acknowledged)." 65 65 + }, 66 66 + "policies": { 67 67 + "type": "array", 68 68 + "maxLength": 5, 69 69 + "items": { 70 70 + "type": "string" 71 71 + }, 72 72 + "description": "Names/Keywords of the policies that drove the decision." 73 73 + }, 74 74 + "severityLevel": { 75 75 + "type": "string", 76 76 + "description": "Severity level of the violation (e.g., 'sev-0', 'sev-1', 'sev-2', etc.)." 77 77 + }, 78 78 + "strikeCount": { 79 79 + "type": "integer", 80 80 + "description": "Number of strikes to assign to the user when takedown is applied." 81 81 + }, 82 82 + "strikeExpiresAt": { 83 83 + "type": "string", 84 84 + "format": "datetime", 85 85 + "description": "When the strike should expire. If not provided, the strike never expires." 86 86 + }, 87 87 + "emailContent": { 88 88 + "type": "string", 89 89 + "description": "Email content to be sent to the user upon takedown." 90 90 + }, 91 91 + "emailSubject": { 92 92 + "type": "string", 93 93 + "description": "Subject of the email to be sent to the user upon takedown." 94 94 + } 95 95 + } 96 96 + }, 97 97 + "schedulingConfig": { 98 98 + "type": "object", 99 99 + "description": "Configuration for when the action should be executed", 100 100 + "properties": { 101 101 + "executeAt": { 102 102 + "type": "string", 103 103 + "format": "datetime", 104 104 + "description": "Exact time to execute the action" 105 105 + }, 106 106 + "executeAfter": { 107 107 + "type": "string", 108 108 + "format": "datetime", 109 109 + "description": "Earliest time to execute the action (for randomized scheduling)" 110 110 + }, 111 111 + "executeUntil": { 112 112 + "type": "string", 113 113 + "format": "datetime", 114 114 + "description": "Latest time to execute the action (for randomized scheduling)" 115 115 + } 116 116 + } 117 117 + }, 118 118 + "scheduledActionResults": { 119 119 + "type": "object", 120 120 + "required": ["succeeded", "failed"], 121 121 + "properties": { 122 122 + "succeeded": { 123 123 + "type": "array", 124 124 + "items": { 125 125 + "type": "string", 126 126 + "format": "did" 127 127 + } 128 128 + }, 129 129 + "failed": { 130 130 + "type": "array", 131 131 + "items": { 132 132 + "type": "ref", 133 133 + "ref": "#failedScheduling" 134 134 + } 135 135 + } 136 136 + } 137 137 + }, 138 138 + "failedScheduling": { 139 139 + "type": "object", 140 140 + "required": ["subject", "error"], 141 141 + "properties": { 142 142 + "subject": { 143 143 + "type": "string", 144 144 + "format": "did" 145 145 + }, 146 146 + "error": { 147 147 + "type": "string" 148 148 + }, 149 149 + "errorCode": { 150 150 + "type": "string" 151 151 + } 152 152 + } 153 153 + } 154 154 + } 155 155 + }

+223

lexicons/tools/ozone/report/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.report.defs", 4 4 + "defs": { 5 5 + "reasonType": { 6 6 + "type": "string", 7 7 + "knownValues": [ 8 8 + "tools.ozone.report.defs#reasonAppeal", 9 9 + "tools.ozone.report.defs#reasonOther", 10 10 + 11 11 + "tools.ozone.report.defs#reasonViolenceAnimal", 12 12 + "tools.ozone.report.defs#reasonViolenceThreats", 13 13 + "tools.ozone.report.defs#reasonViolenceGraphicContent", 14 14 + "tools.ozone.report.defs#reasonViolenceGlorification", 15 15 + "tools.ozone.report.defs#reasonViolenceExtremistContent", 16 16 + "tools.ozone.report.defs#reasonViolenceTrafficking", 17 17 + "tools.ozone.report.defs#reasonViolenceOther", 18 18 + 19 19 + "tools.ozone.report.defs#reasonSexualAbuseContent", 20 20 + "tools.ozone.report.defs#reasonSexualNCII", 21 21 + "tools.ozone.report.defs#reasonSexualDeepfake", 22 22 + "tools.ozone.report.defs#reasonSexualAnimal", 23 23 + "tools.ozone.report.defs#reasonSexualUnlabeled", 24 24 + "tools.ozone.report.defs#reasonSexualOther", 25 25 + 26 26 + "tools.ozone.report.defs#reasonChildSafetyCSAM", 27 27 + "tools.ozone.report.defs#reasonChildSafetyGroom", 28 28 + "tools.ozone.report.defs#reasonChildSafetyPrivacy", 29 29 + "tools.ozone.report.defs#reasonChildSafetyHarassment", 30 30 + "tools.ozone.report.defs#reasonChildSafetyOther", 31 31 + 32 32 + "tools.ozone.report.defs#reasonHarassmentTroll", 33 33 + "tools.ozone.report.defs#reasonHarassmentTargeted", 34 34 + "tools.ozone.report.defs#reasonHarassmentHateSpeech", 35 35 + "tools.ozone.report.defs#reasonHarassmentDoxxing", 36 36 + "tools.ozone.report.defs#reasonHarassmentOther", 37 37 + 38 38 + "tools.ozone.report.defs#reasonMisleadingBot", 39 39 + "tools.ozone.report.defs#reasonMisleadingImpersonation", 40 40 + "tools.ozone.report.defs#reasonMisleadingSpam", 41 41 + "tools.ozone.report.defs#reasonMisleadingScam", 42 42 + "tools.ozone.report.defs#reasonMisleadingElections", 43 43 + "tools.ozone.report.defs#reasonMisleadingOther", 44 44 + 45 45 + "tools.ozone.report.defs#reasonRuleSiteSecurity", 46 46 + "tools.ozone.report.defs#reasonRuleProhibitedSales", 47 47 + "tools.ozone.report.defs#reasonRuleBanEvasion", 48 48 + "tools.ozone.report.defs#reasonRuleOther", 49 49 + 50 50 + "tools.ozone.report.defs#reasonSelfHarmContent", 51 51 + "tools.ozone.report.defs#reasonSelfHarmED", 52 52 + "tools.ozone.report.defs#reasonSelfHarmStunts", 53 53 + "tools.ozone.report.defs#reasonSelfHarmSubstances", 54 54 + "tools.ozone.report.defs#reasonSelfHarmOther" 55 55 + ] 56 56 + }, 57 57 + "reasonAppeal": { 58 58 + "type": "token", 59 59 + "description": "Appeal a previously taken moderation action" 60 60 + }, 61 61 + "reasonOther": { 62 62 + "type": "token", 63 63 + "description": "An issue not included in these options" 64 64 + }, 65 65 + "reasonViolenceAnimal": { 66 66 + "type": "token", 67 67 + "description": "Animal welfare violations" 68 68 + }, 69 69 + "reasonViolenceThreats": { 70 70 + "type": "token", 71 71 + "description": "Threats or incitement" 72 72 + }, 73 73 + "reasonViolenceGraphicContent": { 74 74 + "type": "token", 75 75 + "description": "Graphic violent content" 76 76 + }, 77 77 + "reasonViolenceGlorification": { 78 78 + "type": "token", 79 79 + "description": "Glorification of violence" 80 80 + }, 81 81 + "reasonViolenceExtremistContent": { 82 82 + "type": "token", 83 83 + "description": "Extremist content. These reports will be sent only be sent to the application's Moderation Authority." 84 84 + }, 85 85 + "reasonViolenceTrafficking": { 86 86 + "type": "token", 87 87 + "description": "Human trafficking" 88 88 + }, 89 89 + "reasonViolenceOther": { 90 90 + "type": "token", 91 91 + "description": "Other violent content" 92 92 + }, 93 93 + 94 94 + "reasonSexualAbuseContent": { 95 95 + "type": "token", 96 96 + "description": "Adult sexual abuse content" 97 97 + }, 98 98 + "reasonSexualNCII": { 99 99 + "type": "token", 100 100 + "description": "Non-consensual intimate imagery" 101 101 + }, 102 102 + "reasonSexualDeepfake": { 103 103 + "type": "token", 104 104 + "description": "Deepfake adult content" 105 105 + }, 106 106 + "reasonSexualAnimal": { 107 107 + "type": "token", 108 108 + "description": "Animal sexual abuse" 109 109 + }, 110 110 + "reasonSexualUnlabeled": { 111 111 + "type": "token", 112 112 + "description": "Unlabelled adult content" 113 113 + }, 114 114 + "reasonSexualOther": { 115 115 + "type": "token", 116 116 + "description": "Other sexual violence content" 117 117 + }, 118 118 + 119 119 + "reasonChildSafetyCSAM": { 120 120 + "type": "token", 121 121 + "description": "Child sexual abuse material (CSAM). These reports will be sent only be sent to the application's Moderation Authority." 122 122 + }, 123 123 + "reasonChildSafetyGroom": { 124 124 + "type": "token", 125 125 + "description": "Grooming or predatory behavior. These reports will be sent only be sent to the application's Moderation Authority." 126 126 + }, 127 127 + "reasonChildSafetyPrivacy": { 128 128 + "type": "token", 129 129 + "description": "Privacy violation involving a minor" 130 130 + }, 131 131 + "reasonChildSafetyHarassment": { 132 132 + "type": "token", 133 133 + "description": "Harassment or bullying of minors" 134 134 + }, 135 135 + "reasonChildSafetyOther": { 136 136 + "type": "token", 137 137 + "description": "Other child safety. These reports will be sent only be sent to the application's Moderation Authority." 138 138 + }, 139 139 + 140 140 + "reasonHarassmentTroll": { 141 141 + "type": "token", 142 142 + "description": "Trolling" 143 143 + }, 144 144 + "reasonHarassmentTargeted": { 145 145 + "type": "token", 146 146 + "description": "Targeted harassment" 147 147 + }, 148 148 + "reasonHarassmentHateSpeech": { 149 149 + "type": "token", 150 150 + "description": "Hate speech" 151 151 + }, 152 152 + "reasonHarassmentDoxxing": { 153 153 + "type": "token", 154 154 + "description": "Doxxing" 155 155 + }, 156 156 + "reasonHarassmentOther": { 157 157 + "type": "token", 158 158 + "description": "Other harassing or hateful content" 159 159 + }, 160 160 + 161 161 + "reasonMisleadingBot": { 162 162 + "type": "token", 163 163 + "description": "Fake account or bot" 164 164 + }, 165 165 + "reasonMisleadingImpersonation": { 166 166 + "type": "token", 167 167 + "description": "Impersonation" 168 168 + }, 169 169 + "reasonMisleadingSpam": { 170 170 + "type": "token", 171 171 + "description": "Spam" 172 172 + }, 173 173 + "reasonMisleadingScam": { 174 174 + "type": "token", 175 175 + "description": "Scam" 176 176 + }, 177 177 + "reasonMisleadingElections": { 178 178 + "type": "token", 179 179 + "description": "False information about elections" 180 180 + }, 181 181 + "reasonMisleadingOther": { 182 182 + "type": "token", 183 183 + "description": "Other misleading content" 184 184 + }, 185 185 + 186 186 + "reasonRuleSiteSecurity": { 187 187 + "type": "token", 188 188 + "description": "Hacking or system attacks" 189 189 + }, 190 190 + "reasonRuleProhibitedSales": { 191 191 + "type": "token", 192 192 + "description": "Promoting or selling prohibited items or services" 193 193 + }, 194 194 + "reasonRuleBanEvasion": { 195 195 + "type": "token", 196 196 + "description": "Banned user returning" 197 197 + }, 198 198 + "reasonRuleOther": { 199 199 + "type": "token", 200 200 + "description": "Other" 201 201 + }, 202 202 + "reasonSelfHarmContent": { 203 203 + "type": "token", 204 204 + "description": "Content promoting or depicting self-harm" 205 205 + }, 206 206 + "reasonSelfHarmED": { 207 207 + "type": "token", 208 208 + "description": "Eating disorders" 209 209 + }, 210 210 + "reasonSelfHarmStunts": { 211 211 + "type": "token", 212 212 + "description": "Dangerous challenges or activities" 213 213 + }, 214 214 + "reasonSelfHarmSubstances": { 215 215 + "type": "token", 216 216 + "description": "Dangerous substances or drug abuse" 217 217 + }, 218 218 + "reasonSelfHarmOther": { 219 219 + "type": "token", 220 220 + "description": "Other dangerous content" 221 221 + } 222 222 + } 223 223 + }

+61

lexicons/tools/ozone/safelink/addRule.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.safelink.addRule", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Add a new URL safety rule", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["url", "pattern", "action", "reason"], 13 13 + "properties": { 14 14 + "url": { 15 15 + "type": "string", 16 16 + "description": "The URL or domain to apply the rule to" 17 17 + }, 18 18 + "pattern": { 19 19 + "type": "ref", 20 20 + "ref": "tools.ozone.safelink.defs#patternType" 21 21 + }, 22 22 + "action": { 23 23 + "type": "ref", 24 24 + "ref": "tools.ozone.safelink.defs#actionType" 25 25 + }, 26 26 + "reason": { 27 27 + "type": "ref", 28 28 + "ref": "tools.ozone.safelink.defs#reasonType" 29 29 + }, 30 30 + "comment": { 31 31 + "type": "string", 32 32 + "description": "Optional comment about the decision" 33 33 + }, 34 34 + "createdBy": { 35 35 + "type": "string", 36 36 + "format": "did", 37 37 + "description": "Author DID. Only respected when using admin auth" 38 38 + } 39 39 + } 40 40 + } 41 41 + }, 42 42 + "output": { 43 43 + "encoding": "application/json", 44 44 + "schema": { 45 45 + "type": "ref", 46 46 + "ref": "tools.ozone.safelink.defs#event" 47 47 + } 48 48 + }, 49 49 + "errors": [ 50 50 + { 51 51 + "name": "InvalidUrl", 52 52 + "description": "The provided URL is invalid" 53 53 + }, 54 54 + { 55 55 + "name": "RuleAlreadyExists", 56 56 + "description": "A rule for this URL/domain already exists" 57 57 + } 58 58 + ] 59 59 + } 60 60 + } 61 61 + }

+125

lexicons/tools/ozone/safelink/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.safelink.defs", 4 4 + "defs": { 5 5 + "event": { 6 6 + "type": "object", 7 7 + "description": "An event for URL safety decisions", 8 8 + "required": [ 9 9 + "id", 10 10 + "eventType", 11 11 + "url", 12 12 + "pattern", 13 13 + "action", 14 14 + "reason", 15 15 + "createdBy", 16 16 + "createdAt" 17 17 + ], 18 18 + "properties": { 19 19 + "id": { 20 20 + "type": "integer", 21 21 + "description": "Auto-incrementing row ID" 22 22 + }, 23 23 + "eventType": { 24 24 + "type": "ref", 25 25 + "ref": "#eventType" 26 26 + }, 27 27 + "url": { 28 28 + "type": "string", 29 29 + "description": "The URL that this rule applies to" 30 30 + }, 31 31 + "pattern": { 32 32 + "type": "ref", 33 33 + "ref": "#patternType" 34 34 + }, 35 35 + "action": { 36 36 + "type": "ref", 37 37 + "ref": "#actionType" 38 38 + }, 39 39 + "reason": { 40 40 + "type": "ref", 41 41 + "ref": "#reasonType" 42 42 + }, 43 43 + "createdBy": { 44 44 + "type": "string", 45 45 + "format": "did", 46 46 + "description": "DID of the user who created this rule" 47 47 + }, 48 48 + "createdAt": { 49 49 + "type": "string", 50 50 + "format": "datetime" 51 51 + }, 52 52 + "comment": { 53 53 + "type": "string", 54 54 + "description": "Optional comment about the decision" 55 55 + } 56 56 + } 57 57 + }, 58 58 + "eventType": { 59 59 + "type": "string", 60 60 + "knownValues": ["addRule", "updateRule", "removeRule"] 61 61 + }, 62 62 + "patternType": { 63 63 + "type": "string", 64 64 + "knownValues": ["domain", "url"] 65 65 + }, 66 66 + "actionType": { 67 67 + "type": "string", 68 68 + "knownValues": ["block", "warn", "whitelist"] 69 69 + }, 70 70 + "reasonType": { 71 71 + "type": "string", 72 72 + "knownValues": ["csam", "spam", "phishing", "none"] 73 73 + }, 74 74 + "urlRule": { 75 75 + "type": "object", 76 76 + "description": "Input for creating a URL safety rule", 77 77 + "required": [ 78 78 + "url", 79 79 + "pattern", 80 80 + "action", 81 81 + "reason", 82 82 + "createdBy", 83 83 + "createdAt", 84 84 + "updatedAt" 85 85 + ], 86 86 + "properties": { 87 87 + "url": { 88 88 + "type": "string", 89 89 + "description": "The URL or domain to apply the rule to" 90 90 + }, 91 91 + "pattern": { 92 92 + "type": "ref", 93 93 + "ref": "#patternType" 94 94 + }, 95 95 + "action": { 96 96 + "type": "ref", 97 97 + "ref": "#actionType" 98 98 + }, 99 99 + "reason": { 100 100 + "type": "ref", 101 101 + "ref": "#reasonType" 102 102 + }, 103 103 + "comment": { 104 104 + "type": "string", 105 105 + "description": "Optional comment about the decision" 106 106 + }, 107 107 + "createdBy": { 108 108 + "type": "string", 109 109 + "format": "did", 110 110 + "description": "DID of the user added the rule." 111 111 + }, 112 112 + "createdAt": { 113 113 + "type": "string", 114 114 + "format": "datetime", 115 115 + "description": "Timestamp when the rule was created" 116 116 + }, 117 117 + "updatedAt": { 118 118 + "type": "string", 119 119 + "format": "datetime", 120 120 + "description": "Timestamp when the rule was last updated" 121 121 + } 122 122 + } 123 123 + } 124 124 + } 125 125 + }

+66

lexicons/tools/ozone/safelink/queryEvents.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.safelink.queryEvents", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Query URL safety audit events", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "properties": { 13 13 + "cursor": { 14 14 + "type": "string", 15 15 + "description": "Cursor for pagination" 16 16 + }, 17 17 + "limit": { 18 18 + "type": "integer", 19 19 + "minimum": 1, 20 20 + "maximum": 100, 21 21 + "default": 50, 22 22 + "description": "Maximum number of results to return" 23 23 + }, 24 24 + "urls": { 25 25 + "type": "array", 26 26 + "items": { 27 27 + "type": "string" 28 28 + }, 29 29 + "description": "Filter by specific URLs or domains" 30 30 + }, 31 31 + "patternType": { 32 32 + "type": "string", 33 33 + "description": "Filter by pattern type" 34 34 + }, 35 35 + "sortDirection": { 36 36 + "type": "string", 37 37 + "knownValues": ["asc", "desc"], 38 38 + "default": "desc", 39 39 + "description": "Sort direction" 40 40 + } 41 41 + } 42 42 + } 43 43 + }, 44 44 + "output": { 45 45 + "encoding": "application/json", 46 46 + "schema": { 47 47 + "type": "object", 48 48 + "required": ["events"], 49 49 + "properties": { 50 50 + "cursor": { 51 51 + "type": "string", 52 52 + "description": "Next cursor for pagination. Only present if there are more results." 53 53 + }, 54 54 + "events": { 55 55 + "type": "array", 56 56 + "items": { 57 57 + "type": "ref", 58 58 + "ref": "tools.ozone.safelink.defs#event" 59 59 + } 60 60 + } 61 61 + } 62 62 + } 63 63 + } 64 64 + } 65 65 + } 66 66 + }

+82

lexicons/tools/ozone/safelink/queryRules.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.safelink.queryRules", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Query URL safety rules", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "properties": { 13 13 + "cursor": { 14 14 + "type": "string", 15 15 + "description": "Cursor for pagination" 16 16 + }, 17 17 + "limit": { 18 18 + "type": "integer", 19 19 + "minimum": 1, 20 20 + "maximum": 100, 21 21 + "default": 50, 22 22 + "description": "Maximum number of results to return" 23 23 + }, 24 24 + "urls": { 25 25 + "type": "array", 26 26 + "items": { 27 27 + "type": "string" 28 28 + }, 29 29 + "description": "Filter by specific URLs or domains" 30 30 + }, 31 31 + "patternType": { 32 32 + "type": "string", 33 33 + "description": "Filter by pattern type" 34 34 + }, 35 35 + "actions": { 36 36 + "type": "array", 37 37 + "items": { 38 38 + "type": "string" 39 39 + }, 40 40 + "description": "Filter by action types" 41 41 + }, 42 42 + "reason": { 43 43 + "type": "string", 44 44 + "description": "Filter by reason type" 45 45 + }, 46 46 + "createdBy": { 47 47 + "type": "string", 48 48 + "format": "did", 49 49 + "description": "Filter by rule creator" 50 50 + }, 51 51 + "sortDirection": { 52 52 + "type": "string", 53 53 + "knownValues": ["asc", "desc"], 54 54 + "default": "desc", 55 55 + "description": "Sort direction" 56 56 + } 57 57 + } 58 58 + } 59 59 + }, 60 60 + "output": { 61 61 + "encoding": "application/json", 62 62 + "schema": { 63 63 + "type": "object", 64 64 + "required": ["rules"], 65 65 + "properties": { 66 66 + "cursor": { 67 67 + "type": "string", 68 68 + "description": "Next cursor for pagination. Only present if there are more results." 69 69 + }, 70 70 + "rules": { 71 71 + "type": "array", 72 72 + "items": { 73 73 + "type": "ref", 74 74 + "ref": "tools.ozone.safelink.defs#urlRule" 75 75 + } 76 76 + } 77 77 + } 78 78 + } 79 79 + } 80 80 + } 81 81 + } 82 82 + }

+49

lexicons/tools/ozone/safelink/removeRule.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.safelink.removeRule", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Remove an existing URL safety rule", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["url", "pattern"], 13 13 + "properties": { 14 14 + "url": { 15 15 + "type": "string", 16 16 + "description": "The URL or domain to remove the rule for" 17 17 + }, 18 18 + "pattern": { 19 19 + "type": "ref", 20 20 + "ref": "tools.ozone.safelink.defs#patternType" 21 21 + }, 22 22 + "comment": { 23 23 + "type": "string", 24 24 + "description": "Optional comment about why the rule is being removed" 25 25 + }, 26 26 + "createdBy": { 27 27 + "type": "string", 28 28 + "format": "did", 29 29 + "description": "Optional DID of the user. Only respected when using admin auth." 30 30 + } 31 31 + } 32 32 + } 33 33 + }, 34 34 + "output": { 35 35 + "encoding": "application/json", 36 36 + "schema": { 37 37 + "type": "ref", 38 38 + "ref": "tools.ozone.safelink.defs#event" 39 39 + } 40 40 + }, 41 41 + "errors": [ 42 42 + { 43 43 + "name": "RuleNotFound", 44 44 + "description": "No active rule found for this URL/domain" 45 45 + } 46 46 + ] 47 47 + } 48 48 + } 49 49 + }

+57

lexicons/tools/ozone/safelink/updateRule.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.safelink.updateRule", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Update an existing URL safety rule", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["url", "pattern", "action", "reason"], 13 13 + "properties": { 14 14 + "url": { 15 15 + "type": "string", 16 16 + "description": "The URL or domain to update the rule for" 17 17 + }, 18 18 + "pattern": { 19 19 + "type": "ref", 20 20 + "ref": "tools.ozone.safelink.defs#patternType" 21 21 + }, 22 22 + "action": { 23 23 + "type": "ref", 24 24 + "ref": "tools.ozone.safelink.defs#actionType" 25 25 + }, 26 26 + "reason": { 27 27 + "type": "ref", 28 28 + "ref": "tools.ozone.safelink.defs#reasonType" 29 29 + }, 30 30 + "comment": { 31 31 + "type": "string", 32 32 + "description": "Optional comment about the update" 33 33 + }, 34 34 + "createdBy": { 35 35 + "type": "string", 36 36 + "format": "did", 37 37 + "description": "Optional DID to credit as the creator. Only respected for admin_token authentication." 38 38 + } 39 39 + } 40 40 + } 41 41 + }, 42 42 + "output": { 43 43 + "encoding": "application/json", 44 44 + "schema": { 45 45 + "type": "ref", 46 46 + "ref": "tools.ozone.safelink.defs#event" 47 47 + } 48 48 + }, 49 49 + "errors": [ 50 50 + { 51 51 + "name": "RuleNotFound", 52 52 + "description": "No active rule found for this URL/domain" 53 53 + } 54 54 + ] 55 55 + } 56 56 + } 57 57 + }

+7 -1

lexicons/tools/ozone/server/getConfig.json

reviewed

··· 29 29 "viewer": { 30 30 "type": "ref", 31 31 "ref": "#viewerConfig" 32 32 + }, 33 33 + "verifierDid": { 34 34 + "type": "string", 35 35 + "format": "did", 36 36 + "description": "The did of the verifier used for verification." 32 37 } 33 38 } 34 39 } ··· 51 56 "knownValues": [ 52 57 "tools.ozone.team.defs#roleAdmin", 53 58 "tools.ozone.team.defs#roleModerator", 54 54 - "tools.ozone.team.defs#roleTriage" 59 59 + "tools.ozone.team.defs#roleTriage", 60 60 + "tools.ozone.team.defs#roleVerifier" 55 61 ] 56 62 } 57 63 }

+2 -1

lexicons/tools/ozone/setting/defs.json

reviewed

··· 42 42 "knownValues": [ 43 43 "tools.ozone.team.defs#roleModerator", 44 44 "tools.ozone.team.defs#roleTriage", 45 45 - "tools.ozone.team.defs#roleAdmin" 45 45 + "tools.ozone.team.defs#roleAdmin", 46 46 + "tools.ozone.team.defs#roleVerifier" 46 47 ] 47 48 }, 48 49 "scope": {

+1

lexicons/tools/ozone/setting/upsertOption.json

reviewed

··· 31 31 "knownValues": [ 32 32 "tools.ozone.team.defs#roleModerator", 33 33 "tools.ozone.team.defs#roleTriage", 34 34 + "tools.ozone.team.defs#roleVerifier", 34 35 "tools.ozone.team.defs#roleAdmin" 35 36 ] 36 37 }

+1

lexicons/tools/ozone/team/addMember.json

reviewed

··· 17 17 "knownValues": [ 18 18 "tools.ozone.team.defs#roleAdmin", 19 19 "tools.ozone.team.defs#roleModerator", 20 20 + "tools.ozone.team.defs#roleVerifier", 20 21 "tools.ozone.team.defs#roleTriage" 21 22 ] 22 23 }

+10 -1

lexicons/tools/ozone/team/defs.json

reviewed

··· 17 17 "lastUpdatedBy": { "type": "string" }, 18 18 "role": { 19 19 "type": "string", 20 20 - "knownValues": ["#roleAdmin", "#roleModerator", "#roleTriage"] 20 20 + "knownValues": [ 21 21 + "tools.ozone.team.defs#roleAdmin", 22 22 + "tools.ozone.team.defs#roleModerator", 23 23 + "tools.ozone.team.defs#roleTriage", 24 24 + "tools.ozone.team.defs#roleVerifier" 25 25 + ] 21 26 } 22 27 } 23 28 }, ··· 32 37 "roleTriage": { 33 38 "type": "token", 34 39 "description": "Triage role. Mostly intended for monitoring and escalating issues." 40 40 + }, 41 41 + "roleVerifier": { 42 42 + "type": "token", 43 43 + "description": "Verifier role. Only allowed to issue verifications." 35 44 } 36 45 } 37 46 }

+3

lexicons/tools/ozone/team/listMembers.json

reviewed

··· 8 8 "parameters": { 9 9 "type": "params", 10 10 "properties": { 11 11 + "q": { 12 12 + "type": "string" 13 13 + }, 11 14 "disabled": { 12 15 "type": "boolean" 13 16 },

+1

lexicons/tools/ozone/team/updateMember.json

reviewed

··· 18 18 "knownValues": [ 19 19 "tools.ozone.team.defs#roleAdmin", 20 20 "tools.ozone.team.defs#roleModerator", 21 21 + "tools.ozone.team.defs#roleVerifier", 21 22 "tools.ozone.team.defs#roleTriage" 22 23 ] 23 24 }

+85

lexicons/tools/ozone/verification/defs.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.verification.defs", 4 4 + "defs": { 5 5 + "verificationView": { 6 6 + "type": "object", 7 7 + "description": "Verification data for the associated subject.", 8 8 + "required": [ 9 9 + "issuer", 10 10 + "uri", 11 11 + "subject", 12 12 + "handle", 13 13 + "displayName", 14 14 + "createdAt" 15 15 + ], 16 16 + "properties": { 17 17 + "issuer": { 18 18 + "type": "string", 19 19 + "description": "The user who issued this verification.", 20 20 + "format": "did" 21 21 + }, 22 22 + "uri": { 23 23 + "type": "string", 24 24 + "description": "The AT-URI of the verification record.", 25 25 + "format": "at-uri" 26 26 + }, 27 27 + "subject": { 28 28 + "type": "string", 29 29 + "format": "did", 30 30 + "description": "The subject of the verification." 31 31 + }, 32 32 + "handle": { 33 33 + "type": "string", 34 34 + "description": "Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.", 35 35 + "format": "handle" 36 36 + }, 37 37 + "displayName": { 38 38 + "type": "string", 39 39 + "description": "Display name of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current displayName matches the one at the time of verifying." 40 40 + }, 41 41 + "createdAt": { 42 42 + "type": "string", 43 43 + "description": "Timestamp when the verification was created.", 44 44 + "format": "datetime" 45 45 + }, 46 46 + "revokeReason": { 47 47 + "type": "string", 48 48 + "description": "Describes the reason for revocation, also indicating that the verification is no longer valid." 49 49 + }, 50 50 + "revokedAt": { 51 51 + "type": "string", 52 52 + "description": "Timestamp when the verification was revoked.", 53 53 + "format": "datetime" 54 54 + }, 55 55 + "revokedBy": { 56 56 + "type": "string", 57 57 + "description": "The user who revoked this verification.", 58 58 + "format": "did" 59 59 + }, 60 60 + "subjectProfile": { 61 61 + "type": "union", 62 62 + "refs": [] 63 63 + }, 64 64 + "issuerProfile": { 65 65 + "type": "union", 66 66 + "refs": [] 67 67 + }, 68 68 + "subjectRepo": { 69 69 + "type": "union", 70 70 + "refs": [ 71 71 + "tools.ozone.moderation.defs#repoViewDetail", 72 72 + "tools.ozone.moderation.defs#repoViewNotFound" 73 73 + ] 74 74 + }, 75 75 + "issuerRepo": { 76 76 + "type": "union", 77 77 + "refs": [ 78 78 + "tools.ozone.moderation.defs#repoViewDetail", 79 79 + "tools.ozone.moderation.defs#repoViewNotFound" 80 80 + ] 81 81 + } 82 82 + } 83 83 + } 84 84 + } 85 85 + }

+92

lexicons/tools/ozone/verification/grantVerifications.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.verification.grantVerifications", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Grant verifications to multiple subjects. Allows batch processing of up to 100 verifications at once.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["verifications"], 13 13 + "properties": { 14 14 + "verifications": { 15 15 + "type": "array", 16 16 + "description": "Array of verification requests to process", 17 17 + "maxLength": 100, 18 18 + "items": { 19 19 + "type": "ref", 20 20 + "ref": "#verificationInput" 21 21 + } 22 22 + } 23 23 + } 24 24 + } 25 25 + }, 26 26 + "output": { 27 27 + "encoding": "application/json", 28 28 + "schema": { 29 29 + "type": "object", 30 30 + "required": ["verifications", "failedVerifications"], 31 31 + "properties": { 32 32 + "verifications": { 33 33 + "type": "array", 34 34 + "items": { 35 35 + "type": "ref", 36 36 + "ref": "tools.ozone.verification.defs#verificationView" 37 37 + } 38 38 + }, 39 39 + "failedVerifications": { 40 40 + "type": "array", 41 41 + "items": { 42 42 + "type": "ref", 43 43 + "ref": "#grantError" 44 44 + } 45 45 + } 46 46 + } 47 47 + } 48 48 + } 49 49 + }, 50 50 + "verificationInput": { 51 51 + "type": "object", 52 52 + "required": ["subject", "handle", "displayName"], 53 53 + "properties": { 54 54 + "subject": { 55 55 + "type": "string", 56 56 + "description": "The did of the subject being verified", 57 57 + "format": "did" 58 58 + }, 59 59 + "handle": { 60 60 + "type": "string", 61 61 + "description": "Handle of the subject the verification applies to at the moment of verifying.", 62 62 + "format": "handle" 63 63 + }, 64 64 + "displayName": { 65 65 + "type": "string", 66 66 + "description": "Display name of the subject the verification applies to at the moment of verifying." 67 67 + }, 68 68 + "createdAt": { 69 69 + "type": "string", 70 70 + "format": "datetime", 71 71 + "description": "Timestamp for verification record. Defaults to current time when not specified." 72 72 + } 73 73 + } 74 74 + }, 75 75 + "grantError": { 76 76 + "type": "object", 77 77 + "description": "Error object for failed verifications.", 78 78 + "required": ["error", "subject"], 79 79 + "properties": { 80 80 + "error": { 81 81 + "type": "string", 82 82 + "description": "Error message describing the reason for failure." 83 83 + }, 84 84 + "subject": { 85 85 + "type": "string", 86 86 + "description": "The did of the subject being verified", 87 87 + "format": "did" 88 88 + } 89 89 + } 90 90 + } 91 91 + } 92 92 + }

+83

lexicons/tools/ozone/verification/listVerifications.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.verification.listVerifications", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "List verifications", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "properties": { 11 11 + "cursor": { 12 12 + "type": "string", 13 13 + "description": "Pagination cursor" 14 14 + }, 15 15 + "limit": { 16 16 + "type": "integer", 17 17 + "description": "Maximum number of results to return", 18 18 + "minimum": 1, 19 19 + "maximum": 100, 20 20 + "default": 50 21 21 + }, 22 22 + "createdAfter": { 23 23 + "type": "string", 24 24 + "format": "datetime", 25 25 + "description": "Filter to verifications created after this timestamp" 26 26 + }, 27 27 + "createdBefore": { 28 28 + "type": "string", 29 29 + "format": "datetime", 30 30 + "description": "Filter to verifications created before this timestamp" 31 31 + }, 32 32 + "issuers": { 33 33 + "type": "array", 34 34 + "maxLength": 100, 35 35 + "description": "Filter to verifications from specific issuers", 36 36 + "items": { 37 37 + "type": "string", 38 38 + "format": "did" 39 39 + } 40 40 + }, 41 41 + "subjects": { 42 42 + "type": "array", 43 43 + "description": "Filter to specific verified DIDs", 44 44 + "maxLength": 100, 45 45 + "items": { 46 46 + "type": "string", 47 47 + "format": "did" 48 48 + } 49 49 + }, 50 50 + "sortDirection": { 51 51 + "type": "string", 52 52 + "description": "Sort direction for creation date", 53 53 + "enum": ["asc", "desc"], 54 54 + "default": "desc" 55 55 + }, 56 56 + "isRevoked": { 57 57 + "type": "boolean", 58 58 + "description": "Filter to verifications that are revoked or not. By default, includes both." 59 59 + } 60 60 + } 61 61 + }, 62 62 + "output": { 63 63 + "encoding": "application/json", 64 64 + "schema": { 65 65 + "type": "object", 66 66 + "required": ["verifications"], 67 67 + "properties": { 68 68 + "cursor": { 69 69 + "type": "string" 70 70 + }, 71 71 + "verifications": { 72 72 + "type": "array", 73 73 + "items": { 74 74 + "type": "ref", 75 75 + "ref": "tools.ozone.verification.defs#verificationView" 76 76 + } 77 77 + } 78 78 + } 79 79 + } 80 80 + } 81 81 + } 82 82 + } 83 83 + }

+75

lexicons/tools/ozone/verification/revokeVerifications.json

reviewed

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "tools.ozone.verification.revokeVerifications", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "procedure", 7 7 + "description": "Revoke previously granted verifications in batches of up to 100.", 8 8 + "input": { 9 9 + "encoding": "application/json", 10 10 + "schema": { 11 11 + "type": "object", 12 12 + "required": ["uris"], 13 13 + "properties": { 14 14 + "uris": { 15 15 + "type": "array", 16 16 + "description": "Array of verification record uris to revoke", 17 17 + "maxLength": 100, 18 18 + "items": { 19 19 + "type": "string", 20 20 + "description": "The AT-URI of the verification record to revoke.", 21 21 + "format": "at-uri" 22 22 + } 23 23 + }, 24 24 + "revokeReason": { 25 25 + "type": "string", 26 26 + "description": "Reason for revoking the verification. This is optional and can be omitted if not needed.", 27 27 + "maxLength": 1000 28 28 + } 29 29 + } 30 30 + } 31 31 + }, 32 32 + "output": { 33 33 + "encoding": "application/json", 34 34 + "schema": { 35 35 + "type": "object", 36 36 + "required": ["revokedVerifications", "failedRevocations"], 37 37 + "properties": { 38 38 + "revokedVerifications": { 39 39 + "type": "array", 40 40 + "description": "List of verification uris successfully revoked", 41 41 + "items": { 42 42 + "type": "string", 43 43 + "format": "at-uri" 44 44 + } 45 45 + }, 46 46 + "failedRevocations": { 47 47 + "type": "array", 48 48 + "description": "List of verification uris that couldn't be revoked, including failure reasons", 49 49 + "items": { 50 50 + "type": "ref", 51 51 + "ref": "#revokeError" 52 52 + } 53 53 + } 54 54 + } 55 55 + } 56 56 + } 57 57 + }, 58 58 + "revokeError": { 59 59 + "type": "object", 60 60 + "description": "Error object for failed revocations", 61 61 + "required": ["uri", "error"], 62 62 + "properties": { 63 63 + "uri": { 64 64 + "type": "string", 65 65 + "description": "The AT-URI of the verification record that failed to revoke.", 66 66 + "format": "at-uri" 67 67 + }, 68 68 + "error": { 69 69 + "type": "string", 70 70 + "description": "Description of the error that occurred during revocation." 71 71 + } 72 72 + } 73 73 + } 74 74 + } 75 75 + }