@atproto/lexicon-resolver 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @atproto/lexicon-resolver
+
+## 0.1.0
+
+### Minor Changes
+
+- [#4069](https://github.com/bluesky-social/atproto/pull/4069) [`331a356ce`](https://github.com/bluesky-social/atproto/commit/331a356ce27ff1d0b24747b0c16f3b54b07a0a12) Thanks [@devinivy](https://github.com/devinivy)! - Support for Lexicon resolution and DID authority lookups.
+
+### Patch Changes
+
+- Updated dependencies [[`331a356ce`](https://github.com/bluesky-social/atproto/commit/331a356ce27ff1d0b24747b0c16f3b54b07a0a12), [`331a356ce`](https://github.com/bluesky-social/atproto/commit/331a356ce27ff1d0b24747b0c16f3b54b07a0a12)]:
+  - @atproto/repo@0.8.6
+  - @atproto/lexicon@0.4.13
+  - @atproto/xrpc@0.7.2

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Dual MIT/Apache-2.0 License
+
+Copyright (c) 2022-2025 Bluesky Social PBC, and Contributors
+
+Except as otherwise noted in individual files, this software is licensed under the MIT license (<http://opensource.org/licenses/MIT>), or the Apache License, Version 2.0 (<http://www.apache.org/licenses/LICENSE-2.0>).
+
+Downstream projects and end users may chose either license individually, or both together, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

package/README.md

@@ -0,0 +1,79 @@
+# @atproto/lexicon-resolver
+
+ATProto Lexicon resolution
+
+[![NPM](https://img.shields.io/npm/v/@atproto/lexicon-resolver)](https://www.npmjs.com/package/@atproto/lexicon-resolver)
+[![Github CI Status](https://github.com/bluesky-social/atproto/actions/workflows/repo.yaml/badge.svg)](https://github.com/bluesky-social/atproto/actions/workflows/repo.yaml)
+
+## Usage
+
+This package may be used to determine the DID authority for a Lexicon based on its NSID, and to resolve a Lexicon from its NSID based on [Lexicon Resolution](https://atproto.com/specs/lexicon#lexicon-publication-and-resolution) from the network. Resolutions always verify the inclusion proof for the Lexicon schema document published to the ATProto network.
+
+```ts
+import {
+  resolveLexicon,
+  resolveLexiconDidAuthority,
+} from '@atproto/lexicon-resolver'
+
+// Which DID is the authority over this Lexicon?
+const didAuthority = await resolveLexiconDidAuthority('app.bsky.feed.post')
+// Resolve the Lexicon document with resolution details
+const resolved = await resolveLexicon('app.bsky.feed.post')
+/**
+ * {
+ *   commit: {
+ *     did: 'did:plc:4v4y5r3lwsbtmsxhile2ljac',
+ *     rev: '3lnlpukgipj2c',
+ *     sig: Uint8Array(64),
+ *     ...
+ *   },
+ *   uri: AtUri(at://did:plc:4v4y5r3lwsbtmsxhile2ljac/com.atproto.lexicon.schema/app.bsky.feed.post),
+ *   cid: CID(bafyreidgbehqwweghrrddfu6jgj7lyr6fwhzgazhirnszdb5lvr7iynkiy),
+ *   nsid: NSID('app.bsky.feed.post'),
+ *   lexicon: {
+ *     '$type': 'com.atproto.lexicon.schema',
+ *     lexicon: 1
+ *     id: 'app.bsky.feed.post',
+ *     defs: { main: [Object], ... },
+ *   }
+ * }
+ */
+```
+
+### With identity caching
+
+Identity data is used in order to fetch and verify record contents. The @atproto/identity package can be used to offer more control over caching and other behaviors of identity lookups.
+
+```ts
+import { IdResolver, MemoryCache } from '@atproto/identity'
+import { buildLexiconResolver } from '@atproto/lexicon-resolver'
+
+const resolveLexicon = buildLexiconResolver({
+  idResolver: new IdResolver({
+    didCache: new MemoryCache(),
+  }),
+})
+
+const resolved = await resolveLexicon('app.bsky.feed.post')
+```
+
+### With DID authority override
+
+You may specify a specific DID authority you'd like to use to perform a Lexicon resolution, overriding ATProto's DNS-based authority over Lexicons. This is described in some more detail in [Authority and Control](https://atproto.com/specs/lexicon#authority-and-control).
+
+```ts
+import { resolveLexicon } from '@atproto/lexicon-resolver'
+
+const resolved = await resolveLexicon('app.bsky.feed.post', {
+  didAuthority: 'did:plc:...',
+})
+```
+
+## License
+
+This project is dual-licensed under MIT and Apache 2.0 terms:
+
+- MIT license ([LICENSE-MIT.txt](https://github.com/bluesky-social/atproto/blob/main/LICENSE-MIT.txt) or http://opensource.org/licenses/MIT)
+- Apache License, Version 2.0, ([LICENSE-APACHE.txt](https://github.com/bluesky-social/atproto/blob/main/LICENSE-APACHE.txt) or http://www.apache.org/licenses/LICENSE-2.0)
+
+Downstream projects and end users may chose either license individually, or both together, at their discretion. The motivation for this dual-licensing is the additional software patent assurance provided by Apache 2.0.

package/dist/client/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { XrpcClient, type FetchHandler, type FetchHandlerOptions } from '@atproto/xrpc';
+import * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord.js';
+export * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord.js';
+export declare class AtpBaseClient extends XrpcClient {
+    com: ComNS;
+    constructor(options: FetchHandler | FetchHandlerOptions);
+    /** @deprecated use `this` instead */
+    get xrpc(): XrpcClient;
+}
+export declare class ComNS {
+    _client: XrpcClient;
+    atproto: ComAtprotoNS;
+    constructor(client: XrpcClient);
+}
+export declare class ComAtprotoNS {
+    _client: XrpcClient;
+    sync: ComAtprotoSyncNS;
+    constructor(client: XrpcClient);
+}
+export declare class ComAtprotoSyncNS {
+    _client: XrpcClient;
+    constructor(client: XrpcClient);
+    getRecord(params?: ComAtprotoSyncGetRecord.QueryParams, opts?: ComAtprotoSyncGetRecord.CallOptions): Promise<ComAtprotoSyncGetRecord.Response>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,UAAU,EACV,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,eAAe,CAAA;AAItB,OAAO,KAAK,uBAAuB,MAAM,uCAAuC,CAAA;AAEhF,OAAO,KAAK,uBAAuB,MAAM,uCAAuC,CAAA;AAEhF,qBAAa,aAAc,SAAQ,UAAU;IAC3C,GAAG,EAAE,KAAK,CAAA;gBAEE,OAAO,EAAE,YAAY,GAAG,mBAAmB;IAKvD,qCAAqC;IACrC,IAAI,IAAI,IAAI,UAAU,CAErB;CACF;AAED,qBAAa,KAAK;IAChB,OAAO,EAAE,UAAU,CAAA;IACnB,OAAO,EAAE,YAAY,CAAA;gBAET,MAAM,EAAE,UAAU;CAI/B;AAED,qBAAa,YAAY;IACvB,OAAO,EAAE,UAAU,CAAA;IACnB,IAAI,EAAE,gBAAgB,CAAA;gBAEV,MAAM,EAAE,UAAU;CAI/B;AAED,qBAAa,gBAAgB;IAC3B,OAAO,EAAE,UAAU,CAAA;gBAEP,MAAM,EAAE,UAAU;IAI9B,SAAS,CACP,MAAM,CAAC,EAAE,uBAAuB,CAAC,WAAW,EAC5C,IAAI,CAAC,EAAE,uBAAuB,CAAC,WAAW,GACzC,OAAO,CAAC,uBAAuB,CAAC,QAAQ,CAAC;CAO7C"}

package/dist/client/index.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComAtprotoSyncNS = exports.ComAtprotoNS = exports.ComNS = exports.AtpBaseClient = exports.ComAtprotoSyncGetRecord = void 0;
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+const xrpc_1 = require("@atproto/xrpc");
+const lexicons_js_1 = require("./lexicons.js");
+const ComAtprotoSyncGetRecord = __importStar(require("./types/com/atproto/sync/getRecord.js"));
+exports.ComAtprotoSyncGetRecord = __importStar(require("./types/com/atproto/sync/getRecord.js"));
+class AtpBaseClient extends xrpc_1.XrpcClient {
+    constructor(options) {
+        super(options, lexicons_js_1.schemas);
+        Object.defineProperty(this, "com", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.com = new ComNS(this);
+    }
+    /** @deprecated use `this` instead */
+    get xrpc() {
+        return this;
+    }
+}
+exports.AtpBaseClient = AtpBaseClient;
+class ComNS {
+    constructor(client) {
+        Object.defineProperty(this, "_client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "atproto", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._client = client;
+        this.atproto = new ComAtprotoNS(client);
+    }
+}
+exports.ComNS = ComNS;
+class ComAtprotoNS {
+    constructor(client) {
+        Object.defineProperty(this, "_client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sync", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._client = client;
+        this.sync = new ComAtprotoSyncNS(client);
+    }
+}
+exports.ComAtprotoNS = ComAtprotoNS;
+class ComAtprotoSyncNS {
+    constructor(client) {
+        Object.defineProperty(this, "_client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._client = client;
+    }
+    getRecord(params, opts) {
+        return this._client
+            .call('com.atproto.sync.getRecord', params, undefined, opts)
+            .catch((e) => {
+            throw ComAtprotoSyncGetRecord.toKnownErr(e);
+        });
+    }
+}
+exports.ComAtprotoSyncNS = ComAtprotoSyncNS;
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;GAEG;AACH,wCAIsB;AACtB,+CAAuC;AAGvC,+FAAgF;AAEhF,iGAAgF;AAEhF,MAAa,aAAc,SAAQ,iBAAU;IAG3C,YAAY,OAA2C;QACrD,KAAK,CAAC,OAAO,EAAE,qBAAO,CAAC,CAAA;QAHzB;;;;;WAAU;QAIR,IAAI,CAAC,GAAG,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,CAAA;IAC5B,CAAC;IAED,qCAAqC;IACrC,IAAI,IAAI;QACN,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAZD,sCAYC;AAED,MAAa,KAAK;IAIhB,YAAY,MAAkB;QAH9B;;;;;WAAmB;QACnB;;;;;WAAqB;QAGnB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,CAAC,OAAO,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;CACF;AARD,sBAQC;AAED,MAAa,YAAY;IAIvB,YAAY,MAAkB;QAH9B;;;;;WAAmB;QACnB;;;;;WAAsB;QAGpB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,gBAAgB,CAAC,MAAM,CAAC,CAAA;IAC1C,CAAC;CACF;AARD,oCAQC;AAED,MAAa,gBAAgB;IAG3B,YAAY,MAAkB;QAF9B;;;;;WAAmB;QAGjB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;IACvB,CAAC;IAED,SAAS,CACP,MAA4C,EAC5C,IAA0C;QAE1C,OAAO,IAAI,CAAC,OAAO;aAChB,IAAI,CAAC,4BAA4B,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC;aAC3D,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;YACX,MAAM,uBAAuB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;QAC7C,CAAC,CAAC,CAAA;IACN,CAAC;CACF;AAjBD,4CAiBC"}

package/dist/client/lexicons.d.ts

@@ -0,0 +1,105 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { Lexicons, type ValidationResult } from '@atproto/lexicon';
+export declare const schemaDict: {
+    readonly ComAtprotoSyncGetRecord: {
+        readonly lexicon: 1;
+        readonly id: "com.atproto.sync.getRecord";
+        readonly defs: {
+            readonly main: {
+                readonly type: "query";
+                readonly description: "Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.";
+                readonly parameters: {
+                    readonly type: "params";
+                    readonly required: ["did", "collection", "rkey"];
+                    readonly properties: {
+                        readonly did: {
+                            readonly type: "string";
+                            readonly format: "did";
+                            readonly description: "The DID of the repo.";
+                        };
+                        readonly collection: {
+                            readonly type: "string";
+                            readonly format: "nsid";
+                        };
+                        readonly rkey: {
+                            readonly type: "string";
+                            readonly description: "Record Key";
+                            readonly format: "record-key";
+                        };
+                    };
+                };
+                readonly output: {
+                    readonly encoding: "application/vnd.ipld.car";
+                };
+                readonly errors: [{
+                    readonly name: "RecordNotFound";
+                }, {
+                    readonly name: "RepoNotFound";
+                }, {
+                    readonly name: "RepoTakendown";
+                }, {
+                    readonly name: "RepoSuspended";
+                }, {
+                    readonly name: "RepoDeactivated";
+                }];
+            };
+        };
+    };
+};
+export declare const schemas: {
+    readonly lexicon: 1;
+    readonly id: "com.atproto.sync.getRecord";
+    readonly defs: {
+        readonly main: {
+            readonly type: "query";
+            readonly description: "Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.";
+            readonly parameters: {
+                readonly type: "params";
+                readonly required: ["did", "collection", "rkey"];
+                readonly properties: {
+                    readonly did: {
+                        readonly type: "string";
+                        readonly format: "did";
+                        readonly description: "The DID of the repo.";
+                    };
+                    readonly collection: {
+                        readonly type: "string";
+                        readonly format: "nsid";
+                    };
+                    readonly rkey: {
+                        readonly type: "string";
+                        readonly description: "Record Key";
+                        readonly format: "record-key";
+                    };
+                };
+            };
+            readonly output: {
+                readonly encoding: "application/vnd.ipld.car";
+            };
+            readonly errors: [{
+                readonly name: "RecordNotFound";
+            }, {
+                readonly name: "RepoNotFound";
+            }, {
+                readonly name: "RepoTakendown";
+            }, {
+                readonly name: "RepoSuspended";
+            }, {
+                readonly name: "RepoDeactivated";
+            }];
+        };
+    };
+}[];
+export declare const lexicons: Lexicons;
+export declare function validate<T extends {
+    $type: string;
+}>(v: unknown, id: string, hash: string, requiredType: true): ValidationResult<T>;
+export declare function validate<T extends {
+    $type?: string;
+}>(v: unknown, id: string, hash: string, requiredType?: false): ValidationResult<T>;
+export declare const ids: {
+    readonly ComAtprotoSyncGetRecord: "com.atproto.sync.getRecord";
+};
+//# sourceMappingURL=lexicons.d.ts.map

package/dist/client/lexicons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicons.d.ts","sourceRoot":"","sources":["../../src/client/lexicons.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAEL,QAAQ,EAER,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAA;AAGzB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDwB,CAAA;AAC/C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAmD,CAAA;AACvE,eAAO,MAAM,QAAQ,EAAE,QAAgC,CAAA;AAEvD,wBAAgB,QAAQ,CAAC,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EAClD,CAAC,EAAE,OAAO,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,IAAI,GACjB,gBAAgB,CAAC,CAAC,CAAC,CAAA;AACtB,wBAAgB,QAAQ,CAAC,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EACnD,CAAC,EAAE,OAAO,EACV,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,YAAY,CAAC,EAAE,KAAK,GACnB,gBAAgB,CAAC,CAAC,CAAC,CAAA;AAiBtB,eAAO,MAAM,GAAG;;CAEN,CAAA"}

package/dist/client/lexicons.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ids = exports.lexicons = exports.schemas = exports.schemaDict = void 0;
+exports.validate = validate;
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+const lexicon_1 = require("@atproto/lexicon");
+const util_js_1 = require("./util.js");
+exports.schemaDict = {
+    ComAtprotoSyncGetRecord: {
+        lexicon: 1,
+        id: 'com.atproto.sync.getRecord',
+        defs: {
+            main: {
+                type: 'query',
+                description: 'Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.',
+                parameters: {
+                    type: 'params',
+                    required: ['did', 'collection', 'rkey'],
+                    properties: {
+                        did: {
+                            type: 'string',
+                            format: 'did',
+                            description: 'The DID of the repo.',
+                        },
+                        collection: {
+                            type: 'string',
+                            format: 'nsid',
+                        },
+                        rkey: {
+                            type: 'string',
+                            description: 'Record Key',
+                            format: 'record-key',
+                        },
+                    },
+                },
+                output: {
+                    encoding: 'application/vnd.ipld.car',
+                },
+                errors: [
+                    {
+                        name: 'RecordNotFound',
+                    },
+                    {
+                        name: 'RepoNotFound',
+                    },
+                    {
+                        name: 'RepoTakendown',
+                    },
+                    {
+                        name: 'RepoSuspended',
+                    },
+                    {
+                        name: 'RepoDeactivated',
+                    },
+                ],
+            },
+        },
+    },
+};
+exports.schemas = Object.values(exports.schemaDict);
+exports.lexicons = new lexicon_1.Lexicons(exports.schemas);
+function validate(v, id, hash, requiredType) {
+    return (requiredType ? util_js_1.is$typed : util_js_1.maybe$typed)(v, id, hash)
+        ? exports.lexicons.validate(`${id}#${hash}`, v)
+        : {
+            success: false,
+            error: new lexicon_1.ValidationError(`Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`),
+        };
+}
+exports.ids = {
+    ComAtprotoSyncGetRecord: 'com.atproto.sync.getRecord',
+};
+//# sourceMappingURL=lexicons.js.map

package/dist/client/lexicons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicons.js","sourceRoot":"","sources":["../../src/client/lexicons.ts"],"names":[],"mappings":";;;AA+EA,4BAcC;AA7FD;;GAEG;AACH,8CAKyB;AACzB,uCAA8D;AAEjD,QAAA,UAAU,GAAG;IACxB,uBAAuB,EAAE;QACvB,OAAO,EAAE,CAAC;QACV,EAAE,EAAE,4BAA4B;QAChC,IAAI,EAAE;YACJ,IAAI,EAAE;gBACJ,IAAI,EAAE,OAAO;gBACb,WAAW,EACT,iIAAiI;gBACnI,UAAU,EAAE;oBACV,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC;oBACvC,UAAU,EAAE;wBACV,GAAG,EAAE;4BACH,IAAI,EAAE,QAAQ;4BACd,MAAM,EAAE,KAAK;4BACb,WAAW,EAAE,sBAAsB;yBACpC;wBACD,UAAU,EAAE;4BACV,IAAI,EAAE,QAAQ;4BACd,MAAM,EAAE,MAAM;yBACf;wBACD,IAAI,EAAE;4BACJ,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,YAAY;4BACzB,MAAM,EAAE,YAAY;yBACrB;qBACF;iBACF;gBACD,MAAM,EAAE;oBACN,QAAQ,EAAE,0BAA0B;iBACrC;gBACD,MAAM,EAAE;oBACN;wBACE,IAAI,EAAE,gBAAgB;qBACvB;oBACD;wBACE,IAAI,EAAE,cAAc;qBACrB;oBACD;wBACE,IAAI,EAAE,eAAe;qBACtB;oBACD;wBACE,IAAI,EAAE,eAAe;qBACtB;oBACD;wBACE,IAAI,EAAE,iBAAiB;qBACxB;iBACF;aACF;SACF;KACF;CAC4C,CAAA;AAClC,QAAA,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,kBAAU,CAAwB,CAAA;AAC1D,QAAA,QAAQ,GAAa,IAAI,kBAAQ,CAAC,eAAO,CAAC,CAAA;AAcvD,SAAgB,QAAQ,CACtB,CAAU,EACV,EAAU,EACV,IAAY,EACZ,YAAsB;IAEtB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,kBAAQ,CAAC,CAAC,CAAC,qBAAW,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC;QACzD,CAAC,CAAC,gBAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;QACvC,CAAC,CAAC;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,IAAI,yBAAe,CACxB,2BAA2B,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,IAAI,EAAE,kBAAkB,CACpF;SACF,CAAA;AACP,CAAC;AAEY,QAAA,GAAG,GAAG;IACjB,uBAAuB,EAAE,4BAA4B;CAC7C,CAAA"}

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

@@ -0,0 +1,38 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc';
+export type QueryParams = {
+    /** The DID of the repo. */
+    did: string;
+    collection: string;
+    /** Record Key */
+    rkey: string;
+};
+export type InputSchema = undefined;
+export interface CallOptions {
+    signal?: AbortSignal;
+    headers?: HeadersMap;
+}
+export interface Response {
+    success: boolean;
+    headers: HeadersMap;
+    data: Uint8Array;
+}
+export declare class RecordNotFoundError extends XRPCError {
+    constructor(src: XRPCError);
+}
+export declare class RepoNotFoundError extends XRPCError {
+    constructor(src: XRPCError);
+}
+export declare class RepoTakendownError extends XRPCError {
+    constructor(src: XRPCError);
+}
+export declare class RepoSuspendedError extends XRPCError {
+    constructor(src: XRPCError);
+}
+export declare class RepoDeactivatedError extends XRPCError {
+    constructor(src: XRPCError);
+}
+export declare function toKnownErr(e: any): any;
+//# sourceMappingURL=getRecord.d.ts.map

package/dist/client/types/com/atproto/sync/getRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRecord.d.ts","sourceRoot":"","sources":["../../../../../../src/client/types/com/atproto/sync/getRecord.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAcrD,MAAM,MAAM,WAAW,GAAG;IACxB,2BAA2B;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,CAAA;IAClB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AACD,MAAM,MAAM,WAAW,GAAG,SAAS,CAAA;AAEnC,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,OAAO,CAAC,EAAE,UAAU,CAAA;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,UAAU,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;CACjB;AAED,qBAAa,mBAAoB,SAAQ,SAAS;gBACpC,GAAG,EAAE,SAAS;CAG3B;AAED,qBAAa,iBAAkB,SAAQ,SAAS;gBAClC,GAAG,EAAE,SAAS;CAG3B;AAED,qBAAa,kBAAmB,SAAQ,SAAS;gBACnC,GAAG,EAAE,SAAS;CAG3B;AAED,qBAAa,kBAAmB,SAAQ,SAAS;gBACnC,GAAG,EAAE,SAAS;CAG3B;AAED,qBAAa,oBAAqB,SAAQ,SAAS;gBACrC,GAAG,EAAE,SAAS;CAG3B;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,OAUhC"}

package/dist/client/types/com/atproto/sync/getRecord.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoDeactivatedError = exports.RepoSuspendedError = exports.RepoTakendownError = exports.RepoNotFoundError = exports.RecordNotFoundError = void 0;
+exports.toKnownErr = toKnownErr;
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+const xrpc_1 = require("@atproto/xrpc");
+const lexicons_1 = require("../../../../lexicons");
+const util_1 = require("../../../../util");
+const is$typed = util_1.is$typed, validate = lexicons_1.validate;
+const id = 'com.atproto.sync.getRecord';
+class RecordNotFoundError extends xrpc_1.XRPCError {
+    constructor(src) {
+        super(src.status, src.error, src.message, src.headers, { cause: src });
+    }
+}
+exports.RecordNotFoundError = RecordNotFoundError;
+class RepoNotFoundError extends xrpc_1.XRPCError {
+    constructor(src) {
+        super(src.status, src.error, src.message, src.headers, { cause: src });
+    }
+}
+exports.RepoNotFoundError = RepoNotFoundError;
+class RepoTakendownError extends xrpc_1.XRPCError {
+    constructor(src) {
+        super(src.status, src.error, src.message, src.headers, { cause: src });
+    }
+}
+exports.RepoTakendownError = RepoTakendownError;
+class RepoSuspendedError extends xrpc_1.XRPCError {
+    constructor(src) {
+        super(src.status, src.error, src.message, src.headers, { cause: src });
+    }
+}
+exports.RepoSuspendedError = RepoSuspendedError;
+class RepoDeactivatedError extends xrpc_1.XRPCError {
+    constructor(src) {
+        super(src.status, src.error, src.message, src.headers, { cause: src });
+    }
+}
+exports.RepoDeactivatedError = RepoDeactivatedError;
+function toKnownErr(e) {
+    if (e instanceof xrpc_1.XRPCError) {
+        if (e.error === 'RecordNotFound')
+            return new RecordNotFoundError(e);
+        if (e.error === 'RepoNotFound')
+            return new RepoNotFoundError(e);
+        if (e.error === 'RepoTakendown')
+            return new RepoTakendownError(e);
+        if (e.error === 'RepoSuspended')
+            return new RepoSuspendedError(e);
+        if (e.error === 'RepoDeactivated')
+            return new RepoDeactivatedError(e);
+    }
+    return e;
+}
+//# sourceMappingURL=getRecord.js.map

package/dist/client/types/com/atproto/sync/getRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRecord.js","sourceRoot":"","sources":["../../../../../../src/client/types/com/atproto/sync/getRecord.ts"],"names":[],"mappings":";;;AAmEA,gCAUC;AA7ED;;GAEG;AACH,wCAAqD;AAGrD,mDAA4D;AAC5D,2CAIyB;AAEzB,MAAM,QAAQ,GAAG,eAAS,EACxB,QAAQ,GAAG,mBAAS,CAAA;AACtB,MAAM,EAAE,GAAG,4BAA4B,CAAA;AAsBvC,MAAa,mBAAoB,SAAQ,gBAAS;IAChD,YAAY,GAAc;QACxB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACxE,CAAC;CACF;AAJD,kDAIC;AAED,MAAa,iBAAkB,SAAQ,gBAAS;IAC9C,YAAY,GAAc;QACxB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACxE,CAAC;CACF;AAJD,8CAIC;AAED,MAAa,kBAAmB,SAAQ,gBAAS;IAC/C,YAAY,GAAc;QACxB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACxE,CAAC;CACF;AAJD,gDAIC;AAED,MAAa,kBAAmB,SAAQ,gBAAS;IAC/C,YAAY,GAAc;QACxB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACxE,CAAC;CACF;AAJD,gDAIC;AAED,MAAa,oBAAqB,SAAQ,gBAAS;IACjD,YAAY,GAAc;QACxB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IACxE,CAAC;CACF;AAJD,oDAIC;AAED,SAAgB,UAAU,CAAC,CAAM;IAC/B,IAAI,CAAC,YAAY,gBAAS,EAAE,CAAC;QAC3B,IAAI,CAAC,CAAC,KAAK,KAAK,gBAAgB;YAAE,OAAO,IAAI,mBAAmB,CAAC,CAAC,CAAC,CAAA;QACnE,IAAI,CAAC,CAAC,KAAK,KAAK,cAAc;YAAE,OAAO,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAAA;QAC/D,IAAI,CAAC,CAAC,KAAK,KAAK,eAAe;YAAE,OAAO,IAAI,kBAAkB,CAAC,CAAC,CAAC,CAAA;QACjE,IAAI,CAAC,CAAC,KAAK,KAAK,eAAe;YAAE,OAAO,IAAI,kBAAkB,CAAC,CAAC,CAAC,CAAA;QACjE,IAAI,CAAC,CAAC,KAAK,KAAK,iBAAiB;YAAE,OAAO,IAAI,oBAAoB,CAAC,CAAC,CAAC,CAAA;IACvE,CAAC;IAED,OAAO,CAAC,CAAA;AACV,CAAC"}

package/dist/client/util.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult } from '@atproto/lexicon';
+export type OmitKey<T, K extends keyof T> = {
+    [K2 in keyof T as K2 extends K ? never : K2]: T[K2];
+};
+export type $Typed<V, T extends string = string> = V & {
+    $type: T;
+};
+export type Un$Typed<V extends {
+    $type?: string;
+}> = OmitKey<V, '$type'>;
+export type $Type<Id extends string, Hash extends string> = Hash extends 'main' ? Id : `${Id}#${Hash}`;
+export type $TypedObject<V, Id extends string, Hash extends string> = V extends {
+    $type: $Type<Id, Hash>;
+} ? V : V extends {
+    $type?: string;
+} ? V extends {
+    $type?: infer T extends $Type<Id, Hash>;
+} ? V & {
+    $type: T;
+} : never : V & {
+    $type: $Type<Id, Hash>;
+};
+export declare function is$typed<V, Id extends string, Hash extends string>(v: V, id: Id, hash: Hash): v is $TypedObject<V, Id, Hash>;
+export declare function maybe$typed<V, Id extends string, Hash extends string>(v: V, id: Id, hash: Hash): v is V & object & {
+    $type?: $Type<Id, Hash>;
+};
+export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>;
+export type ValidatorParam<V extends Validator> = V extends Validator<infer R> ? R : never;
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+export declare function asPredicate<V extends Validator>(validate: V): <T>(v: T) => v is T & ValidatorParam<V>;
+//# sourceMappingURL=util.d.ts.map

package/dist/client/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/client/util.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI;KACzC,EAAE,IAAI,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,KAAK,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;CACpD,CAAA;AAED,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,CAAA;AACnE,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,IAAI,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAA;AAExE,MAAM,MAAM,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,IAAI,IAAI,SAAS,MAAM,GAC3E,EAAE,GACF,GAAG,EAAE,IAAI,IAAI,EAAE,CAAA;AAqBnB,MAAM,MAAM,YAAY,CACtB,CAAC,EACD,EAAE,SAAS,MAAM,EACjB,IAAI,SAAS,MAAM,IACjB,CAAC,SAAS;IACZ,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CACvB,GACG,CAAC,GACD,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1B,CAAC,SAAS;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC,SAAS,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CAAE,GACnD,CAAC,GAAG;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,GAChB,KAAK,GACP,CAAC,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CAAE,CAAA;AAEpC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAChE,CAAC,EAAE,CAAC,EACJ,EAAE,EAAE,EAAE,EACN,IAAI,EAAE,IAAI,GACT,CAAC,IAAI,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,CAEhC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EACnE,CAAC,EAAE,CAAC,EACJ,EAAE,EAAE,EAAE,EACN,IAAI,EAAE,IAAI,GACT,CAAC,IAAI,CAAC,GAAG,MAAM,GAAG;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;CAAE,CAK/C;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,OAAO,KAAK,gBAAgB,CAAC,CAAC,CAAC,CAAA;AACxE,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,SAAS,IAC5C,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE1C;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,EAAE,QAAQ,EAAE,CAAC,IACzC,CAAC,EAAE,GAAG,CAAC,KAAG,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAGtD"}

package/dist/client/util.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.is$typed = is$typed;
+exports.maybe$typed = maybe$typed;
+exports.asPredicate = asPredicate;
+function isObject(v) {
+    return v != null && typeof v === 'object';
+}
+function is$type($type, id, hash) {
+    return hash === 'main'
+        ? $type === id
+        : // $type === `${id}#${hash}`
+            typeof $type === 'string' &&
+                $type.length === id.length + 1 + hash.length &&
+                $type.charCodeAt(id.length) === 35 /* '#' */ &&
+                $type.startsWith(id) &&
+                $type.endsWith(hash);
+}
+function is$typed(v, id, hash) {
+    return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
+}
+function maybe$typed(v, id, hash) {
+    return (isObject(v) &&
+        ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true));
+}
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+function asPredicate(validate) {
+    return function (v) {
+        return validate(v).success;
+    };
+}
+//# sourceMappingURL=util.js.map

package/dist/client/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/client/util.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAgDH,4BAMC;AAED,kCASC;AAUD,kCAIC;AAhED,SAAS,QAAQ,CAAI,CAAI;IACvB,OAAO,CAAC,IAAI,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,CAAA;AAC3C,CAAC;AAED,SAAS,OAAO,CACd,KAAc,EACd,EAAM,EACN,IAAU;IAEV,OAAO,IAAI,KAAK,MAAM;QACpB,CAAC,CAAC,KAAK,KAAK,EAAE;QACd,CAAC,CAAC,4BAA4B;YAC5B,OAAO,KAAK,KAAK,QAAQ;gBACvB,KAAK,CAAC,MAAM,KAAK,EAAE,CAAC,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM;gBAC5C,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,SAAS;gBAC5C,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;gBACpB,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;AAC5B,CAAC;AAgBD,SAAgB,QAAQ,CACtB,CAAI,EACJ,EAAM,EACN,IAAU;IAEV,OAAO,QAAQ,CAAC,CAAC,CAAC,IAAI,OAAO,IAAI,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,CAAC,CAAA;AAClE,CAAC;AAED,SAAgB,WAAW,CACzB,CAAI,EACJ,EAAM,EACN,IAAU;IAEV,OAAO,CACL,QAAQ,CAAC,CAAC,CAAC;QACX,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAC5E,CAAA;AACH,CAAC;AAMD;;;GAGG;AACH,SAAgB,WAAW,CAAsB,QAAW;IAC1D,OAAO,UAAa,CAAI;QACtB,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAA;IAC5B,CAAC,CAAA;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './record.js';
+export * from './lexicon.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}