git.squeep.com Git - akkoma/blob - lib/pleroma/web/api_spec/operations/account_operation.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ApiSpec.AccountOperation do
   6   alias OpenApiSpex.Operation
   7   alias OpenApiSpex.Reference
   8   alias OpenApiSpex.Schema
   9   alias Pleroma.Web.ApiSpec.Schemas.Account
  10   alias Pleroma.Web.ApiSpec.Schemas.AccountRelationship
  11   alias Pleroma.Web.ApiSpec.Schemas.ActorType
  12   alias Pleroma.Web.ApiSpec.Schemas.ApiError
  13   alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
  14   alias Pleroma.Web.ApiSpec.Schemas.List
  15   alias Pleroma.Web.ApiSpec.Schemas.Status
  16   alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope
  17
  18   import Pleroma.Web.ApiSpec.Helpers
  19
  20   @spec open_api_operation(atom) :: Operation.t()
  21   def open_api_operation(action) do
  22     operation = String.to_existing_atom("#{action}_operation")
  23     apply(__MODULE__, operation, [])
  24   end
  25
  26   @spec create_operation() :: Operation.t()
  27   def create_operation do
  28     %Operation{
  29       tags: ["Account credentials"],
  30       summary: "Register an account",
  31       description:
  32         "Creates a user and account records. Returns an account access token for the app that initiated the request. The app should save this token for later, and should wait for the user to confirm their account by clicking a link in their email inbox.",
  33       operationId: "AccountController.create",
  34       requestBody: request_body("Parameters", create_request(), required: true),
  35       responses: %{
  36         200 => Operation.response("Account", "application/json", create_response()),
  37         400 => Operation.response("Error", "application/json", ApiError),
  38         403 => Operation.response("Error", "application/json", ApiError),
  39         429 => Operation.response("Error", "application/json", ApiError)
  40       }
  41     }
  42   end
  43
  44   def verify_credentials_operation do
  45     %Operation{
  46       tags: ["Account credentials"],
  47       description: "Test to make sure that the user token works.",
  48       summary: "Verify account credentials",
  49       operationId: "AccountController.verify_credentials",
  50       security: [%{"oAuth" => ["read:accounts"]}],
  51       responses: %{
  52         200 => Operation.response("Account", "application/json", Account)
  53       }
  54     }
  55   end
  56
  57   def update_credentials_operation do
  58     %Operation{
  59       tags: ["Account credentials"],
  60       summary: "Update account credentials",
  61       description: "Update the user's display and preferences.",
  62       operationId: "AccountController.update_credentials",
  63       security: [%{"oAuth" => ["write:accounts"]}],
  64       requestBody: request_body("Parameters", update_credentials_request(), required: true),
  65       responses: %{
  66         200 => Operation.response("Account", "application/json", Account),
  67         403 => Operation.response("Error", "application/json", ApiError)
  68       }
  69     }
  70   end
  71
  72   def relationships_operation do
  73     %Operation{
  74       tags: ["Retrieve account information"],
  75       summary: "Relationship with current account",
  76       operationId: "AccountController.relationships",
  77       description: "Find out whether a given account is followed, blocked, muted, etc.",
  78       security: [%{"oAuth" => ["read:follows"]}],
  79       parameters: [
  80         Operation.parameter(
  81           :id,
  82           :query,
  83           %Schema{
  84             oneOf: [%Schema{type: :array, items: %Schema{type: :string}}, %Schema{type: :string}]
  85           },
  86           "Account IDs",
  87           example: "123"
  88         )
  89       ],
  90       responses: %{
  91         200 => Operation.response("Account", "application/json", array_of_relationships())
  92       }
  93     }
  94   end
  95
  96   def show_operation do
  97     %Operation{
  98       tags: ["Retrieve account information"],
  99       summary: "Account",
 100       operationId: "AccountController.show",
 101       description: "View information about a profile.",
 102       parameters: [
 103         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 104         with_relationships_param()
 105       ],
 106       responses: %{
 107         200 => Operation.response("Account", "application/json", Account),
 108         401 => Operation.response("Error", "application/json", ApiError),
 109         404 => Operation.response("Error", "application/json", ApiError)
 110       }
 111     }
 112   end
 113
 114   def statuses_operation do
 115     %Operation{
 116       summary: "Statuses",
 117       tags: ["Retrieve account information"],
 118       operationId: "AccountController.statuses",
 119       description:
 120         "Statuses posted to the given account. Public (for public statuses only), or user token + `read:statuses` (for private statuses the user is authorized to see)",
 121       parameters:
 122         [
 123           %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 124           Operation.parameter(:pinned, :query, BooleanLike, "Include only pinned statuses"),
 125           Operation.parameter(:tagged, :query, :string, "With tag"),
 126           Operation.parameter(
 127             :only_media,
 128             :query,
 129             BooleanLike,
 130             "Include only statuses with media attached"
 131           ),
 132           Operation.parameter(
 133             :with_muted,
 134             :query,
 135             BooleanLike,
 136             "Include statuses from muted accounts."
 137           ),
 138           Operation.parameter(:exclude_reblogs, :query, BooleanLike, "Exclude reblogs"),
 139           Operation.parameter(:exclude_replies, :query, BooleanLike, "Exclude replies"),
 140           Operation.parameter(
 141             :exclude_visibilities,
 142             :query,
 143             %Schema{type: :array, items: VisibilityScope},
 144             "Exclude visibilities"
 145           ),
 146           Operation.parameter(
 147             :with_muted,
 148             :query,
 149             BooleanLike,
 150             "Include reactions from muted accounts."
 151           )
 152         ] ++ pagination_params(),
 153       responses: %{
 154         200 => Operation.response("Statuses", "application/json", array_of_statuses()),
 155         401 => Operation.response("Error", "application/json", ApiError),
 156         404 => Operation.response("Error", "application/json", ApiError)
 157       }
 158     }
 159   end
 160
 161   def followers_operation do
 162     %Operation{
 163       tags: ["Retrieve account information"],
 164       summary: "Followers",
 165       operationId: "AccountController.followers",
 166       security: [%{"oAuth" => ["read:accounts"]}],
 167       description:
 168         "Accounts which follow the given account, if network is not hidden by the account owner.",
 169       parameters: [
 170         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 171         Operation.parameter(:id, :query, :string, "ID of the resource owner"),
 172         with_relationships_param() | pagination_params()
 173       ],
 174       responses: %{
 175         200 => Operation.response("Accounts", "application/json", array_of_accounts())
 176       }
 177     }
 178   end
 179
 180   def following_operation do
 181     %Operation{
 182       tags: ["Retrieve account information"],
 183       summary: "Following",
 184       operationId: "AccountController.following",
 185       security: [%{"oAuth" => ["read:accounts"]}],
 186       description:
 187         "Accounts which the given account is following, if network is not hidden by the account owner.",
 188       parameters: [
 189         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 190         Operation.parameter(:id, :query, :string, "ID of the resource owner"),
 191         with_relationships_param() | pagination_params()
 192       ],
 193       responses: %{200 => Operation.response("Accounts", "application/json", array_of_accounts())}
 194     }
 195   end
 196
 197   def lists_operation do
 198     %Operation{
 199       tags: ["Retrieve account information"],
 200       summary: "Lists containing this account",
 201       operationId: "AccountController.lists",
 202       security: [%{"oAuth" => ["read:lists"]}],
 203       description: "User lists that you have added this account to.",
 204       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 205       responses: %{200 => Operation.response("Lists", "application/json", array_of_lists())}
 206     }
 207   end
 208
 209   def follow_operation do
 210     %Operation{
 211       tags: ["Account actions"],
 212       summary: "Follow",
 213       operationId: "AccountController.follow",
 214       security: [%{"oAuth" => ["follow", "write:follows"]}],
 215       description: "Follow the given account",
 216       parameters: [
 217         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
 218       ],
 219       requestBody:
 220         request_body(
 221           "Parameters",
 222           %Schema{
 223             type: :object,
 224             properties: %{
 225               reblogs: %Schema{
 226                 type: :boolean,
 227                 description: "Receive this account's reblogs in home timeline? Defaults to true.",
 228                 default: true
 229               },
 230               notify: %Schema{
 231                 type: :boolean,
 232                 description:
 233                   "Receive notifications for all statuses posted by the account? Defaults to false.",
 234                 default: false
 235               }
 236             }
 237           },
 238           required: false
 239         ),
 240       responses: %{
 241         200 => Operation.response("Relationship", "application/json", AccountRelationship),
 242         400 => Operation.response("Error", "application/json", ApiError),
 243         404 => Operation.response("Error", "application/json", ApiError)
 244       }
 245     }
 246   end
 247
 248   def unfollow_operation do
 249     %Operation{
 250       tags: ["Account actions"],
 251       summary: "Unfollow",
 252       operationId: "AccountController.unfollow",
 253       security: [%{"oAuth" => ["follow", "write:follows"]}],
 254       description: "Unfollow the given account",
 255       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 256       responses: %{
 257         200 => Operation.response("Relationship", "application/json", AccountRelationship),
 258         400 => Operation.response("Error", "application/json", ApiError),
 259         404 => Operation.response("Error", "application/json", ApiError)
 260       }
 261     }
 262   end
 263
 264   def mute_operation do
 265     %Operation{
 266       tags: ["Account actions"],
 267       summary: "Mute",
 268       operationId: "AccountController.mute",
 269       security: [%{"oAuth" => ["follow", "write:mutes"]}],
 270       requestBody: request_body("Parameters", mute_request()),
 271       description:
 272         "Mute the given account. Clients should filter statuses and notifications from this account, if received (e.g. due to a boost in the Home timeline).",
 273       parameters: [
 274         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 275         Operation.parameter(
 276           :notifications,
 277           :query,
 278           %Schema{allOf: [BooleanLike], default: true},
 279           "Mute notifications in addition to statuses? Defaults to `true`."
 280         ),
 281         Operation.parameter(
 282           :expires_in,
 283           :query,
 284           %Schema{type: :integer, default: 0},
 285           "Expire the mute in `expires_in` seconds. Default 0 for infinity"
 286         )
 287       ],
 288       responses: %{
 289         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 290       }
 291     }
 292   end
 293
 294   def unmute_operation do
 295     %Operation{
 296       tags: ["Account actions"],
 297       summary: "Unmute",
 298       operationId: "AccountController.unmute",
 299       security: [%{"oAuth" => ["follow", "write:mutes"]}],
 300       description: "Unmute the given account.",
 301       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 302       responses: %{
 303         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 304       }
 305     }
 306   end
 307
 308   def block_operation do
 309     %Operation{
 310       tags: ["Account actions"],
 311       summary: "Block",
 312       operationId: "AccountController.block",
 313       security: [%{"oAuth" => ["follow", "write:blocks"]}],
 314       description:
 315         "Block the given account. Clients should filter statuses from this account if received (e.g. due to a boost in the Home timeline)",
 316       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 317       responses: %{
 318         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 319       }
 320     }
 321   end
 322
 323   def unblock_operation do
 324     %Operation{
 325       tags: ["Account actions"],
 326       summary: "Unblock",
 327       operationId: "AccountController.unblock",
 328       security: [%{"oAuth" => ["follow", "write:blocks"]}],
 329       description: "Unblock the given account.",
 330       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 331       responses: %{
 332         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 333       }
 334     }
 335   end
 336
 337   def note_operation do
 338     %Operation{
 339       tags: ["Account actions"],
 340       summary: "Set a private note about a user.",
 341       operationId: "AccountController.note",
 342       security: [%{"oAuth" => ["follow", "write:accounts"]}],
 343       requestBody: request_body("Parameters", note_request()),
 344       description: "Create a note for the given account.",
 345       parameters: [
 346         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 347         Operation.parameter(
 348           :comment,
 349           :query,
 350           %Schema{type: :string},
 351           "Account note body"
 352         )
 353       ],
 354       responses: %{
 355         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 356       }
 357     }
 358   end
 359
 360   def follow_by_uri_operation do
 361     %Operation{
 362       tags: ["Account actions"],
 363       summary: "Follow by URI",
 364       operationId: "AccountController.follows",
 365       security: [%{"oAuth" => ["follow", "write:follows"]}],
 366       requestBody: request_body("Parameters", follow_by_uri_request(), required: true),
 367       responses: %{
 368         200 => Operation.response("Account", "application/json", AccountRelationship),
 369         400 => Operation.response("Error", "application/json", ApiError),
 370         404 => Operation.response("Error", "application/json", ApiError)
 371       }
 372     }
 373   end
 374
 375   def mutes_operation do
 376     %Operation{
 377       tags: ["Blocks and mutes"],
 378       summary: "Retrieve list of mutes",
 379       operationId: "AccountController.mutes",
 380       description: "Accounts the user has muted.",
 381       security: [%{"oAuth" => ["follow", "read:mutes"]}],
 382       parameters: [with_relationships_param() | pagination_params()],
 383       responses: %{
 384         200 => Operation.response("Accounts", "application/json", array_of_accounts())
 385       }
 386     }
 387   end
 388
 389   def blocks_operation do
 390     %Operation{
 391       tags: ["Blocks and mutes"],
 392       summary: "Retrieve list of blocks",
 393       operationId: "AccountController.blocks",
 394       description: "View your blocks. See also accounts/:id/{block,unblock}",
 395       security: [%{"oAuth" => ["read:blocks"]}],
 396       parameters: pagination_params(),
 397       responses: %{
 398         200 => Operation.response("Accounts", "application/json", array_of_accounts())
 399       }
 400     }
 401   end
 402
 403   def lookup_operation do
 404     %Operation{
 405       tags: ["Account lookup"],
 406       summary: "Find a user by nickname",
 407       operationId: "AccountController.lookup",
 408       parameters: [
 409         Operation.parameter(
 410           :acct,
 411           :query,
 412           :string,
 413           "User nickname"
 414         )
 415       ],
 416       responses: %{
 417         200 => Operation.response("Account", "application/json", Account),
 418         404 => Operation.response("Error", "application/json", ApiError)
 419       }
 420     }
 421   end
 422
 423   def endorsements_operation do
 424     %Operation{
 425       tags: ["Retrieve account information"],
 426       summary: "Endorsements",
 427       operationId: "AccountController.endorsements",
 428       description: "Not implemented",
 429       security: [%{"oAuth" => ["read:accounts"]}],
 430       responses: %{
 431         200 => empty_array_response()
 432       }
 433     }
 434   end
 435
 436   def identity_proofs_operation do
 437     %Operation{
 438       tags: ["Retrieve account information"],
 439       summary: "Identity proofs",
 440       operationId: "AccountController.identity_proofs",
 441       # Validators complains about unused path params otherwise
 442       parameters: [
 443         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
 444       ],
 445       description: "Not implemented",
 446       responses: %{
 447         200 => empty_array_response()
 448       }
 449     }
 450   end
 451
 452   defp create_request do
 453     %Schema{
 454       title: "AccountCreateRequest",
 455       description: "POST body for creating an account",
 456       type: :object,
 457       required: [:username, :password, :agreement],
 458       properties: %{
 459         reason: %Schema{
 460           type: :string,
 461           nullable: true,
 462           description:
 463             "Text that will be reviewed by moderators if registrations require manual approval"
 464         },
 465         username: %Schema{type: :string, description: "The desired username for the account"},
 466         email: %Schema{
 467           type: :string,
 468           nullable: true,
 469           description:
 470             "The email address to be used for login. Required when `account_activation_required` is enabled.",
 471           format: :email
 472         },
 473         password: %Schema{
 474           type: :string,
 475           description: "The password to be used for login",
 476           format: :password
 477         },
 478         agreement: %Schema{
 479           allOf: [BooleanLike],
 480           description:
 481             "Whether the user agrees to the local rules, terms, and policies. These should be presented to the user in order to allow them to consent before setting this parameter to TRUE."
 482         },
 483         locale: %Schema{
 484           type: :string,
 485           nullable: true,
 486           description: "The language of the confirmation email that will be sent"
 487         },
 488         # Pleroma-specific properties:
 489         fullname: %Schema{type: :string, nullable: true, description: "Full name"},
 490         bio: %Schema{type: :string, description: "Bio", nullable: true, default: ""},
 491         captcha_solution: %Schema{
 492           type: :string,
 493           nullable: true,
 494           description: "Provider-specific captcha solution"
 495         },
 496         captcha_token: %Schema{
 497           type: :string,
 498           nullable: true,
 499           description: "Provider-specific captcha token"
 500         },
 501         captcha_answer_data: %Schema{
 502           type: :string,
 503           nullable: true,
 504           description: "Provider-specific captcha data"
 505         },
 506         token: %Schema{
 507           type: :string,
 508           nullable: true,
 509           description: "Invite token required when the registrations aren't public"
 510         }
 511       },
 512       example: %{
 513         "username" => "cofe",
 514         "email" => "cofe@example.com",
 515         "password" => "secret",
 516         "agreement" => "true",
 517         "bio" => "☕️"
 518       }
 519     }
 520   end
 521
 522   # Note: this is a token response (if login succeeds!), but there's no oauth operation file yet.
 523   defp create_response do
 524     %Schema{
 525       title: "AccountCreateResponse",
 526       description: "Response schema for an account",
 527       type: :object,
 528       properties: %{
 529         # The response when auto-login on create succeeds (token is issued):
 530         token_type: %Schema{type: :string},
 531         access_token: %Schema{type: :string},
 532         refresh_token: %Schema{type: :string},
 533         scope: %Schema{type: :string},
 534         created_at: %Schema{type: :integer, format: :"date-time"},
 535         me: %Schema{type: :string},
 536         expires_in: %Schema{type: :integer},
 537         #
 538         # The response when registration succeeds but auto-login fails (no token):
 539         identifier: %Schema{type: :string},
 540         message: %Schema{type: :string}
 541       },
 542       # Note: example of successful registration with failed login response:
 543       # example: %{
 544       #   "identifier" => "missing_confirmed_email",
 545       #   "message" => "You have been registered. Please check your email for further instructions."
 546       # },
 547       example: %{
 548         "token_type" => "Bearer",
 549         "access_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzk",
 550         "refresh_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzz",
 551         "created_at" => 1_585_918_714,
 552         "expires_in" => 600,
 553         "scope" => "read write follow push",
 554         "me" => "https://gensokyo.2hu/users/raymoo"
 555       }
 556     }
 557   end
 558
 559   defp update_credentials_request do
 560     %Schema{
 561       title: "AccountUpdateCredentialsRequest",
 562       description: "POST body for creating an account",
 563       type: :object,
 564       properties: %{
 565         bot: %Schema{
 566           allOf: [BooleanLike],
 567           nullable: true,
 568           description: "Whether the account has a bot flag."
 569         },
 570         display_name: %Schema{
 571           type: :string,
 572           nullable: true,
 573           description: "The display name to use for the profile."
 574         },
 575         note: %Schema{type: :string, description: "The account bio."},
 576         avatar: %Schema{
 577           type: :string,
 578           nullable: true,
 579           description: "Avatar image encoded using multipart/form-data",
 580           format: :binary
 581         },
 582         header: %Schema{
 583           type: :string,
 584           nullable: true,
 585           description: "Header image encoded using multipart/form-data",
 586           format: :binary
 587         },
 588         locked: %Schema{
 589           allOf: [BooleanLike],
 590           nullable: true,
 591           description: "Whether manual approval of follow requests is required."
 592         },
 593         accepts_chat_messages: %Schema{
 594           allOf: [BooleanLike],
 595           nullable: true,
 596           description: "Whether the user accepts receiving chat messages."
 597         },
 598         fields_attributes: %Schema{
 599           nullable: true,
 600           oneOf: [
 601             %Schema{type: :array, items: attribute_field()},
 602             %Schema{type: :object, additionalProperties: attribute_field()}
 603           ]
 604         },
 605         # NOTE: `source` field is not supported
 606         #
 607         # source: %Schema{
 608         #   type: :object,
 609         #   properties: %{
 610         #     privacy: %Schema{type: :string},
 611         #     sensitive: %Schema{type: :boolean},
 612         #     language: %Schema{type: :string}
 613         #   }
 614         # },
 615
 616         # Pleroma-specific fields
 617         no_rich_text: %Schema{
 618           allOf: [BooleanLike],
 619           nullable: true,
 620           description: "html tags are stripped from all statuses requested from the API"
 621         },
 622         hide_followers: %Schema{
 623           allOf: [BooleanLike],
 624           nullable: true,
 625           description: "user's followers will be hidden"
 626         },
 627         hide_follows: %Schema{
 628           allOf: [BooleanLike],
 629           nullable: true,
 630           description: "user's follows will be hidden"
 631         },
 632         hide_followers_count: %Schema{
 633           allOf: [BooleanLike],
 634           nullable: true,
 635           description: "user's follower count will be hidden"
 636         },
 637         hide_follows_count: %Schema{
 638           allOf: [BooleanLike],
 639           nullable: true,
 640           description: "user's follow count will be hidden"
 641         },
 642         hide_favorites: %Schema{
 643           allOf: [BooleanLike],
 644           nullable: true,
 645           description: "user's favorites timeline will be hidden"
 646         },
 647         show_role: %Schema{
 648           allOf: [BooleanLike],
 649           nullable: true,
 650           description: "user's role (e.g admin, moderator) will be exposed to anyone in the
 651         API"
 652         },
 653         default_scope: VisibilityScope,
 654         pleroma_settings_store: %Schema{
 655           type: :object,
 656           nullable: true,
 657           description: "Opaque user settings to be saved on the backend."
 658         },
 659         skip_thread_containment: %Schema{
 660           allOf: [BooleanLike],
 661           nullable: true,
 662           description: "Skip filtering out broken threads"
 663         },
 664         allow_following_move: %Schema{
 665           allOf: [BooleanLike],
 666           nullable: true,
 667           description: "Allows automatically follow moved following accounts"
 668         },
 669         also_known_as: %Schema{
 670           type: :array,
 671           items: %Schema{type: :string},
 672           nullable: true,
 673           description: "List of alternate ActivityPub IDs"
 674         },
 675         pleroma_background_image: %Schema{
 676           type: :string,
 677           nullable: true,
 678           description: "Sets the background image of the user.",
 679           format: :binary
 680         },
 681         discoverable: %Schema{
 682           allOf: [BooleanLike],
 683           nullable: true,
 684           description:
 685             "Discovery (listing, indexing) of this account by external services (search bots etc.) is allowed."
 686         },
 687         actor_type: ActorType
 688       },
 689       example: %{
 690         bot: false,
 691         display_name: "cofe",
 692         note: "foobar",
 693         fields_attributes: [%{name: "foo", value: "bar"}],
 694         no_rich_text: false,
 695         hide_followers: true,
 696         hide_follows: false,
 697         hide_followers_count: false,
 698         hide_follows_count: false,
 699         hide_favorites: false,
 700         show_role: false,
 701         default_scope: "private",
 702         pleroma_settings_store: %{"pleroma-fe" => %{"key" => "val"}},
 703         skip_thread_containment: false,
 704         allow_following_move: false,
 705         also_known_as: ["https://foo.bar/users/foo"],
 706         discoverable: false,
 707         actor_type: "Person"
 708       }
 709     }
 710   end
 711
 712   def array_of_accounts do
 713     %Schema{
 714       title: "ArrayOfAccounts",
 715       type: :array,
 716       items: Account,
 717       example: [Account.schema().example]
 718     }
 719   end
 720
 721   defp array_of_relationships do
 722     %Schema{
 723       title: "ArrayOfRelationships",
 724       description: "Response schema for account relationships",
 725       type: :array,
 726       items: AccountRelationship,
 727       example: [
 728         %{
 729           "id" => "1",
 730           "following" => true,
 731           "showing_reblogs" => true,
 732           "followed_by" => true,
 733           "blocking" => false,
 734           "blocked_by" => true,
 735           "muting" => false,
 736           "muting_notifications" => false,
 737           "note" => "",
 738           "requested" => false,
 739           "domain_blocking" => false,
 740           "subscribing" => false,
 741           "notifying" => false,
 742           "endorsed" => true
 743         },
 744         %{
 745           "id" => "2",
 746           "following" => true,
 747           "showing_reblogs" => true,
 748           "followed_by" => true,
 749           "blocking" => false,
 750           "blocked_by" => true,
 751           "muting" => true,
 752           "muting_notifications" => false,
 753           "note" => "",
 754           "requested" => true,
 755           "domain_blocking" => false,
 756           "subscribing" => false,
 757           "notifying" => false,
 758           "endorsed" => false
 759         },
 760         %{
 761           "id" => "3",
 762           "following" => true,
 763           "showing_reblogs" => true,
 764           "followed_by" => true,
 765           "blocking" => true,
 766           "blocked_by" => false,
 767           "muting" => true,
 768           "muting_notifications" => false,
 769           "note" => "",
 770           "requested" => false,
 771           "domain_blocking" => true,
 772           "subscribing" => true,
 773           "notifying" => true,
 774           "endorsed" => false
 775         }
 776       ]
 777     }
 778   end
 779
 780   defp follow_by_uri_request do
 781     %Schema{
 782       title: "AccountFollowsRequest",
 783       description: "POST body for muting an account",
 784       type: :object,
 785       properties: %{
 786         uri: %Schema{type: :string, nullable: true, format: :uri}
 787       },
 788       required: [:uri]
 789     }
 790   end
 791
 792   defp mute_request do
 793     %Schema{
 794       title: "AccountMuteRequest",
 795       description: "POST body for muting an account",
 796       type: :object,
 797       properties: %{
 798         notifications: %Schema{
 799           allOf: [BooleanLike],
 800           nullable: true,
 801           description: "Mute notifications in addition to statuses? Defaults to true.",
 802           default: true
 803         },
 804         expires_in: %Schema{
 805           type: :integer,
 806           nullable: true,
 807           description: "Expire the mute in `expires_in` seconds. Default 0 for infinity",
 808           default: 0
 809         }
 810       },
 811       example: %{
 812         "notifications" => true,
 813         "expires_in" => 86_400
 814       }
 815     }
 816   end
 817
 818   defp note_request do
 819     %Schema{
 820       title: "AccountNoteRequest",
 821       description: "POST body for adding a note for an account",
 822       type: :object,
 823       properties: %{
 824         comment: %Schema{
 825           type: :string,
 826           description: "Account note body"
 827         }
 828       },
 829       example: %{
 830         "comment" => "Example note"
 831       }
 832     }
 833   end
 834
 835   defp array_of_lists do
 836     %Schema{
 837       title: "ArrayOfLists",
 838       description: "Response schema for lists",
 839       type: :array,
 840       items: List,
 841       example: [
 842         %{"id" => "123", "title" => "my list"},
 843         %{"id" => "1337", "title" => "anotehr list"}
 844       ]
 845     }
 846   end
 847
 848   defp array_of_statuses do
 849     %Schema{
 850       title: "ArrayOfStatuses",
 851       type: :array,
 852       items: Status
 853     }
 854   end
 855
 856   defp attribute_field do
 857     %Schema{
 858       title: "AccountAttributeField",
 859       description: "Request schema for account custom fields",
 860       type: :object,
 861       properties: %{
 862         name: %Schema{type: :string},
 863         value: %Schema{type: :string}
 864       },
 865       required: [:name, :value],
 866       example: %{
 867         "name" => "Website",
 868         "value" => "https://pleroma.com"
 869       }
 870     }
 871   end
 872 end