@atproto/api 0.3.11 → 0.3.13

package/dist/client/index.d.ts

@@ -344,8 +344,8 @@ export declare class SyncNS {
     getRepo(params?: ComAtprotoSyncGetRepo.QueryParams, opts?: ComAtprotoSyncGetRepo.CallOptions): Promise<ComAtprotoSyncGetRepo.Response>;
     listBlobs(params?: ComAtprotoSyncListBlobs.QueryParams, opts?: ComAtprotoSyncListBlobs.CallOptions): Promise<ComAtprotoSyncListBlobs.Response>;
     listRepos(params?: ComAtprotoSyncListRepos.QueryParams, opts?: ComAtprotoSyncListRepos.CallOptions): Promise<ComAtprotoSyncListRepos.Response>;
-    notifyOfUpdate(params?: ComAtprotoSyncNotifyOfUpdate.QueryParams, opts?: ComAtprotoSyncNotifyOfUpdate.CallOptions): Promise<ComAtprotoSyncNotifyOfUpdate.Response>;
-    requestCrawl(params?: ComAtprotoSyncRequestCrawl.QueryParams, opts?: ComAtprotoSyncRequestCrawl.CallOptions): Promise<ComAtprotoSyncRequestCrawl.Response>;
+    notifyOfUpdate(data?: ComAtprotoSyncNotifyOfUpdate.InputSchema, opts?: ComAtprotoSyncNotifyOfUpdate.CallOptions): Promise<ComAtprotoSyncNotifyOfUpdate.Response>;
+    requestCrawl(data?: ComAtprotoSyncRequestCrawl.InputSchema, opts?: ComAtprotoSyncRequestCrawl.CallOptions): Promise<ComAtprotoSyncRequestCrawl.Response>;
 }
 export declare class AppNS {
     _service: AtpServiceClient;

package/dist/client/lexicons.d.ts

@@ -771,6 +771,13 @@ export declare const schemaDict: {
                                 type: string;
                             };
                         };
+                        reporters: {
+                            type: string;
+                            items: {
+                                type: string;
+                            };
+                            description: string;
+                        };
                         resolved: {
                             type: string;
                         };
@@ -2817,6 +2824,9 @@ export declare const schemaDict: {
                         };
                     };
                 };
+                errors: {
+                    name: string;
+                }[];
             };
         };
     };
@@ -3001,13 +3011,16 @@ export declare const schemaDict: {
             main: {
                 type: string;
                 description: string;
-                parameters: {
-                    type: string;
-                    required: string[];
-                    properties: {
-                        hostname: {
-                            type: string;
-                            description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            hostname: {
+                                type: string;
+                                description: string;
+                            };
                         };
                     };
                 };
@@ -3021,13 +3034,16 @@ export declare const schemaDict: {
             main: {
                 type: string;
                 description: string;
-                parameters: {
-                    type: string;
-                    required: string[];
-                    properties: {
-                        hostname: {
-                            type: string;
-                            description: string;
+                input: {
+                    encoding: string;
+                    schema: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            hostname: {
+                                type: string;
+                                description: string;
+                            };
                         };
                     };
                 };
@@ -4905,6 +4921,14 @@ export declare const schemaDict: {
                             type: string;
                             refs: string[];
                         };
+                        langs: {
+                            type: string;
+                            maxLength: number;
+                            items: {
+                                type: string;
+                                format: string;
+                            };
+                        };
                         createdAt: {
                             type: string;
                             format: string;
@@ -5022,6 +5046,10 @@ export declare const schemaDict: {
                         type: string;
                         format: string;
                     };
+                    cid: {
+                        type: string;
+                        format: string;
+                    };
                     name: {
                         type: string;
                         maxLength: number;
@@ -5052,6 +5080,10 @@ export declare const schemaDict: {
                         type: string;
                         format: string;
                     };
+                    cid: {
+                        type: string;
+                        format: string;
+                    };
                     creator: {
                         type: string;
                         ref: string;

package/dist/client/types/app/bsky/embed/record.d.ts

@@ -1,6 +1,7 @@
 import { ValidationResult } from '@atproto/lexicon';
 import * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef';
 import * as AppBskyFeedDefs from '../feed/defs';
+import * as AppBskyGraphDefs from '../graph/defs';
 import * as AppBskyActorDefs from '../actor/defs';
 import * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs';
 import * as AppBskyEmbedImages from './images';
@@ -13,7 +14,7 @@ export interface Main {
 export declare function isMain(v: unknown): v is Main;
 export declare function validateMain(v: unknown): ValidationResult;
 export interface View {
-    record: ViewRecord | ViewNotFound | ViewBlocked | AppBskyFeedDefs.GeneratorView | {
+    record: ViewRecord | ViewNotFound | ViewBlocked | AppBskyFeedDefs.GeneratorView | AppBskyGraphDefs.ListView | {
         $type: string;
         [k: string]: unknown;
     };

package/dist/client/types/app/bsky/feed/defs.d.ts

@@ -94,7 +94,7 @@ export declare function validateBlockedPost(v: unknown): ValidationResult;
 export interface GeneratorView {
     uri: string;
     cid: string;
-    did?: string;
+    did: string;
     creator: AppBskyActorDefs.ProfileView;
     displayName: string;
     description?: string;

package/dist/client/types/app/bsky/feed/post.d.ts

@@ -14,6 +14,7 @@ export interface Record {
         $type: string;
         [k: string]: unknown;
     };
+    langs?: string[];
     createdAt: string;
     [k: string]: unknown;
 }

package/dist/client/types/app/bsky/graph/defs.d.ts

@@ -3,6 +3,7 @@ import * as AppBskyActorDefs from '../actor/defs';
 import * as AppBskyRichtextFacet from '../richtext/facet';
 export interface ListViewBasic {
     uri: string;
+    cid: string;
     name: string;
     purpose: ListPurpose;
     avatar?: string;
@@ -14,6 +15,7 @@ export declare function isListViewBasic(v: unknown): v is ListViewBasic;
 export declare function validateListViewBasic(v: unknown): ValidationResult;
 export interface ListView {
     uri: string;
+    cid: string;
     creator: AppBskyActorDefs.ProfileView;
     name: string;
     purpose: ListPurpose;

package/dist/client/types/com/atproto/admin/getModerationReports.d.ts

@@ -3,6 +3,7 @@ import * as ComAtprotoAdminDefs from './defs';
 export interface QueryParams {
     subject?: string;
     ignoreSubjects?: string[];
+    reporters?: string[];
     resolved?: boolean;
     actionType?: 'com.atproto.admin.defs#takedown' | 'com.atproto.admin.defs#flag' | 'com.atproto.admin.defs#acknowledge' | 'com.atproto.admin.defs#escalate' | (string & {});
     limit?: number;

package/dist/client/types/com/atproto/sync/getHead.d.ts

@@ -1,4 +1,4 @@
-import { Headers } from '@atproto/xrpc';
+import { Headers, XRPCError } from '@atproto/xrpc';
 export interface QueryParams {
     did: string;
 }
@@ -15,4 +15,7 @@ export interface Response {
     headers: Headers;
     data: OutputSchema;
 }
+export declare class HeadNotFoundError extends XRPCError {
+    constructor(src: XRPCError);
+}
 export declare function toKnownErr(e: any): any;

package/dist/client/types/com/atproto/sync/notifyOfUpdate.d.ts

@@ -1,10 +1,14 @@
 import { Headers } from '@atproto/xrpc';
 export interface QueryParams {
+}
+export interface InputSchema {
     hostname: string;
+    [k: string]: unknown;
 }
-export declare type InputSchema = undefined;
 export interface CallOptions {
     headers?: Headers;
+    qp?: QueryParams;
+    encoding: 'application/json';
 }
 export interface Response {
     success: boolean;

package/dist/client/types/com/atproto/sync/requestCrawl.d.ts

@@ -1,10 +1,14 @@
 import { Headers } from '@atproto/xrpc';
 export interface QueryParams {
+}
+export interface InputSchema {
     hostname: string;
+    [k: string]: unknown;
 }
-export declare type InputSchema = undefined;
 export interface CallOptions {
     headers?: Headers;
+    qp?: QueryParams;
+    encoding: 'application/json';
 }
 export interface Response {
     success: boolean;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { AtUri } from '@atproto/uri';
 export { BlobRef, lexToJson, stringifyLex, jsonToLex, jsonStringToLex, } from '@atproto/lexicon';
+export { parseLanguage } from '@atproto/common-web';
 export * from './types';
 export * from './client';
 export * from './agent';

package/dist/index.js

@@ -9031,6 +9031,7 @@ __export(src_exports4, {
   jsonStringToLex: () => jsonStringToLex,
   jsonToLex: () => jsonToLex,
   lexToJson: () => lexToJson,
+  parseLanguage: () => parseLanguage,
   sanitizeRichText: () => sanitizeRichText,
   stringifyLex: () => stringifyLex
 });
@@ -15214,6 +15215,26 @@ var graphemeLen = (str) => {
   const splitter = new import_graphemer.default();
   return splitter.countGraphemes(str);
 };
+var parseLanguage = (langTag) => {
+  const parsed = langTag.match(bcp47Regexp);
+  if (!parsed?.groups)
+    return null;
+  const parts = parsed.groups;
+  return {
+    grandfathered: parts.grandfathered,
+    language: parts.language,
+    extlang: parts.extlang,
+    script: parts.script,
+    region: parts.region,
+    variant: parts.variant,
+    extension: parts.extension,
+    privateUse: parts.privateUseA || parts.privateUseB
+  };
+};
+var validateLanguage = (langTag) => {
+  return bcp47Regexp.test(langTag);
+};
+var bcp47Regexp = /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/;
 
 // ../lexicon/src/validators/formats.ts
 var import_iso_datestring_validator = __toESM(require_dist());
@@ -15310,6 +15331,17 @@ function cid(path, value) {
   }
   return { success: true, value };
 }
+function language(path, value) {
+  if (validateLanguage(value)) {
+    return { success: true, value };
+  }
+  return {
+    success: false,
+    error: new ValidationError(
+      `${path} must be a well-formed BCP 47 language tag`
+    )
+  };
+}
 
 // ../lexicon/src/validators/primitives.ts
 function validate(lexicons2, path, def2, value) {
@@ -15509,6 +15541,8 @@ function string2(lexicons2, path, def2, value) {
         return nsid(path, value);
       case "cid":
         return cid(path, value);
+      case "language":
+        return language(path, value);
     }
   }
   return { success: true, value };
@@ -15874,7 +15908,8 @@ var lexStringFormat = z.enum([
   "handle",
   "at-identifier",
   "nsid",
-  "cid"
+  "cid",
+  "language"
 ]);
 var lexString = z.object({
   type: z.literal("string"),
@@ -15992,7 +16027,6 @@ var lexXrpcSubscription = z.object({
   description: z.string().optional(),
   parameters: lexXrpcParameters.optional(),
   message: lexXrpcSubscriptionMessage.optional(),
-  infos: lexXrpcError.array().optional(),
   errors: lexXrpcError.array().optional()
 }).strict();
 var lexRecord = z.object({
@@ -17568,6 +17602,13 @@ var schemaDict = {
                 type: "string"
               }
             },
+            reporters: {
+              type: "array",
+              items: {
+                type: "string"
+              },
+              description: "Filter reports made by one or more DIDs"
+            },
             resolved: {
               type: "boolean"
             },
@@ -19731,7 +19772,12 @@ var schemaDict = {
               }
             }
           }
-        }
+        },
+        errors: [
+          {
+            name: "HeadNotFound"
+          }
+        ]
       }
     }
   },
@@ -19914,15 +19960,18 @@ var schemaDict = {
     id: "com.atproto.sync.notifyOfUpdate",
     defs: {
       main: {
-        type: "query",
+        type: "procedure",
         description: "Notify a crawling service of a recent update. Often when a long break between updates causes the connection with the crawling service to break.",
-        parameters: {
-          type: "params",
-          required: ["hostname"],
-          properties: {
-            hostname: {
-              type: "string",
-              description: "Hostname of the service that is notifying of update."
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["hostname"],
+            properties: {
+              hostname: {
+                type: "string",
+                description: "Hostname of the service that is notifying of update."
+              }
             }
           }
         }
@@ -19934,15 +19983,18 @@ var schemaDict = {
     id: "com.atproto.sync.requestCrawl",
     defs: {
       main: {
-        type: "query",
+        type: "procedure",
         description: "Request a service to persistently crawl hosted repos.",
-        parameters: {
-          type: "params",
-          required: ["hostname"],
-          properties: {
-            hostname: {
-              type: "string",
-              description: "Hostname of the service that is requesting to be crawled."
+        input: {
+          encoding: "application/json",
+          schema: {
+            type: "object",
+            required: ["hostname"],
+            properties: {
+              hostname: {
+                type: "string",
+                description: "Hostname of the service that is requesting to be crawled."
+              }
             }
           }
         }
@@ -20789,7 +20841,8 @@ var schemaDict = {
               "lex:app.bsky.embed.record#viewRecord",
               "lex:app.bsky.embed.record#viewNotFound",
               "lex:app.bsky.embed.record#viewBlocked",
-              "lex:app.bsky.feed.defs#generatorView"
+              "lex:app.bsky.feed.defs#generatorView",
+              "lex:app.bsky.graph.defs#listView"
             ]
           }
         }
@@ -21082,7 +21135,7 @@ var schemaDict = {
       },
       generatorView: {
         type: "object",
-        required: ["uri", "cid", "creator", "displayName", "indexedAt"],
+        required: ["uri", "cid", "did", "creator", "displayName", "indexedAt"],
         properties: {
           uri: {
             type: "string",
@@ -21900,6 +21953,14 @@ var schemaDict = {
                 "lex:app.bsky.embed.recordWithMedia"
               ]
             },
+            langs: {
+              type: "array",
+              maxLength: 3,
+              items: {
+                type: "string",
+                format: "language"
+              }
+            },
             createdAt: {
               type: "string",
               format: "datetime"
@@ -22011,12 +22072,16 @@ var schemaDict = {
     defs: {
       listViewBasic: {
         type: "object",
-        required: ["uri", "name", "purpose"],
+        required: ["uri", "cid", "name", "purpose"],
         properties: {
           uri: {
             type: "string",
             format: "at-uri"
           },
+          cid: {
+            type: "string",
+            format: "cid"
+          },
           name: {
             type: "string",
             maxLength: 64,
@@ -22041,12 +22106,16 @@ var schemaDict = {
       },
       listView: {
         type: "object",
-        required: ["uri", "creator", "name", "purpose", "indexedAt"],
+        required: ["uri", "cid", "creator", "name", "purpose", "indexedAt"],
         properties: {
           uri: {
             type: "string",
             format: "at-uri"
           },
+          cid: {
+            type: "string",
+            format: "cid"
+          },
           creator: {
             type: "ref",
             ref: "lex:app.bsky.actor.defs#profileView"
@@ -23786,10 +23855,18 @@ function toKnownErr50(e) {
 // src/client/types/com/atproto/sync/getHead.ts
 var getHead_exports = {};
 __export(getHead_exports, {
+  HeadNotFoundError: () => HeadNotFoundError,
   toKnownErr: () => toKnownErr51
 });
+var HeadNotFoundError = class extends XRPCError {
+  constructor(src2) {
+    super(src2.status, src2.error, src2.message);
+  }
+};
 function toKnownErr51(e) {
   if (e instanceof XRPCError) {
+    if (e.error === "HeadNotFound")
+      return new HeadNotFoundError(e);
   }
   return e;
 }
@@ -25507,13 +25584,13 @@ var SyncNS = class {
       throw toKnownErr55(e);
     });
   }
-  notifyOfUpdate(params2, opts) {
-    return this._service.xrpc.call("com.atproto.sync.notifyOfUpdate", params2, void 0, opts).catch((e) => {
+  notifyOfUpdate(data, opts) {
+    return this._service.xrpc.call("com.atproto.sync.notifyOfUpdate", opts?.qp, data, opts).catch((e) => {
       throw toKnownErr56(e);
     });
   }
-  requestCrawl(params2, opts) {
-    return this._service.xrpc.call("com.atproto.sync.requestCrawl", params2, void 0, opts).catch((e) => {
+  requestCrawl(data, opts) {
+    return this._service.xrpc.call("com.atproto.sync.requestCrawl", opts?.qp, data, opts).catch((e) => {
       throw toKnownErr57(e);
     });
   }