commit 31e2da4b7b5f73b357bb5484a1c0be9a1662e46c · comet.sh/atex

+3 -19

.gitignore

···

       1
       -
       # The directory Mix will write compiled artifacts to.

     

       2
        
       /_build/

     

       3
       -
       

     

       4
       -
       # If you run "mix test --cover", coverage assets end up here.

     

       5
        
       /cover/

     

       6
       -
       

     

       7
       -
       # The directory Mix downloads your dependencies sources to.

     

       8
        
       /deps/

     

       9
       -
       

     

       10
       -
       # Where third-party dependencies like ExDoc output generated docs.

     

       11
        
       /doc/

     

       12
       -
       

     

       13
       -
       # If the VM crashes, it generates a dump, let's ignore it too.

     

       14
        
       erl_crash.dump

     

       15
       -
       

     

       16
       -
       # Also ignore archive artifacts (built via "mix archive.build").

     

       17
        
       *.ez

     

       18
       -
       

     

       19
       -
       # Ignore package tarball (built via "mix hex.build").

     

       20
        
       atex-*.tar

     

       21
       -
       

     

       22
       -
       # Temporary files, for example, from tests.

     

       23
        
       /tmp/

     

       24
        
       

     

       25
        
       .envrc

     
···

       27
        
       .vscode/

     

       28
        
       .elixir_ls

     

       29
        
       lexicons

     

       30
       -
       lib/atproto

     

       31
        
       secrets

     

       32
       -
       node_modules

     

       33
       -
       atproto-oauth-example

     

       34
        
       .DS_Store

     

       35
       -
       CLAUDE.md
     

       0
        
       
     

       0

···

       0
        
       
     

       1
        
       /_build/

     

       0
        
       
     

       0
        
       
     

       2
        
       /cover/

     

       0
        
       
     

       0
        
       
     

       3
        
       /deps/

     

       0
        
       
     

       0
        
       
     

       4
        
       /doc/

     

       0
        
       
     

       0
        
       
     

       5
        
       erl_crash.dump

     

       0
        
       
     

       0
        
       
     

       6
        
       *.ez

     

       0
        
       
     

       0
        
       
     

       7
        
       atex-*.tar

     

       0
        
       
     

       0
        
       
     

       8
        
       /tmp/

     

       9
        
       

     

       10
        
       .envrc

     
···

       12
        
       .vscode/

     

       13
        
       .elixir_ls

     

       14
        
       lexicons

     

       0
        
       
     

       15
        
       secrets

     

       0
        
       
     

       0
        
       
     

       16
        
       .DS_Store

     

       17
       +
       CLAUDE.md

     

       18
       +
       tmp

     

       19
       +
       temp

+2 -1

CHANGELOG.md

···

       18
        
       - `deflexicon` now emits structs for records, objects, queries, and procedures.

     

       19
        
       - `Atex.XRPC.get/3` and `Atex.XRPC.post/3` now support having a lexicon struct

     

       20
        
         as the second argument instead of the method's name, making it easier to have

     

       21
       -
         properly checked API calls.

     

       0
        
       
     

       22
        
       

     

       23
        
       ## [0.5.0] - 2025-10-11

     

       24

···

       18
        
       - `deflexicon` now emits structs for records, objects, queries, and procedures.

     

       19
        
       - `Atex.XRPC.get/3` and `Atex.XRPC.post/3` now support having a lexicon struct

     

       20
        
         as the second argument instead of the method's name, making it easier to have

     

       21
       +
         properly checked XRPC calls.

     

       22
       +
       - Add pre-transpiled modules for the core `com.atproto` lexicons.

     

       23
        
       

     

       24
        
       ## [0.5.0] - 2025-10-11

     

       25

+3 -1

README.md

···

       12
        
       - [x] Macro for converting a Lexicon definition into a runtime-validation schema

     

       13
        
         - [x] Codegen to convert a directory of lexicons

     

       14
        
       - [x] Oauth stuff

     

       15
       -
       - [ ] Extended XRPC client with support for validated inputs/outputs

     

       0
        
       
     

       0
        
       
     

       16
        
       

     

       17
        
       ## Installation

     

       18

···

       12
        
       - [x] Macro for converting a Lexicon definition into a runtime-validation schema

     

       13
        
         - [x] Codegen to convert a directory of lexicons

     

       14
        
       - [x] Oauth stuff

     

       15
       +
       - [x] Extended XRPC client with support for validated inputs/outputs

     

       16
       +
       - [ ] Proper MST & CAR handling things

     

       17
       +
       - [ ] Pre-transpiled libraries for popular lexicons

     

       18
        
       

     

       19
        
       ## Installation

     

       20

+11

bump_builtin_lexicons.sh

···

       1
       +
       #!/usr/bin/env bash

     

       2
       +
       

     

       3
       +
       set -euo pipefail

     

       4
       +
       

     

       5
       +
       SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

     

       6
       +
       cd "$SCRIPT_DIR"

     

       7
       +
       

     

       8
       +
       mkdir -p ./tmp

     

       9
       +
       git clone --depth 1 --single-branch https://github.com/bluesky-social/atproto.git ./tmp/atproto

     

       10
       +
       mix atex.lexicons ./tmp/atproto/lexicons/com/atproto/**/*.json

     

       11
       +
       rm -rf ./tmp

+73

lib/atproto/com/atproto/admin/defs.ex

···

       1
       +
       defmodule Com.Atproto.Admin.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "accountView" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "deactivatedAt" => %{"format" => "datetime", "type" => "string"},

     

       9
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       10
       +
                 "email" => %{"type" => "string"},

     

       11
       +
                 "emailConfirmedAt" => %{"format" => "datetime", "type" => "string"},

     

       12
       +
                 "handle" => %{"format" => "handle", "type" => "string"},

     

       13
       +
                 "indexedAt" => %{"format" => "datetime", "type" => "string"},

     

       14
       +
                 "inviteNote" => %{"type" => "string"},

     

       15
       +
                 "invitedBy" => %{

     

       16
       +
                   "ref" => "com.atproto.server.defs#inviteCode",

     

       17
       +
                   "type" => "ref"

     

       18
       +
                 },

     

       19
       +
                 "invites" => %{

     

       20
       +
                   "items" => %{

     

       21
       +
                     "ref" => "com.atproto.server.defs#inviteCode",

     

       22
       +
                     "type" => "ref"

     

       23
       +
                   },

     

       24
       +
                   "type" => "array"

     

       25
       +
                 },

     

       26
       +
                 "invitesDisabled" => %{"type" => "boolean"},

     

       27
       +
                 "relatedRecords" => %{

     

       28
       +
                   "items" => %{"type" => "unknown"},

     

       29
       +
                   "type" => "array"

     

       30
       +
                 },

     

       31
       +
                 "threatSignatures" => %{

     

       32
       +
                   "items" => %{"ref" => "#threatSignature", "type" => "ref"},

     

       33
       +
                   "type" => "array"

     

       34
       +
                 }

     

       35
       +
               },

     

       36
       +
               "required" => ["did", "handle", "indexedAt"],

     

       37
       +
               "type" => "object"

     

       38
       +
             },

     

       39
       +
             "repoBlobRef" => %{

     

       40
       +
               "properties" => %{

     

       41
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       42
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       43
       +
                 "recordUri" => %{"format" => "at-uri", "type" => "string"}

     

       44
       +
               },

     

       45
       +
               "required" => ["did", "cid"],

     

       46
       +
               "type" => "object"

     

       47
       +
             },

     

       48
       +
             "repoRef" => %{

     

       49
       +
               "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       50
       +
               "required" => ["did"],

     

       51
       +
               "type" => "object"

     

       52
       +
             },

     

       53
       +
             "statusAttr" => %{

     

       54
       +
               "properties" => %{

     

       55
       +
                 "applied" => %{"type" => "boolean"},

     

       56
       +
                 "ref" => %{"type" => "string"}

     

       57
       +
               },

     

       58
       +
               "required" => ["applied"],

     

       59
       +
               "type" => "object"

     

       60
       +
             },

     

       61
       +
             "threatSignature" => %{

     

       62
       +
               "properties" => %{

     

       63
       +
                 "property" => %{"type" => "string"},

     

       64
       +
                 "value" => %{"type" => "string"}

     

       65
       +
               },

     

       66
       +
               "required" => ["property", "value"],

     

       67
       +
               "type" => "object"

     

       68
       +
             }

     

       69
       +
           },

     

       70
       +
           "id" => "com.atproto.admin.defs",

     

       71
       +
           "lexicon" => 1

     

       72
       +
         })

     

       73
       +
       end

+22

lib/atproto/com/atproto/admin/deleteAccount.ex

···

       1
       +
       defmodule Com.Atproto.Admin.DeleteAccount do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Delete a user account as an administrator.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       12
       +
                   "required" => ["did"],

     

       13
       +
                   "type" => "object"

     

       14
       +
                 }

     

       15
       +
               },

     

       16
       +
               "type" => "procedure"

     

       17
       +
             }

     

       18
       +
           },

     

       19
       +
           "id" => "com.atproto.admin.deleteAccount",

     

       20
       +
           "lexicon" => 1

     

       21
       +
         })

     

       22
       +
       end

+29

lib/atproto/com/atproto/admin/disableAccountInvites.ex

···

       1
       +
       defmodule Com.Atproto.Admin.DisableAccountInvites do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Disable an account from receiving new invite codes, but does not invalidate existing codes.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "account" => %{"format" => "did", "type" => "string"},

     

       14
       +
                     "note" => %{

     

       15
       +
                       "description" => "Optional reason for disabled invites.",

     

       16
       +
                       "type" => "string"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "required" => ["account"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "type" => "procedure"

     

       24
       +
             }

     

       25
       +
           },

     

       26
       +
           "id" => "com.atproto.admin.disableAccountInvites",

     

       27
       +
           "lexicon" => 1

     

       28
       +
         })

     

       29
       +
       end

+25

lib/atproto/com/atproto/admin/disableInviteCodes.ex

···

       1
       +
       defmodule Com.Atproto.Admin.DisableInviteCodes do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Disable some set of codes and/or all codes associated with a set of users.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "accounts" => %{"items" => %{"type" => "string"}, "type" => "array"},

     

       14
       +
                     "codes" => %{"items" => %{"type" => "string"}, "type" => "array"}

     

       15
       +
                   },

     

       16
       +
                   "type" => "object"

     

       17
       +
                 }

     

       18
       +
               },

     

       19
       +
               "type" => "procedure"

     

       20
       +
             }

     

       21
       +
           },

     

       22
       +
           "id" => "com.atproto.admin.disableInviteCodes",

     

       23
       +
           "lexicon" => 1

     

       24
       +
         })

     

       25
       +
       end

+28

lib/atproto/com/atproto/admin/enableAccountInvites.ex

···

       1
       +
       defmodule Com.Atproto.Admin.EnableAccountInvites do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Re-enable an account's ability to receive invite codes.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "account" => %{"format" => "did", "type" => "string"},

     

       13
       +
                     "note" => %{

     

       14
       +
                       "description" => "Optional reason for enabled invites.",

     

       15
       +
                       "type" => "string"

     

       16
       +
                     }

     

       17
       +
                   },

     

       18
       +
                   "required" => ["account"],

     

       19
       +
                   "type" => "object"

     

       20
       +
                 }

     

       21
       +
               },

     

       22
       +
               "type" => "procedure"

     

       23
       +
             }

     

       24
       +
           },

     

       25
       +
           "id" => "com.atproto.admin.enableAccountInvites",

     

       26
       +
           "lexicon" => 1

     

       27
       +
         })

     

       28
       +
       end

+26

lib/atproto/com/atproto/admin/getAccountInfo.ex

···

       1
       +
       defmodule Com.Atproto.Admin.GetAccountInfo do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get details about an account.",

     

       8
       +
               "output" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "ref" => "com.atproto.admin.defs#accountView",

     

       12
       +
                   "type" => "ref"

     

       13
       +
                 }

     

       14
       +
               },

     

       15
       +
               "parameters" => %{

     

       16
       +
                 "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       17
       +
                 "required" => ["did"],

     

       18
       +
                 "type" => "params"

     

       19
       +
               },

     

       20
       +
               "type" => "query"

     

       21
       +
             }

     

       22
       +
           },

     

       23
       +
           "id" => "com.atproto.admin.getAccountInfo",

     

       24
       +
           "lexicon" => 1

     

       25
       +
         })

     

       26
       +
       end

+40

lib/atproto/com/atproto/admin/getAccountInfos.ex

···

       1
       +
       defmodule Com.Atproto.Admin.GetAccountInfos do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get details about some accounts.",

     

       8
       +
               "output" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "infos" => %{

     

       13
       +
                       "items" => %{

     

       14
       +
                         "ref" => "com.atproto.admin.defs#accountView",

     

       15
       +
                         "type" => "ref"

     

       16
       +
                       },

     

       17
       +
                       "type" => "array"

     

       18
       +
                     }

     

       19
       +
                   },

     

       20
       +
                   "required" => ["infos"],

     

       21
       +
                   "type" => "object"

     

       22
       +
                 }

     

       23
       +
               },

     

       24
       +
               "parameters" => %{

     

       25
       +
                 "properties" => %{

     

       26
       +
                   "dids" => %{

     

       27
       +
                     "items" => %{"format" => "did", "type" => "string"},

     

       28
       +
                     "type" => "array"

     

       29
       +
                   }

     

       30
       +
                 },

     

       31
       +
                 "required" => ["dids"],

     

       32
       +
                 "type" => "params"

     

       33
       +
               },

     

       34
       +
               "type" => "query"

     

       35
       +
             }

     

       36
       +
           },

     

       37
       +
           "id" => "com.atproto.admin.getAccountInfos",

     

       38
       +
           "lexicon" => 1

     

       39
       +
         })

     

       40
       +
       end

+48

lib/atproto/com/atproto/admin/getInviteCodes.ex

···

       1
       +
       defmodule Com.Atproto.Admin.GetInviteCodes do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get an admin view of invite codes.",

     

       8
       +
               "output" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "codes" => %{

     

       13
       +
                       "items" => %{

     

       14
       +
                         "ref" => "com.atproto.server.defs#inviteCode",

     

       15
       +
                         "type" => "ref"

     

       16
       +
                       },

     

       17
       +
                       "type" => "array"

     

       18
       +
                     },

     

       19
       +
                     "cursor" => %{"type" => "string"}

     

       20
       +
                   },

     

       21
       +
                   "required" => ["codes"],

     

       22
       +
                   "type" => "object"

     

       23
       +
                 }

     

       24
       +
               },

     

       25
       +
               "parameters" => %{

     

       26
       +
                 "properties" => %{

     

       27
       +
                   "cursor" => %{"type" => "string"},

     

       28
       +
                   "limit" => %{

     

       29
       +
                     "default" => 100,

     

       30
       +
                     "maximum" => 500,

     

       31
       +
                     "minimum" => 1,

     

       32
       +
                     "type" => "integer"

     

       33
       +
                   },

     

       34
       +
                   "sort" => %{

     

       35
       +
                     "default" => "recent",

     

       36
       +
                     "knownValues" => ["recent", "usage"],

     

       37
       +
                     "type" => "string"

     

       38
       +
                   }

     

       39
       +
                 },

     

       40
       +
                 "type" => "params"

     

       41
       +
               },

     

       42
       +
               "type" => "query"

     

       43
       +
             }

     

       44
       +
           },

     

       45
       +
           "id" => "com.atproto.admin.getInviteCodes",

     

       46
       +
           "lexicon" => 1

     

       47
       +
         })

     

       48
       +
       end

+48

lib/atproto/com/atproto/admin/getSubjectStatus.ex

···

       1
       +
       defmodule Com.Atproto.Admin.GetSubjectStatus do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get the service-specific admin status of a subject (account, record, or blob).",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "deactivated" => %{

     

       14
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       15
       +
                       "type" => "ref"

     

       16
       +
                     },

     

       17
       +
                     "subject" => %{

     

       18
       +
                       "refs" => [

     

       19
       +
                         "com.atproto.admin.defs#repoRef",

     

       20
       +
                         "com.atproto.repo.strongRef",

     

       21
       +
                         "com.atproto.admin.defs#repoBlobRef"

     

       22
       +
                       ],

     

       23
       +
                       "type" => "union"

     

       24
       +
                     },

     

       25
       +
                     "takedown" => %{

     

       26
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       27
       +
                       "type" => "ref"

     

       28
       +
                     }

     

       29
       +
                   },

     

       30
       +
                   "required" => ["subject"],

     

       31
       +
                   "type" => "object"

     

       32
       +
                 }

     

       33
       +
               },

     

       34
       +
               "parameters" => %{

     

       35
       +
                 "properties" => %{

     

       36
       +
                   "blob" => %{"format" => "cid", "type" => "string"},

     

       37
       +
                   "did" => %{"format" => "did", "type" => "string"},

     

       38
       +
                   "uri" => %{"format" => "at-uri", "type" => "string"}

     

       39
       +
                 },

     

       40
       +
                 "type" => "params"

     

       41
       +
               },

     

       42
       +
               "type" => "query"

     

       43
       +
             }

     

       44
       +
           },

     

       45
       +
           "id" => "com.atproto.admin.getSubjectStatus",

     

       46
       +
           "lexicon" => 1

     

       47
       +
         })

     

       48
       +
       end

+44

lib/atproto/com/atproto/admin/searchAccounts.ex

···

       1
       +
       defmodule Com.Atproto.Admin.SearchAccounts do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get list of accounts that matches your search query.",

     

       8
       +
               "output" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "accounts" => %{

     

       13
       +
                       "items" => %{

     

       14
       +
                         "ref" => "com.atproto.admin.defs#accountView",

     

       15
       +
                         "type" => "ref"

     

       16
       +
                       },

     

       17
       +
                       "type" => "array"

     

       18
       +
                     },

     

       19
       +
                     "cursor" => %{"type" => "string"}

     

       20
       +
                   },

     

       21
       +
                   "required" => ["accounts"],

     

       22
       +
                   "type" => "object"

     

       23
       +
                 }

     

       24
       +
               },

     

       25
       +
               "parameters" => %{

     

       26
       +
                 "properties" => %{

     

       27
       +
                   "cursor" => %{"type" => "string"},

     

       28
       +
                   "email" => %{"type" => "string"},

     

       29
       +
                   "limit" => %{

     

       30
       +
                     "default" => 50,

     

       31
       +
                     "maximum" => 100,

     

       32
       +
                     "minimum" => 1,

     

       33
       +
                     "type" => "integer"

     

       34
       +
                   }

     

       35
       +
                 },

     

       36
       +
                 "type" => "params"

     

       37
       +
               },

     

       38
       +
               "type" => "query"

     

       39
       +
             }

     

       40
       +
           },

     

       41
       +
           "id" => "com.atproto.admin.searchAccounts",

     

       42
       +
           "lexicon" => 1

     

       43
       +
         })

     

       44
       +
       end

+40

lib/atproto/com/atproto/admin/sendEmail.ex

···

       1
       +
       defmodule Com.Atproto.Admin.SendEmail do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Send email to a user's account email address.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "comment" => %{

     

       13
       +
                       "description" =>

     

       14
       +
                         "Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers",

     

       15
       +
                       "type" => "string"

     

       16
       +
                     },

     

       17
       +
                     "content" => %{"type" => "string"},

     

       18
       +
                     "recipientDid" => %{"format" => "did", "type" => "string"},

     

       19
       +
                     "senderDid" => %{"format" => "did", "type" => "string"},

     

       20
       +
                     "subject" => %{"type" => "string"}

     

       21
       +
                   },

     

       22
       +
                   "required" => ["recipientDid", "content", "senderDid"],

     

       23
       +
                   "type" => "object"

     

       24
       +
                 }

     

       25
       +
               },

     

       26
       +
               "output" => %{

     

       27
       +
                 "encoding" => "application/json",

     

       28
       +
                 "schema" => %{

     

       29
       +
                   "properties" => %{"sent" => %{"type" => "boolean"}},

     

       30
       +
                   "required" => ["sent"],

     

       31
       +
                   "type" => "object"

     

       32
       +
                 }

     

       33
       +
               },

     

       34
       +
               "type" => "procedure"

     

       35
       +
             }

     

       36
       +
           },

     

       37
       +
           "id" => "com.atproto.admin.sendEmail",

     

       38
       +
           "lexicon" => 1

     

       39
       +
         })

     

       40
       +
       end

+29

lib/atproto/com/atproto/admin/updateAccountEmail.ex

···

       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountEmail do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Administrative action to update an account's email.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "account" => %{

     

       13
       +
                       "description" => "The handle or DID of the repo.",

     

       14
       +
                       "format" => "at-identifier",

     

       15
       +
                       "type" => "string"

     

       16
       +
                     },

     

       17
       +
                     "email" => %{"type" => "string"}

     

       18
       +
                   },

     

       19
       +
                   "required" => ["account", "email"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "type" => "procedure"

     

       24
       +
             }

     

       25
       +
           },

     

       26
       +
           "id" => "com.atproto.admin.updateAccountEmail",

     

       27
       +
           "lexicon" => 1

     

       28
       +
         })

     

       29
       +
       end

+25

lib/atproto/com/atproto/admin/updateAccountHandle.ex

···

       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountHandle do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Administrative action to update an account's handle.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       13
       +
                     "handle" => %{"format" => "handle", "type" => "string"}

     

       14
       +
                   },

     

       15
       +
                   "required" => ["did", "handle"],

     

       16
       +
                   "type" => "object"

     

       17
       +
                 }

     

       18
       +
               },

     

       19
       +
               "type" => "procedure"

     

       20
       +
             }

     

       21
       +
           },

     

       22
       +
           "id" => "com.atproto.admin.updateAccountHandle",

     

       23
       +
           "lexicon" => 1

     

       24
       +
         })

     

       25
       +
       end

+25

lib/atproto/com/atproto/admin/updateAccountPassword.ex

···

       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountPassword do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Update the password for a user account as an administrator.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       13
       +
                     "password" => %{"type" => "string"}

     

       14
       +
                   },

     

       15
       +
                   "required" => ["did", "password"],

     

       16
       +
                   "type" => "object"

     

       17
       +
                 }

     

       18
       +
               },

     

       19
       +
               "type" => "procedure"

     

       20
       +
             }

     

       21
       +
           },

     

       22
       +
           "id" => "com.atproto.admin.updateAccountPassword",

     

       23
       +
           "lexicon" => 1

     

       24
       +
         })

     

       25
       +
       end

+30

lib/atproto/com/atproto/admin/updateAccountSigningKey.ex

···

       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountSigningKey do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Administrative action to update an account's signing key in their Did document.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       14
       +
                     "signingKey" => %{

     

       15
       +
                       "description" => "Did-key formatted public key",

     

       16
       +
                       "format" => "did",

     

       17
       +
                       "type" => "string"

     

       18
       +
                     }

     

       19
       +
                   },

     

       20
       +
                   "required" => ["did", "signingKey"],

     

       21
       +
                   "type" => "object"

     

       22
       +
                 }

     

       23
       +
               },

     

       24
       +
               "type" => "procedure"

     

       25
       +
             }

     

       26
       +
           },

     

       27
       +
           "id" => "com.atproto.admin.updateAccountSigningKey",

     

       28
       +
           "lexicon" => 1

     

       29
       +
         })

     

       30
       +
       end

+61

lib/atproto/com/atproto/admin/updateSubjectStatus.ex

···

       1
       +
       defmodule Com.Atproto.Admin.UpdateSubjectStatus do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Update the service-specific admin status of a subject (account, record, or blob).",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "deactivated" => %{

     

       14
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       15
       +
                       "type" => "ref"

     

       16
       +
                     },

     

       17
       +
                     "subject" => %{

     

       18
       +
                       "refs" => [

     

       19
       +
                         "com.atproto.admin.defs#repoRef",

     

       20
       +
                         "com.atproto.repo.strongRef",

     

       21
       +
                         "com.atproto.admin.defs#repoBlobRef"

     

       22
       +
                       ],

     

       23
       +
                       "type" => "union"

     

       24
       +
                     },

     

       25
       +
                     "takedown" => %{

     

       26
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       27
       +
                       "type" => "ref"

     

       28
       +
                     }

     

       29
       +
                   },

     

       30
       +
                   "required" => ["subject"],

     

       31
       +
                   "type" => "object"

     

       32
       +
                 }

     

       33
       +
               },

     

       34
       +
               "output" => %{

     

       35
       +
                 "encoding" => "application/json",

     

       36
       +
                 "schema" => %{

     

       37
       +
                   "properties" => %{

     

       38
       +
                     "subject" => %{

     

       39
       +
                       "refs" => [

     

       40
       +
                         "com.atproto.admin.defs#repoRef",

     

       41
       +
                         "com.atproto.repo.strongRef",

     

       42
       +
                         "com.atproto.admin.defs#repoBlobRef"

     

       43
       +
                       ],

     

       44
       +
                       "type" => "union"

     

       45
       +
                     },

     

       46
       +
                     "takedown" => %{

     

       47
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       48
       +
                       "type" => "ref"

     

       49
       +
                     }

     

       50
       +
                   },

     

       51
       +
                   "required" => ["subject"],

     

       52
       +
                   "type" => "object"

     

       53
       +
                 }

     

       54
       +
               },

     

       55
       +
               "type" => "procedure"

     

       56
       +
             }

     

       57
       +
           },

     

       58
       +
           "id" => "com.atproto.admin.updateSubjectStatus",

     

       59
       +
           "lexicon" => 1

     

       60
       +
         })

     

       61
       +
       end

+27

lib/atproto/com/atproto/identity/defs.ex

···

       1
       +
       defmodule Com.Atproto.Identity.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "identityInfo" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       9
       +
                 "didDoc" => %{

     

       10
       +
                   "description" => "The complete DID document for the identity.",

     

       11
       +
                   "type" => "unknown"

     

       12
       +
                 },

     

       13
       +
                 "handle" => %{

     

       14
       +
                   "description" =>

     

       15
       +
                     "The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document.",

     

       16
       +
                   "format" => "handle",

     

       17
       +
                   "type" => "string"

     

       18
       +
                 }

     

       19
       +
               },

     

       20
       +
               "required" => ["did", "handle", "didDoc"],

     

       21
       +
               "type" => "object"

     

       22
       +
             }

     

       23
       +
           },

     

       24
       +
           "id" => "com.atproto.identity.defs",

     

       25
       +
           "lexicon" => 1

     

       26
       +
         })

     

       27
       +
       end

+35

lib/atproto/com/atproto/identity/getRecommendedDidCredentials.ex

···

       1
       +
       defmodule Com.Atproto.Identity.GetRecommendedDidCredentials do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Describe the credentials that should be included in the DID doc of an account that is migrating to this service.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "alsoKnownAs" => %{

     

       14
       +
                       "items" => %{"type" => "string"},

     

       15
       +
                       "type" => "array"

     

       16
       +
                     },

     

       17
       +
                     "rotationKeys" => %{

     

       18
       +
                       "description" =>

     

       19
       +
                         "Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs.",

     

       20
       +
                       "items" => %{"type" => "string"},

     

       21
       +
                       "type" => "array"

     

       22
       +
                     },

     

       23
       +
                     "services" => %{"type" => "unknown"},

     

       24
       +
                     "verificationMethods" => %{"type" => "unknown"}

     

       25
       +
                   },

     

       26
       +
                   "type" => "object"

     

       27
       +
                 }

     

       28
       +
               },

     

       29
       +
               "type" => "query"

     

       30
       +
             }

     

       31
       +
           },

     

       32
       +
           "id" => "com.atproto.identity.getRecommendedDidCredentials",

     

       33
       +
           "lexicon" => 1

     

       34
       +
         })

     

       35
       +
       end

+47

lib/atproto/com/atproto/identity/refreshIdentity.ex

···

       1
       +
       defmodule Com.Atproto.Identity.RefreshIdentity do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "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.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{

     

       11
       +
                   "description" =>

     

       12
       +
                     "The resolution process confirmed that the handle does not resolve to any DID.",

     

       13
       +
                   "name" => "HandleNotFound"

     

       14
       +
                 },

     

       15
       +
                 %{

     

       16
       +
                   "description" => "The DID resolution process confirmed that there is no current DID.",

     

       17
       +
                   "name" => "DidNotFound"

     

       18
       +
                 },

     

       19
       +
                 %{

     

       20
       +
                   "description" => "The DID previously existed, but has been deactivated.",

     

       21
       +
                   "name" => "DidDeactivated"

     

       22
       +
                 }

     

       23
       +
               ],

     

       24
       +
               "input" => %{

     

       25
       +
                 "encoding" => "application/json",

     

       26
       +
                 "schema" => %{

     

       27
       +
                   "properties" => %{

     

       28
       +
                     "identifier" => %{"format" => "at-identifier", "type" => "string"}

     

       29
       +
                   },

     

       30
       +
                   "required" => ["identifier"],

     

       31
       +
                   "type" => "object"

     

       32
       +
                 }

     

       33
       +
               },

     

       34
       +
               "output" => %{

     

       35
       +
                 "encoding" => "application/json",

     

       36
       +
                 "schema" => %{

     

       37
       +
                   "ref" => "com.atproto.identity.defs#identityInfo",

     

       38
       +
                   "type" => "ref"

     

       39
       +
                 }

     

       40
       +
               },

     

       41
       +
               "type" => "procedure"

     

       42
       +
             }

     

       43
       +
           },

     

       44
       +
           "id" => "com.atproto.identity.refreshIdentity",

     

       45
       +
           "lexicon" => 1

     

       46
       +
         })

     

       47
       +
       end

+15

lib/atproto/com/atproto/identity/requestPlcOperationSignature.ex

···

       1
       +
       defmodule Com.Atproto.Identity.RequestPlcOperationSignature do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Request an email with a code to in order to request a signed PLC operation. Requires Auth.",

     

       9
       +
               "type" => "procedure"

     

       10
       +
             }

     

       11
       +
           },

     

       12
       +
           "id" => "com.atproto.identity.requestPlcOperationSignature",

     

       13
       +
           "lexicon" => 1

     

       14
       +
         })

     

       15
       +
       end

+48

lib/atproto/com/atproto/identity/resolveDid.ex

···

       1
       +
       defmodule Com.Atproto.Identity.ResolveDid do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Resolves DID to DID document. Does not bi-directionally verify handle.",

     

       8
       +
               "errors" => [

     

       9
       +
                 %{

     

       10
       +
                   "description" => "The DID resolution process confirmed that there is no current DID.",

     

       11
       +
                   "name" => "DidNotFound"

     

       12
       +
                 },

     

       13
       +
                 %{

     

       14
       +
                   "description" => "The DID previously existed, but has been deactivated.",

     

       15
       +
                   "name" => "DidDeactivated"

     

       16
       +
                 }

     

       17
       +
               ],

     

       18
       +
               "output" => %{

     

       19
       +
                 "encoding" => "application/json",

     

       20
       +
                 "schema" => %{

     

       21
       +
                   "properties" => %{

     

       22
       +
                     "didDoc" => %{

     

       23
       +
                       "description" => "The complete DID document for the identity.",

     

       24
       +
                       "type" => "unknown"

     

       25
       +
                     }

     

       26
       +
                   },

     

       27
       +
                   "required" => ["didDoc"],

     

       28
       +
                   "type" => "object"

     

       29
       +
                 }

     

       30
       +
               },

     

       31
       +
               "parameters" => %{

     

       32
       +
                 "properties" => %{

     

       33
       +
                   "did" => %{

     

       34
       +
                     "description" => "DID to resolve.",

     

       35
       +
                     "format" => "did",

     

       36
       +
                     "type" => "string"

     

       37
       +
                   }

     

       38
       +
                 },

     

       39
       +
                 "required" => ["did"],

     

       40
       +
                 "type" => "params"

     

       41
       +
               },

     

       42
       +
               "type" => "query"

     

       43
       +
             }

     

       44
       +
           },

     

       45
       +
           "id" => "com.atproto.identity.resolveDid",

     

       46
       +
           "lexicon" => 1

     

       47
       +
         })

     

       48
       +
       end

+41

lib/atproto/com/atproto/identity/resolveHandle.ex

···

       1
       +
       defmodule Com.Atproto.Identity.ResolveHandle do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Resolves an atproto handle (hostname) to a DID. Does not necessarily bi-directionally verify against the the DID document.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{

     

       11
       +
                   "description" =>

     

       12
       +
                     "The resolution process confirmed that the handle does not resolve to any DID.",

     

       13
       +
                   "name" => "HandleNotFound"

     

       14
       +
                 }

     

       15
       +
               ],

     

       16
       +
               "output" => %{

     

       17
       +
                 "encoding" => "application/json",

     

       18
       +
                 "schema" => %{

     

       19
       +
                   "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       20
       +
                   "required" => ["did"],

     

       21
       +
                   "type" => "object"

     

       22
       +
                 }

     

       23
       +
               },

     

       24
       +
               "parameters" => %{

     

       25
       +
                 "properties" => %{

     

       26
       +
                   "handle" => %{

     

       27
       +
                     "description" => "The handle to resolve.",

     

       28
       +
                     "format" => "handle",

     

       29
       +
                     "type" => "string"

     

       30
       +
                   }

     

       31
       +
                 },

     

       32
       +
                 "required" => ["handle"],

     

       33
       +
                 "type" => "params"

     

       34
       +
               },

     

       35
       +
               "type" => "query"

     

       36
       +
             }

     

       37
       +
           },

     

       38
       +
           "id" => "com.atproto.identity.resolveHandle",

     

       39
       +
           "lexicon" => 1

     

       40
       +
         })

     

       41
       +
       end

+48

lib/atproto/com/atproto/identity/resolveIdentity.ex

···

       1
       +
       defmodule Com.Atproto.Identity.ResolveIdentity do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Resolves an identity (DID or Handle) to a full identity (DID document and verified handle).",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{

     

       11
       +
                   "description" =>

     

       12
       +
                     "The resolution process confirmed that the handle does not resolve to any DID.",

     

       13
       +
                   "name" => "HandleNotFound"

     

       14
       +
                 },

     

       15
       +
                 %{

     

       16
       +
                   "description" => "The DID resolution process confirmed that there is no current DID.",

     

       17
       +
                   "name" => "DidNotFound"

     

       18
       +
                 },

     

       19
       +
                 %{

     

       20
       +
                   "description" => "The DID previously existed, but has been deactivated.",

     

       21
       +
                   "name" => "DidDeactivated"

     

       22
       +
                 }

     

       23
       +
               ],

     

       24
       +
               "output" => %{

     

       25
       +
                 "encoding" => "application/json",

     

       26
       +
                 "schema" => %{

     

       27
       +
                   "ref" => "com.atproto.identity.defs#identityInfo",

     

       28
       +
                   "type" => "ref"

     

       29
       +
                 }

     

       30
       +
               },

     

       31
       +
               "parameters" => %{

     

       32
       +
                 "properties" => %{

     

       33
       +
                   "identifier" => %{

     

       34
       +
                     "description" => "Handle or DID to resolve.",

     

       35
       +
                     "format" => "at-identifier",

     

       36
       +
                     "type" => "string"

     

       37
       +
                   }

     

       38
       +
                 },

     

       39
       +
                 "required" => ["identifier"],

     

       40
       +
                 "type" => "params"

     

       41
       +
               },

     

       42
       +
               "type" => "query"

     

       43
       +
             }

     

       44
       +
           },

     

       45
       +
           "id" => "com.atproto.identity.resolveIdentity",

     

       46
       +
           "lexicon" => 1

     

       47
       +
         })

     

       48
       +
       end

+51

lib/atproto/com/atproto/identity/signPlcOperation.ex

···

       1
       +
       defmodule Com.Atproto.Identity.SignPlcOperation do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Signs a PLC operation to update some value(s) in the requesting DID's document.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "alsoKnownAs" => %{

     

       14
       +
                       "items" => %{"type" => "string"},

     

       15
       +
                       "type" => "array"

     

       16
       +
                     },

     

       17
       +
                     "rotationKeys" => %{

     

       18
       +
                       "items" => %{"type" => "string"},

     

       19
       +
                       "type" => "array"

     

       20
       +
                     },

     

       21
       +
                     "services" => %{"type" => "unknown"},

     

       22
       +
                     "token" => %{

     

       23
       +
                       "description" =>

     

       24
       +
                         "A token received through com.atproto.identity.requestPlcOperationSignature",

     

       25
       +
                       "type" => "string"

     

       26
       +
                     },

     

       27
       +
                     "verificationMethods" => %{"type" => "unknown"}

     

       28
       +
                   },

     

       29
       +
                   "type" => "object"

     

       30
       +
                 }

     

       31
       +
               },

     

       32
       +
               "output" => %{

     

       33
       +
                 "encoding" => "application/json",

     

       34
       +
                 "schema" => %{

     

       35
       +
                   "properties" => %{

     

       36
       +
                     "operation" => %{

     

       37
       +
                       "description" => "A signed DID PLC operation.",

     

       38
       +
                       "type" => "unknown"

     

       39
       +
                     }

     

       40
       +
                   },

     

       41
       +
                   "required" => ["operation"],

     

       42
       +
                   "type" => "object"

     

       43
       +
                 }

     

       44
       +
               },

     

       45
       +
               "type" => "procedure"

     

       46
       +
             }

     

       47
       +
           },

     

       48
       +
           "id" => "com.atproto.identity.signPlcOperation",

     

       49
       +
           "lexicon" => 1

     

       50
       +
         })

     

       51
       +
       end

+23

lib/atproto/com/atproto/identity/submitPlcOperation.ex

···

       1
       +
       defmodule Com.Atproto.Identity.SubmitPlcOperation do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Validates a PLC operation to ensure that it doesn't violate a service's constraints or get the identity into a bad state, then submits it to the PLC registry",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{"operation" => %{"type" => "unknown"}},

     

       13
       +
                   "required" => ["operation"],

     

       14
       +
                   "type" => "object"

     

       15
       +
                 }

     

       16
       +
               },

     

       17
       +
               "type" => "procedure"

     

       18
       +
             }

     

       19
       +
           },

     

       20
       +
           "id" => "com.atproto.identity.submitPlcOperation",

     

       21
       +
           "lexicon" => 1

     

       22
       +
         })

     

       23
       +
       end

+29

lib/atproto/com/atproto/identity/updateHandle.ex

···

       1
       +
       defmodule Com.Atproto.Identity.UpdateHandle do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Updates the current account's handle. Verifies handle validity, and updates did:plc document if necessary. Implemented by PDS, and requires auth.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "handle" => %{

     

       14
       +
                       "description" => "The new handle.",

     

       15
       +
                       "format" => "handle",

     

       16
       +
                       "type" => "string"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "required" => ["handle"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "type" => "procedure"

     

       24
       +
             }

     

       25
       +
           },

     

       26
       +
           "id" => "com.atproto.identity.updateHandle",

     

       27
       +
           "lexicon" => 1

     

       28
       +
         })

     

       29
       +
       end

+170

lib/atproto/com/atproto/label/defs.ex

···

       1
       +
       defmodule Com.Atproto.Label.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "label" => %{

     

       7
       +
               "description" => "Metadata tag on an atproto resource (eg, repo or record).",

     

       8
       +
               "properties" => %{

     

       9
       +
                 "cid" => %{

     

       10
       +
                   "description" =>

     

       11
       +
                     "Optionally, CID specifying the specific version of 'uri' resource this label applies to.",

     

       12
       +
                   "format" => "cid",

     

       13
       +
                   "type" => "string"

     

       14
       +
                 },

     

       15
       +
                 "cts" => %{

     

       16
       +
                   "description" => "Timestamp when this label was created.",

     

       17
       +
                   "format" => "datetime",

     

       18
       +
                   "type" => "string"

     

       19
       +
                 },

     

       20
       +
                 "exp" => %{

     

       21
       +
                   "description" => "Timestamp at which this label expires (no longer applies).",

     

       22
       +
                   "format" => "datetime",

     

       23
       +
                   "type" => "string"

     

       24
       +
                 },

     

       25
       +
                 "neg" => %{

     

       26
       +
                   "description" => "If true, this is a negation label, overwriting a previous label.",

     

       27
       +
                   "type" => "boolean"

     

       28
       +
                 },

     

       29
       +
                 "sig" => %{

     

       30
       +
                   "description" => "Signature of dag-cbor encoded label.",

     

       31
       +
                   "type" => "bytes"

     

       32
       +
                 },

     

       33
       +
                 "src" => %{

     

       34
       +
                   "description" => "DID of the actor who created this label.",

     

       35
       +
                   "format" => "did",

     

       36
       +
                   "type" => "string"

     

       37
       +
                 },

     

       38
       +
                 "uri" => %{

     

       39
       +
                   "description" =>

     

       40
       +
                     "AT URI of the record, repository (account), or other resource that this label applies to.",

     

       41
       +
                   "format" => "uri",

     

       42
       +
                   "type" => "string"

     

       43
       +
                 },

     

       44
       +
                 "val" => %{

     

       45
       +
                   "description" => "The short string name of the value or type of this label.",

     

       46
       +
                   "maxLength" => 128,

     

       47
       +
                   "type" => "string"

     

       48
       +
                 },

     

       49
       +
                 "ver" => %{

     

       50
       +
                   "description" => "The AT Protocol version of the label object.",

     

       51
       +
                   "type" => "integer"

     

       52
       +
                 }

     

       53
       +
               },

     

       54
       +
               "required" => ["src", "uri", "val", "cts"],

     

       55
       +
               "type" => "object"

     

       56
       +
             },

     

       57
       +
             "labelValue" => %{

     

       58
       +
               "knownValues" => [

     

       59
       +
                 "!hide",

     

       60
       +
                 "!no-promote",

     

       61
       +
                 "!warn",

     

       62
       +
                 "!no-unauthenticated",

     

       63
       +
                 "dmca-violation",

     

       64
       +
                 "doxxing",

     

       65
       +
                 "porn",

     

       66
       +
                 "sexual",

     

       67
       +
                 "nudity",

     

       68
       +
                 "nsfl",

     

       69
       +
                 "gore"

     

       70
       +
               ],

     

       71
       +
               "type" => "string"

     

       72
       +
             },

     

       73
       +
             "labelValueDefinition" => %{

     

       74
       +
               "description" => "Declares a label value and its expected interpretations and behaviors.",

     

       75
       +
               "properties" => %{

     

       76
       +
                 "adultOnly" => %{

     

       77
       +
                   "description" =>

     

       78
       +
                     "Does the user need to have adult content enabled in order to configure this label?",

     

       79
       +
                   "type" => "boolean"

     

       80
       +
                 },

     

       81
       +
                 "blurs" => %{

     

       82
       +
                   "description" =>

     

       83
       +
                     "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",

     

       84
       +
                   "knownValues" => ["content", "media", "none"],

     

       85
       +
                   "type" => "string"

     

       86
       +
                 },

     

       87
       +
                 "defaultSetting" => %{

     

       88
       +
                   "default" => "warn",

     

       89
       +
                   "description" => "The default setting for this label.",

     

       90
       +
                   "knownValues" => ["ignore", "warn", "hide"],

     

       91
       +
                   "type" => "string"

     

       92
       +
                 },

     

       93
       +
                 "identifier" => %{

     

       94
       +
                   "description" =>

     

       95
       +
                     "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",

     

       96
       +
                   "maxGraphemes" => 100,

     

       97
       +
                   "maxLength" => 100,

     

       98
       +
                   "type" => "string"

     

       99
       +
                 },

     

       100
       +
                 "locales" => %{

     

       101
       +
                   "items" => %{"ref" => "#labelValueDefinitionStrings", "type" => "ref"},

     

       102
       +
                   "type" => "array"

     

       103
       +
                 },

     

       104
       +
                 "severity" => %{

     

       105
       +
                   "description" =>

     

       106
       +
                     "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",

     

       107
       +
                   "knownValues" => ["inform", "alert", "none"],

     

       108
       +
                   "type" => "string"

     

       109
       +
                 }

     

       110
       +
               },

     

       111
       +
               "required" => ["identifier", "severity", "blurs", "locales"],

     

       112
       +
               "type" => "object"

     

       113
       +
             },

     

       114
       +
             "labelValueDefinitionStrings" => %{

     

       115
       +
               "description" =>

     

       116
       +
                 "Strings which describe the label in the UI, localized into a specific language.",

     

       117
       +
               "properties" => %{

     

       118
       +
                 "description" => %{

     

       119
       +
                   "description" =>

     

       120
       +
                     "A longer description of what the label means and why it might be applied.",

     

       121
       +
                   "maxGraphemes" => 10000,

     

       122
       +
                   "maxLength" => 100_000,

     

       123
       +
                   "type" => "string"

     

       124
       +
                 },

     

       125
       +
                 "lang" => %{

     

       126
       +
                   "description" => "The code of the language these strings are written in.",

     

       127
       +
                   "format" => "language",

     

       128
       +
                   "type" => "string"

     

       129
       +
                 },

     

       130
       +
                 "name" => %{

     

       131
       +
                   "description" => "A short human-readable name for the label.",

     

       132
       +
                   "maxGraphemes" => 64,

     

       133
       +
                   "maxLength" => 640,

     

       134
       +
                   "type" => "string"

     

       135
       +
                 }

     

       136
       +
               },

     

       137
       +
               "required" => ["lang", "name", "description"],

     

       138
       +
               "type" => "object"

     

       139
       +
             },

     

       140
       +
             "selfLabel" => %{

     

       141
       +
               "description" =>

     

       142
       +
                 "Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.",

     

       143
       +
               "properties" => %{

     

       144
       +
                 "val" => %{

     

       145
       +
                   "description" => "The short string name of the value or type of this label.",

     

       146
       +
                   "maxLength" => 128,

     

       147
       +
                   "type" => "string"

     

       148
       +
                 }

     

       149
       +
               },

     

       150
       +
               "required" => ["val"],

     

       151
       +
               "type" => "object"

     

       152
       +
             },

     

       153
       +
             "selfLabels" => %{

     

       154
       +
               "description" =>

     

       155
       +
                 "Metadata tags on an atproto record, published by the author within the record.",

     

       156
       +
               "properties" => %{

     

       157
       +
                 "values" => %{

     

       158
       +
                   "items" => %{"ref" => "#selfLabel", "type" => "ref"},

     

       159
       +
                   "maxLength" => 10,

     

       160
       +
                   "type" => "array"

     

       161
       +
                 }

     

       162
       +
               },

     

       163
       +
               "required" => ["values"],

     

       164
       +
               "type" => "object"

     

       165
       +
             }

     

       166
       +
           },

     

       167
       +
           "id" => "com.atproto.label.defs",

     

       168
       +
           "lexicon" => 1

     

       169
       +
         })

     

       170
       +
       end

+56

lib/atproto/com/atproto/label/queryLabels.ex

···

       1
       +
       defmodule Com.Atproto.Label.QueryLabels do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Find labels relevant to the provided AT-URI patterns. Public endpoint for moderation services, though may return different or additional results with auth.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       +
                     "labels" => %{

     

       15
       +
                       "items" => %{

     

       16
       +
                         "ref" => "com.atproto.label.defs#label",

     

       17
       +
                         "type" => "ref"

     

       18
       +
                       },

     

       19
       +
                       "type" => "array"

     

       20
       +
                     }

     

       21
       +
                   },

     

       22
       +
                   "required" => ["labels"],

     

       23
       +
                   "type" => "object"

     

       24
       +
                 }

     

       25
       +
               },

     

       26
       +
               "parameters" => %{

     

       27
       +
                 "properties" => %{

     

       28
       +
                   "cursor" => %{"type" => "string"},

     

       29
       +
                   "limit" => %{

     

       30
       +
                     "default" => 50,

     

       31
       +
                     "maximum" => 250,

     

       32
       +
                     "minimum" => 1,

     

       33
       +
                     "type" => "integer"

     

       34
       +
                   },

     

       35
       +
                   "sources" => %{

     

       36
       +
                     "description" => "Optional list of label sources (DIDs) to filter on.",

     

       37
       +
                     "items" => %{"format" => "did", "type" => "string"},

     

       38
       +
                     "type" => "array"

     

       39
       +
                   },

     

       40
       +
                   "uriPatterns" => %{

     

       41
       +
                     "description" =>

     

       42
       +
                       "List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI.",

     

       43
       +
                     "items" => %{"type" => "string"},

     

       44
       +
                     "type" => "array"

     

       45
       +
                   }

     

       46
       +
                 },

     

       47
       +
                 "required" => ["uriPatterns"],

     

       48
       +
                 "type" => "params"

     

       49
       +
               },

     

       50
       +
               "type" => "query"

     

       51
       +
             }

     

       52
       +
           },

     

       53
       +
           "id" => "com.atproto.label.queryLabels",

     

       54
       +
           "lexicon" => 1

     

       55
       +
         })

     

       56
       +
       end

+47

lib/atproto/com/atproto/label/subscribeLabels.ex

···

       1
       +
       defmodule Com.Atproto.Label.SubscribeLabels do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "info" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "message" => %{"type" => "string"},

     

       9
       +
                 "name" => %{"knownValues" => ["OutdatedCursor"], "type" => "string"}

     

       10
       +
               },

     

       11
       +
               "required" => ["name"],

     

       12
       +
               "type" => "object"

     

       13
       +
             },

     

       14
       +
             "labels" => %{

     

       15
       +
               "properties" => %{

     

       16
       +
                 "labels" => %{

     

       17
       +
                   "items" => %{"ref" => "com.atproto.label.defs#label", "type" => "ref"},

     

       18
       +
                   "type" => "array"

     

       19
       +
                 },

     

       20
       +
                 "seq" => %{"type" => "integer"}

     

       21
       +
               },

     

       22
       +
               "required" => ["seq", "labels"],

     

       23
       +
               "type" => "object"

     

       24
       +
             },

     

       25
       +
             "main" => %{

     

       26
       +
               "description" =>

     

       27
       +
                 "Subscribe to stream of labels (and negations). Public endpoint implemented by mod services. Uses same sequencing scheme as repo event stream.",

     

       28
       +
               "errors" => [%{"name" => "FutureCursor"}],

     

       29
       +
               "message" => %{

     

       30
       +
                 "schema" => %{"refs" => ["#labels", "#info"], "type" => "union"}

     

       31
       +
               },

     

       32
       +
               "parameters" => %{

     

       33
       +
                 "properties" => %{

     

       34
       +
                   "cursor" => %{

     

       35
       +
                     "description" => "The last known event seq number to backfill from.",

     

       36
       +
                     "type" => "integer"

     

       37
       +
                   }

     

       38
       +
                 },

     

       39
       +
                 "type" => "params"

     

       40
       +
               },

     

       41
       +
               "type" => "subscription"

     

       42
       +
             }

     

       43
       +
           },

     

       44
       +
           "id" => "com.atproto.label.subscribeLabels",

     

       45
       +
           "lexicon" => 1

     

       46
       +
         })

     

       47
       +
       end

+27

lib/atproto/com/atproto/lexicon/schema.ex

···

       1
       +
       defmodule Com.Atproto.Lexicon.Schema do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Representation of Lexicon schemas themselves, when published as atproto records. Note that the schema language is not defined in Lexicon; this meta schema currently only includes a single version field ('lexicon'). See the atproto specifications for description of the other expected top-level fields ('id', 'defs', etc).",

     

       9
       +
               "key" => "nsid",

     

       10
       +
               "record" => %{

     

       11
       +
                 "properties" => %{

     

       12
       +
                   "lexicon" => %{

     

       13
       +
                     "description" =>

     

       14
       +
                       "Indicates the 'version' of the Lexicon language. Must be '1' for the current atproto/Lexicon schema system.",

     

       15
       +
                     "type" => "integer"

     

       16
       +
                   }

     

       17
       +
                 },

     

       18
       +
                 "required" => ["lexicon"],

     

       19
       +
                 "type" => "object"

     

       20
       +
               },

     

       21
       +
               "type" => "record"

     

       22
       +
             }

     

       23
       +
           },

     

       24
       +
           "id" => "com.atproto.lexicon.schema",

     

       25
       +
           "lexicon" => 1

     

       26
       +
         })

     

       27
       +
       end

+81

lib/atproto/com/atproto/moderation/createReport.ex

···

       1
       +
       defmodule Com.Atproto.Moderation.CreateReport do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Submit a moderation report regarding an atproto account or record. Implemented by moderation services (with PDS proxying), and requires auth.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "modTool" => %{"ref" => "#modTool", "type" => "ref"},

     

       14
       +
                     "reason" => %{

     

       15
       +
                       "description" => "Additional context about the content and violation.",

     

       16
       +
                       "maxGraphemes" => 2000,

     

       17
       +
                       "maxLength" => 20000,

     

       18
       +
                       "type" => "string"

     

       19
       +
                     },

     

       20
       +
                     "reasonType" => %{

     

       21
       +
                       "description" => "Indicates the broad category of violation the report is for.",

     

       22
       +
                       "ref" => "com.atproto.moderation.defs#reasonType",

     

       23
       +
                       "type" => "ref"

     

       24
       +
                     },

     

       25
       +
                     "subject" => %{

     

       26
       +
                       "refs" => ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"],

     

       27
       +
                       "type" => "union"

     

       28
       +
                     }

     

       29
       +
                   },

     

       30
       +
                   "required" => ["reasonType", "subject"],

     

       31
       +
                   "type" => "object"

     

       32
       +
                 }

     

       33
       +
               },

     

       34
       +
               "output" => %{

     

       35
       +
                 "encoding" => "application/json",

     

       36
       +
                 "schema" => %{

     

       37
       +
                   "properties" => %{

     

       38
       +
                     "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       39
       +
                     "id" => %{"type" => "integer"},

     

       40
       +
                     "reason" => %{

     

       41
       +
                       "maxGraphemes" => 2000,

     

       42
       +
                       "maxLength" => 20000,

     

       43
       +
                       "type" => "string"

     

       44
       +
                     },

     

       45
       +
                     "reasonType" => %{

     

       46
       +
                       "ref" => "com.atproto.moderation.defs#reasonType",

     

       47
       +
                       "type" => "ref"

     

       48
       +
                     },

     

       49
       +
                     "reportedBy" => %{"format" => "did", "type" => "string"},

     

       50
       +
                     "subject" => %{

     

       51
       +
                       "refs" => ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"],

     

       52
       +
                       "type" => "union"

     

       53
       +
                     }

     

       54
       +
                   },

     

       55
       +
                   "required" => ["id", "reasonType", "subject", "reportedBy", "createdAt"],

     

       56
       +
                   "type" => "object"

     

       57
       +
                 }

     

       58
       +
               },

     

       59
       +
               "type" => "procedure"

     

       60
       +
             },

     

       61
       +
             "modTool" => %{

     

       62
       +
               "description" => "Moderation tool information for tracing the source of the action",

     

       63
       +
               "properties" => %{

     

       64
       +
                 "meta" => %{

     

       65
       +
                   "description" => "Additional arbitrary metadata about the source",

     

       66
       +
                   "type" => "unknown"

     

       67
       +
                 },

     

       68
       +
                 "name" => %{

     

       69
       +
                   "description" =>

     

       70
       +
                     "Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome')",

     

       71
       +
                   "type" => "string"

     

       72
       +
                 }

     

       73
       +
               },

     

       74
       +
               "required" => ["name"],

     

       75
       +
               "type" => "object"

     

       76
       +
             }

     

       77
       +
           },

     

       78
       +
           "id" => "com.atproto.moderation.createReport",

     

       79
       +
           "lexicon" => 1

     

       80
       +
         })

     

       81
       +
       end

+101

lib/atproto/com/atproto/moderation/defs.ex

···

       1
       +
       defmodule Com.Atproto.Moderation.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "reasonAppeal" => %{

     

       7
       +
               "description" => "Appeal a previously taken moderation action",

     

       8
       +
               "type" => "token"

     

       9
       +
             },

     

       10
       +
             "reasonMisleading" => %{

     

       11
       +
               "description" =>

     

       12
       +
                 "Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`.",

     

       13
       +
               "type" => "token"

     

       14
       +
             },

     

       15
       +
             "reasonOther" => %{

     

       16
       +
               "description" =>

     

       17
       +
                 "Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`.",

     

       18
       +
               "type" => "token"

     

       19
       +
             },

     

       20
       +
             "reasonRude" => %{

     

       21
       +
               "description" =>

     

       22
       +
                 "Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`.",

     

       23
       +
               "type" => "token"

     

       24
       +
             },

     

       25
       +
             "reasonSexual" => %{

     

       26
       +
               "description" =>

     

       27
       +
                 "Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`.",

     

       28
       +
               "type" => "token"

     

       29
       +
             },

     

       30
       +
             "reasonSpam" => %{

     

       31
       +
               "description" =>

     

       32
       +
                 "Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`.",

     

       33
       +
               "type" => "token"

     

       34
       +
             },

     

       35
       +
             "reasonType" => %{

     

       36
       +
               "knownValues" => [

     

       37
       +
                 "com.atproto.moderation.defs#reasonSpam",

     

       38
       +
                 "com.atproto.moderation.defs#reasonViolation",

     

       39
       +
                 "com.atproto.moderation.defs#reasonMisleading",

     

       40
       +
                 "com.atproto.moderation.defs#reasonSexual",

     

       41
       +
                 "com.atproto.moderation.defs#reasonRude",

     

       42
       +
                 "com.atproto.moderation.defs#reasonOther",

     

       43
       +
                 "com.atproto.moderation.defs#reasonAppeal",

     

       44
       +
                 "tools.ozone.report.defs#reasonAppeal",

     

       45
       +
                 "tools.ozone.report.defs#reasonOther",

     

       46
       +
                 "tools.ozone.report.defs#reasonViolenceAnimal",

     

       47
       +
                 "tools.ozone.report.defs#reasonViolenceThreats",

     

       48
       +
                 "tools.ozone.report.defs#reasonViolenceGraphicContent",

     

       49
       +
                 "tools.ozone.report.defs#reasonViolenceGlorification",

     

       50
       +
                 "tools.ozone.report.defs#reasonViolenceExtremistContent",

     

       51
       +
                 "tools.ozone.report.defs#reasonViolenceTrafficking",

     

       52
       +
                 "tools.ozone.report.defs#reasonViolenceOther",

     

       53
       +
                 "tools.ozone.report.defs#reasonSexualAbuseContent",

     

       54
       +
                 "tools.ozone.report.defs#reasonSexualNCII",

     

       55
       +
                 "tools.ozone.report.defs#reasonSexualDeepfake",

     

       56
       +
                 "tools.ozone.report.defs#reasonSexualAnimal",

     

       57
       +
                 "tools.ozone.report.defs#reasonSexualUnlabeled",

     

       58
       +
                 "tools.ozone.report.defs#reasonSexualOther",

     

       59
       +
                 "tools.ozone.report.defs#reasonChildSafetyCSAM",

     

       60
       +
                 "tools.ozone.report.defs#reasonChildSafetyGroom",

     

       61
       +
                 "tools.ozone.report.defs#reasonChildSafetyPrivacy",

     

       62
       +
                 "tools.ozone.report.defs#reasonChildSafetyHarassment",

     

       63
       +
                 "tools.ozone.report.defs#reasonChildSafetyOther",

     

       64
       +
                 "tools.ozone.report.defs#reasonHarassmentTroll",

     

       65
       +
                 "tools.ozone.report.defs#reasonHarassmentTargeted",

     

       66
       +
                 "tools.ozone.report.defs#reasonHarassmentHateSpeech",

     

       67
       +
                 "tools.ozone.report.defs#reasonHarassmentDoxxing",

     

       68
       +
                 "tools.ozone.report.defs#reasonHarassmentOther",

     

       69
       +
                 "tools.ozone.report.defs#reasonMisleadingBot",

     

       70
       +
                 "tools.ozone.report.defs#reasonMisleadingImpersonation",

     

       71
       +
                 "tools.ozone.report.defs#reasonMisleadingSpam",

     

       72
       +
                 "tools.ozone.report.defs#reasonMisleadingScam",

     

       73
       +
                 "tools.ozone.report.defs#reasonMisleadingElections",

     

       74
       +
                 "tools.ozone.report.defs#reasonMisleadingOther",

     

       75
       +
                 "tools.ozone.report.defs#reasonRuleSiteSecurity",

     

       76
       +
                 "tools.ozone.report.defs#reasonRuleProhibitedSales",

     

       77
       +
                 "tools.ozone.report.defs#reasonRuleBanEvasion",

     

       78
       +
                 "tools.ozone.report.defs#reasonRuleOther",

     

       79
       +
                 "tools.ozone.report.defs#reasonSelfHarmContent",

     

       80
       +
                 "tools.ozone.report.defs#reasonSelfHarmED",

     

       81
       +
                 "tools.ozone.report.defs#reasonSelfHarmStunts",

     

       82
       +
                 "tools.ozone.report.defs#reasonSelfHarmSubstances",

     

       83
       +
                 "tools.ozone.report.defs#reasonSelfHarmOther"

     

       84
       +
               ],

     

       85
       +
               "type" => "string"

     

       86
       +
             },

     

       87
       +
             "reasonViolation" => %{

     

       88
       +
               "description" =>

     

       89
       +
                 "Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`.",

     

       90
       +
               "type" => "token"

     

       91
       +
             },

     

       92
       +
             "subjectType" => %{

     

       93
       +
               "description" => "Tag describing a type of subject that might be reported.",

     

       94
       +
               "knownValues" => ["account", "record", "chat"],

     

       95
       +
               "type" => "string"

     

       96
       +
             }

     

       97
       +
           },

     

       98
       +
           "id" => "com.atproto.moderation.defs",

     

       99
       +
           "lexicon" => 1

     

       100
       +
         })

     

       101
       +
       end

+140

lib/atproto/com/atproto/repo/applyWrites.ex

···

       1
       +
       defmodule Com.Atproto.Repo.ApplyWrites do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "create" => %{

     

       7
       +
               "description" => "Operation which creates a new record.",

     

       8
       +
               "properties" => %{

     

       9
       +
                 "collection" => %{"format" => "nsid", "type" => "string"},

     

       10
       +
                 "rkey" => %{

     

       11
       +
                   "description" =>

     

       12
       +
                     "NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility.",

     

       13
       +
                   "format" => "record-key",

     

       14
       +
                   "maxLength" => 512,

     

       15
       +
                   "type" => "string"

     

       16
       +
                 },

     

       17
       +
                 "value" => %{"type" => "unknown"}

     

       18
       +
               },

     

       19
       +
               "required" => ["collection", "value"],

     

       20
       +
               "type" => "object"

     

       21
       +
             },

     

       22
       +
             "createResult" => %{

     

       23
       +
               "properties" => %{

     

       24
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       25
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"},

     

       26
       +
                 "validationStatus" => %{

     

       27
       +
                   "knownValues" => ["valid", "unknown"],

     

       28
       +
                   "type" => "string"

     

       29
       +
                 }

     

       30
       +
               },

     

       31
       +
               "required" => ["uri", "cid"],

     

       32
       +
               "type" => "object"

     

       33
       +
             },

     

       34
       +
             "delete" => %{

     

       35
       +
               "description" => "Operation which deletes an existing record.",

     

       36
       +
               "properties" => %{

     

       37
       +
                 "collection" => %{"format" => "nsid", "type" => "string"},

     

       38
       +
                 "rkey" => %{"format" => "record-key", "type" => "string"}

     

       39
       +
               },

     

       40
       +
               "required" => ["collection", "rkey"],

     

       41
       +
               "type" => "object"

     

       42
       +
             },

     

       43
       +
             "deleteResult" => %{

     

       44
       +
               "properties" => %{},

     

       45
       +
               "required" => [],

     

       46
       +
               "type" => "object"

     

       47
       +
             },

     

       48
       +
             "main" => %{

     

       49
       +
               "description" =>

     

       50
       +
                 "Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.",

     

       51
       +
               "errors" => [

     

       52
       +
                 %{

     

       53
       +
                   "description" =>

     

       54
       +
                     "Indicates that the 'swapCommit' parameter did not match current commit.",

     

       55
       +
                   "name" => "InvalidSwap"

     

       56
       +
                 }

     

       57
       +
               ],

     

       58
       +
               "input" => %{

     

       59
       +
                 "encoding" => "application/json",

     

       60
       +
                 "schema" => %{

     

       61
       +
                   "properties" => %{

     

       62
       +
                     "repo" => %{

     

       63
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       64
       +
                       "format" => "at-identifier",

     

       65
       +
                       "type" => "string"

     

       66
       +
                     },

     

       67
       +
                     "swapCommit" => %{

     

       68
       +
                       "description" =>

     

       69
       +
                         "If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations.",

     

       70
       +
                       "format" => "cid",

     

       71
       +
                       "type" => "string"

     

       72
       +
                     },

     

       73
       +
                     "validate" => %{

     

       74
       +
                       "description" =>

     

       75
       +
                         "Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons.",

     

       76
       +
                       "type" => "boolean"

     

       77
       +
                     },

     

       78
       +
                     "writes" => %{

     

       79
       +
                       "items" => %{

     

       80
       +
                         "closed" => true,

     

       81
       +
                         "refs" => ["#create", "#update", "#delete"],

     

       82
       +
                         "type" => "union"

     

       83
       +
                       },

     

       84
       +
                       "type" => "array"

     

       85
       +
                     }

     

       86
       +
                   },

     

       87
       +
                   "required" => ["repo", "writes"],

     

       88
       +
                   "type" => "object"

     

       89
       +
                 }

     

       90
       +
               },

     

       91
       +
               "output" => %{

     

       92
       +
                 "encoding" => "application/json",

     

       93
       +
                 "schema" => %{

     

       94
       +
                   "properties" => %{

     

       95
       +
                     "commit" => %{

     

       96
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       97
       +
                       "type" => "ref"

     

       98
       +
                     },

     

       99
       +
                     "results" => %{

     

       100
       +
                       "items" => %{

     

       101
       +
                         "closed" => true,

     

       102
       +
                         "refs" => ["#createResult", "#updateResult", "#deleteResult"],

     

       103
       +
                         "type" => "union"

     

       104
       +
                       },

     

       105
       +
                       "type" => "array"

     

       106
       +
                     }

     

       107
       +
                   },

     

       108
       +
                   "required" => [],

     

       109
       +
                   "type" => "object"

     

       110
       +
                 }

     

       111
       +
               },

     

       112
       +
               "type" => "procedure"

     

       113
       +
             },

     

       114
       +
             "update" => %{

     

       115
       +
               "description" => "Operation which updates an existing record.",

     

       116
       +
               "properties" => %{

     

       117
       +
                 "collection" => %{"format" => "nsid", "type" => "string"},

     

       118
       +
                 "rkey" => %{"format" => "record-key", "type" => "string"},

     

       119
       +
                 "value" => %{"type" => "unknown"}

     

       120
       +
               },

     

       121
       +
               "required" => ["collection", "rkey", "value"],

     

       122
       +
               "type" => "object"

     

       123
       +
             },

     

       124
       +
             "updateResult" => %{

     

       125
       +
               "properties" => %{

     

       126
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       127
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"},

     

       128
       +
                 "validationStatus" => %{

     

       129
       +
                   "knownValues" => ["valid", "unknown"],

     

       130
       +
                   "type" => "string"

     

       131
       +
                 }

     

       132
       +
               },

     

       133
       +
               "required" => ["uri", "cid"],

     

       134
       +
               "type" => "object"

     

       135
       +
             }

     

       136
       +
           },

     

       137
       +
           "id" => "com.atproto.repo.applyWrites",

     

       138
       +
           "lexicon" => 1

     

       139
       +
         })

     

       140
       +
       end

+79

lib/atproto/com/atproto/repo/createRecord.ex

···

       1
       +
       defmodule Com.Atproto.Repo.CreateRecord do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Create a single new repository record. Requires auth, implemented by PDS.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{

     

       11
       +
                   "description" => "Indicates that 'swapCommit' didn't match current repo commit.",

     

       12
       +
                   "name" => "InvalidSwap"

     

       13
       +
                 }

     

       14
       +
               ],

     

       15
       +
               "input" => %{

     

       16
       +
                 "encoding" => "application/json",

     

       17
       +
                 "schema" => %{

     

       18
       +
                   "properties" => %{

     

       19
       +
                     "collection" => %{

     

       20
       +
                       "description" => "The NSID of the record collection.",

     

       21
       +
                       "format" => "nsid",

     

       22
       +
                       "type" => "string"

     

       23
       +
                     },

     

       24
       +
                     "record" => %{

     

       25
       +
                       "description" => "The record itself. Must contain a $type field.",

     

       26
       +
                       "type" => "unknown"

     

       27
       +
                     },

     

       28
       +
                     "repo" => %{

     

       29
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       30
       +
                       "format" => "at-identifier",

     

       31
       +
                       "type" => "string"

     

       32
       +
                     },

     

       33
       +
                     "rkey" => %{

     

       34
       +
                       "description" => "The Record Key.",

     

       35
       +
                       "format" => "record-key",

     

       36
       +
                       "maxLength" => 512,

     

       37
       +
                       "type" => "string"

     

       38
       +
                     },

     

       39
       +
                     "swapCommit" => %{

     

       40
       +
                       "description" => "Compare and swap with the previous commit by CID.",

     

       41
       +
                       "format" => "cid",

     

       42
       +
                       "type" => "string"

     

       43
       +
                     },

     

       44
       +
                     "validate" => %{

     

       45
       +
                       "description" =>

     

       46
       +
                         "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",

     

       47
       +
                       "type" => "boolean"

     

       48
       +
                     }

     

       49
       +
                   },

     

       50
       +
                   "required" => ["repo", "collection", "record"],

     

       51
       +
                   "type" => "object"

     

       52
       +
                 }

     

       53
       +
               },

     

       54
       +
               "output" => %{

     

       55
       +
                 "encoding" => "application/json",

     

       56
       +
                 "schema" => %{

     

       57
       +
                   "properties" => %{

     

       58
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       59
       +
                     "commit" => %{

     

       60
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       61
       +
                       "type" => "ref"

     

       62
       +
                     },

     

       63
       +
                     "uri" => %{"format" => "at-uri", "type" => "string"},

     

       64
       +
                     "validationStatus" => %{

     

       65
       +
                       "knownValues" => ["valid", "unknown"],

     

       66
       +
                       "type" => "string"

     

       67
       +
                     }

     

       68
       +
                   },

     

       69
       +
                   "required" => ["uri", "cid"],

     

       70
       +
                   "type" => "object"

     

       71
       +
                 }

     

       72
       +
               },

     

       73
       +
               "type" => "procedure"

     

       74
       +
             }

     

       75
       +
           },

     

       76
       +
           "id" => "com.atproto.repo.createRecord",

     

       77
       +
           "lexicon" => 1

     

       78
       +
         })

     

       79
       +
       end

+18

lib/atproto/com/atproto/repo/defs.ex

···

       1
       +
       defmodule Com.Atproto.Repo.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "commitMeta" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       9
       +
                 "rev" => %{"format" => "tid", "type" => "string"}

     

       10
       +
               },

     

       11
       +
               "required" => ["cid", "rev"],

     

       12
       +
               "type" => "object"

     

       13
       +
             }

     

       14
       +
           },

     

       15
       +
           "id" => "com.atproto.repo.defs",

     

       16
       +
           "lexicon" => 1

     

       17
       +
         })

     

       18
       +
       end

+62

lib/atproto/com/atproto/repo/deleteRecord.ex

···

       1
       +
       defmodule Com.Atproto.Repo.DeleteRecord do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.",

     

       9
       +
               "errors" => [%{"name" => "InvalidSwap"}],

     

       10
       +
               "input" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{

     

       14
       +
                     "collection" => %{

     

       15
       +
                       "description" => "The NSID of the record collection.",

     

       16
       +
                       "format" => "nsid",

     

       17
       +
                       "type" => "string"

     

       18
       +
                     },

     

       19
       +
                     "repo" => %{

     

       20
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       21
       +
                       "format" => "at-identifier",

     

       22
       +
                       "type" => "string"

     

       23
       +
                     },

     

       24
       +
                     "rkey" => %{

     

       25
       +
                       "description" => "The Record Key.",

     

       26
       +
                       "format" => "record-key",

     

       27
       +
                       "type" => "string"

     

       28
       +
                     },

     

       29
       +
                     "swapCommit" => %{

     

       30
       +
                       "description" => "Compare and swap with the previous commit by CID.",

     

       31
       +
                       "format" => "cid",

     

       32
       +
                       "type" => "string"

     

       33
       +
                     },

     

       34
       +
                     "swapRecord" => %{

     

       35
       +
                       "description" => "Compare and swap with the previous record by CID.",

     

       36
       +
                       "format" => "cid",

     

       37
       +
                       "type" => "string"

     

       38
       +
                     }

     

       39
       +
                   },

     

       40
       +
                   "required" => ["repo", "collection", "rkey"],

     

       41
       +
                   "type" => "object"

     

       42
       +
                 }

     

       43
       +
               },

     

       44
       +
               "output" => %{

     

       45
       +
                 "encoding" => "application/json",

     

       46
       +
                 "schema" => %{

     

       47
       +
                   "properties" => %{

     

       48
       +
                     "commit" => %{

     

       49
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       50
       +
                       "type" => "ref"

     

       51
       +
                     }

     

       52
       +
                   },

     

       53
       +
                   "type" => "object"

     

       54
       +
                 }

     

       55
       +
               },

     

       56
       +
               "type" => "procedure"

     

       57
       +
             }

     

       58
       +
           },

     

       59
       +
           "id" => "com.atproto.repo.deleteRecord",

     

       60
       +
           "lexicon" => 1

     

       61
       +
         })

     

       62
       +
       end

+52

lib/atproto/com/atproto/repo/describeRepo.ex

···

       1
       +
       defmodule Com.Atproto.Repo.DescribeRepo do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get information about an account and repository, including the list of collections. Does not require auth.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "collections" => %{

     

       14
       +
                       "description" =>

     

       15
       +
                         "List of all the collections (NSIDs) for which this repo contains at least one record.",

     

       16
       +
                       "items" => %{"format" => "nsid", "type" => "string"},

     

       17
       +
                       "type" => "array"

     

       18
       +
                     },

     

       19
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       20
       +
                     "didDoc" => %{

     

       21
       +
                       "description" => "The complete DID document for this account.",

     

       22
       +
                       "type" => "unknown"

     

       23
       +
                     },

     

       24
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       25
       +
                     "handleIsCorrect" => %{

     

       26
       +
                       "description" =>

     

       27
       +
                         "Indicates if handle is currently valid (resolves bi-directionally)",

     

       28
       +
                       "type" => "boolean"

     

       29
       +
                     }

     

       30
       +
                   },

     

       31
       +
                   "required" => ["handle", "did", "didDoc", "collections", "handleIsCorrect"],

     

       32
       +
                   "type" => "object"

     

       33
       +
                 }

     

       34
       +
               },

     

       35
       +
               "parameters" => %{

     

       36
       +
                 "properties" => %{

     

       37
       +
                   "repo" => %{

     

       38
       +
                     "description" => "The handle or DID of the repo.",

     

       39
       +
                     "format" => "at-identifier",

     

       40
       +
                     "type" => "string"

     

       41
       +
                   }

     

       42
       +
                 },

     

       43
       +
                 "required" => ["repo"],

     

       44
       +
                 "type" => "params"

     

       45
       +
               },

     

       46
       +
               "type" => "query"

     

       47
       +
             }

     

       48
       +
           },

     

       49
       +
           "id" => "com.atproto.repo.describeRepo",

     

       50
       +
           "lexicon" => 1

     

       51
       +
         })

     

       52
       +
       end

+54

lib/atproto/com/atproto/repo/getRecord.ex

···

       1
       +
       defmodule Com.Atproto.Repo.GetRecord do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get a single record from a repository. Does not require auth.",

     

       8
       +
               "errors" => [%{"name" => "RecordNotFound"}],

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       14
       +
                     "uri" => %{"format" => "at-uri", "type" => "string"},

     

       15
       +
                     "value" => %{"type" => "unknown"}

     

       16
       +
                   },

     

       17
       +
                   "required" => ["uri", "value"],

     

       18
       +
                   "type" => "object"

     

       19
       +
                 }

     

       20
       +
               },

     

       21
       +
               "parameters" => %{

     

       22
       +
                 "properties" => %{

     

       23
       +
                   "cid" => %{

     

       24
       +
                     "description" =>

     

       25
       +
                       "The CID of the version of the record. If not specified, then return the most recent version.",

     

       26
       +
                     "format" => "cid",

     

       27
       +
                     "type" => "string"

     

       28
       +
                   },

     

       29
       +
                   "collection" => %{

     

       30
       +
                     "description" => "The NSID of the record collection.",

     

       31
       +
                     "format" => "nsid",

     

       32
       +
                     "type" => "string"

     

       33
       +
                   },

     

       34
       +
                   "repo" => %{

     

       35
       +
                     "description" => "The handle or DID of the repo.",

     

       36
       +
                     "format" => "at-identifier",

     

       37
       +
                     "type" => "string"

     

       38
       +
                   },

     

       39
       +
                   "rkey" => %{

     

       40
       +
                     "description" => "The Record Key.",

     

       41
       +
                     "format" => "record-key",

     

       42
       +
                     "type" => "string"

     

       43
       +
                   }

     

       44
       +
                 },

     

       45
       +
                 "required" => ["repo", "collection", "rkey"],

     

       46
       +
                 "type" => "params"

     

       47
       +
               },

     

       48
       +
               "type" => "query"

     

       49
       +
             }

     

       50
       +
           },

     

       51
       +
           "id" => "com.atproto.repo.getRecord",

     

       52
       +
           "lexicon" => 1

     

       53
       +
         })

     

       54
       +
       end

+16

lib/atproto/com/atproto/repo/importRepo.ex

···

       1
       +
       defmodule Com.Atproto.Repo.ImportRepo do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Import a repo in the form of a CAR file. Requires Content-Length HTTP header to be set.",

     

       9
       +
               "input" => %{"encoding" => "application/vnd.ipld.car"},

     

       10
       +
               "type" => "procedure"

     

       11
       +
             }

     

       12
       +
           },

     

       13
       +
           "id" => "com.atproto.repo.importRepo",

     

       14
       +
           "lexicon" => 1

     

       15
       +
         })

     

       16
       +
       end

+49

lib/atproto/com/atproto/repo/listMissingBlobs.ex

···

       1
       +
       defmodule Com.Atproto.Repo.ListMissingBlobs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Returns a list of missing blobs for the requesting account. Intended to be used in the account migration flow.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "blobs" => %{

     

       14
       +
                       "items" => %{"ref" => "#recordBlob", "type" => "ref"},

     

       15
       +
                       "type" => "array"

     

       16
       +
                     },

     

       17
       +
                     "cursor" => %{"type" => "string"}

     

       18
       +
                   },

     

       19
       +
                   "required" => ["blobs"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "parameters" => %{

     

       24
       +
                 "properties" => %{

     

       25
       +
                   "cursor" => %{"type" => "string"},

     

       26
       +
                   "limit" => %{

     

       27
       +
                     "default" => 500,

     

       28
       +
                     "maximum" => 1000,

     

       29
       +
                     "minimum" => 1,

     

       30
       +
                     "type" => "integer"

     

       31
       +
                   }

     

       32
       +
                 },

     

       33
       +
                 "type" => "params"

     

       34
       +
               },

     

       35
       +
               "type" => "query"

     

       36
       +
             },

     

       37
       +
             "recordBlob" => %{

     

       38
       +
               "properties" => %{

     

       39
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       40
       +
                 "recordUri" => %{"format" => "at-uri", "type" => "string"}

     

       41
       +
               },

     

       42
       +
               "required" => ["cid", "recordUri"],

     

       43
       +
               "type" => "object"

     

       44
       +
             }

     

       45
       +
           },

     

       46
       +
           "id" => "com.atproto.repo.listMissingBlobs",

     

       47
       +
           "lexicon" => 1

     

       48
       +
         })

     

       49
       +
       end

+66

lib/atproto/com/atproto/repo/listRecords.ex

···

       1
       +
       defmodule Com.Atproto.Repo.ListRecords do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "List a range of records in a repository, matching a specific collection. Does not require auth.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       +
                     "records" => %{

     

       15
       +
                       "items" => %{"ref" => "#record", "type" => "ref"},

     

       16
       +
                       "type" => "array"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "required" => ["records"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "parameters" => %{

     

       24
       +
                 "properties" => %{

     

       25
       +
                   "collection" => %{

     

       26
       +
                     "description" => "The NSID of the record type.",

     

       27
       +
                     "format" => "nsid",

     

       28
       +
                     "type" => "string"

     

       29
       +
                   },

     

       30
       +
                   "cursor" => %{"type" => "string"},

     

       31
       +
                   "limit" => %{

     

       32
       +
                     "default" => 50,

     

       33
       +
                     "description" => "The number of records to return.",

     

       34
       +
                     "maximum" => 100,

     

       35
       +
                     "minimum" => 1,

     

       36
       +
                     "type" => "integer"

     

       37
       +
                   },

     

       38
       +
                   "repo" => %{

     

       39
       +
                     "description" => "The handle or DID of the repo.",

     

       40
       +
                     "format" => "at-identifier",

     

       41
       +
                     "type" => "string"

     

       42
       +
                   },

     

       43
       +
                   "reverse" => %{

     

       44
       +
                     "description" => "Flag to reverse the order of the returned records.",

     

       45
       +
                     "type" => "boolean"

     

       46
       +
                   }

     

       47
       +
                 },

     

       48
       +
                 "required" => ["repo", "collection"],

     

       49
       +
                 "type" => "params"

     

       50
       +
               },

     

       51
       +
               "type" => "query"

     

       52
       +
             },

     

       53
       +
             "record" => %{

     

       54
       +
               "properties" => %{

     

       55
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       56
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"},

     

       57
       +
                 "value" => %{"type" => "unknown"}

     

       58
       +
               },

     

       59
       +
               "required" => ["uri", "cid", "value"],

     

       60
       +
               "type" => "object"

     

       61
       +
             }

     

       62
       +
           },

     

       63
       +
           "id" => "com.atproto.repo.listRecords",

     

       64
       +
           "lexicon" => 1

     

       65
       +
         })

     

       66
       +
       end

+81

lib/atproto/com/atproto/repo/putRecord.ex

···

       1
       +
       defmodule Com.Atproto.Repo.PutRecord do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.",

     

       9
       +
               "errors" => [%{"name" => "InvalidSwap"}],

     

       10
       +
               "input" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "nullable" => ["swapRecord"],

     

       14
       +
                   "properties" => %{

     

       15
       +
                     "collection" => %{

     

       16
       +
                       "description" => "The NSID of the record collection.",

     

       17
       +
                       "format" => "nsid",

     

       18
       +
                       "type" => "string"

     

       19
       +
                     },

     

       20
       +
                     "record" => %{

     

       21
       +
                       "description" => "The record to write.",

     

       22
       +
                       "type" => "unknown"

     

       23
       +
                     },

     

       24
       +
                     "repo" => %{

     

       25
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       26
       +
                       "format" => "at-identifier",

     

       27
       +
                       "type" => "string"

     

       28
       +
                     },

     

       29
       +
                     "rkey" => %{

     

       30
       +
                       "description" => "The Record Key.",

     

       31
       +
                       "format" => "record-key",

     

       32
       +
                       "maxLength" => 512,

     

       33
       +
                       "type" => "string"

     

       34
       +
                     },

     

       35
       +
                     "swapCommit" => %{

     

       36
       +
                       "description" => "Compare and swap with the previous commit by CID.",

     

       37
       +
                       "format" => "cid",

     

       38
       +
                       "type" => "string"

     

       39
       +
                     },

     

       40
       +
                     "swapRecord" => %{

     

       41
       +
                       "description" =>

     

       42
       +
                         "Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation",

     

       43
       +
                       "format" => "cid",

     

       44
       +
                       "type" => "string"

     

       45
       +
                     },

     

       46
       +
                     "validate" => %{

     

       47
       +
                       "description" =>

     

       48
       +
                         "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",

     

       49
       +
                       "type" => "boolean"

     

       50
       +
                     }

     

       51
       +
                   },

     

       52
       +
                   "required" => ["repo", "collection", "rkey", "record"],

     

       53
       +
                   "type" => "object"

     

       54
       +
                 }

     

       55
       +
               },

     

       56
       +
               "output" => %{

     

       57
       +
                 "encoding" => "application/json",

     

       58
       +
                 "schema" => %{

     

       59
       +
                   "properties" => %{

     

       60
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       61
       +
                     "commit" => %{

     

       62
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       63
       +
                       "type" => "ref"

     

       64
       +
                     },

     

       65
       +
                     "uri" => %{"format" => "at-uri", "type" => "string"},

     

       66
       +
                     "validationStatus" => %{

     

       67
       +
                       "knownValues" => ["valid", "unknown"],

     

       68
       +
                       "type" => "string"

     

       69
       +
                     }

     

       70
       +
                   },

     

       71
       +
                   "required" => ["uri", "cid"],

     

       72
       +
                   "type" => "object"

     

       73
       +
                 }

     

       74
       +
               },

     

       75
       +
               "type" => "procedure"

     

       76
       +
             }

     

       77
       +
           },

     

       78
       +
           "id" => "com.atproto.repo.putRecord",

     

       79
       +
           "lexicon" => 1

     

       80
       +
         })

     

       81
       +
       end

+19

lib/atproto/com/atproto/repo/strongRef.ex

···

       1
       +
       defmodule Com.Atproto.Repo.StrongRef do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       9
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"}

     

       10
       +
               },

     

       11
       +
               "required" => ["uri", "cid"],

     

       12
       +
               "type" => "object"

     

       13
       +
             }

     

       14
       +
           },

     

       15
       +
           "description" => "A URI with a content-hash fingerprint.",

     

       16
       +
           "id" => "com.atproto.repo.strongRef",

     

       17
       +
           "lexicon" => 1

     

       18
       +
         })

     

       19
       +
       end

+24

lib/atproto/com/atproto/repo/uploadBlob.ex

···

       1
       +
       defmodule Com.Atproto.Repo.UploadBlob do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS.",

     

       9
       +
               "input" => %{"encoding" => "*/*"},

     

       10
       +
               "output" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{"blob" => %{"type" => "blob"}},

     

       14
       +
                   "required" => ["blob"],

     

       15
       +
                   "type" => "object"

     

       16
       +
                 }

     

       17
       +
               },

     

       18
       +
               "type" => "procedure"

     

       19
       +
             }

     

       20
       +
           },

     

       21
       +
           "id" => "com.atproto.repo.uploadBlob",

     

       22
       +
           "lexicon" => 1

     

       23
       +
         })

     

       24
       +
       end

+15

lib/atproto/com/atproto/server/activateAccount.ex

···

       1
       +
       defmodule Com.Atproto.Server.ActivateAccount do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Activates a currently deactivated account. Used to finalize account migration after the account's repo is imported and identity is setup.",

     

       9
       +
               "type" => "procedure"

     

       10
       +
             }

     

       11
       +
           },

     

       12
       +
           "id" => "com.atproto.server.activateAccount",

     

       13
       +
           "lexicon" => 1

     

       14
       +
         })

     

       15
       +
       end

+43

lib/atproto/com/atproto/server/checkAccountStatus.ex

···

       1
       +
       defmodule Com.Atproto.Server.CheckAccountStatus do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "activated" => %{"type" => "boolean"},

     

       14
       +
                     "expectedBlobs" => %{"type" => "integer"},

     

       15
       +
                     "importedBlobs" => %{"type" => "integer"},

     

       16
       +
                     "indexedRecords" => %{"type" => "integer"},

     

       17
       +
                     "privateStateValues" => %{"type" => "integer"},

     

       18
       +
                     "repoBlocks" => %{"type" => "integer"},

     

       19
       +
                     "repoCommit" => %{"format" => "cid", "type" => "string"},

     

       20
       +
                     "repoRev" => %{"type" => "string"},

     

       21
       +
                     "validDid" => %{"type" => "boolean"}

     

       22
       +
                   },

     

       23
       +
                   "required" => [

     

       24
       +
                     "activated",

     

       25
       +
                     "validDid",

     

       26
       +
                     "repoCommit",

     

       27
       +
                     "repoRev",

     

       28
       +
                     "repoBlocks",

     

       29
       +
                     "indexedRecords",

     

       30
       +
                     "privateStateValues",

     

       31
       +
                     "expectedBlobs",

     

       32
       +
                     "importedBlobs"

     

       33
       +
                   ],

     

       34
       +
                   "type" => "object"

     

       35
       +
                 }

     

       36
       +
               },

     

       37
       +
               "type" => "query"

     

       38
       +
             }

     

       39
       +
           },

     

       40
       +
           "id" => "com.atproto.server.checkAccountStatus",

     

       41
       +
           "lexicon" => 1

     

       42
       +
         })

     

       43
       +
       end

+32

lib/atproto/com/atproto/server/confirmEmail.ex

···

       1
       +
       defmodule Com.Atproto.Server.ConfirmEmail do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Confirm an email using a token from com.atproto.server.requestEmailConfirmation.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "AccountNotFound"},

     

       11
       +
                 %{"name" => "ExpiredToken"},

     

       12
       +
                 %{"name" => "InvalidToken"},

     

       13
       +
                 %{"name" => "InvalidEmail"}

     

       14
       +
               ],

     

       15
       +
               "input" => %{

     

       16
       +
                 "encoding" => "application/json",

     

       17
       +
                 "schema" => %{

     

       18
       +
                   "properties" => %{

     

       19
       +
                     "email" => %{"type" => "string"},

     

       20
       +
                     "token" => %{"type" => "string"}

     

       21
       +
                   },

     

       22
       +
                   "required" => ["email", "token"],

     

       23
       +
                   "type" => "object"

     

       24
       +
                 }

     

       25
       +
               },

     

       26
       +
               "type" => "procedure"

     

       27
       +
             }

     

       28
       +
           },

     

       29
       +
           "id" => "com.atproto.server.confirmEmail",

     

       30
       +
           "lexicon" => 1

     

       31
       +
         })

     

       32
       +
       end

+83

lib/atproto/com/atproto/server/createAccount.ex

···

       1
       +
       defmodule Com.Atproto.Server.CreateAccount do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Create an account. Implemented by PDS.",

     

       8
       +
               "errors" => [

     

       9
       +
                 %{"name" => "InvalidHandle"},

     

       10
       +
                 %{"name" => "InvalidPassword"},

     

       11
       +
                 %{"name" => "InvalidInviteCode"},

     

       12
       +
                 %{"name" => "HandleNotAvailable"},

     

       13
       +
                 %{"name" => "UnsupportedDomain"},

     

       14
       +
                 %{"name" => "UnresolvableDid"},

     

       15
       +
                 %{"name" => "IncompatibleDidDoc"}

     

       16
       +
               ],

     

       17
       +
               "input" => %{

     

       18
       +
                 "encoding" => "application/json",

     

       19
       +
                 "schema" => %{

     

       20
       +
                   "properties" => %{

     

       21
       +
                     "did" => %{

     

       22
       +
                       "description" => "Pre-existing atproto DID, being imported to a new account.",

     

       23
       +
                       "format" => "did",

     

       24
       +
                       "type" => "string"

     

       25
       +
                     },

     

       26
       +
                     "email" => %{"type" => "string"},

     

       27
       +
                     "handle" => %{

     

       28
       +
                       "description" => "Requested handle for the account.",

     

       29
       +
                       "format" => "handle",

     

       30
       +
                       "type" => "string"

     

       31
       +
                     },

     

       32
       +
                     "inviteCode" => %{"type" => "string"},

     

       33
       +
                     "password" => %{

     

       34
       +
                       "description" =>

     

       35
       +
                         "Initial account password. May need to meet instance-specific password strength requirements.",

     

       36
       +
                       "type" => "string"

     

       37
       +
                     },

     

       38
       +
                     "plcOp" => %{

     

       39
       +
                       "description" =>

     

       40
       +
                         "A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented.",

     

       41
       +
                       "type" => "unknown"

     

       42
       +
                     },

     

       43
       +
                     "recoveryKey" => %{

     

       44
       +
                       "description" =>

     

       45
       +
                         "DID PLC rotation key (aka, recovery key) to be included in PLC creation operation.",

     

       46
       +
                       "type" => "string"

     

       47
       +
                     },

     

       48
       +
                     "verificationCode" => %{"type" => "string"},

     

       49
       +
                     "verificationPhone" => %{"type" => "string"}

     

       50
       +
                   },

     

       51
       +
                   "required" => ["handle"],

     

       52
       +
                   "type" => "object"

     

       53
       +
                 }

     

       54
       +
               },

     

       55
       +
               "output" => %{

     

       56
       +
                 "encoding" => "application/json",

     

       57
       +
                 "schema" => %{

     

       58
       +
                   "description" => "Account login session returned on successful account creation.",

     

       59
       +
                   "properties" => %{

     

       60
       +
                     "accessJwt" => %{"type" => "string"},

     

       61
       +
                     "did" => %{

     

       62
       +
                       "description" => "The DID of the new account.",

     

       63
       +
                       "format" => "did",

     

       64
       +
                       "type" => "string"

     

       65
       +
                     },

     

       66
       +
                     "didDoc" => %{

     

       67
       +
                       "description" => "Complete DID document.",

     

       68
       +
                       "type" => "unknown"

     

       69
       +
                     },

     

       70
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       71
       +
                     "refreshJwt" => %{"type" => "string"}

     

       72
       +
                   },

     

       73
       +
                   "required" => ["accessJwt", "refreshJwt", "handle", "did"],

     

       74
       +
                   "type" => "object"

     

       75
       +
                 }

     

       76
       +
               },

     

       77
       +
               "type" => "procedure"

     

       78
       +
             }

     

       79
       +
           },

     

       80
       +
           "id" => "com.atproto.server.createAccount",

     

       81
       +
           "lexicon" => 1

     

       82
       +
         })

     

       83
       +
       end

+47

lib/atproto/com/atproto/server/createAppPassword.ex

···

       1
       +
       defmodule Com.Atproto.Server.CreateAppPassword do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "appPassword" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       9
       +
                 "name" => %{"type" => "string"},

     

       10
       +
                 "password" => %{"type" => "string"},

     

       11
       +
                 "privileged" => %{"type" => "boolean"}

     

       12
       +
               },

     

       13
       +
               "required" => ["name", "password", "createdAt"],

     

       14
       +
               "type" => "object"

     

       15
       +
             },

     

       16
       +
             "main" => %{

     

       17
       +
               "description" => "Create an App Password.",

     

       18
       +
               "errors" => [%{"name" => "AccountTakedown"}],

     

       19
       +
               "input" => %{

     

       20
       +
                 "encoding" => "application/json",

     

       21
       +
                 "schema" => %{

     

       22
       +
                   "properties" => %{

     

       23
       +
                     "name" => %{

     

       24
       +
                       "description" => "A short name for the App Password, to help distinguish them.",

     

       25
       +
                       "type" => "string"

     

       26
       +
                     },

     

       27
       +
                     "privileged" => %{

     

       28
       +
                       "description" =>

     

       29
       +
                         "If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients.",

     

       30
       +
                       "type" => "boolean"

     

       31
       +
                     }

     

       32
       +
                   },

     

       33
       +
                   "required" => ["name"],

     

       34
       +
                   "type" => "object"

     

       35
       +
                 }

     

       36
       +
               },

     

       37
       +
               "output" => %{

     

       38
       +
                 "encoding" => "application/json",

     

       39
       +
                 "schema" => %{"ref" => "#appPassword", "type" => "ref"}

     

       40
       +
               },

     

       41
       +
               "type" => "procedure"

     

       42
       +
             }

     

       43
       +
           },

     

       44
       +
           "id" => "com.atproto.server.createAppPassword",

     

       45
       +
           "lexicon" => 1

     

       46
       +
         })

     

       47
       +
       end

+33

lib/atproto/com/atproto/server/createInviteCode.ex

···

       1
       +
       defmodule Com.Atproto.Server.CreateInviteCode do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Create an invite code.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "forAccount" => %{"format" => "did", "type" => "string"},

     

       13
       +
                     "useCount" => %{"type" => "integer"}

     

       14
       +
                   },

     

       15
       +
                   "required" => ["useCount"],

     

       16
       +
                   "type" => "object"

     

       17
       +
                 }

     

       18
       +
               },

     

       19
       +
               "output" => %{

     

       20
       +
                 "encoding" => "application/json",

     

       21
       +
                 "schema" => %{

     

       22
       +
                   "properties" => %{"code" => %{"type" => "string"}},

     

       23
       +
                   "required" => ["code"],

     

       24
       +
                   "type" => "object"

     

       25
       +
                 }

     

       26
       +
               },

     

       27
       +
               "type" => "procedure"

     

       28
       +
             }

     

       29
       +
           },

     

       30
       +
           "id" => "com.atproto.server.createInviteCode",

     

       31
       +
           "lexicon" => 1

     

       32
       +
         })

     

       33
       +
       end

+50

lib/atproto/com/atproto/server/createInviteCodes.ex

···

       1
       +
       defmodule Com.Atproto.Server.CreateInviteCodes do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "accountCodes" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "account" => %{"type" => "string"},

     

       9
       +
                 "codes" => %{"items" => %{"type" => "string"}, "type" => "array"}

     

       10
       +
               },

     

       11
       +
               "required" => ["account", "codes"],

     

       12
       +
               "type" => "object"

     

       13
       +
             },

     

       14
       +
             "main" => %{

     

       15
       +
               "description" => "Create invite codes.",

     

       16
       +
               "input" => %{

     

       17
       +
                 "encoding" => "application/json",

     

       18
       +
                 "schema" => %{

     

       19
       +
                   "properties" => %{

     

       20
       +
                     "codeCount" => %{"default" => 1, "type" => "integer"},

     

       21
       +
                     "forAccounts" => %{

     

       22
       +
                       "items" => %{"format" => "did", "type" => "string"},

     

       23
       +
                       "type" => "array"

     

       24
       +
                     },

     

       25
       +
                     "useCount" => %{"type" => "integer"}

     

       26
       +
                   },

     

       27
       +
                   "required" => ["codeCount", "useCount"],

     

       28
       +
                   "type" => "object"

     

       29
       +
                 }

     

       30
       +
               },

     

       31
       +
               "output" => %{

     

       32
       +
                 "encoding" => "application/json",

     

       33
       +
                 "schema" => %{

     

       34
       +
                   "properties" => %{

     

       35
       +
                     "codes" => %{

     

       36
       +
                       "items" => %{"ref" => "#accountCodes", "type" => "ref"},

     

       37
       +
                       "type" => "array"

     

       38
       +
                     }

     

       39
       +
                   },

     

       40
       +
                   "required" => ["codes"],

     

       41
       +
                   "type" => "object"

     

       42
       +
                 }

     

       43
       +
               },

     

       44
       +
               "type" => "procedure"

     

       45
       +
             }

     

       46
       +
           },

     

       47
       +
           "id" => "com.atproto.server.createInviteCodes",

     

       48
       +
           "lexicon" => 1

     

       49
       +
         })

     

       50
       +
       end

+63

lib/atproto/com/atproto/server/createSession.ex

···

       1
       +
       defmodule Com.Atproto.Server.CreateSession do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Create an authentication session.",

     

       8
       +
               "errors" => [

     

       9
       +
                 %{"name" => "AccountTakedown"},

     

       10
       +
                 %{"name" => "AuthFactorTokenRequired"}

     

       11
       +
               ],

     

       12
       +
               "input" => %{

     

       13
       +
                 "encoding" => "application/json",

     

       14
       +
                 "schema" => %{

     

       15
       +
                   "properties" => %{

     

       16
       +
                     "allowTakendown" => %{

     

       17
       +
                       "description" =>

     

       18
       +
                         "When true, instead of throwing error for takendown accounts, a valid response with a narrow scoped token will be returned",

     

       19
       +
                       "type" => "boolean"

     

       20
       +
                     },

     

       21
       +
                     "authFactorToken" => %{"type" => "string"},

     

       22
       +
                     "identifier" => %{

     

       23
       +
                       "description" =>

     

       24
       +
                         "Handle or other identifier supported by the server for the authenticating user.",

     

       25
       +
                       "type" => "string"

     

       26
       +
                     },

     

       27
       +
                     "password" => %{"type" => "string"}

     

       28
       +
                   },

     

       29
       +
                   "required" => ["identifier", "password"],

     

       30
       +
                   "type" => "object"

     

       31
       +
                 }

     

       32
       +
               },

     

       33
       +
               "output" => %{

     

       34
       +
                 "encoding" => "application/json",

     

       35
       +
                 "schema" => %{

     

       36
       +
                   "properties" => %{

     

       37
       +
                     "accessJwt" => %{"type" => "string"},

     

       38
       +
                     "active" => %{"type" => "boolean"},

     

       39
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       40
       +
                     "didDoc" => %{"type" => "unknown"},

     

       41
       +
                     "email" => %{"type" => "string"},

     

       42
       +
                     "emailAuthFactor" => %{"type" => "boolean"},

     

       43
       +
                     "emailConfirmed" => %{"type" => "boolean"},

     

       44
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       45
       +
                     "refreshJwt" => %{"type" => "string"},

     

       46
       +
                     "status" => %{

     

       47
       +
                       "description" =>

     

       48
       +
                         "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.",

     

       49
       +
                       "knownValues" => ["takendown", "suspended", "deactivated"],

     

       50
       +
                       "type" => "string"

     

       51
       +
                     }

     

       52
       +
                   },

     

       53
       +
                   "required" => ["accessJwt", "refreshJwt", "handle", "did"],

     

       54
       +
                   "type" => "object"

     

       55
       +
                 }

     

       56
       +
               },

     

       57
       +
               "type" => "procedure"

     

       58
       +
             }

     

       59
       +
           },

     

       60
       +
           "id" => "com.atproto.server.createSession",

     

       61
       +
           "lexicon" => 1

     

       62
       +
         })

     

       63
       +
       end

+29

lib/atproto/com/atproto/server/deactivateAccount.ex

···

       1
       +
       defmodule Com.Atproto.Server.DeactivateAccount do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Deactivates a currently active account. Stops serving of repo, and future writes to repo until reactivated. Used to finalize account migration with the old host after the account has been activated on the new host.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "deleteAfter" => %{

     

       14
       +
                       "description" =>

     

       15
       +
                         "A recommendation to server as to how long they should hold onto the deactivated account before deleting.",

     

       16
       +
                       "format" => "datetime",

     

       17
       +
                       "type" => "string"

     

       18
       +
                     }

     

       19
       +
                   },

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "type" => "procedure"

     

       24
       +
             }

     

       25
       +
           },

     

       26
       +
           "id" => "com.atproto.server.deactivateAccount",

     

       27
       +
           "lexicon" => 1

     

       28
       +
         })

     

       29
       +
       end

+42

lib/atproto/com/atproto/server/defs.ex

···

       1
       +
       defmodule Com.Atproto.Server.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "inviteCode" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "available" => %{"type" => "integer"},

     

       9
       +
                 "code" => %{"type" => "string"},

     

       10
       +
                 "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       11
       +
                 "createdBy" => %{"type" => "string"},

     

       12
       +
                 "disabled" => %{"type" => "boolean"},

     

       13
       +
                 "forAccount" => %{"type" => "string"},

     

       14
       +
                 "uses" => %{

     

       15
       +
                   "items" => %{"ref" => "#inviteCodeUse", "type" => "ref"},

     

       16
       +
                   "type" => "array"

     

       17
       +
                 }

     

       18
       +
               },

     

       19
       +
               "required" => [

     

       20
       +
                 "code",

     

       21
       +
                 "available",

     

       22
       +
                 "disabled",

     

       23
       +
                 "forAccount",

     

       24
       +
                 "createdBy",

     

       25
       +
                 "createdAt",

     

       26
       +
                 "uses"

     

       27
       +
               ],

     

       28
       +
               "type" => "object"

     

       29
       +
             },

     

       30
       +
             "inviteCodeUse" => %{

     

       31
       +
               "properties" => %{

     

       32
       +
                 "usedAt" => %{"format" => "datetime", "type" => "string"},

     

       33
       +
                 "usedBy" => %{"format" => "did", "type" => "string"}

     

       34
       +
               },

     

       35
       +
               "required" => ["usedBy", "usedAt"],

     

       36
       +
               "type" => "object"

     

       37
       +
             }

     

       38
       +
           },

     

       39
       +
           "id" => "com.atproto.server.defs",

     

       40
       +
           "lexicon" => 1

     

       41
       +
         })

     

       42
       +
       end

+28

lib/atproto/com/atproto/server/deleteAccount.ex

···

       1
       +
       defmodule Com.Atproto.Server.DeleteAccount do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Delete an actor's account with a token and password. Can only be called after requesting a deletion token. Requires auth.",

     

       9
       +
               "errors" => [%{"name" => "ExpiredToken"}, %{"name" => "InvalidToken"}],

     

       10
       +
               "input" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{

     

       14
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       15
       +
                     "password" => %{"type" => "string"},

     

       16
       +
                     "token" => %{"type" => "string"}

     

       17
       +
                   },

     

       18
       +
                   "required" => ["did", "password", "token"],

     

       19
       +
                   "type" => "object"

     

       20
       +
                 }

     

       21
       +
               },

     

       22
       +
               "type" => "procedure"

     

       23
       +
             }

     

       24
       +
           },

     

       25
       +
           "id" => "com.atproto.server.deleteAccount",

     

       26
       +
           "lexicon" => 1

     

       27
       +
         })

     

       28
       +
       end

+14

lib/atproto/com/atproto/server/deleteSession.ex

···

       1
       +
       defmodule Com.Atproto.Server.DeleteSession do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Delete the current session. Requires auth.",

     

       8
       +
               "type" => "procedure"

     

       9
       +
             }

     

       10
       +
           },

     

       11
       +
           "id" => "com.atproto.server.deleteSession",

     

       12
       +
           "lexicon" => 1

     

       13
       +
         })

     

       14
       +
       end

+61

lib/atproto/com/atproto/server/describeServer.ex

···

       1
       +
       defmodule Com.Atproto.Server.DescribeServer do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "contact" => %{

     

       7
       +
               "properties" => %{"email" => %{"type" => "string"}},

     

       8
       +
               "type" => "object"

     

       9
       +
             },

     

       10
       +
             "links" => %{

     

       11
       +
               "properties" => %{

     

       12
       +
                 "privacyPolicy" => %{"format" => "uri", "type" => "string"},

     

       13
       +
                 "termsOfService" => %{"format" => "uri", "type" => "string"}

     

       14
       +
               },

     

       15
       +
               "type" => "object"

     

       16
       +
             },

     

       17
       +
             "main" => %{

     

       18
       +
               "description" =>

     

       19
       +
                 "Describes the server's account creation requirements and capabilities. Implemented by PDS.",

     

       20
       +
               "output" => %{

     

       21
       +
                 "encoding" => "application/json",

     

       22
       +
                 "schema" => %{

     

       23
       +
                   "properties" => %{

     

       24
       +
                     "availableUserDomains" => %{

     

       25
       +
                       "description" => "List of domain suffixes that can be used in account handles.",

     

       26
       +
                       "items" => %{"type" => "string"},

     

       27
       +
                       "type" => "array"

     

       28
       +
                     },

     

       29
       +
                     "contact" => %{

     

       30
       +
                       "description" => "Contact information",

     

       31
       +
                       "ref" => "#contact",

     

       32
       +
                       "type" => "ref"

     

       33
       +
                     },

     

       34
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       35
       +
                     "inviteCodeRequired" => %{

     

       36
       +
                       "description" =>

     

       37
       +
                         "If true, an invite code must be supplied to create an account on this instance.",

     

       38
       +
                       "type" => "boolean"

     

       39
       +
                     },

     

       40
       +
                     "links" => %{

     

       41
       +
                       "description" => "URLs of service policy documents.",

     

       42
       +
                       "ref" => "#links",

     

       43
       +
                       "type" => "ref"

     

       44
       +
                     },

     

       45
       +
                     "phoneVerificationRequired" => %{

     

       46
       +
                       "description" =>

     

       47
       +
                         "If true, a phone verification token must be supplied to create an account on this instance.",

     

       48
       +
                       "type" => "boolean"

     

       49
       +
                     }

     

       50
       +
                   },

     

       51
       +
                   "required" => ["did", "availableUserDomains"],

     

       52
       +
                   "type" => "object"

     

       53
       +
                 }

     

       54
       +
               },

     

       55
       +
               "type" => "query"

     

       56
       +
             }

     

       57
       +
           },

     

       58
       +
           "id" => "com.atproto.server.describeServer",

     

       59
       +
           "lexicon" => 1

     

       60
       +
         })

     

       61
       +
       end

+43

lib/atproto/com/atproto/server/getAccountInviteCodes.ex

···

       1
       +
       defmodule Com.Atproto.Server.GetAccountInviteCodes do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get all invite codes for the current account. Requires auth.",

     

       8
       +
               "errors" => [%{"name" => "DuplicateCreate"}],

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "codes" => %{

     

       14
       +
                       "items" => %{

     

       15
       +
                         "ref" => "com.atproto.server.defs#inviteCode",

     

       16
       +
                         "type" => "ref"

     

       17
       +
                       },

     

       18
       +
                       "type" => "array"

     

       19
       +
                     }

     

       20
       +
                   },

     

       21
       +
                   "required" => ["codes"],

     

       22
       +
                   "type" => "object"

     

       23
       +
                 }

     

       24
       +
               },

     

       25
       +
               "parameters" => %{

     

       26
       +
                 "properties" => %{

     

       27
       +
                   "createAvailable" => %{

     

       28
       +
                     "default" => true,

     

       29
       +
                     "description" =>

     

       30
       +
                       "Controls whether any new 'earned' but not 'created' invites should be created.",

     

       31
       +
                     "type" => "boolean"

     

       32
       +
                   },

     

       33
       +
                   "includeUsed" => %{"default" => true, "type" => "boolean"}

     

       34
       +
                 },

     

       35
       +
                 "type" => "params"

     

       36
       +
               },

     

       37
       +
               "type" => "query"

     

       38
       +
             }

     

       39
       +
           },

     

       40
       +
           "id" => "com.atproto.server.getAccountInviteCodes",

     

       41
       +
           "lexicon" => 1

     

       42
       +
         })

     

       43
       +
       end

+52

lib/atproto/com/atproto/server/getServiceAuth.ex

···

       1
       +
       defmodule Com.Atproto.Server.GetServiceAuth do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get a signed token on behalf of the requesting DID for the requested service.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{

     

       11
       +
                   "description" =>

     

       12
       +
                     "Indicates that the requested expiration date is not a valid. May be in the past or may be reliant on the requested scopes.",

     

       13
       +
                   "name" => "BadExpiration"

     

       14
       +
                 }

     

       15
       +
               ],

     

       16
       +
               "output" => %{

     

       17
       +
                 "encoding" => "application/json",

     

       18
       +
                 "schema" => %{

     

       19
       +
                   "properties" => %{"token" => %{"type" => "string"}},

     

       20
       +
                   "required" => ["token"],

     

       21
       +
                   "type" => "object"

     

       22
       +
                 }

     

       23
       +
               },

     

       24
       +
               "parameters" => %{

     

       25
       +
                 "properties" => %{

     

       26
       +
                   "aud" => %{

     

       27
       +
                     "description" =>

     

       28
       +
                       "The DID of the service that the token will be used to authenticate with",

     

       29
       +
                     "format" => "did",

     

       30
       +
                     "type" => "string"

     

       31
       +
                   },

     

       32
       +
                   "exp" => %{

     

       33
       +
                     "description" =>

     

       34
       +
                       "The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope.",

     

       35
       +
                     "type" => "integer"

     

       36
       +
                   },

     

       37
       +
                   "lxm" => %{

     

       38
       +
                     "description" => "Lexicon (XRPC) method to bind the requested token to",

     

       39
       +
                     "format" => "nsid",

     

       40
       +
                     "type" => "string"

     

       41
       +
                   }

     

       42
       +
                 },

     

       43
       +
                 "required" => ["aud"],

     

       44
       +
                 "type" => "params"

     

       45
       +
               },

     

       46
       +
               "type" => "query"

     

       47
       +
             }

     

       48
       +
           },

     

       49
       +
           "id" => "com.atproto.server.getServiceAuth",

     

       50
       +
           "lexicon" => 1

     

       51
       +
         })

     

       52
       +
       end

+36

lib/atproto/com/atproto/server/getSession.ex

···

       1
       +
       defmodule Com.Atproto.Server.GetSession do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Get information about the current auth session. Requires auth.",

     

       8
       +
               "output" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{

     

       12
       +
                     "active" => %{"type" => "boolean"},

     

       13
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       14
       +
                     "didDoc" => %{"type" => "unknown"},

     

       15
       +
                     "email" => %{"type" => "string"},

     

       16
       +
                     "emailAuthFactor" => %{"type" => "boolean"},

     

       17
       +
                     "emailConfirmed" => %{"type" => "boolean"},

     

       18
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       19
       +
                     "status" => %{

     

       20
       +
                       "description" =>

     

       21
       +
                         "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.",

     

       22
       +
                       "knownValues" => ["takendown", "suspended", "deactivated"],

     

       23
       +
                       "type" => "string"

     

       24
       +
                     }

     

       25
       +
                   },

     

       26
       +
                   "required" => ["handle", "did"],

     

       27
       +
                   "type" => "object"

     

       28
       +
                 }

     

       29
       +
               },

     

       30
       +
               "type" => "query"

     

       31
       +
             }

     

       32
       +
           },

     

       33
       +
           "id" => "com.atproto.server.getSession",

     

       34
       +
           "lexicon" => 1

     

       35
       +
         })

     

       36
       +
       end

+37

lib/atproto/com/atproto/server/listAppPasswords.ex

···

       1
       +
       defmodule Com.Atproto.Server.ListAppPasswords do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "appPassword" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       9
       +
                 "name" => %{"type" => "string"},

     

       10
       +
                 "privileged" => %{"type" => "boolean"}

     

       11
       +
               },

     

       12
       +
               "required" => ["name", "createdAt"],

     

       13
       +
               "type" => "object"

     

       14
       +
             },

     

       15
       +
             "main" => %{

     

       16
       +
               "description" => "List all App Passwords.",

     

       17
       +
               "errors" => [%{"name" => "AccountTakedown"}],

     

       18
       +
               "output" => %{

     

       19
       +
                 "encoding" => "application/json",

     

       20
       +
                 "schema" => %{

     

       21
       +
                   "properties" => %{

     

       22
       +
                     "passwords" => %{

     

       23
       +
                       "items" => %{"ref" => "#appPassword", "type" => "ref"},

     

       24
       +
                       "type" => "array"

     

       25
       +
                     }

     

       26
       +
                   },

     

       27
       +
                   "required" => ["passwords"],

     

       28
       +
                   "type" => "object"

     

       29
       +
                 }

     

       30
       +
               },

     

       31
       +
               "type" => "query"

     

       32
       +
             }

     

       33
       +
           },

     

       34
       +
           "id" => "com.atproto.server.listAppPasswords",

     

       35
       +
           "lexicon" => 1

     

       36
       +
         })

     

       37
       +
       end

+37

lib/atproto/com/atproto/server/refreshSession.ex

···

       1
       +
       defmodule Com.Atproto.Server.RefreshSession do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt').",

     

       9
       +
               "errors" => [%{"name" => "AccountTakedown"}],

     

       10
       +
               "output" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{

     

       14
       +
                     "accessJwt" => %{"type" => "string"},

     

       15
       +
                     "active" => %{"type" => "boolean"},

     

       16
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       17
       +
                     "didDoc" => %{"type" => "unknown"},

     

       18
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       19
       +
                     "refreshJwt" => %{"type" => "string"},

     

       20
       +
                     "status" => %{

     

       21
       +
                       "description" =>

     

       22
       +
                         "Hosting status of the account. If not specified, then assume 'active'.",

     

       23
       +
                       "knownValues" => ["takendown", "suspended", "deactivated"],

     

       24
       +
                       "type" => "string"

     

       25
       +
                     }

     

       26
       +
                   },

     

       27
       +
                   "required" => ["accessJwt", "refreshJwt", "handle", "did"],

     

       28
       +
                   "type" => "object"

     

       29
       +
                 }

     

       30
       +
               },

     

       31
       +
               "type" => "procedure"

     

       32
       +
             }

     

       33
       +
           },

     

       34
       +
           "id" => "com.atproto.server.refreshSession",

     

       35
       +
           "lexicon" => 1

     

       36
       +
         })

     

       37
       +
       end

+14

lib/atproto/com/atproto/server/requestAccountDelete.ex

···

       1
       +
       defmodule Com.Atproto.Server.RequestAccountDelete do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Initiate a user account deletion via email.",

     

       8
       +
               "type" => "procedure"

     

       9
       +
             }

     

       10
       +
           },

     

       11
       +
           "id" => "com.atproto.server.requestAccountDelete",

     

       12
       +
           "lexicon" => 1

     

       13
       +
         })

     

       14
       +
       end

+14

lib/atproto/com/atproto/server/requestEmailConfirmation.ex

···

       1
       +
       defmodule Com.Atproto.Server.RequestEmailConfirmation do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Request an email with a code to confirm ownership of email.",

     

       8
       +
               "type" => "procedure"

     

       9
       +
             }

     

       10
       +
           },

     

       11
       +
           "id" => "com.atproto.server.requestEmailConfirmation",

     

       12
       +
           "lexicon" => 1

     

       13
       +
         })

     

       14
       +
       end

+22

lib/atproto/com/atproto/server/requestEmailUpdate.ex

···

       1
       +
       defmodule Com.Atproto.Server.RequestEmailUpdate do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Request a token in order to update email.",

     

       8
       +
               "output" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{"tokenRequired" => %{"type" => "boolean"}},

     

       12
       +
                   "required" => ["tokenRequired"],

     

       13
       +
                   "type" => "object"

     

       14
       +
                 }

     

       15
       +
               },

     

       16
       +
               "type" => "procedure"

     

       17
       +
             }

     

       18
       +
           },

     

       19
       +
           "id" => "com.atproto.server.requestEmailUpdate",

     

       20
       +
           "lexicon" => 1

     

       21
       +
         })

     

       22
       +
       end

+22

lib/atproto/com/atproto/server/requestPasswordReset.ex

···

       1
       +
       defmodule Com.Atproto.Server.RequestPasswordReset do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Initiate a user account password reset via email.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{"email" => %{"type" => "string"}},

     

       12
       +
                   "required" => ["email"],

     

       13
       +
                   "type" => "object"

     

       14
       +
                 }

     

       15
       +
               },

     

       16
       +
               "type" => "procedure"

     

       17
       +
             }

     

       18
       +
           },

     

       19
       +
           "id" => "com.atproto.server.requestPasswordReset",

     

       20
       +
           "lexicon" => 1

     

       21
       +
         })

     

       22
       +
       end

+42

lib/atproto/com/atproto/server/reserveSigningKey.ex

···

       1
       +
       defmodule Com.Atproto.Server.ReserveSigningKey do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Reserve a repo signing key, for use with account creation. Necessary so that a DID PLC update operation can be constructed during an account migraiton. Public and does not require auth; implemented by PDS. NOTE: this endpoint may change when full account migration is implemented.",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "did" => %{

     

       14
       +
                       "description" => "The DID to reserve a key for.",

     

       15
       +
                       "format" => "did",

     

       16
       +
                       "type" => "string"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "type" => "object"

     

       20
       +
                 }

     

       21
       +
               },

     

       22
       +
               "output" => %{

     

       23
       +
                 "encoding" => "application/json",

     

       24
       +
                 "schema" => %{

     

       25
       +
                   "properties" => %{

     

       26
       +
                     "signingKey" => %{

     

       27
       +
                       "description" =>

     

       28
       +
                         "The public key for the reserved signing key, in did:key serialization.",

     

       29
       +
                       "type" => "string"

     

       30
       +
                     }

     

       31
       +
                   },

     

       32
       +
                   "required" => ["signingKey"],

     

       33
       +
                   "type" => "object"

     

       34
       +
                 }

     

       35
       +
               },

     

       36
       +
               "type" => "procedure"

     

       37
       +
             }

     

       38
       +
           },

     

       39
       +
           "id" => "com.atproto.server.reserveSigningKey",

     

       40
       +
           "lexicon" => 1

     

       41
       +
         })

     

       42
       +
       end

+26

lib/atproto/com/atproto/server/resetPassword.ex

···

       1
       +
       defmodule Com.Atproto.Server.ResetPassword do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Reset a user account password using a token.",

     

       8
       +
               "errors" => [%{"name" => "ExpiredToken"}, %{"name" => "InvalidToken"}],

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "password" => %{"type" => "string"},

     

       14
       +
                     "token" => %{"type" => "string"}

     

       15
       +
                   },

     

       16
       +
                   "required" => ["token", "password"],

     

       17
       +
                   "type" => "object"

     

       18
       +
                 }

     

       19
       +
               },

     

       20
       +
               "type" => "procedure"

     

       21
       +
             }

     

       22
       +
           },

     

       23
       +
           "id" => "com.atproto.server.resetPassword",

     

       24
       +
           "lexicon" => 1

     

       25
       +
         })

     

       26
       +
       end

+22

lib/atproto/com/atproto/server/revokeAppPassword.ex

···

       1
       +
       defmodule Com.Atproto.Server.RevokeAppPassword do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Revoke an App Password by name.",

     

       8
       +
               "input" => %{

     

       9
       +
                 "encoding" => "application/json",

     

       10
       +
                 "schema" => %{

     

       11
       +
                   "properties" => %{"name" => %{"type" => "string"}},

     

       12
       +
                   "required" => ["name"],

     

       13
       +
                   "type" => "object"

     

       14
       +
                 }

     

       15
       +
               },

     

       16
       +
               "type" => "procedure"

     

       17
       +
             }

     

       18
       +
           },

     

       19
       +
           "id" => "com.atproto.server.revokeAppPassword",

     

       20
       +
           "lexicon" => 1

     

       21
       +
         })

     

       22
       +
       end

+35

lib/atproto/com/atproto/server/updateEmail.ex

···

       1
       +
       defmodule Com.Atproto.Server.UpdateEmail do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "Update an account's email.",

     

       8
       +
               "errors" => [

     

       9
       +
                 %{"name" => "ExpiredToken"},

     

       10
       +
                 %{"name" => "InvalidToken"},

     

       11
       +
                 %{"name" => "TokenRequired"}

     

       12
       +
               ],

     

       13
       +
               "input" => %{

     

       14
       +
                 "encoding" => "application/json",

     

       15
       +
                 "schema" => %{

     

       16
       +
                   "properties" => %{

     

       17
       +
                     "email" => %{"type" => "string"},

     

       18
       +
                     "emailAuthFactor" => %{"type" => "boolean"},

     

       19
       +
                     "token" => %{

     

       20
       +
                       "description" =>

     

       21
       +
                         "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed.",

     

       22
       +
                       "type" => "string"

     

       23
       +
                     }

     

       24
       +
                   },

     

       25
       +
                   "required" => ["email"],

     

       26
       +
                   "type" => "object"

     

       27
       +
                 }

     

       28
       +
               },

     

       29
       +
               "type" => "procedure"

     

       30
       +
             }

     

       31
       +
           },

     

       32
       +
           "id" => "com.atproto.server.updateEmail",

     

       33
       +
           "lexicon" => 1

     

       34
       +
         })

     

       35
       +
       end

+14

lib/atproto/com/atproto/sync/defs.ex

···

       1
       +
       defmodule Com.Atproto.Sync.Defs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "hostStatus" => %{

     

       7
       +
               "knownValues" => ["active", "idle", "offline", "throttled", "banned"],

     

       8
       +
               "type" => "string"

     

       9
       +
             }

     

       10
       +
           },

     

       11
       +
           "id" => "com.atproto.sync.defs",

     

       12
       +
           "lexicon" => 1

     

       13
       +
         })

     

       14
       +
       end

+39

lib/atproto/com/atproto/sync/getBlob.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetBlob do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get a blob associated with a given account. Returns the full blob as originally uploaded. Does not require auth; implemented by PDS.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "BlobNotFound"},

     

       11
       +
                 %{"name" => "RepoNotFound"},

     

       12
       +
                 %{"name" => "RepoTakendown"},

     

       13
       +
                 %{"name" => "RepoSuspended"},

     

       14
       +
                 %{"name" => "RepoDeactivated"}

     

       15
       +
               ],

     

       16
       +
               "output" => %{"encoding" => "*/*"},

     

       17
       +
               "parameters" => %{

     

       18
       +
                 "properties" => %{

     

       19
       +
                   "cid" => %{

     

       20
       +
                     "description" => "The CID of the blob to fetch",

     

       21
       +
                     "format" => "cid",

     

       22
       +
                     "type" => "string"

     

       23
       +
                   },

     

       24
       +
                   "did" => %{

     

       25
       +
                     "description" => "The DID of the account.",

     

       26
       +
                     "format" => "did",

     

       27
       +
                     "type" => "string"

     

       28
       +
                   }

     

       29
       +
                 },

     

       30
       +
                 "required" => ["did", "cid"],

     

       31
       +
                 "type" => "params"

     

       32
       +
               },

     

       33
       +
               "type" => "query"

     

       34
       +
             }

     

       35
       +
           },

     

       36
       +
           "id" => "com.atproto.sync.getBlob",

     

       37
       +
           "lexicon" => 1

     

       38
       +
         })

     

       39
       +
       end

+38

lib/atproto/com/atproto/sync/getBlocks.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetBlocks do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get data blocks from a given repo, by CID. For example, intermediate MST nodes, or records. Does not require auth; implemented by PDS.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "BlockNotFound"},

     

       11
       +
                 %{"name" => "RepoNotFound"},

     

       12
       +
                 %{"name" => "RepoTakendown"},

     

       13
       +
                 %{"name" => "RepoSuspended"},

     

       14
       +
                 %{"name" => "RepoDeactivated"}

     

       15
       +
               ],

     

       16
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       17
       +
               "parameters" => %{

     

       18
       +
                 "properties" => %{

     

       19
       +
                   "cids" => %{

     

       20
       +
                     "items" => %{"format" => "cid", "type" => "string"},

     

       21
       +
                     "type" => "array"

     

       22
       +
                   },

     

       23
       +
                   "did" => %{

     

       24
       +
                     "description" => "The DID of the repo.",

     

       25
       +
                     "format" => "did",

     

       26
       +
                     "type" => "string"

     

       27
       +
                   }

     

       28
       +
                 },

     

       29
       +
                 "required" => ["did", "cids"],

     

       30
       +
                 "type" => "params"

     

       31
       +
               },

     

       32
       +
               "type" => "query"

     

       33
       +
             }

     

       34
       +
           },

     

       35
       +
           "id" => "com.atproto.sync.getBlocks",

     

       36
       +
           "lexicon" => 1

     

       37
       +
         })

     

       38
       +
       end

+26

lib/atproto/com/atproto/sync/getCheckout.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetCheckout do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "DEPRECATED - please use com.atproto.sync.getRepo instead",

     

       8
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       9
       +
               "parameters" => %{

     

       10
       +
                 "properties" => %{

     

       11
       +
                   "did" => %{

     

       12
       +
                     "description" => "The DID of the repo.",

     

       13
       +
                     "format" => "did",

     

       14
       +
                     "type" => "string"

     

       15
       +
                   }

     

       16
       +
                 },

     

       17
       +
                 "required" => ["did"],

     

       18
       +
                 "type" => "params"

     

       19
       +
               },

     

       20
       +
               "type" => "query"

     

       21
       +
             }

     

       22
       +
           },

     

       23
       +
           "id" => "com.atproto.sync.getCheckout",

     

       24
       +
           "lexicon" => 1

     

       25
       +
         })

     

       26
       +
       end

+34

lib/atproto/com/atproto/sync/getHead.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetHead do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" => "DEPRECATED - please use com.atproto.sync.getLatestCommit instead",

     

       8
       +
               "errors" => [%{"name" => "HeadNotFound"}],

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{"root" => %{"format" => "cid", "type" => "string"}},

     

       13
       +
                   "required" => ["root"],

     

       14
       +
                   "type" => "object"

     

       15
       +
                 }

     

       16
       +
               },

     

       17
       +
               "parameters" => %{

     

       18
       +
                 "properties" => %{

     

       19
       +
                   "did" => %{

     

       20
       +
                     "description" => "The DID of the repo.",

     

       21
       +
                     "format" => "did",

     

       22
       +
                     "type" => "string"

     

       23
       +
                   }

     

       24
       +
                 },

     

       25
       +
                 "required" => ["did"],

     

       26
       +
                 "type" => "params"

     

       27
       +
               },

     

       28
       +
               "type" => "query"

     

       29
       +
             }

     

       30
       +
           },

     

       31
       +
           "id" => "com.atproto.sync.getHead",

     

       32
       +
           "lexicon" => 1

     

       33
       +
         })

     

       34
       +
       end

+50

lib/atproto/com/atproto/sync/getHostStatus.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetHostStatus do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Returns information about a specified upstream host, as consumed by the server. Implemented by relays.",

     

       9
       +
               "errors" => [%{"name" => "HostNotFound"}],

     

       10
       +
               "output" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{

     

       14
       +
                     "accountCount" => %{

     

       15
       +
                       "description" =>

     

       16
       +
                         "Number of accounts on the server which are associated with the upstream host. Note that the upstream may actually have more accounts.",

     

       17
       +
                       "type" => "integer"

     

       18
       +
                     },

     

       19
       +
                     "hostname" => %{"type" => "string"},

     

       20
       +
                     "seq" => %{

     

       21
       +
                       "description" =>

     

       22
       +
                         "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).",

     

       23
       +
                       "type" => "integer"

     

       24
       +
                     },

     

       25
       +
                     "status" => %{

     

       26
       +
                       "ref" => "com.atproto.sync.defs#hostStatus",

     

       27
       +
                       "type" => "ref"

     

       28
       +
                     }

     

       29
       +
                   },

     

       30
       +
                   "required" => ["hostname"],

     

       31
       +
                   "type" => "object"

     

       32
       +
                 }

     

       33
       +
               },

     

       34
       +
               "parameters" => %{

     

       35
       +
                 "properties" => %{

     

       36
       +
                   "hostname" => %{

     

       37
       +
                     "description" => "Hostname of the host (eg, PDS or relay) being queried.",

     

       38
       +
                     "type" => "string"

     

       39
       +
                   }

     

       40
       +
                 },

     

       41
       +
                 "required" => ["hostname"],

     

       42
       +
                 "type" => "params"

     

       43
       +
               },

     

       44
       +
               "type" => "query"

     

       45
       +
             }

     

       46
       +
           },

     

       47
       +
           "id" => "com.atproto.sync.getHostStatus",

     

       48
       +
           "lexicon" => 1

     

       49
       +
         })

     

       50
       +
       end

+43

lib/atproto/com/atproto/sync/getLatestCommit.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetLatestCommit do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get the current commit CID & revision of the specified repo. Does not require auth.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "RepoNotFound"},

     

       11
       +
                 %{"name" => "RepoTakendown"},

     

       12
       +
                 %{"name" => "RepoSuspended"},

     

       13
       +
                 %{"name" => "RepoDeactivated"}

     

       14
       +
               ],

     

       15
       +
               "output" => %{

     

       16
       +
                 "encoding" => "application/json",

     

       17
       +
                 "schema" => %{

     

       18
       +
                   "properties" => %{

     

       19
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       20
       +
                     "rev" => %{"format" => "tid", "type" => "string"}

     

       21
       +
                   },

     

       22
       +
                   "required" => ["cid", "rev"],

     

       23
       +
                   "type" => "object"

     

       24
       +
                 }

     

       25
       +
               },

     

       26
       +
               "parameters" => %{

     

       27
       +
                 "properties" => %{

     

       28
       +
                   "did" => %{

     

       29
       +
                     "description" => "The DID of the repo.",

     

       30
       +
                     "format" => "did",

     

       31
       +
                     "type" => "string"

     

       32
       +
                   }

     

       33
       +
                 },

     

       34
       +
                 "required" => ["did"],

     

       35
       +
                 "type" => "params"

     

       36
       +
               },

     

       37
       +
               "type" => "query"

     

       38
       +
             }

     

       39
       +
           },

     

       40
       +
           "id" => "com.atproto.sync.getLatestCommit",

     

       41
       +
           "lexicon" => 1

     

       42
       +
         })

     

       43
       +
       end

+40

lib/atproto/com/atproto/sync/getRecord.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetRecord do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "RecordNotFound"},

     

       11
       +
                 %{"name" => "RepoNotFound"},

     

       12
       +
                 %{"name" => "RepoTakendown"},

     

       13
       +
                 %{"name" => "RepoSuspended"},

     

       14
       +
                 %{"name" => "RepoDeactivated"}

     

       15
       +
               ],

     

       16
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       17
       +
               "parameters" => %{

     

       18
       +
                 "properties" => %{

     

       19
       +
                   "collection" => %{"format" => "nsid", "type" => "string"},

     

       20
       +
                   "did" => %{

     

       21
       +
                     "description" => "The DID of the repo.",

     

       22
       +
                     "format" => "did",

     

       23
       +
                     "type" => "string"

     

       24
       +
                   },

     

       25
       +
                   "rkey" => %{

     

       26
       +
                     "description" => "Record Key",

     

       27
       +
                     "format" => "record-key",

     

       28
       +
                     "type" => "string"

     

       29
       +
                   }

     

       30
       +
                 },

     

       31
       +
                 "required" => ["did", "collection", "rkey"],

     

       32
       +
                 "type" => "params"

     

       33
       +
               },

     

       34
       +
               "type" => "query"

     

       35
       +
             }

     

       36
       +
           },

     

       37
       +
           "id" => "com.atproto.sync.getRecord",

     

       38
       +
           "lexicon" => 1

     

       39
       +
         })

     

       40
       +
       end

+38

lib/atproto/com/atproto/sync/getRepo.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetRepo do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Download a repository export as CAR file. Optionally only a 'diff' since a previous revision. Does not require auth; implemented by PDS.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "RepoNotFound"},

     

       11
       +
                 %{"name" => "RepoTakendown"},

     

       12
       +
                 %{"name" => "RepoSuspended"},

     

       13
       +
                 %{"name" => "RepoDeactivated"}

     

       14
       +
               ],

     

       15
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       16
       +
               "parameters" => %{

     

       17
       +
                 "properties" => %{

     

       18
       +
                   "did" => %{

     

       19
       +
                     "description" => "The DID of the repo.",

     

       20
       +
                     "format" => "did",

     

       21
       +
                     "type" => "string"

     

       22
       +
                   },

     

       23
       +
                   "since" => %{

     

       24
       +
                     "description" => "The revision ('rev') of the repo to create a diff from.",

     

       25
       +
                     "format" => "tid",

     

       26
       +
                     "type" => "string"

     

       27
       +
                   }

     

       28
       +
                 },

     

       29
       +
                 "required" => ["did"],

     

       30
       +
                 "type" => "params"

     

       31
       +
               },

     

       32
       +
               "type" => "query"

     

       33
       +
             }

     

       34
       +
           },

     

       35
       +
           "id" => "com.atproto.sync.getRepo",

     

       36
       +
           "lexicon" => 1

     

       37
       +
         })

     

       38
       +
       end

+56

lib/atproto/com/atproto/sync/getRepoStatus.ex

···

       1
       +
       defmodule Com.Atproto.Sync.GetRepoStatus do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Get the hosting status for a repository, on this server. Expected to be implemented by PDS and Relay.",

     

       9
       +
               "errors" => [%{"name" => "RepoNotFound"}],

     

       10
       +
               "output" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{

     

       14
       +
                     "active" => %{"type" => "boolean"},

     

       15
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       16
       +
                     "rev" => %{

     

       17
       +
                       "description" => "Optional field, the current rev of the repo, if active=true",

     

       18
       +
                       "format" => "tid",

     

       19
       +
                       "type" => "string"

     

       20
       +
                     },

     

       21
       +
                     "status" => %{

     

       22
       +
                       "description" =>

     

       23
       +
                         "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.",

     

       24
       +
                       "knownValues" => [

     

       25
       +
                         "takendown",

     

       26
       +
                         "suspended",

     

       27
       +
                         "deleted",

     

       28
       +
                         "deactivated",

     

       29
       +
                         "desynchronized",

     

       30
       +
                         "throttled"

     

       31
       +
                       ],

     

       32
       +
                       "type" => "string"

     

       33
       +
                     }

     

       34
       +
                   },

     

       35
       +
                   "required" => ["did", "active"],

     

       36
       +
                   "type" => "object"

     

       37
       +
                 }

     

       38
       +
               },

     

       39
       +
               "parameters" => %{

     

       40
       +
                 "properties" => %{

     

       41
       +
                   "did" => %{

     

       42
       +
                     "description" => "The DID of the repo.",

     

       43
       +
                     "format" => "did",

     

       44
       +
                     "type" => "string"

     

       45
       +
                   }

     

       46
       +
                 },

     

       47
       +
                 "required" => ["did"],

     

       48
       +
                 "type" => "params"

     

       49
       +
               },

     

       50
       +
               "type" => "query"

     

       51
       +
             }

     

       52
       +
           },

     

       53
       +
           "id" => "com.atproto.sync.getRepoStatus",

     

       54
       +
           "lexicon" => 1

     

       55
       +
         })

     

       56
       +
       end

+58

lib/atproto/com/atproto/sync/listBlobs.ex

···

       1
       +
       defmodule Com.Atproto.Sync.ListBlobs do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS.",

     

       9
       +
               "errors" => [

     

       10
       +
                 %{"name" => "RepoNotFound"},

     

       11
       +
                 %{"name" => "RepoTakendown"},

     

       12
       +
                 %{"name" => "RepoSuspended"},

     

       13
       +
                 %{"name" => "RepoDeactivated"}

     

       14
       +
               ],

     

       15
       +
               "output" => %{

     

       16
       +
                 "encoding" => "application/json",

     

       17
       +
                 "schema" => %{

     

       18
       +
                   "properties" => %{

     

       19
       +
                     "cids" => %{

     

       20
       +
                       "items" => %{"format" => "cid", "type" => "string"},

     

       21
       +
                       "type" => "array"

     

       22
       +
                     },

     

       23
       +
                     "cursor" => %{"type" => "string"}

     

       24
       +
                   },

     

       25
       +
                   "required" => ["cids"],

     

       26
       +
                   "type" => "object"

     

       27
       +
                 }

     

       28
       +
               },

     

       29
       +
               "parameters" => %{

     

       30
       +
                 "properties" => %{

     

       31
       +
                   "cursor" => %{"type" => "string"},

     

       32
       +
                   "did" => %{

     

       33
       +
                     "description" => "The DID of the repo.",

     

       34
       +
                     "format" => "did",

     

       35
       +
                     "type" => "string"

     

       36
       +
                   },

     

       37
       +
                   "limit" => %{

     

       38
       +
                     "default" => 500,

     

       39
       +
                     "maximum" => 1000,

     

       40
       +
                     "minimum" => 1,

     

       41
       +
                     "type" => "integer"

     

       42
       +
                   },

     

       43
       +
                   "since" => %{

     

       44
       +
                     "description" => "Optional revision of the repo to list blobs since.",

     

       45
       +
                     "format" => "tid",

     

       46
       +
                     "type" => "string"

     

       47
       +
                   }

     

       48
       +
                 },

     

       49
       +
                 "required" => ["did"],

     

       50
       +
                 "type" => "params"

     

       51
       +
               },

     

       52
       +
               "type" => "query"

     

       53
       +
             }

     

       54
       +
           },

     

       55
       +
           "id" => "com.atproto.sync.listBlobs",

     

       56
       +
           "lexicon" => 1

     

       57
       +
         })

     

       58
       +
       end

+63

lib/atproto/com/atproto/sync/listHosts.ex

···

       1
       +
       defmodule Com.Atproto.Sync.ListHosts do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "host" => %{

     

       7
       +
               "properties" => %{

     

       8
       +
                 "accountCount" => %{"type" => "integer"},

     

       9
       +
                 "hostname" => %{

     

       10
       +
                   "description" => "hostname of server; not a URL (no scheme)",

     

       11
       +
                   "type" => "string"

     

       12
       +
                 },

     

       13
       +
                 "seq" => %{

     

       14
       +
                   "description" =>

     

       15
       +
                     "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).",

     

       16
       +
                   "type" => "integer"

     

       17
       +
                 },

     

       18
       +
                 "status" => %{

     

       19
       +
                   "ref" => "com.atproto.sync.defs#hostStatus",

     

       20
       +
                   "type" => "ref"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "required" => ["hostname"],

     

       24
       +
               "type" => "object"

     

       25
       +
             },

     

       26
       +
             "main" => %{

     

       27
       +
               "description" =>

     

       28
       +
                 "Enumerates upstream hosts (eg, PDS or relay instances) that this service consumes from. Implemented by relays.",

     

       29
       +
               "output" => %{

     

       30
       +
                 "encoding" => "application/json",

     

       31
       +
                 "schema" => %{

     

       32
       +
                   "properties" => %{

     

       33
       +
                     "cursor" => %{"type" => "string"},

     

       34
       +
                     "hosts" => %{

     

       35
       +
                       "description" =>

     

       36
       +
                         "Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first.",

     

       37
       +
                       "items" => %{"ref" => "#host", "type" => "ref"},

     

       38
       +
                       "type" => "array"

     

       39
       +
                     }

     

       40
       +
                   },

     

       41
       +
                   "required" => ["hosts"],

     

       42
       +
                   "type" => "object"

     

       43
       +
                 }

     

       44
       +
               },

     

       45
       +
               "parameters" => %{

     

       46
       +
                 "properties" => %{

     

       47
       +
                   "cursor" => %{"type" => "string"},

     

       48
       +
                   "limit" => %{

     

       49
       +
                     "default" => 200,

     

       50
       +
                     "maximum" => 1000,

     

       51
       +
                     "minimum" => 1,

     

       52
       +
                     "type" => "integer"

     

       53
       +
                   }

     

       54
       +
                 },

     

       55
       +
                 "type" => "params"

     

       56
       +
               },

     

       57
       +
               "type" => "query"

     

       58
       +
             }

     

       59
       +
           },

     

       60
       +
           "id" => "com.atproto.sync.listHosts",

     

       61
       +
           "lexicon" => 1

     

       62
       +
         })

     

       63
       +
       end

+68

lib/atproto/com/atproto/sync/listRepos.ex

···

       1
       +
       defmodule Com.Atproto.Sync.ListRepos do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Enumerates all the DID, rev, and commit CID for all repos hosted by this service. Does not require auth; implemented by PDS and Relay.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       +
                     "repos" => %{

     

       15
       +
                       "items" => %{"ref" => "#repo", "type" => "ref"},

     

       16
       +
                       "type" => "array"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "required" => ["repos"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "parameters" => %{

     

       24
       +
                 "properties" => %{

     

       25
       +
                   "cursor" => %{"type" => "string"},

     

       26
       +
                   "limit" => %{

     

       27
       +
                     "default" => 500,

     

       28
       +
                     "maximum" => 1000,

     

       29
       +
                     "minimum" => 1,

     

       30
       +
                     "type" => "integer"

     

       31
       +
                   }

     

       32
       +
                 },

     

       33
       +
                 "type" => "params"

     

       34
       +
               },

     

       35
       +
               "type" => "query"

     

       36
       +
             },

     

       37
       +
             "repo" => %{

     

       38
       +
               "properties" => %{

     

       39
       +
                 "active" => %{"type" => "boolean"},

     

       40
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       41
       +
                 "head" => %{

     

       42
       +
                   "description" => "Current repo commit CID",

     

       43
       +
                   "format" => "cid",

     

       44
       +
                   "type" => "string"

     

       45
       +
                 },

     

       46
       +
                 "rev" => %{"format" => "tid", "type" => "string"},

     

       47
       +
                 "status" => %{

     

       48
       +
                   "description" =>

     

       49
       +
                     "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
       +
                   "knownValues" => [

     

       51
       +
                     "takendown",

     

       52
       +
                     "suspended",

     

       53
       +
                     "deleted",

     

       54
       +
                     "deactivated",

     

       55
       +
                     "desynchronized",

     

       56
       +
                     "throttled"

     

       57
       +
                   ],

     

       58
       +
                   "type" => "string"

     

       59
       +
                 }

     

       60
       +
               },

     

       61
       +
               "required" => ["did", "head", "rev"],

     

       62
       +
               "type" => "object"

     

       63
       +
             }

     

       64
       +
           },

     

       65
       +
           "id" => "com.atproto.sync.listRepos",

     

       66
       +
           "lexicon" => 1

     

       67
       +
         })

     

       68
       +
       end

+50

lib/atproto/com/atproto/sync/listReposByCollection.ex

···

       1
       +
       defmodule Com.Atproto.Sync.ListReposByCollection do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Enumerates all the DIDs which have records with the given collection NSID.",

     

       9
       +
               "output" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       +
                     "repos" => %{

     

       15
       +
                       "items" => %{"ref" => "#repo", "type" => "ref"},

     

       16
       +
                       "type" => "array"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "required" => ["repos"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "parameters" => %{

     

       24
       +
                 "properties" => %{

     

       25
       +
                   "collection" => %{"format" => "nsid", "type" => "string"},

     

       26
       +
                   "cursor" => %{"type" => "string"},

     

       27
       +
                   "limit" => %{

     

       28
       +
                     "default" => 500,

     

       29
       +
                     "description" =>

     

       30
       +
                       "Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists.",

     

       31
       +
                     "maximum" => 2000,

     

       32
       +
                     "minimum" => 1,

     

       33
       +
                     "type" => "integer"

     

       34
       +
                   }

     

       35
       +
                 },

     

       36
       +
                 "required" => ["collection"],

     

       37
       +
                 "type" => "params"

     

       38
       +
               },

     

       39
       +
               "type" => "query"

     

       40
       +
             },

     

       41
       +
             "repo" => %{

     

       42
       +
               "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       43
       +
               "required" => ["did"],

     

       44
       +
               "type" => "object"

     

       45
       +
             }

     

       46
       +
           },

     

       47
       +
           "id" => "com.atproto.sync.listReposByCollection",

     

       48
       +
           "lexicon" => 1

     

       49
       +
         })

     

       50
       +
       end

+29

lib/atproto/com/atproto/sync/notifyOfUpdate.ex

···

       1
       +
       defmodule Com.Atproto.Sync.NotifyOfUpdate do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "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",

     

       9
       +
               "input" => %{

     

       10
       +
                 "encoding" => "application/json",

     

       11
       +
                 "schema" => %{

     

       12
       +
                   "properties" => %{

     

       13
       +
                     "hostname" => %{

     

       14
       +
                       "description" =>

     

       15
       +
                         "Hostname of the current service (usually a PDS) that is notifying of update.",

     

       16
       +
                       "type" => "string"

     

       17
       +
                     }

     

       18
       +
                   },

     

       19
       +
                   "required" => ["hostname"],

     

       20
       +
                   "type" => "object"

     

       21
       +
                 }

     

       22
       +
               },

     

       23
       +
               "type" => "procedure"

     

       24
       +
             }

     

       25
       +
           },

     

       26
       +
           "id" => "com.atproto.sync.notifyOfUpdate",

     

       27
       +
           "lexicon" => 1

     

       28
       +
         })

     

       29
       +
       end

+30

lib/atproto/com/atproto/sync/requestCrawl.ex

···

       1
       +
       defmodule Com.Atproto.Sync.RequestCrawl do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "main" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "Request a service to persistently crawl hosted repos. Expected use is new PDS instances declaring their existence to Relays. Does not require auth.",

     

       9
       +
               "errors" => [%{"name" => "HostBanned"}],

     

       10
       +
               "input" => %{

     

       11
       +
                 "encoding" => "application/json",

     

       12
       +
                 "schema" => %{

     

       13
       +
                   "properties" => %{

     

       14
       +
                     "hostname" => %{

     

       15
       +
                       "description" =>

     

       16
       +
                         "Hostname of the current service (eg, PDS) that is requesting to be crawled.",

     

       17
       +
                       "type" => "string"

     

       18
       +
                     }

     

       19
       +
                   },

     

       20
       +
                   "required" => ["hostname"],

     

       21
       +
                   "type" => "object"

     

       22
       +
                 }

     

       23
       +
               },

     

       24
       +
               "type" => "procedure"

     

       25
       +
             }

     

       26
       +
           },

     

       27
       +
           "id" => "com.atproto.sync.requestCrawl",

     

       28
       +
           "lexicon" => 1

     

       29
       +
         })

     

       30
       +
       end

+237

lib/atproto/com/atproto/sync/subscribeRepos.ex

···

       1
       +
       defmodule Com.Atproto.Sync.SubscribeRepos do

     

       2
       +
         use Atex.Lexicon

     

       3
       +
       

     

       4
       +
         deflexicon(%{

     

       5
       +
           "defs" => %{

     

       6
       +
             "account" => %{

     

       7
       +
               "description" =>

     

       8
       +
                 "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.",

     

       9
       +
               "properties" => %{

     

       10
       +
                 "active" => %{

     

       11
       +
                   "description" =>

     

       12
       +
                     "Indicates that the account has a repository which can be fetched from the host that emitted this event.",

     

       13
       +
                   "type" => "boolean"

     

       14
       +
                 },

     

       15
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       16
       +
                 "seq" => %{"type" => "integer"},

     

       17
       +
                 "status" => %{

     

       18
       +
                   "description" =>

     

       19
       +
                     "If active=false, this optional field indicates a reason for why the account is not active.",

     

       20
       +
                   "knownValues" => [

     

       21
       +
                     "takendown",

     

       22
       +
                     "suspended",

     

       23
       +
                     "deleted",

     

       24
       +
                     "deactivated",

     

       25
       +
                     "desynchronized",

     

       26
       +
                     "throttled"

     

       27
       +
                   ],

     

       28
       +
                   "type" => "string"

     

       29
       +
                 },

     

       30
       +
                 "time" => %{"format" => "datetime", "type" => "string"}

     

       31
       +
               },

     

       32
       +
               "required" => ["seq", "did", "time", "active"],

     

       33
       +
               "type" => "object"

     

       34
       +
             },

     

       35
       +
             "commit" => %{

     

       36
       +
               "description" =>

     

       37
       +
                 "Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature.",

     

       38
       +
               "nullable" => ["since"],

     

       39
       +
               "properties" => %{

     

       40
       +
                 "blobs" => %{

     

       41
       +
                   "items" => %{

     

       42
       +
                     "description" =>

     

       43
       +
                       "DEPRECATED -- will soon always be empty. List of new blobs (by CID) referenced by records in this commit.",

     

       44
       +
                     "type" => "cid-link"

     

       45
       +
                   },

     

       46
       +
                   "type" => "array"

     

       47
       +
                 },

     

       48
       +
                 "blocks" => %{

     

       49
       +
                   "description" =>

     

       50
       +
                     "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.",

     

       51
       +
                   "maxLength" => 2_000_000,

     

       52
       +
                   "type" => "bytes"

     

       53
       +
                 },

     

       54
       +
                 "commit" => %{

     

       55
       +
                   "description" => "Repo commit object CID.",

     

       56
       +
                   "type" => "cid-link"

     

       57
       +
                 },

     

       58
       +
                 "ops" => %{

     

       59
       +
                   "items" => %{

     

       60
       +
                     "description" =>

     

       61
       +
                       "List of repo mutation operations in this commit (eg, records created, updated, or deleted).",

     

       62
       +
                     "ref" => "#repoOp",

     

       63
       +
                     "type" => "ref"

     

       64
       +
                   },

     

       65
       +
                   "maxLength" => 200,

     

       66
       +
                   "type" => "array"

     

       67
       +
                 },

     

       68
       +
                 "prevData" => %{

     

       69
       +
                   "description" =>

     

       70
       +
                     "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.",

     

       71
       +
                   "type" => "cid-link"

     

       72
       +
                 },

     

       73
       +
                 "rebase" => %{

     

       74
       +
                   "description" => "DEPRECATED -- unused",

     

       75
       +
                   "type" => "boolean"

     

       76
       +
                 },

     

       77
       +
                 "repo" => %{

     

       78
       +
                   "description" =>

     

       79
       +
                     "The repo this event comes from. Note that all other message types name this field 'did'.",

     

       80
       +
                   "format" => "did",

     

       81
       +
                   "type" => "string"

     

       82
       +
                 },

     

       83
       +
                 "rev" => %{

     

       84
       +
                   "description" =>

     

       85
       +
                     "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.",

     

       86
       +
                   "format" => "tid",

     

       87
       +
                   "type" => "string"

     

       88
       +
                 },

     

       89
       +
                 "seq" => %{

     

       90
       +
                   "description" => "The stream sequence number of this message.",

     

       91
       +
                   "type" => "integer"

     

       92
       +
                 },

     

       93
       +
                 "since" => %{

     

       94
       +
                   "description" => "The rev of the last emitted commit from this repo (if any).",

     

       95
       +
                   "format" => "tid",

     

       96
       +
                   "type" => "string"

     

       97
       +
                 },

     

       98
       +
                 "time" => %{

     

       99
       +
                   "description" => "Timestamp of when this message was originally broadcast.",

     

       100
       +
                   "format" => "datetime",

     

       101
       +
                   "type" => "string"

     

       102
       +
                 },

     

       103
       +
                 "tooBig" => %{

     

       104
       +
                   "description" =>

     

       105
       +
                     "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.",

     

       106
       +
                   "type" => "boolean"

     

       107
       +
                 }

     

       108
       +
               },

     

       109
       +
               "required" => [

     

       110
       +
                 "seq",

     

       111
       +
                 "rebase",

     

       112
       +
                 "tooBig",

     

       113
       +
                 "repo",

     

       114
       +
                 "commit",

     

       115
       +
                 "rev",

     

       116
       +
                 "since",

     

       117
       +
                 "blocks",

     

       118
       +
                 "ops",

     

       119
       +
                 "blobs",

     

       120
       +
                 "time"

     

       121
       +
               ],

     

       122
       +
               "type" => "object"

     

       123
       +
             },

     

       124
       +
             "identity" => %{

     

       125
       +
               "description" =>

     

       126
       +
                 "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.",

     

       127
       +
               "properties" => %{

     

       128
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       129
       +
                 "handle" => %{

     

       130
       +
                   "description" =>

     

       131
       +
                     "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.",

     

       132
       +
                   "format" => "handle",

     

       133
       +
                   "type" => "string"

     

       134
       +
                 },

     

       135
       +
                 "seq" => %{"type" => "integer"},

     

       136
       +
                 "time" => %{"format" => "datetime", "type" => "string"}

     

       137
       +
               },

     

       138
       +
               "required" => ["seq", "did", "time"],

     

       139
       +
               "type" => "object"

     

       140
       +
             },

     

       141
       +
             "info" => %{

     

       142
       +
               "properties" => %{

     

       143
       +
                 "message" => %{"type" => "string"},

     

       144
       +
                 "name" => %{"knownValues" => ["OutdatedCursor"], "type" => "string"}

     

       145
       +
               },

     

       146
       +
               "required" => ["name"],

     

       147
       +
               "type" => "object"

     

       148
       +
             },

     

       149
       +
             "main" => %{

     

       150
       +
               "description" =>

     

       151
       +
                 "Repository event stream, aka Firehose endpoint. Outputs repo commits with diff data, and identity update events, for all repositories on the current server. See the atproto specifications for details around stream sequencing, repo versioning, CAR diff format, and more. Public and does not require auth; implemented by PDS and Relay.",

     

       152
       +
               "errors" => [

     

       153
       +
                 %{"name" => "FutureCursor"},

     

       154
       +
                 %{

     

       155
       +
                   "description" =>

     

       156
       +
                     "If the consumer of the stream can not keep up with events, and a backlog gets too large, the server will drop the connection.",

     

       157
       +
                   "name" => "ConsumerTooSlow"

     

       158
       +
                 }

     

       159
       +
               ],

     

       160
       +
               "message" => %{

     

       161
       +
                 "schema" => %{

     

       162
       +
                   "refs" => ["#commit", "#sync", "#identity", "#account", "#info"],

     

       163
       +
                   "type" => "union"

     

       164
       +
                 }

     

       165
       +
               },

     

       166
       +
               "parameters" => %{

     

       167
       +
                 "properties" => %{

     

       168
       +
                   "cursor" => %{

     

       169
       +
                     "description" => "The last known event seq number to backfill from.",

     

       170
       +
                     "type" => "integer"

     

       171
       +
                   }

     

       172
       +
                 },

     

       173
       +
                 "type" => "params"

     

       174
       +
               },

     

       175
       +
               "type" => "subscription"

     

       176
       +
             },

     

       177
       +
             "repoOp" => %{

     

       178
       +
               "description" => "A repo operation, ie a mutation of a single record.",

     

       179
       +
               "nullable" => ["cid"],

     

       180
       +
               "properties" => %{

     

       181
       +
                 "action" => %{

     

       182
       +
                   "knownValues" => ["create", "update", "delete"],

     

       183
       +
                   "type" => "string"

     

       184
       +
                 },

     

       185
       +
                 "cid" => %{

     

       186
       +
                   "description" => "For creates and updates, the new record CID. For deletions, null.",

     

       187
       +
                   "type" => "cid-link"

     

       188
       +
                 },

     

       189
       +
                 "path" => %{"type" => "string"},

     

       190
       +
                 "prev" => %{

     

       191
       +
                   "description" =>

     

       192
       +
                     "For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined.",

     

       193
       +
                   "type" => "cid-link"

     

       194
       +
                 }

     

       195
       +
               },

     

       196
       +
               "required" => ["action", "path", "cid"],

     

       197
       +
               "type" => "object"

     

       198
       +
             },

     

       199
       +
             "sync" => %{

     

       200
       +
               "description" =>

     

       201
       +
                 "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.",

     

       202
       +
               "properties" => %{

     

       203
       +
                 "blocks" => %{

     

       204
       +
                   "description" =>

     

       205
       +
                     "CAR file containing the commit, as a block. The CAR header must include the commit block CID as the first 'root'.",

     

       206
       +
                   "maxLength" => 10000,

     

       207
       +
                   "type" => "bytes"

     

       208
       +
                 },

     

       209
       +
                 "did" => %{

     

       210
       +
                   "description" =>

     

       211
       +
                     "The account this repo event corresponds to. Must match that in the commit object.",

     

       212
       +
                   "format" => "did",

     

       213
       +
                   "type" => "string"

     

       214
       +
                 },

     

       215
       +
                 "rev" => %{

     

       216
       +
                   "description" =>

     

       217
       +
                     "The rev of the commit. This value must match that in the commit object.",

     

       218
       +
                   "type" => "string"

     

       219
       +
                 },

     

       220
       +
                 "seq" => %{

     

       221
       +
                   "description" => "The stream sequence number of this message.",

     

       222
       +
                   "type" => "integer"

     

       223
       +
                 },

     

       224
       +
                 "time" => %{

     

       225
       +
                   "description" => "Timestamp of when this message was originally broadcast.",

     

       226
       +
                   "format" => "datetime",

     

       227
       +
                   "type" => "string"

     

       228
       +
                 }

     

       229
       +
               },

     

       230
       +
               "required" => ["seq", "did", "blocks", "rev", "time"],

     

       231
       +
               "type" => "object"

     

       232
       +
             }

     

       233
       +
           },

     

       234
       +
           "id" => "com.atproto.sync.subscribeRepos",

     

       235
       +
           "lexicon" => 1

     

       236
       +
         })

     

       237
       +
       end