@atproto/lexicon-resolver 0.2.5 → 0.3.0

package/dist/client/lexicons.d.ts

@@ -1,105 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,75 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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","sourcesContent":["/**\n * GENERATED CODE - DO NOT MODIFY\n */\nimport {\n  type LexiconDoc,\n  Lexicons,\n  ValidationError,\n  type ValidationResult,\n} from '@atproto/lexicon'\nimport { type $Typed, is$typed, maybe$typed } from './util.js'\n\nexport const schemaDict = {\n  ComAtprotoSyncGetRecord: {\n    lexicon: 1,\n    id: 'com.atproto.sync.getRecord',\n    defs: {\n      main: {\n        type: 'query',\n        description:\n          'Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.',\n        parameters: {\n          type: 'params',\n          required: ['did', 'collection', 'rkey'],\n          properties: {\n            did: {\n              type: 'string',\n              format: 'did',\n              description: 'The DID of the repo.',\n            },\n            collection: {\n              type: 'string',\n              format: 'nsid',\n            },\n            rkey: {\n              type: 'string',\n              description: 'Record Key',\n              format: 'record-key',\n            },\n          },\n        },\n        output: {\n          encoding: 'application/vnd.ipld.car',\n        },\n        errors: [\n          {\n            name: 'RecordNotFound',\n          },\n          {\n            name: 'RepoNotFound',\n          },\n          {\n            name: 'RepoTakendown',\n          },\n          {\n            name: 'RepoSuspended',\n          },\n          {\n            name: 'RepoDeactivated',\n          },\n        ],\n      },\n    },\n  },\n} as const satisfies Record<string, LexiconDoc>\nexport const schemas = Object.values(schemaDict) satisfies LexiconDoc[]\nexport const lexicons: Lexicons = new Lexicons(schemas)\n\nexport function validate<T extends { $type: string }>(\n  v: unknown,\n  id: string,\n  hash: string,\n  requiredType: true,\n): ValidationResult<T>\nexport function validate<T extends { $type?: string }>(\n  v: unknown,\n  id: string,\n  hash: string,\n  requiredType?: false,\n): ValidationResult<T>\nexport function validate(\n  v: unknown,\n  id: string,\n  hash: string,\n  requiredType?: boolean,\n): ValidationResult {\n  return (requiredType ? is$typed : maybe$typed)(v, id, hash)\n    ? lexicons.validate(`${id}#${hash}`, v)\n    : {\n        success: false,\n        error: new ValidationError(\n          `Must be an object with \"${hash === 'main' ? id : `${id}#${hash}`}\" $type property`,\n        ),\n      }\n}\n\nexport const ids = {\n  ComAtprotoSyncGetRecord: 'com.atproto.sync.getRecord',\n} as const\n"]}

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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,58 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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","sourcesContent":["/**\n * GENERATED CODE - DO NOT MODIFY\n */\nimport { HeadersMap, XRPCError } from '@atproto/xrpc'\nimport { type ValidationResult, BlobRef } from '@atproto/lexicon'\nimport { CID } from 'multiformats/cid'\nimport { validate as _validate } from '../../../../lexicons'\nimport {\n  type $Typed,\n  is$typed as _is$typed,\n  type OmitKey,\n} from '../../../../util'\n\nconst is$typed = _is$typed,\n  validate = _validate\nconst id = 'com.atproto.sync.getRecord'\n\nexport type QueryParams = {\n  /** The DID of the repo. */\n  did: string\n  collection: string\n  /** Record Key */\n  rkey: string\n}\nexport type InputSchema = undefined\n\nexport interface CallOptions {\n  signal?: AbortSignal\n  headers?: HeadersMap\n}\n\nexport interface Response {\n  success: boolean\n  headers: HeadersMap\n  data: Uint8Array\n}\n\nexport class RecordNotFoundError extends XRPCError {\n  constructor(src: XRPCError) {\n    super(src.status, src.error, src.message, src.headers, { cause: src })\n  }\n}\n\nexport class RepoNotFoundError extends XRPCError {\n  constructor(src: XRPCError) {\n    super(src.status, src.error, src.message, src.headers, { cause: src })\n  }\n}\n\nexport class RepoTakendownError extends XRPCError {\n  constructor(src: XRPCError) {\n    super(src.status, src.error, src.message, src.headers, { cause: src })\n  }\n}\n\nexport class RepoSuspendedError extends XRPCError {\n  constructor(src: XRPCError) {\n    super(src.status, src.error, src.message, src.headers, { cause: src })\n  }\n}\n\nexport class RepoDeactivatedError extends XRPCError {\n  constructor(src: XRPCError) {\n    super(src.status, src.error, src.message, src.headers, { cause: src })\n  }\n}\n\nexport function toKnownErr(e: any) {\n  if (e instanceof XRPCError) {\n    if (e.error === 'RecordNotFound') return new RecordNotFoundError(e)\n    if (e.error === 'RepoNotFound') return new RepoNotFoundError(e)\n    if (e.error === 'RepoTakendown') return new RepoTakendownError(e)\n    if (e.error === 'RepoSuspended') return new RepoSuspendedError(e)\n    if (e.error === 'RepoDeactivated') return new RepoDeactivatedError(e)\n  }\n\n  return e\n}\n"]}

package/dist/client/util.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,38 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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","sourcesContent":["/**\n * GENERATED CODE - DO NOT MODIFY\n */\n\nimport { type ValidationResult } from '@atproto/lexicon'\n\nexport type OmitKey<T, K extends keyof T> = {\n  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]\n}\n\nexport type $Typed<V, T extends string = string> = V & { $type: T }\nexport type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>\n\nexport type $Type<Id extends string, Hash extends string> = Hash extends 'main'\n  ? Id\n  : `${Id}#${Hash}`\n\nfunction isObject<V>(v: V): v is V & object {\n  return v != null && typeof v === 'object'\n}\n\nfunction is$type<Id extends string, Hash extends string>(\n  $type: unknown,\n  id: Id,\n  hash: Hash,\n): $type is $Type<Id, Hash> {\n  return hash === 'main'\n    ? $type === id\n    : // $type === `${id}#${hash}`\n      typeof $type === 'string' &&\n        $type.length === id.length + 1 + hash.length &&\n        $type.charCodeAt(id.length) === 35 /* '#' */ &&\n        $type.startsWith(id) &&\n        $type.endsWith(hash)\n}\n\nexport type $TypedObject<\n  V,\n  Id extends string,\n  Hash extends string,\n> = V extends {\n  $type: $Type<Id, Hash>\n}\n  ? V\n  : V extends { $type?: string }\n    ? V extends { $type?: infer T extends $Type<Id, Hash> }\n      ? V & { $type: T }\n      : never\n    : V & { $type: $Type<Id, Hash> }\n\nexport function is$typed<V, Id extends string, Hash extends string>(\n  v: V,\n  id: Id,\n  hash: Hash,\n): v is $TypedObject<V, Id, Hash> {\n  return isObject(v) && '$type' in v && is$type(v.$type, id, hash)\n}\n\nexport function maybe$typed<V, Id extends string, Hash extends string>(\n  v: V,\n  id: Id,\n  hash: Hash,\n): v is V & object & { $type?: $Type<Id, Hash> } {\n  return (\n    isObject(v) &&\n    ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true)\n  )\n}\n\nexport type Validator<R = unknown> = (v: unknown) => ValidationResult<R>\nexport type ValidatorParam<V extends Validator> =\n  V extends Validator<infer R> ? R : never\n\n/**\n * Utility function that allows to convert a \"validate*\" utility function into a\n * type predicate.\n */\nexport function asPredicate<V extends Validator>(validate: V) {\n  return function <T>(v: T): v is T & ValidatorParam<V> {\n    return validate(v).success\n  }\n}\n"]}

package/src/client/index.ts

@@ -1,67 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import {
-  XrpcClient,
-  type FetchHandler,
-  type FetchHandlerOptions,
-} from '@atproto/xrpc'
-import { schemas } from './lexicons.js'
-import { CID } from 'multiformats/cid'
-import { type OmitKey, type Un$Typed } from './util.js'
-import * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord.js'
-
-export * as ComAtprotoSyncGetRecord from './types/com/atproto/sync/getRecord.js'
-
-export class AtpBaseClient extends XrpcClient {
-  com: ComNS
-
-  constructor(options: FetchHandler | FetchHandlerOptions) {
-    super(options, schemas)
-    this.com = new ComNS(this)
-  }
-
-  /** @deprecated use `this` instead */
-  get xrpc(): XrpcClient {
-    return this
-  }
-}
-
-export class ComNS {
-  _client: XrpcClient
-  atproto: ComAtprotoNS
-
-  constructor(client: XrpcClient) {
-    this._client = client
-    this.atproto = new ComAtprotoNS(client)
-  }
-}
-
-export class ComAtprotoNS {
-  _client: XrpcClient
-  sync: ComAtprotoSyncNS
-
-  constructor(client: XrpcClient) {
-    this._client = client
-    this.sync = new ComAtprotoSyncNS(client)
-  }
-}
-
-export class ComAtprotoSyncNS {
-  _client: XrpcClient
-
-  constructor(client: XrpcClient) {
-    this._client = client
-  }
-
-  getRecord(
-    params?: ComAtprotoSyncGetRecord.QueryParams,
-    opts?: ComAtprotoSyncGetRecord.CallOptions,
-  ): Promise<ComAtprotoSyncGetRecord.Response> {
-    return this._client
-      .call('com.atproto.sync.getRecord', params, undefined, opts)
-      .catch((e) => {
-        throw ComAtprotoSyncGetRecord.toKnownErr(e)
-      })
-  }
-}

package/src/client/lexicons.ts

@@ -1,98 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import {
-  type LexiconDoc,
-  Lexicons,
-  ValidationError,
-  type ValidationResult,
-} from '@atproto/lexicon'
-import { type $Typed, is$typed, maybe$typed } from './util.js'
-
-export const 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',
-          },
-        ],
-      },
-    },
-  },
-} as const satisfies Record<string, LexiconDoc>
-export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
-export const lexicons: Lexicons = new Lexicons(schemas)
-
-export function validate<T extends { $type: string }>(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType: true,
-): ValidationResult<T>
-export function validate<T extends { $type?: string }>(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType?: false,
-): ValidationResult<T>
-export function validate(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType?: boolean,
-): ValidationResult {
-  return (requiredType ? is$typed : maybe$typed)(v, id, hash)
-    ? lexicons.validate(`${id}#${hash}`, v)
-    : {
-        success: false,
-        error: new ValidationError(
-          `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`,
-        ),
-      }
-}
-
-export const ids = {
-  ComAtprotoSyncGetRecord: 'com.atproto.sync.getRecord',
-} as const

package/src/client/types/com/atproto/sync/getRecord.ts

@@ -1,78 +0,0 @@
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { HeadersMap, XRPCError } from '@atproto/xrpc'
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.sync.getRecord'
-
-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 class RecordNotFoundError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export class RepoNotFoundError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export class RepoTakendownError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export class RepoSuspendedError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export class RepoDeactivatedError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export function toKnownErr(e: any) {
-  if (e instanceof 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
-}