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

package/dist/lexicons.d.ts

@@ -1,227 +1,129 @@
-import { Agent } from '@atproto/api';
 import { LexiconDoc } from '@atproto/lexicon';
-export { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS } from '@hypercerts-org/lexicon';
 
 /**
- * Result of validating a record against a lexicon schema.
- */
-interface ValidationResult {
-    /**
-     * Whether the record is valid according to the lexicon schema.
-     */
-    valid: boolean;
-    /**
-     * Error message if validation failed.
-     *
-     * Only present when `valid` is `false`.
-     */
-    error?: string;
-}
-/**
- * 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:
+ * Lexicons entrypoint - Lexicon definitions and registry.
  *
- * - Register custom lexicons for your application's record types
- * - Validate records against their lexicon schemas
- * - Extend the AT Protocol Agent with custom lexicon support
+ * This sub-entrypoint exports the lexicon registry and hypercert
+ * lexicon constants for working with AT Protocol record schemas.
  *
  * @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.
+ * Import from `@hypercerts-org/sdk/lexicons`:
+ *
+ * ```typescript
+ * import {
+ *   LexiconRegistry,
+ *   HYPERCERT_LEXICONS,
+ *   HYPERCERT_COLLECTIONS,
+ * } from "@hypercerts-org/sdk/lexicons";
+ * ```
  *
- * **Lexicon IDs** follow the NSID (Namespaced Identifier) format:
- * `{authority}.{name}` (e.g., `org.hypercerts.hypercert`)
+ * **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 Registering custom lexicons
+ * @example Using collection constants
  * ```typescript
- * const registry = sdk.getLexiconRegistry();
+ * import { HYPERCERT_COLLECTIONS } from "@hypercerts-org/sdk/lexicons";
  *
- * // Register a single 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" },
- *         },
- *       },
- *     },
- *   },
+ * // List hypercerts using the correct collection name
+ * const records = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.RECORD,
  * });
  *
- * // Register multiple lexicons at once
- * registry.registerMany([lexicon1, lexicon2, lexicon3]);
+ * // List contributions
+ * const contributions = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,
+ * });
  * ```
  *
- * @example Validating records
+ * @example Custom lexicon registration
  * ```typescript
- * const result = registry.validate("org.example.myRecord", {
- *   title: "Test",
- *   createdAt: new Date().toISOString(),
+ * import { LexiconRegistry } from "@hypercerts-org/sdk/lexicons";
+ *
+ * const registry = sdk.getLexiconRegistry();
+ *
+ * // Register custom lexicon
+ * registry.register({
+ *   lexicon: 1,
+ *   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
  */
-declare class LexiconRegistry {
-    /** Map of lexicon ID to lexicon document */
-    private lexicons;
-    /** Lexicons collection for validation */
-    private lexiconsCollection;
+
+/**
+ * All hypercert-related lexicons for registration with AT Protocol Agent.
+ * This array contains all lexicon documents from the published package.
+ */
+declare const HYPERCERT_LEXICONS: LexiconDoc[];
+/**
+ * Collection NSIDs (Namespaced Identifiers) for hypercert records.
+ *
+ * Use these constants when performing record operations to ensure
+ * correct collection names.
+ */
+declare const HYPERCERT_COLLECTIONS: {
+    /**
+     * Main hypercert claim record collection.
+     */
+    readonly CLAIM: "org.hypercerts.claim.activity";
+    /**
+     * Rights record collection.
+     */
+    readonly RIGHTS: "org.hypercerts.claim.rights";
+    /**
+     * Location record collection (shared certified lexicon).
+     */
+    readonly LOCATION: "app.certified.location";
+    /**
+     * Contribution record collection.
+     */
+    readonly CONTRIBUTION: "org.hypercerts.claim.contribution";
+    /**
+     * Measurement record collection.
+     */
+    readonly MEASUREMENT: "org.hypercerts.claim.measurement";
     /**
-     * Creates a new LexiconRegistry.
-     *
-     * The registry starts empty. Use {@link register} or {@link registerMany}
-     * to add lexicons.
+     * Evaluation record collection.
      */
-    constructor();
+    readonly EVALUATION: "org.hypercerts.claim.evaluation";
     /**
-     * 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: LexiconDoc): void;
+    readonly EVIDENCE: "org.hypercerts.claim.evidence";
     /**
-     * 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: LexiconDoc[]): void;
+    readonly COLLECTION: "org.hypercerts.claim.collection";
     /**
-     * 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: string): LexiconDoc | undefined;
+    readonly PROJECT: "org.hypercerts.claim.project";
     /**
-     * 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: string, record: unknown): ValidationResult;
+    readonly BADGE_AWARD: "app.certified.badge.award";
     /**
-     * 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: Agent): void;
+    readonly BADGE_DEFINITION: "app.certified.badge.definition";
     /**
-     * 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(): string[];
+    readonly BADGE_RESPONSE: "app.certified.badge.response";
     /**
-     * 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: string): boolean;
-}
+    readonly FUNDING_RECEIPT: "org.hypercerts.funding.receipt";
+};
 
-export { LexiconRegistry };
-export type { ValidationResult };
+export { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS };