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-2020 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: ["accounts"],
  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: ["accounts"],
  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: ["accounts"],
  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: ["accounts"],
  75       summary: "Check relationships to other accounts",
  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: ["accounts"],
  99       summary: "Account",
 100       operationId: "AccountController.show",
 101       description: "View information about a profile.",
 102       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 103       responses: %{
 104         200 => Operation.response("Account", "application/json", Account),
 105         401 => Operation.response("Error", "application/json", ApiError),
 106         404 => Operation.response("Error", "application/json", ApiError)
 107       }
 108     }
 109   end
 110
 111   def statuses_operation do
 112     %Operation{
 113       tags: ["accounts"],
 114       summary: "Statuses",
 115       operationId: "AccountController.statuses",
 116       description:
 117         "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)",
 118       parameters:
 119         [
 120           %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 121           Operation.parameter(:pinned, :query, BooleanLike, "Include only pinned statuses"),
 122           Operation.parameter(:tagged, :query, :string, "With tag"),
 123           Operation.parameter(
 124             :only_media,
 125             :query,
 126             BooleanLike,
 127             "Include only statuses with media attached"
 128           ),
 129           Operation.parameter(
 130             :with_muted,
 131             :query,
 132             BooleanLike,
 133             "Include statuses from muted acccounts."
 134           ),
 135           Operation.parameter(:exclude_reblogs, :query, BooleanLike, "Exclude reblogs"),
 136           Operation.parameter(:exclude_replies, :query, BooleanLike, "Exclude replies"),
 137           Operation.parameter(
 138             :exclude_visibilities,
 139             :query,
 140             %Schema{type: :array, items: VisibilityScope},
 141             "Exclude visibilities"
 142           )
 143         ] ++ pagination_params(),
 144       responses: %{
 145         200 => Operation.response("Statuses", "application/json", array_of_statuses()),
 146         401 => Operation.response("Error", "application/json", ApiError),
 147         404 => Operation.response("Error", "application/json", ApiError)
 148       }
 149     }
 150   end
 151
 152   def followers_operation do
 153     %Operation{
 154       tags: ["accounts"],
 155       summary: "Followers",
 156       operationId: "AccountController.followers",
 157       security: [%{"oAuth" => ["read:accounts"]}],
 158       description:
 159         "Accounts which follow the given account, if network is not hidden by the account owner.",
 160       parameters: [
 161         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 162         Operation.parameter(:id, :query, :string, "ID of the resource owner"),
 163         with_relationships_param() | pagination_params()
 164       ],
 165       responses: %{
 166         200 => Operation.response("Accounts", "application/json", array_of_accounts())
 167       }
 168     }
 169   end
 170
 171   def following_operation do
 172     %Operation{
 173       tags: ["accounts"],
 174       summary: "Following",
 175       operationId: "AccountController.following",
 176       security: [%{"oAuth" => ["read:accounts"]}],
 177       description:
 178         "Accounts which the given account is following, if network is not hidden by the account owner.",
 179       parameters: [
 180         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 181         Operation.parameter(:id, :query, :string, "ID of the resource owner"),
 182         with_relationships_param() | pagination_params()
 183       ],
 184       responses: %{200 => Operation.response("Accounts", "application/json", array_of_accounts())}
 185     }
 186   end
 187
 188   def lists_operation do
 189     %Operation{
 190       tags: ["accounts"],
 191       summary: "Lists containing this account",
 192       operationId: "AccountController.lists",
 193       security: [%{"oAuth" => ["read:lists"]}],
 194       description: "User lists that you have added this account to.",
 195       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 196       responses: %{200 => Operation.response("Lists", "application/json", array_of_lists())}
 197     }
 198   end
 199
 200   def follow_operation do
 201     %Operation{
 202       tags: ["accounts"],
 203       summary: "Follow",
 204       operationId: "AccountController.follow",
 205       security: [%{"oAuth" => ["follow", "write:follows"]}],
 206       description: "Follow the given account",
 207       parameters: [
 208         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"}
 209       ],
 210       requestBody:
 211         request_body(
 212           "Parameters",
 213           %Schema{
 214             type: :object,
 215             properties: %{
 216               reblogs: %Schema{
 217                 type: :boolean,
 218                 description: "Receive this account's reblogs in home timeline? Defaults to true.",
 219                 default: true
 220               }
 221             }
 222           },
 223           required: false
 224         ),
 225       responses: %{
 226         200 => Operation.response("Relationship", "application/json", AccountRelationship),
 227         400 => Operation.response("Error", "application/json", ApiError),
 228         404 => Operation.response("Error", "application/json", ApiError)
 229       }
 230     }
 231   end
 232
 233   def unfollow_operation do
 234     %Operation{
 235       tags: ["accounts"],
 236       summary: "Unfollow",
 237       operationId: "AccountController.unfollow",
 238       security: [%{"oAuth" => ["follow", "write:follows"]}],
 239       description: "Unfollow the given account",
 240       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 241       responses: %{
 242         200 => Operation.response("Relationship", "application/json", AccountRelationship),
 243         400 => Operation.response("Error", "application/json", ApiError),
 244         404 => Operation.response("Error", "application/json", ApiError)
 245       }
 246     }
 247   end
 248
 249   def mute_operation do
 250     %Operation{
 251       tags: ["accounts"],
 252       summary: "Mute",
 253       operationId: "AccountController.mute",
 254       security: [%{"oAuth" => ["follow", "write:mutes"]}],
 255       requestBody: request_body("Parameters", mute_request()),
 256       description:
 257         "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).",
 258       parameters: [
 259         %Reference{"$ref": "#/components/parameters/accountIdOrNickname"},
 260         Operation.parameter(
 261           :notifications,
 262           :query,
 263           %Schema{allOf: [BooleanLike], default: true},
 264           "Mute notifications in addition to statuses? Defaults to `true`."
 265         ),
 266         Operation.parameter(
 267           :expires_in,
 268           :query,
 269           %Schema{type: :integer, default: 0},
 270           "Expire the mute in `expires_in` seconds. Default 0 for infinity"
 271         )
 272       ],
 273       responses: %{
 274         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 275       }
 276     }
 277   end
 278
 279   def unmute_operation do
 280     %Operation{
 281       tags: ["accounts"],
 282       summary: "Unmute",
 283       operationId: "AccountController.unmute",
 284       security: [%{"oAuth" => ["follow", "write:mutes"]}],
 285       description: "Unmute the given account.",
 286       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 287       responses: %{
 288         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 289       }
 290     }
 291   end
 292
 293   def block_operation do
 294     %Operation{
 295       tags: ["accounts"],
 296       summary: "Block",
 297       operationId: "AccountController.block",
 298       security: [%{"oAuth" => ["follow", "write:blocks"]}],
 299       description:
 300         "Block the given account. Clients should filter statuses from this account if received (e.g. due to a boost in the Home timeline)",
 301       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 302       responses: %{
 303         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 304       }
 305     }
 306   end
 307
 308   def unblock_operation do
 309     %Operation{
 310       tags: ["accounts"],
 311       summary: "Unblock",
 312       operationId: "AccountController.unblock",
 313       security: [%{"oAuth" => ["follow", "write:blocks"]}],
 314       description: "Unblock the given account.",
 315       parameters: [%Reference{"$ref": "#/components/parameters/accountIdOrNickname"}],
 316       responses: %{
 317         200 => Operation.response("Relationship", "application/json", AccountRelationship)
 318       }
 319     }
 320   end
 321
 322   def follow_by_uri_operation do
 323     %Operation{
 324       tags: ["accounts"],
 325       summary: "Follow by URI",
 326       operationId: "AccountController.follows",
 327       security: [%{"oAuth" => ["follow", "write:follows"]}],
 328       requestBody: request_body("Parameters", follow_by_uri_request(), required: true),
 329       responses: %{
 330         200 => Operation.response("Account", "application/json", AccountRelationship),
 331         400 => Operation.response("Error", "application/json", ApiError),
 332         404 => Operation.response("Error", "application/json", ApiError)
 333       }
 334     }
 335   end
 336
 337   def mutes_operation do
 338     %Operation{
 339       tags: ["accounts"],
 340       summary: "Muted accounts",
 341       operationId: "AccountController.mutes",
 342       description: "Accounts the user has muted.",
 343       security: [%{"oAuth" => ["follow", "read:mutes"]}],
 344       responses: %{
 345         200 => Operation.response("Accounts", "application/json", array_of_accounts())
 346       }
 347     }
 348   end
 349
 350   def blocks_operation do
 351     %Operation{
 352       tags: ["accounts"],
 353       summary: "Blocked users",
 354       operationId: "AccountController.blocks",
 355       description: "View your blocks. See also accounts/:id/{block,unblock}",
 356       security: [%{"oAuth" => ["read:blocks"]}],
 357       responses: %{
 358         200 => Operation.response("Accounts", "application/json", array_of_accounts())
 359       }
 360     }
 361   end
 362
 363   def endorsements_operation do
 364     %Operation{
 365       tags: ["accounts"],
 366       summary: "Endorsements",
 367       operationId: "AccountController.endorsements",
 368       description: "Not implemented",
 369       security: [%{"oAuth" => ["read:accounts"]}],
 370       responses: %{
 371         200 => empty_array_response()
 372       }
 373     }
 374   end
 375
 376   def identity_proofs_operation do
 377     %Operation{
 378       tags: ["accounts"],
 379       summary: "Identity proofs",
 380       operationId: "AccountController.identity_proofs",
 381       description: "Not implemented",
 382       responses: %{
 383         200 => empty_array_response()
 384       }
 385     }
 386   end
 387
 388   defp create_request do
 389     %Schema{
 390       title: "AccountCreateRequest",
 391       description: "POST body for creating an account",
 392       type: :object,
 393       required: [:username, :password, :agreement],
 394       properties: %{
 395         reason: %Schema{
 396           type: :string,
 397           nullable: true,
 398           description:
 399             "Text that will be reviewed by moderators if registrations require manual approval"
 400         },
 401         username: %Schema{type: :string, description: "The desired username for the account"},
 402         email: %Schema{
 403           type: :string,
 404           nullable: true,
 405           description:
 406             "The email address to be used for login. Required when `account_activation_required` is enabled.",
 407           format: :email
 408         },
 409         password: %Schema{
 410           type: :string,
 411           description: "The password to be used for login",
 412           format: :password
 413         },
 414         agreement: %Schema{
 415           allOf: [BooleanLike],
 416           description:
 417             "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."
 418         },
 419         locale: %Schema{
 420           type: :string,
 421           nullable: true,
 422           description: "The language of the confirmation email that will be sent"
 423         },
 424         # Pleroma-specific properties:
 425         fullname: %Schema{type: :string, nullable: true, description: "Full name"},
 426         bio: %Schema{type: :string, description: "Bio", nullable: true, default: ""},
 427         captcha_solution: %Schema{
 428           type: :string,
 429           nullable: true,
 430           description: "Provider-specific captcha solution"
 431         },
 432         captcha_token: %Schema{
 433           type: :string,
 434           nullable: true,
 435           description: "Provider-specific captcha token"
 436         },
 437         captcha_answer_data: %Schema{
 438           type: :string,
 439           nullable: true,
 440           description: "Provider-specific captcha data"
 441         },
 442         token: %Schema{
 443           type: :string,
 444           nullable: true,
 445           description: "Invite token required when the registrations aren't public"
 446         }
 447       },
 448       example: %{
 449         "username" => "cofe",
 450         "email" => "cofe@example.com",
 451         "password" => "secret",
 452         "agreement" => "true",
 453         "bio" => "☕️"
 454       }
 455     }
 456   end
 457
 458   # Note: this is a token response (if login succeeds!), but there's no oauth operation file yet.
 459   defp create_response do
 460     %Schema{
 461       title: "AccountCreateResponse",
 462       description: "Response schema for an account",
 463       type: :object,
 464       properties: %{
 465         # The response when auto-login on create succeeds (token is issued):
 466         token_type: %Schema{type: :string},
 467         access_token: %Schema{type: :string},
 468         refresh_token: %Schema{type: :string},
 469         scope: %Schema{type: :string},
 470         created_at: %Schema{type: :integer, format: :"date-time"},
 471         me: %Schema{type: :string},
 472         expires_in: %Schema{type: :integer},
 473         #
 474         # The response when registration succeeds but auto-login fails (no token):
 475         identifier: %Schema{type: :string},
 476         message: %Schema{type: :string}
 477       },
 478       required: [],
 479       # Note: example of successful registration with failed login response:
 480       # example: %{
 481       #   "identifier" => "missing_confirmed_email",
 482       #   "message" => "You have been registered. Please check your email for further instructions."
 483       # },
 484       example: %{
 485         "token_type" => "Bearer",
 486         "access_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzk",
 487         "refresh_token" => "i9hAVVzGld86Pl5JtLtizKoXVvtTlSCJvwaugCxvZzz",
 488         "created_at" => 1_585_918_714,
 489         "expires_in" => 600,
 490         "scope" => "read write follow push",
 491         "me" => "https://gensokyo.2hu/users/raymoo"
 492       }
 493     }
 494   end
 495
 496   defp update_credentials_request do
 497     %Schema{
 498       title: "AccountUpdateCredentialsRequest",
 499       description: "POST body for creating an account",
 500       type: :object,
 501       properties: %{
 502         bot: %Schema{
 503           allOf: [BooleanLike],
 504           nullable: true,
 505           description: "Whether the account has a bot flag."
 506         },
 507         display_name: %Schema{
 508           type: :string,
 509           nullable: true,
 510           description: "The display name to use for the profile."
 511         },
 512         note: %Schema{type: :string, description: "The account bio."},
 513         avatar: %Schema{
 514           type: :string,
 515           nullable: true,
 516           description: "Avatar image encoded using multipart/form-data",
 517           format: :binary
 518         },
 519         header: %Schema{
 520           type: :string,
 521           nullable: true,
 522           description: "Header image encoded using multipart/form-data",
 523           format: :binary
 524         },
 525         locked: %Schema{
 526           allOf: [BooleanLike],
 527           nullable: true,
 528           description: "Whether manual approval of follow requests is required."
 529         },
 530         accepts_chat_messages: %Schema{
 531           allOf: [BooleanLike],
 532           nullable: true,
 533           description: "Whether the user accepts receiving chat messages."
 534         },
 535         fields_attributes: %Schema{
 536           nullable: true,
 537           oneOf: [
 538             %Schema{type: :array, items: attribute_field()},
 539             %Schema{type: :object, additionalProperties: %Schema{type: attribute_field()}}
 540           ]
 541         },
 542         # NOTE: `source` field is not supported
 543         #
 544         # source: %Schema{
 545         #   type: :object,
 546         #   properties: %{
 547         #     privacy: %Schema{type: :string},
 548         #     sensitive: %Schema{type: :boolean},
 549         #     language: %Schema{type: :string}
 550         #   }
 551         # },
 552
 553         # Pleroma-specific fields
 554         no_rich_text: %Schema{
 555           allOf: [BooleanLike],
 556           nullable: true,
 557           description: "html tags are stripped from all statuses requested from the API"
 558         },
 559         hide_followers: %Schema{
 560           allOf: [BooleanLike],
 561           nullable: true,
 562           description: "user's followers will be hidden"
 563         },
 564         hide_follows: %Schema{
 565           allOf: [BooleanLike],
 566           nullable: true,
 567           description: "user's follows will be hidden"
 568         },
 569         hide_followers_count: %Schema{
 570           allOf: [BooleanLike],
 571           nullable: true,
 572           description: "user's follower count will be hidden"
 573         },
 574         hide_follows_count: %Schema{
 575           allOf: [BooleanLike],
 576           nullable: true,
 577           description: "user's follow count will be hidden"
 578         },
 579         hide_favorites: %Schema{
 580           allOf: [BooleanLike],
 581           nullable: true,
 582           description: "user's favorites timeline will be hidden"
 583         },
 584         show_role: %Schema{
 585           allOf: [BooleanLike],
 586           nullable: true,
 587           description: "user's role (e.g admin, moderator) will be exposed to anyone in the
 588         API"
 589         },
 590         default_scope: VisibilityScope,
 591         pleroma_settings_store: %Schema{
 592           type: :object,
 593           nullable: true,
 594           description: "Opaque user settings to be saved on the backend."
 595         },
 596         skip_thread_containment: %Schema{
 597           allOf: [BooleanLike],
 598           nullable: true,
 599           description: "Skip filtering out broken threads"
 600         },
 601         allow_following_move: %Schema{
 602           allOf: [BooleanLike],
 603           nullable: true,
 604           description: "Allows automatically follow moved following accounts"
 605         },
 606         pleroma_background_image: %Schema{
 607           type: :string,
 608           nullable: true,
 609           description: "Sets the background image of the user.",
 610           format: :binary
 611         },
 612         discoverable: %Schema{
 613           allOf: [BooleanLike],
 614           nullable: true,
 615           description:
 616             "Discovery of this account in search results and other services is allowed."
 617         },
 618         actor_type: ActorType
 619       },
 620       example: %{
 621         bot: false,
 622         display_name: "cofe",
 623         note: "foobar",
 624         fields_attributes: [%{name: "foo", value: "bar"}],
 625         no_rich_text: false,
 626         hide_followers: true,
 627         hide_follows: false,
 628         hide_followers_count: false,
 629         hide_follows_count: false,
 630         hide_favorites: false,
 631         show_role: false,
 632         default_scope: "private",
 633         pleroma_settings_store: %{"pleroma-fe" => %{"key" => "val"}},
 634         skip_thread_containment: false,
 635         allow_following_move: false,
 636         discoverable: false,
 637         actor_type: "Person"
 638       }
 639     }
 640   end
 641
 642   def array_of_accounts do
 643     %Schema{
 644       title: "ArrayOfAccounts",
 645       type: :array,
 646       items: Account,
 647       example: [Account.schema().example]
 648     }
 649   end
 650
 651   defp array_of_relationships do
 652     %Schema{
 653       title: "ArrayOfRelationships",
 654       description: "Response schema for account relationships",
 655       type: :array,
 656       items: AccountRelationship,
 657       example: [
 658         %{
 659           "id" => "1",
 660           "following" => true,
 661           "showing_reblogs" => true,
 662           "followed_by" => true,
 663           "blocking" => false,
 664           "blocked_by" => true,
 665           "muting" => false,
 666           "muting_notifications" => false,
 667           "requested" => false,
 668           "domain_blocking" => false,
 669           "subscribing" => false,
 670           "endorsed" => true
 671         },
 672         %{
 673           "id" => "2",
 674           "following" => true,
 675           "showing_reblogs" => true,
 676           "followed_by" => true,
 677           "blocking" => false,
 678           "blocked_by" => true,
 679           "muting" => true,
 680           "muting_notifications" => false,
 681           "requested" => true,
 682           "domain_blocking" => false,
 683           "subscribing" => false,
 684           "endorsed" => false
 685         },
 686         %{
 687           "id" => "3",
 688           "following" => true,
 689           "showing_reblogs" => true,
 690           "followed_by" => true,
 691           "blocking" => true,
 692           "blocked_by" => false,
 693           "muting" => true,
 694           "muting_notifications" => false,
 695           "requested" => false,
 696           "domain_blocking" => true,
 697           "subscribing" => true,
 698           "endorsed" => false
 699         }
 700       ]
 701     }
 702   end
 703
 704   defp follow_by_uri_request do
 705     %Schema{
 706       title: "AccountFollowsRequest",
 707       description: "POST body for muting an account",
 708       type: :object,
 709       properties: %{
 710         uri: %Schema{type: :string, nullable: true, format: :uri}
 711       },
 712       required: [:uri]
 713     }
 714   end
 715
 716   defp mute_request do
 717     %Schema{
 718       title: "AccountMuteRequest",
 719       description: "POST body for muting an account",
 720       type: :object,
 721       properties: %{
 722         notifications: %Schema{
 723           allOf: [BooleanLike],
 724           nullable: true,
 725           description: "Mute notifications in addition to statuses? Defaults to true.",
 726           default: true
 727         },
 728         expires_in: %Schema{
 729           type: :integer,
 730           nullable: true,
 731           description: "Expire the mute in `expires_in` seconds. Default 0 for infinity",
 732           default: 0
 733         }
 734       },
 735       example: %{
 736         "notifications" => true,
 737         "expires_in" => 86_400
 738       }
 739     }
 740   end
 741
 742   defp array_of_lists do
 743     %Schema{
 744       title: "ArrayOfLists",
 745       description: "Response schema for lists",
 746       type: :array,
 747       items: List,
 748       example: [
 749         %{"id" => "123", "title" => "my list"},
 750         %{"id" => "1337", "title" => "anotehr list"}
 751       ]
 752     }
 753   end
 754
 755   defp array_of_statuses do
 756     %Schema{
 757       title: "ArrayOfStatuses",
 758       type: :array,
 759       items: Status
 760     }
 761   end
 762
 763   defp attribute_field do
 764     %Schema{
 765       title: "AccountAttributeField",
 766       description: "Request schema for account custom fields",
 767       type: :object,
 768       properties: %{
 769         name: %Schema{type: :string},
 770         value: %Schema{type: :string}
 771       },
 772       required: [:name, :value],
 773       example: %{
 774         "name" => "Website",
 775         "value" => "https://pleroma.com"
 776       }
 777     }
 778   end
 779 end