npm - @hypercerts-org/sdk-core - Versions diffs - 0.10.0-beta.0 → 0.10.0-beta.1 - Mend

@hypercerts-org/sdk-core 0.10.0-beta.0 → 0.10.0-beta.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/lexicons.mjs CHANGED Viewed

@@ -1,410 +1,146 @@
-import { Lexicons } from '@atproto/lexicon';
-export { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS } from '@hypercerts-org/lexicon';
+import { CERTIFIED_DEFS_LEXICON_JSON, LOCATION_LEXICON_JSON, STRONGREF_LEXICON_JSON, HYPERCERTS_DEFS_LEXICON_JSON, ACTIVITY_LEXICON_JSON, COLLECTION_LEXICON_JSON, CONTRIBUTION_LEXICON_JSON, EVALUATION_LEXICON_JSON, EVIDENCE_LEXICON_JSON, MEASUREMENT_LEXICON_JSON, RIGHTS_LEXICON_JSON, PROJECT_LEXICON_JSON, BADGE_AWARD_LEXICON_JSON, BADGE_DEFINITION_LEXICON_JSON, BADGE_RESPONSE_LEXICON_JSON, FUNDING_RECEIPT_LEXICON_JSON, FUNDING_RECEIPT_NSID, BADGE_RESPONSE_NSID, BADGE_DEFINITION_NSID, BADGE_AWARD_NSID, PROJECT_NSID, COLLECTION_NSID, EVIDENCE_NSID, EVALUATION_NSID, MEASUREMENT_NSID, CONTRIBUTION_NSID, LOCATION_NSID, RIGHTS_NSID, ACTIVITY_NSID } from '@hypercerts-org/lexicon';
 /**
- * Base error class for all SDK errors.
+ * Lexicons entrypoint - Lexicon definitions and registry.
  *
- * All errors thrown by the Hypercerts SDK extend this class, making it easy
- * to catch and handle SDK-specific errors.
+ * This sub-entrypoint exports the lexicon registry and hypercert
+ * lexicon constants for working with AT Protocol record schemas.
  *
- * @example Catching all SDK errors
- * ```typescript
- * try {
- *   await sdk.authorize("user.bsky.social");
- * } catch (error) {
- *   if (error instanceof ATProtoSDKError) {
- *     console.error(`SDK Error [${error.code}]: ${error.message}`);
- *     console.error(`HTTP Status: ${error.status}`);
- *   }
- * }
- * ```
+ * @remarks
+ * Import from `@hypercerts-org/sdk/lexicons`:
  *
- * @example Checking error codes
  * ```typescript
- * try {
- *   await repo.records.get(collection, rkey);
- * } catch (error) {
- *   if (error instanceof ATProtoSDKError) {
- *     switch (error.code) {
- *       case "AUTHENTICATION_ERROR":
- *         // Redirect to login
- *         break;
- *       case "VALIDATION_ERROR":
- *         // Show form errors
- *         break;
- *       case "NETWORK_ERROR":
- *         // Retry or show offline message
- *         break;
- *     }
- *   }
- * }
+ * import {
+ *   LexiconRegistry,
+ *   HYPERCERT_LEXICONS,
+ *   HYPERCERT_COLLECTIONS,
+ * } from "@hypercerts-org/sdk/lexicons";
  * ```
- */
-class ATProtoSDKError extends Error {
-    /**
-     * Creates a new SDK error.
-     *
-     * @param message - Human-readable error description
-     * @param code - Machine-readable error code for programmatic handling
-     * @param status - HTTP status code associated with this error type
-     * @param cause - The underlying error that caused this error, if any
-     */
-    constructor(message, code, status, cause) {
-        super(message);
-        this.code = code;
-        this.status = status;
-        this.cause = cause;
-        this.name = "ATProtoSDKError";
-        Error.captureStackTrace?.(this, this.constructor);
-    }
-}
-/**
- * Error thrown when input validation fails.
  *
- * This error indicates that provided data doesn't meet the required format
- * or constraints. Common causes:
- * - Missing required fields
- * - Invalid URL formats
- * - Invalid DID format
- * - Schema validation failures for records
- * - Invalid configuration values
- *
- * @example
- * ```typescript
- * try {
- *   await sdk.authorize("");  // Empty identifier
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.error("Invalid input:", error.message);
- *     // Show validation error to user
- *   }
- * }
- * ```
+ * **Exports**:
+ * - {@link LexiconRegistry} - Registry for managing and validating lexicons
+ * - {@link HYPERCERT_LEXICONS} - Array of all hypercert lexicon documents
+ * - {@link HYPERCERT_COLLECTIONS} - Constants for collection NSIDs
  *
- * @example With Zod validation cause
+ * @example Using collection constants
  * ```typescript
- * try {
- *   await repo.records.create(collection, record);
- * } catch (error) {
- *   if (error instanceof ValidationError && error.cause) {
- *     // error.cause may be a ZodError with detailed field errors
- *     const zodError = error.cause as ZodError;
- *     zodError.errors.forEach(e => {
- *       console.error(`Field ${e.path.join(".")}: ${e.message}`);
- *     });
- *   }
- * }
- * ```
- */
-class ValidationError extends ATProtoSDKError {
-    /**
-     * Creates a validation error.
-     *
-     * @param message - Description of what validation failed
-     * @param cause - The underlying validation error (e.g., ZodError)
-     */
-    constructor(message, cause) {
-        super(message, "VALIDATION_ERROR", 400, cause);
-        this.name = "ValidationError";
-    }
-}
-/**
- * Registry for managing and validating AT Protocol lexicon schemas.
- *
- * Lexicons are schema definitions that describe the structure of records
- * in the AT Protocol. This registry allows you to:
+ * import { HYPERCERT_COLLECTIONS } from "@hypercerts-org/sdk/lexicons";
  *
- * - Register custom lexicons for your application's record types
- * - Validate records against their lexicon schemas
- * - Extend the AT Protocol Agent with custom lexicon support
- *
- * @remarks
- * The SDK automatically registers hypercert lexicons when creating a Repository.
- * You only need to use this class directly if you're working with custom
- * record types.
+ * // List hypercerts using the correct collection name
+ * const records = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.RECORD,
+ * });
  *
- * **Lexicon IDs** follow the NSID (Namespaced Identifier) format:
- * `{authority}.{name}` (e.g., `org.hypercerts.hypercert`)
+ * // List contributions
+ * const contributions = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,
+ * });
+ * ```
  *
- * @example Registering custom lexicons
+ * @example Custom lexicon registration
  * ```typescript
+ * import { LexiconRegistry } from "@hypercerts-org/sdk/lexicons";
+ *
  * const registry = sdk.getLexiconRegistry();
  *
- * // Register a single lexicon
+ * // Register custom lexicon
  * registry.register({
  *   lexicon: 1,
- *   id: "org.example.myRecord",
- *   defs: {
- *     main: {
- *       type: "record",
- *       key: "tid",
- *       record: {
- *         type: "object",
- *         required: ["title", "createdAt"],
- *         properties: {
- *           title: { type: "string" },
- *           description: { type: "string" },
- *           createdAt: { type: "string", format: "datetime" },
- *         },
- *       },
- *     },
- *   },
- * });
- *
- * // Register multiple lexicons at once
- * registry.registerMany([lexicon1, lexicon2, lexicon3]);
- * ```
- *
- * @example Validating records
- * ```typescript
- * const result = registry.validate("org.example.myRecord", {
- *   title: "Test",
- *   createdAt: new Date().toISOString(),
+ *   id: "org.myapp.customRecord",
+ *   defs: { ... },
  * });
  *
+ * // Validate a record
+ * const result = registry.validate("org.myapp.customRecord", record);
  * if (!result.valid) {
- *   console.error(`Validation failed: ${result.error}`);
+ *   console.error(result.error);
  * }
  * ```
  *
- * @see https://atproto.com/specs/lexicon for the Lexicon specification
+ * @packageDocumentation
+ */
+/**
+ * All hypercert-related lexicons for registration with AT Protocol Agent.
+ * This array contains all lexicon documents from the published package.
  */
-class LexiconRegistry {
+const HYPERCERT_LEXICONS = [
+    CERTIFIED_DEFS_LEXICON_JSON,
+    LOCATION_LEXICON_JSON,
+    STRONGREF_LEXICON_JSON,
+    HYPERCERTS_DEFS_LEXICON_JSON,
+    ACTIVITY_LEXICON_JSON,
+    COLLECTION_LEXICON_JSON,
+    CONTRIBUTION_LEXICON_JSON,
+    EVALUATION_LEXICON_JSON,
+    EVIDENCE_LEXICON_JSON,
+    MEASUREMENT_LEXICON_JSON,
+    RIGHTS_LEXICON_JSON,
+    PROJECT_LEXICON_JSON,
+    BADGE_AWARD_LEXICON_JSON,
+    BADGE_DEFINITION_LEXICON_JSON,
+    BADGE_RESPONSE_LEXICON_JSON,
+    FUNDING_RECEIPT_LEXICON_JSON,
+];
+/**
+ * Collection NSIDs (Namespaced Identifiers) for hypercert records.
+ *
+ * Use these constants when performing record operations to ensure
+ * correct collection names.
+ */
+const HYPERCERT_COLLECTIONS = {
+    /**
+     * Main hypercert claim record collection.
+     */
+    CLAIM: ACTIVITY_NSID,
+    /**
+     * Rights record collection.
+     */
+    RIGHTS: RIGHTS_NSID,
+    /**
+     * Location record collection (shared certified lexicon).
+     */
+    LOCATION: LOCATION_NSID,
+    /**
+     * Contribution record collection.
+     */
+    CONTRIBUTION: CONTRIBUTION_NSID,
+    /**
+     * Measurement record collection.
+     */
+    MEASUREMENT: MEASUREMENT_NSID,
     /**
-     * Creates a new LexiconRegistry.
-     *
-     * The registry starts empty. Use {@link register} or {@link registerMany}
-     * to add lexicons.
+     * Evaluation record collection.
      */
-    constructor() {
-        /** Map of lexicon ID to lexicon document */
-        this.lexicons = new Map();
-        this.lexiconsCollection = new Lexicons();
-    }
+    EVALUATION: EVALUATION_NSID,
     /**
-     * Registers a single lexicon schema.
-     *
-     * @param lexicon - The lexicon document to register
-     * @throws {@link ValidationError} if the lexicon doesn't have an `id` field
-     *
-     * @remarks
-     * If a lexicon with the same ID is already registered, it will be
-     * replaced with the new definition. This is useful for testing but
-     * should generally be avoided in production.
-     *
-     * @example
-     * ```typescript
-     * registry.register({
-     *   lexicon: 1,
-     *   id: "org.example.post",
-     *   defs: {
-     *     main: {
-     *       type: "record",
-     *       key: "tid",
-     *       record: {
-     *         type: "object",
-     *         required: ["text", "createdAt"],
-     *         properties: {
-     *           text: { type: "string", maxLength: 300 },
-     *           createdAt: { type: "string", format: "datetime" },
-     *         },
-     *       },
-     *     },
-     *   },
-     * });
-     * ```
+     * Evidence record collection.
      */
-    register(lexicon) {
-        if (!lexicon.id) {
-            throw new ValidationError("Lexicon must have an 'id' field");
-        }
-        // Remove existing lexicon if present (to allow overwriting)
-        if (this.lexicons.has(lexicon.id)) {
-            // Lexicons collection doesn't support removal, so we create a new one
-            // This is a limitation - in practice, lexicons shouldn't be overwritten
-            // But we allow it for testing and flexibility
-            const existingLexicon = this.lexicons.get(lexicon.id);
-            if (existingLexicon) {
-                // Try to remove from collection (may fail if not supported)
-                try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this.lexiconsCollection.remove?.(lexicon.id);
-                }
-                catch {
-                    // If removal fails, create a new collection
-                    this.lexiconsCollection = new Lexicons();
-                    // Re-register all other lexicons
-                    for (const [id, lex] of this.lexicons.entries()) {
-                        if (id !== lexicon.id) {
-                            this.lexiconsCollection.add(lex);
-                        }
-                    }
-                }
-            }
-        }
-        this.lexicons.set(lexicon.id, lexicon);
-        this.lexiconsCollection.add(lexicon);
-    }
+    EVIDENCE: EVIDENCE_NSID,
     /**
-     * Registers multiple lexicons at once.
-     *
-     * @param lexicons - Array of lexicon documents to register
-     *
-     * @example
-     * ```typescript
-     * import { HYPERCERT_LEXICONS } from "@hypercerts-org/sdk/lexicons";
-     *
-     * registry.registerMany(HYPERCERT_LEXICONS);
-     * ```
+     * Collection record collection (groups of hypercerts).
      */
-    registerMany(lexicons) {
-        for (const lexicon of lexicons) {
-            this.register(lexicon);
-        }
-    }
+    COLLECTION: COLLECTION_NSID,
     /**
-     * Gets a lexicon document by ID.
-     *
-     * @param id - The lexicon NSID (e.g., "org.hypercerts.hypercert")
-     * @returns The lexicon document, or `undefined` if not registered
-     *
-     * @example
-     * ```typescript
-     * const lexicon = registry.get("org.hypercerts.hypercert");
-     * if (lexicon) {
-     *   console.log(`Found lexicon: ${lexicon.id}`);
-     * }
-     * ```
+     * Project record collection.
      */
-    get(id) {
-        return this.lexicons.get(id);
-    }
+    PROJECT: PROJECT_NSID,
     /**
-     * Validates a record against a collection's lexicon schema.
-     *
-     * @param collection - The collection NSID (same as lexicon ID)
-     * @param record - The record data to validate
-     * @returns Validation result with `valid` boolean and optional `error` message
-     *
-     * @remarks
-     * - If no lexicon is registered for the collection, validation passes
-     *   (we can't validate against unknown schemas)
-     * - Validation checks required fields and type constraints defined
-     *   in the lexicon schema
-     *
-     * @example
-     * ```typescript
-     * const result = registry.validate("org.hypercerts.hypercert", {
-     *   title: "My Hypercert",
-     *   description: "Description...",
-     *   // ... other fields
-     * });
-     *
-     * if (!result.valid) {
-     *   throw new Error(`Invalid record: ${result.error}`);
-     * }
-     * ```
+     * Badge award record collection.
      */
-    validate(collection, record) {
-        // Check if we have a lexicon registered for this collection
-        // Collection format is typically "namespace.collection" (e.g., "app.bsky.feed.post")
-        // Lexicon ID format is the same
-        const lexiconId = collection;
-        const lexicon = this.lexicons.get(lexiconId);
-        if (!lexicon) {
-            // No lexicon registered - validation passes (can't validate unknown schemas)
-            return { valid: true };
-        }
-        // Check required fields if the lexicon defines them
-        const recordDef = lexicon.defs?.record;
-        if (recordDef && typeof recordDef === "object" && "record" in recordDef) {
-            const recordSchema = recordDef.record;
-            if (typeof recordSchema === "object" && "required" in recordSchema && Array.isArray(recordSchema.required)) {
-                const recordObj = record;
-                for (const requiredField of recordSchema.required) {
-                    if (typeof requiredField === "string" && !(requiredField in recordObj)) {
-                        return {
-                            valid: false,
-                            error: `Missing required field: ${requiredField}`,
-                        };
-                    }
-                }
-            }
-        }
-        try {
-            this.lexiconsCollection.assertValidRecord(collection, record);
-            return { valid: true };
-        }
-        catch (error) {
-            // If error indicates lexicon not found, treat as validation pass
-            // (the lexicon might exist in Agent's collection but not ours)
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("not found") || errorMessage.includes("Lexicon not found")) {
-                return { valid: true };
-            }
-            return {
-                valid: false,
-                error: errorMessage,
-            };
-        }
-    }
+    BADGE_AWARD: BADGE_AWARD_NSID,
     /**
-     * Adds all registered lexicons to an AT Protocol Agent instance.
-     *
-     * This allows the Agent to understand custom lexicon types when making
-     * API requests.
-     *
-     * @param agent - The Agent instance to extend
-     *
-     * @remarks
-     * This is called automatically when creating a Repository. You typically
-     * don't need to call this directly unless you're using the Agent
-     * independently.
-     *
-     * @internal
+     * Badge definition record collection.
      */
-    addToAgent(agent) {
-        // Access the internal lexicons collection and merge our lexicons
-        // The Agent's lex property is a Lexicons instance
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const agentLex = agent.lex;
-        // Add each registered lexicon to the agent
-        for (const lexicon of this.lexicons.values()) {
-            agentLex.add(lexicon);
-        }
-    }
+    BADGE_DEFINITION: BADGE_DEFINITION_NSID,
     /**
-     * Gets all registered lexicon IDs.
-     *
-     * @returns Array of lexicon NSIDs
-     *
-     * @example
-     * ```typescript
-     * const ids = registry.getRegisteredIds();
-     * console.log(`Registered lexicons: ${ids.join(", ")}`);
-     * ```
+     * Badge response record collection.
      */
-    getRegisteredIds() {
-        return Array.from(this.lexicons.keys());
-    }
+    BADGE_RESPONSE: BADGE_RESPONSE_NSID,
     /**
-     * Checks if a lexicon is registered.
-     *
-     * @param id - The lexicon NSID to check
-     * @returns `true` if the lexicon is registered
-     *
-     * @example
-     * ```typescript
-     * if (registry.has("org.hypercerts.hypercert")) {
-     *   // Hypercert lexicon is available
-     * }
-     * ```
+     * Funding receipt record collection.
      */
-    has(id) {
-        return this.lexicons.has(id);
-    }
-}
+    FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
+};
-export { LexiconRegistry };
+export { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS };
 //# sourceMappingURL=lexicons.mjs.map

package/dist/lexicons.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"lexicons.mjs","sources":["../src/core/errors.ts","../src/repository/LexiconRegistry.ts"],"sourcesContent":["/*\n Base error class for all SDK errors.\n \n All errors thrown by the Hypercerts SDK extend this class, making it easy\n * to catch and handle SDK-specific errors.\n \n @example Catching all SDK errors\n * ```typescript\n * try {\n * await sdk.authorize(\"user.bsky.social\");\n * } catch (error) {\n * if (error instanceof ATProtoSDKError) {\n * console.error(`SDK Error [${error.code}]: ${error.message}`);\n * console.error(`HTTP Status: ${error.status}`);\n * }\n * }\n * ```\n \n @example Checking error codes\n * ```typescript\n * try {\n * await repo.records.get(collection, rkey);\n * } catch (error) {\n * if (error instanceof ATProtoSDKError) {\n * switch (error.code) {\n * case \"AUTHENTICATION_ERROR\":\n * // Redirect to login\n * break;\n * case \"VALIDATION_ERROR\":\n * // Show form errors\n * break;\n * case \"NETWORK_ERROR\":\n * // Retry or show offline message\n * break;\n * }\n * }\n * }\n * ```\n /\nexport class ATProtoSDKError extends Error {\n /\n Creates a new SDK error.\n \n @param message - Human-readable error description\n * @param code - Machine-readable error code for programmatic handling\n * @param status - HTTP status code associated with this error type\n * @param cause - The underlying error that caused this error, if any\n /\n constructor(\n message: string,\n public code: string,\n public status?: number,\n public cause?: unknown,\n ) {\n super(message);\n this.name = \"ATProtoSDKError\";\n Error.captureStackTrace?.(this, this.constructor);\n }\n}\n\n/\n Error thrown when authentication fails.\n \n This error indicates problems with the OAuth flow, invalid credentials,\n * or failed token exchanges. Common causes:\n * - Invalid authorization code\n * - Expired or invalid state parameter\n * - Revoked or invalid tokens\n * - User denied authorization\n \n @example\n * ```typescript\n * try {\n * const session = await sdk.callback(params);\n * } catch (error) {\n * if (error instanceof AuthenticationError) {\n * // Clear any stored state and redirect to login\n * console.error(\"Authentication failed:\", error.message);\n * }\n * }\n * ```\n /\nexport class AuthenticationError extends ATProtoSDKError {\n /\n Creates an authentication error.\n \n @param message - Description of what went wrong during authentication\n * @param cause - The underlying error (e.g., from the OAuth client)\n /\n constructor(message: string, cause?: unknown) {\n super(message, \"AUTHENTICATION_ERROR\", 401, cause);\n this.name = \"AuthenticationError\";\n }\n}\n\n/\n Error thrown when a session has expired and cannot be refreshed.\n \n This typically occurs when:\n * - The refresh token has expired (usually after extended inactivity)\n * - The user has revoked access to your application\n * - The PDS has invalidated all sessions for the user\n \n When this error occurs, the user must re-authenticate.\n \n @example\n * ```typescript\n * try {\n * const session = await sdk.restoreSession(did);\n * } catch (error) {\n * if (error instanceof SessionExpiredError) {\n * // Clear stored session and prompt user to log in again\n * localStorage.removeItem(\"userDid\");\n * window.location.href = \"/login\";\n * }\n * }\n * ```\n /\nexport class SessionExpiredError extends ATProtoSDKError {\n /\n Creates a session expired error.\n \n @param message - Description of why the session expired\n * @param cause - The underlying error from the token refresh attempt\n /\n constructor(message: string = \"Session expired\", cause?: unknown) {\n super(message, \"SESSION_EXPIRED\", 401, cause);\n this.name = \"SessionExpiredError\";\n }\n}\n\n/\n Error thrown when input validation fails.\n \n This error indicates that provided data doesn't meet the required format\n * or constraints. Common causes:\n * - Missing required fields\n * - Invalid URL formats\n * - Invalid DID format\n * - Schema validation failures for records\n * - Invalid configuration values\n \n @example\n * ```typescript\n * try {\n * await sdk.authorize(\"\"); // Empty identifier\n * } catch (error) {\n * if (error instanceof ValidationError) {\n * console.error(\"Invalid input:\", error.message);\n * // Show validation error to user\n * }\n * }\n * ```\n \n @example With Zod validation cause\n * ```typescript\n * try {\n * await repo.records.create(collection, record);\n * } catch (error) {\n * if (error instanceof ValidationError && error.cause) {\n * // error.cause may be a ZodError with detailed field errors\n * const zodError = error.cause as ZodError;\n * zodError.errors.forEach(e => {\n * console.error(`Field ${e.path.join(\".\")}: ${e.message}`);\n * });\n * }\n * }\n * ```\n /\nexport class ValidationError extends ATProtoSDKError {\n /\n Creates a validation error.\n \n @param message - Description of what validation failed\n * @param cause - The underlying validation error (e.g., ZodError)\n /\n constructor(message: string, cause?: unknown) {\n super(message, \"VALIDATION_ERROR\", 400, cause);\n this.name = \"ValidationError\";\n }\n}\n\n/\n Error thrown when a network request fails.\n \n This error indicates connectivity issues or server unavailability.\n * Common causes:\n * - No internet connection\n * - DNS resolution failure\n * - Server timeout\n * - Server returned 5xx error\n * - TLS/SSL errors\n \n These errors are typically transient and may succeed on retry.\n \n @example\n * ```typescript\n * try {\n * await repo.records.list(collection);\n * } catch (error) {\n * if (error instanceof NetworkError) {\n * // Implement retry logic or show offline indicator\n * console.error(\"Network error:\", error.message);\n * await retryWithBackoff(() => repo.records.list(collection));\n * }\n * }\n * ```\n /\nexport class NetworkError extends ATProtoSDKError {\n /\n Creates a network error.\n \n @param message - Description of the network failure\n * @param cause - The underlying error (e.g., fetch error, timeout)\n /\n constructor(message: string, cause?: unknown) {\n super(message, \"NETWORK_ERROR\", 503, cause);\n this.name = \"NetworkError\";\n }\n}\n\n/\n Error thrown when an SDS-only operation is attempted on a PDS.\n \n Certain operations are only available on Shared Data Servers (SDS),\n * such as collaborator management and organization operations.\n * This error is thrown when these operations are attempted on a\n * Personal Data Server (PDS).\n \n @example\n * ```typescript\n * const pdsRepo = sdk.repository(session); // Default is PDS\n \n try {\n * // This will throw SDSRequiredError\n * await pdsRepo.collaborators.list();\n * } catch (error) {\n * if (error instanceof SDSRequiredError) {\n * // Switch to SDS for this operation\n * const sdsRepo = sdk.repository(session, { server: \"sds\" });\n * const collaborators = await sdsRepo.collaborators.list();\n * }\n * }\n * ```\n /\nexport class SDSRequiredError extends ATProtoSDKError {\n /\n Creates an SDS required error.\n \n @param message - Description of which operation requires SDS\n * @param cause - Any underlying error\n /\n constructor(message: string = \"This operation requires a Shared Data Server (SDS)\", cause?: unknown) {\n super(message, \"SDS_REQUIRED\", 400, cause);\n this.name = \"SDSRequiredError\";\n }\n}\n","import type { Agent } from \"@atproto/api\";\nimport type { LexiconDoc } from \"@atproto/lexicon\";\nimport { Lexicons } from \"@atproto/lexicon\";\nimport { ValidationError } from \"../core/errors.js\";\n\n/\n Result of validating a record against a lexicon schema.\n /\nexport interface ValidationResult {\n /\n Whether the record is valid according to the lexicon schema.\n /\n valid: boolean;\n\n /\n Error message if validation failed.\n \n Only present when `valid` is `false`.\n /\n error?: string;\n}\n\n/\n Registry for managing and validating AT Protocol lexicon schemas.\n \n Lexicons are schema definitions that describe the structure of records\n * in the AT Protocol. This registry allows you to:\n \n - Register custom lexicons for your application's record types\n * - Validate records against their lexicon schemas\n * - Extend the AT Protocol Agent with custom lexicon support\n \n @remarks\n * The SDK automatically registers hypercert lexicons when creating a Repository.\n * You only need to use this class directly if you're working with custom\n * record types.\n \n Lexicon IDs follow the NSID (Namespaced Identifier) format:\n * `{authority}.{name}` (e.g., `org.hypercerts.hypercert`)\n \n @example Registering custom lexicons\n * ```typescript\n * const registry = sdk.getLexiconRegistry();\n \n // Register a single lexicon\n * registry.register({\n * lexicon: 1,\n * id: \"org.example.myRecord\",\n * defs: {\n * main: {\n * type: \"record\",\n * key: \"tid\",\n * record: {\n * type: \"object\",\n * required: [\"title\", \"createdAt\"],\n * properties: {\n * title: { type: \"string\" },\n * description: { type: \"string\" },\n * createdAt: { type: \"string\", format: \"datetime\" },\n * },\n * },\n * },\n * },\n * });\n \n // Register multiple lexicons at once\n * registry.registerMany([lexicon1, lexicon2, lexicon3]);\n * ```\n \n @example Validating records\n * ```typescript\n * const result = registry.validate(\"org.example.myRecord\", {\n * title: \"Test\",\n * createdAt: new Date().toISOString(),\n * });\n \n if (!result.valid) {\n * console.error(`Validation failed: ${result.error}`);\n * }\n * ```\n \n @see https://atproto.com/specs/lexicon for the Lexicon specification\n /\nexport class LexiconRegistry {\n /* Map of lexicon ID to lexicon document /\n private lexicons = new Map<string, LexiconDoc>();\n\n /* Lexicons collection for validation /\n private lexiconsCollection: Lexicons;\n\n /\n Creates a new LexiconRegistry.\n \n The registry starts empty. Use {@link register} or {@link registerMany}\n * to add lexicons.\n /\n constructor() {\n this.lexiconsCollection = new Lexicons();\n }\n\n /\n Registers a single lexicon schema.\n \n @param lexicon - The lexicon document to register\n * @throws {@link ValidationError} if the lexicon doesn't have an `id` field\n \n @remarks\n * If a lexicon with the same ID is already registered, it will be\n * replaced with the new definition. This is useful for testing but\n * should generally be avoided in production.\n \n @example\n * ```typescript\n * registry.register({\n * lexicon: 1,\n * id: \"org.example.post\",\n * defs: {\n * main: {\n * type: \"record\",\n * key: \"tid\",\n * record: {\n * type: \"object\",\n * required: [\"text\", \"createdAt\"],\n * properties: {\n * text: { type: \"string\", maxLength: 300 },\n * createdAt: { type: \"string\", format: \"datetime\" },\n * },\n * },\n * },\n * },\n * });\n * ```\n /\n register(lexicon: LexiconDoc): void {\n if (!lexicon.id) {\n throw new ValidationError(\"Lexicon must have an 'id' field\");\n }\n\n // Remove existing lexicon if present (to allow overwriting)\n if (this.lexicons.has(lexicon.id)) {\n // Lexicons collection doesn't support removal, so we create a new one\n // This is a limitation - in practice, lexicons shouldn't be overwritten\n // But we allow it for testing and flexibility\n const existingLexicon = this.lexicons.get(lexicon.id);\n if (existingLexicon) {\n // Try to remove from collection (may fail if not supported)\n try {\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (this.lexiconsCollection as any).remove?.(lexicon.id);\n } catch {\n // If removal fails, create a new collection\n this.lexiconsCollection = new Lexicons();\n // Re-register all other lexicons\n for (const [id, lex] of this.lexicons.entries()) {\n if (id !== lexicon.id) {\n this.lexiconsCollection.add(lex);\n }\n }\n }\n }\n }\n\n this.lexicons.set(lexicon.id, lexicon);\n this.lexiconsCollection.add(lexicon);\n }\n\n /\n Registers multiple lexicons at once.\n \n @param lexicons - Array of lexicon documents to register\n \n @example\n * ```typescript\n * import { HYPERCERT_LEXICONS } from \"@hypercerts-org/sdk/lexicons\";\n \n registry.registerMany(HYPERCERT_LEXICONS);\n * ```\n /\n registerMany(lexicons: LexiconDoc[]): void {\n for (const lexicon of lexicons) {\n this.register(lexicon);\n }\n }\n\n /\n Gets a lexicon document by ID.\n \n @param id - The lexicon NSID (e.g., \"org.hypercerts.hypercert\")\n * @returns The lexicon document, or `undefined` if not registered\n \n @example\n * ```typescript\n * const lexicon = registry.get(\"org.hypercerts.hypercert\");\n * if (lexicon) {\n * console.log(`Found lexicon: ${lexicon.id}`);\n * }\n * ```\n /\n get(id: string): LexiconDoc \| undefined {\n return this.lexicons.get(id);\n }\n\n /\n Validates a record against a collection's lexicon schema.\n \n @param collection - The collection NSID (same as lexicon ID)\n * @param record - The record data to validate\n * @returns Validation result with `valid` boolean and optional `error` message\n \n @remarks\n * - If no lexicon is registered for the collection, validation passes\n * (we can't validate against unknown schemas)\n * - Validation checks required fields and type constraints defined\n * in the lexicon schema\n \n @example\n * ```typescript\n * const result = registry.validate(\"org.hypercerts.hypercert\", {\n * title: \"My Hypercert\",\n * description: \"Description...\",\n * // ... other fields\n * });\n \n if (!result.valid) {\n * throw new Error(`Invalid record: ${result.error}`);\n * }\n * ```\n /\n validate(collection: string, record: unknown): ValidationResult {\n // Check if we have a lexicon registered for this collection\n // Collection format is typically \"namespace.collection\" (e.g., \"app.bsky.feed.post\")\n // Lexicon ID format is the same\n const lexiconId = collection;\n const lexicon = this.lexicons.get(lexiconId);\n if (!lexicon) {\n // No lexicon registered - validation passes (can't validate unknown schemas)\n return { valid: true };\n }\n\n // Check required fields if the lexicon defines them\n const recordDef = lexicon.defs?.record;\n if (recordDef && typeof recordDef === \"object\" && \"record\" in recordDef) {\n const recordSchema = recordDef.record;\n if (typeof recordSchema === \"object\" && \"required\" in recordSchema && Array.isArray(recordSchema.required)) {\n const recordObj = record as Record<string, unknown>;\n for (const requiredField of recordSchema.required) {\n if (typeof requiredField === \"string\" && !(requiredField in recordObj)) {\n return {\n valid: false,\n error: `Missing required field: ${requiredField}`,\n };\n }\n }\n }\n }\n\n try {\n this.lexiconsCollection.assertValidRecord(collection, record);\n return { valid: true };\n } catch (error) {\n // If error indicates lexicon not found, treat as validation pass\n // (the lexicon might exist in Agent's collection but not ours)\n const errorMessage = error instanceof Error ? error.message : String(error);\n if (errorMessage.includes(\"not found\") \|\| errorMessage.includes(\"Lexicon not found\")) {\n return { valid: true };\n }\n return {\n valid: false,\n error: errorMessage,\n };\n }\n }\n\n /\n Adds all registered lexicons to an AT Protocol Agent instance.\n \n This allows the Agent to understand custom lexicon types when making\n * API requests.\n \n @param agent - The Agent instance to extend\n \n @remarks\n * This is called automatically when creating a Repository. You typically\n * don't need to call this directly unless you're using the Agent\n * independently.\n \n @internal\n /\n addToAgent(agent: Agent): void {\n // Access the internal lexicons collection and merge our lexicons\n // The Agent's lex property is a Lexicons instance\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const agentLex = (agent as any).lex as Lexicons;\n\n // Add each registered lexicon to the agent\n for (const lexicon of this.lexicons.values()) {\n agentLex.add(lexicon);\n }\n }\n\n /\n Gets all registered lexicon IDs.\n \n @returns Array of lexicon NSIDs\n \n @example\n * ```typescript\n * const ids = registry.getRegisteredIds();\n * console.log(`Registered lexicons: ${ids.join(\", \")}`);\n * ```\n /\n getRegisteredIds(): string[] {\n return Array.from(this.lexicons.keys());\n }\n\n /\n Checks if a lexicon is registered.\n \n @param id - The lexicon NSID to check\n * @returns `true` if the lexicon is registered\n \n @example\n * ```typescript\n * if (registry.has(\"org.hypercerts.hypercert\")) {\n * // Hypercert lexicon is available\n * }\n * ```\n */\n has(id: string): boolean {\n return this.lexicons.has(id);\n }\n}\n"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;AACG,MAAO,eAAgB,SAAQ,KAAK,CAAA;AACxC;;;;;;;AAOG;AACH,IAAA,WAAA,CACE,OAAe,EACR,IAAY,EACZ,MAAe,EACf,KAAe,EAAA;QAEtB,KAAK,CAAC,OAAO,CAAC;QAJP,IAAA,CAAA,IAAI,GAAJ,IAAI;QACJ,IAAA,CAAA,MAAM,GAAN,MAAM;QACN,IAAA,CAAA,KAAK,GAAL,KAAK;AAGZ,QAAA,IAAI,CAAC,IAAI,GAAG,iBAAiB;QAC7B,KAAK,CAAC,iBAAiB,GAAG,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC;IACnD;AACD;AAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACG,MAAO,eAAgB,SAAQ,eAAe,CAAA;AAClD;;;;;AAKG;IACH,WAAA,CAAY,OAAe,EAAE,KAAe,EAAA;QAC1C,KAAK,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,EAAE,KAAK,CAAC;AAC9C,QAAA,IAAI,CAAC,IAAI,GAAG,iBAAiB;IAC/B;AACD;;AC9JD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DG;MACU,eAAe,CAAA;AAO1B;;;;;AAKG;AACH,IAAA,WAAA,GAAA;;AAXQ,QAAA,IAAA,CAAA,QAAQ,GAAG,IAAI,GAAG,EAAsB;AAY9C,QAAA,IAAI,CAAC,kBAAkB,GAAG,IAAI,QAAQ,EAAE;IAC1C;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCG;AACH,IAAA,QAAQ,CAAC,OAAmB,EAAA;AAC1B,QAAA,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE;AACf,YAAA,MAAM,IAAI,eAAe,CAAC,iCAAiC,CAAC;QAC9D;;QAGA,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;;;;AAIjC,YAAA,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YACrD,IAAI,eAAe,EAAE;;AAEnB,gBAAA,IAAI;;oBAED,IAAI,CAAC,kBAA0B,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;gBACvD;AAAE,gBAAA,MAAM;;AAEN,oBAAA,IAAI,CAAC,kBAAkB,GAAG,IAAI,QAAQ,EAAE;;AAExC,oBAAA,KAAK,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,EAAE;AAC/C,wBAAA,IAAI,EAAE,KAAK,OAAO,CAAC,EAAE,EAAE;AACrB,4BAAA,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC;wBAClC;oBACF;gBACF;YACF;QACF;QAEA,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC;AACtC,QAAA,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,OAAO,CAAC;IACtC;AAEA;;;;;;;;;;;AAWG;AACH,IAAA,YAAY,CAAC,QAAsB,EAAA;AACjC,QAAA,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;AAC9B,YAAA,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;QACxB;IACF;AAEA;;;;;;;;;;;;;AAaG;AACH,IAAA,GAAG,CAAC,EAAU,EAAA;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;IAC9B;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;IACH,QAAQ,CAAC,UAAkB,EAAE,MAAe,EAAA;;;;QAI1C,MAAM,SAAS,GAAG,UAAU;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC;QAC5C,IAAI,CAAC,OAAO,EAAE;;AAEZ,YAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE;QACxB;;AAGA,QAAA,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,EAAE,MAAM;QACtC,IAAI,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,QAAQ,IAAI,SAAS,EAAE;AACvE,YAAA,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM;AACrC,YAAA,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,UAAU,IAAI,YAAY,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;gBAC1G,MAAM,SAAS,GAAG,MAAiC;AACnD,gBAAA,KAAK,MAAM,aAAa,IAAI,YAAY,CAAC,QAAQ,EAAE;AACjD,oBAAA,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,EAAE,aAAa,IAAI,SAAS,CAAC,EAAE;wBACtE,OAAO;AACL,4BAAA,KAAK,EAAE,KAAK;4BACZ,KAAK,EAAE,CAAA,wBAAA,EAA2B,aAAa,CAAA,CAAE;yBAClD;oBACH;gBACF;YACF;QACF;AAEA,QAAA,IAAI;YACF,IAAI,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM,CAAC;AAC7D,YAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE;QACxB;QAAE,OAAO,KAAK,EAAE;;;AAGd,YAAA,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC;AAC3E,YAAA,IAAI,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE;AACpF,gBAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE;YACxB;YACA,OAAO;AACL,gBAAA,KAAK,EAAE,KAAK;AACZ,gBAAA,KAAK,EAAE,YAAY;aACpB;QACH;IACF;AAEA;;;;;;;;;;;;;;AAcG;AACH,IAAA,UAAU,CAAC,KAAY,EAAA;;;;AAIrB,QAAA,MAAM,QAAQ,GAAI,KAAa,CAAC,GAAe;;QAG/C,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE;AAC5C,YAAA,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;QACvB;IACF;AAEA;;;;;;;;;;AAUG;IACH,gBAAgB,GAAA;QACd,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACzC;AAEA;;;;;;;;;;;;AAYG;AACH,IAAA,GAAG,CAAC,EAAU,EAAA;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;IAC9B;AACD;;;;"}
1	+ {"version":3,"file":"lexicons.mjs","sources":["../src/lexicons.ts"],"sourcesContent":["/*\n Lexicons entrypoint - Lexicon definitions and registry.\n \n This sub-entrypoint exports the lexicon registry and hypercert\n * lexicon constants for working with AT Protocol record schemas.\n \n @remarks\n * Import from `@hypercerts-org/sdk/lexicons`:\n \n ```typescript\n * import {\n * LexiconRegistry,\n * HYPERCERT_LEXICONS,\n * HYPERCERT_COLLECTIONS,\n * } from \"@hypercerts-org/sdk/lexicons\";\n * ```\n \n Exports:\n * - {@link LexiconRegistry} - Registry for managing and validating lexicons\n * - {@link HYPERCERT_LEXICONS} - Array of all hypercert lexicon documents\n * - {@link HYPERCERT_COLLECTIONS} - Constants for collection NSIDs\n \n @example Using collection constants\n * ```typescript\n * import { HYPERCERT_COLLECTIONS } from \"@hypercerts-org/sdk/lexicons\";\n \n // List hypercerts using the correct collection name\n * const records = await repo.records.list({\n * collection: HYPERCERT_COLLECTIONS.RECORD,\n * });\n \n // List contributions\n * const contributions = await repo.records.list({\n * collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,\n * });\n * ```\n \n @example Custom lexicon registration\n * ```typescript\n * import { LexiconRegistry } from \"@hypercerts-org/sdk/lexicons\";\n \n const registry = sdk.getLexiconRegistry();\n \n // Register custom lexicon\n * registry.register({\n * lexicon: 1,\n * id: \"org.myapp.customRecord\",\n * defs: { ... },\n * });\n \n // Validate a record\n * const result = registry.validate(\"org.myapp.customRecord\", record);\n * if (!result.valid) {\n * console.error(result.error);\n * }\n * ```\n \n @packageDocumentation\n /\n\n// Import lexicon JSON files and constants from the published package\nimport type { LexiconDoc } from \"@atproto/lexicon\";\nimport {\n CERTIFIED_DEFS_LEXICON_JSON,\n LOCATION_LEXICON_JSON,\n STRONGREF_LEXICON_JSON,\n HYPERCERTS_DEFS_LEXICON_JSON,\n ACTIVITY_LEXICON_JSON,\n COLLECTION_LEXICON_JSON,\n CONTRIBUTION_LEXICON_JSON,\n EVALUATION_LEXICON_JSON,\n EVIDENCE_LEXICON_JSON,\n MEASUREMENT_LEXICON_JSON,\n RIGHTS_LEXICON_JSON,\n PROJECT_LEXICON_JSON,\n BADGE_AWARD_LEXICON_JSON,\n BADGE_DEFINITION_LEXICON_JSON,\n BADGE_RESPONSE_LEXICON_JSON,\n FUNDING_RECEIPT_LEXICON_JSON,\n // NSID constants\n ACTIVITY_NSID,\n RIGHTS_NSID,\n LOCATION_NSID,\n CONTRIBUTION_NSID,\n MEASUREMENT_NSID,\n EVALUATION_NSID,\n EVIDENCE_NSID,\n COLLECTION_NSID,\n PROJECT_NSID,\n BADGE_AWARD_NSID,\n BADGE_DEFINITION_NSID,\n BADGE_RESPONSE_NSID,\n FUNDING_RECEIPT_NSID,\n} from \"@hypercerts-org/lexicon\";\n\n/\n All hypercert-related lexicons for registration with AT Protocol Agent.\n * This array contains all lexicon documents from the published package.\n /\nexport const HYPERCERT_LEXICONS: LexiconDoc[] = [\n CERTIFIED_DEFS_LEXICON_JSON as LexiconDoc,\n LOCATION_LEXICON_JSON as LexiconDoc,\n STRONGREF_LEXICON_JSON as LexiconDoc,\n HYPERCERTS_DEFS_LEXICON_JSON as LexiconDoc,\n ACTIVITY_LEXICON_JSON as LexiconDoc,\n COLLECTION_LEXICON_JSON as LexiconDoc,\n CONTRIBUTION_LEXICON_JSON as LexiconDoc,\n EVALUATION_LEXICON_JSON as LexiconDoc,\n EVIDENCE_LEXICON_JSON as LexiconDoc,\n MEASUREMENT_LEXICON_JSON as LexiconDoc,\n RIGHTS_LEXICON_JSON as LexiconDoc,\n PROJECT_LEXICON_JSON as LexiconDoc,\n BADGE_AWARD_LEXICON_JSON as LexiconDoc,\n BADGE_DEFINITION_LEXICON_JSON as LexiconDoc,\n BADGE_RESPONSE_LEXICON_JSON as LexiconDoc,\n FUNDING_RECEIPT_LEXICON_JSON as LexiconDoc,\n];\n\n/\n Collection NSIDs (Namespaced Identifiers) for hypercert records.\n \n Use these constants when performing record operations to ensure\n * correct collection names.\n /\nexport const HYPERCERT_COLLECTIONS = {\n /\n Main hypercert claim record collection.\n /\n CLAIM: ACTIVITY_NSID,\n\n /\n Rights record collection.\n /\n RIGHTS: RIGHTS_NSID,\n\n /\n Location record collection (shared certified lexicon).\n /\n LOCATION: LOCATION_NSID,\n\n /\n Contribution record collection.\n /\n CONTRIBUTION: CONTRIBUTION_NSID,\n\n /\n Measurement record collection.\n /\n MEASUREMENT: MEASUREMENT_NSID,\n\n /\n Evaluation record collection.\n /\n EVALUATION: EVALUATION_NSID,\n\n /\n Evidence record collection.\n /\n EVIDENCE: EVIDENCE_NSID,\n\n /\n Collection record collection (groups of hypercerts).\n /\n COLLECTION: COLLECTION_NSID,\n\n /\n Project record collection.\n /\n PROJECT: PROJECT_NSID,\n\n /\n Badge award record collection.\n /\n BADGE_AWARD: BADGE_AWARD_NSID,\n\n /\n Badge definition record collection.\n /\n BADGE_DEFINITION: BADGE_DEFINITION_NSID,\n\n /\n Badge response record collection.\n /\n BADGE_RESPONSE: BADGE_RESPONSE_NSID,\n\n /\n Funding receipt record collection.\n */\n FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,\n} as const;\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AAqCH;;;AAGG;AACI,MAAM,kBAAkB,GAAiB;IAC9C,2BAAyC;IACzC,qBAAmC;IACnC,sBAAoC;IACpC,4BAA0C;IAC1C,qBAAmC;IACnC,uBAAqC;IACrC,yBAAuC;IACvC,uBAAqC;IACrC,qBAAmC;IACnC,wBAAsC;IACtC,mBAAiC;IACjC,oBAAkC;IAClC,wBAAsC;IACtC,6BAA2C;IAC3C,2BAAyC;IACzC,4BAA0C;;AAG5C;;;;;AAKG;AACI,MAAM,qBAAqB,GAAG;AACnC;;AAEG;AACH,IAAA,KAAK,EAAE,aAAa;AAEpB;;AAEG;AACH,IAAA,MAAM,EAAE,WAAW;AAEnB;;AAEG;AACH,IAAA,QAAQ,EAAE,aAAa;AAEvB;;AAEG;AACH,IAAA,YAAY,EAAE,iBAAiB;AAE/B;;AAEG;AACH,IAAA,WAAW,EAAE,gBAAgB;AAE7B;;AAEG;AACH,IAAA,UAAU,EAAE,eAAe;AAE3B;;AAEG;AACH,IAAA,QAAQ,EAAE,aAAa;AAEvB;;AAEG;AACH,IAAA,UAAU,EAAE,eAAe;AAE3B;;AAEG;AACH,IAAA,OAAO,EAAE,YAAY;AAErB;;AAEG;AACH,IAAA,WAAW,EAAE,gBAAgB;AAE7B;;AAEG;AACH,IAAA,gBAAgB,EAAE,qBAAqB;AAEvC;;AAEG;AACH,IAAA,cAAc,EAAE,mBAAmB;AAEnC;;AAEG;AACH,IAAA,eAAe,EAAE,oBAAoB;;;;;"}

package/dist/types.cjs CHANGED Viewed

@@ -1,6 +1,8 @@
 'use strict';
 var zod = require('zod');
+var lexicon = require('@atproto/lexicon');
+require('@hypercerts-org/lexicon');
 /**
  * Zod schema for OAuth configuration validation.
@@ -236,6 +238,10 @@ const CollaboratorSchema = zod.z.object({
     revokedAt: zod.z.string().optional(),
 });
+Object.defineProperty(exports, "BlobRef", {
+    enumerable: true,
+    get: function () { return lexicon.BlobRef; }
+});
 exports.ATProtoSDKConfigSchema = ATProtoSDKConfigSchema;
 exports.CollaboratorPermissionsSchema = CollaboratorPermissionsSchema;
 exports.CollaboratorSchema = CollaboratorSchema;