@hypercerts-org/lexicon 0.10.0 → 0.11.0

package/dist/lexicons.mjs

@@ -28,6 +28,83 @@ function maybe$typed(v, id, hash) {
  * GENERATED CODE - DO NOT MODIFY
  */
 const schemaDict = {
+    AppBskyRichtextFacet: {
+        lexicon: 1,
+        id: 'app.bsky.richtext.facet',
+        defs: {
+            main: {
+                type: 'object',
+                description: 'Annotation of a sub-string within rich text.',
+                required: ['index', 'features'],
+                properties: {
+                    index: {
+                        type: 'ref',
+                        ref: 'lex:app.bsky.richtext.facet#byteSlice',
+                    },
+                    features: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:app.bsky.richtext.facet#mention',
+                                'lex:app.bsky.richtext.facet#link',
+                                'lex:app.bsky.richtext.facet#tag',
+                            ],
+                        },
+                    },
+                },
+            },
+            mention: {
+                type: 'object',
+                description: "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",
+                required: ['did'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                    },
+                },
+            },
+            link: {
+                type: 'object',
+                description: 'Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.',
+                required: ['uri'],
+                properties: {
+                    uri: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+            tag: {
+                type: 'object',
+                description: "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",
+                required: ['tag'],
+                properties: {
+                    tag: {
+                        type: 'string',
+                        maxLength: 640,
+                        maxGraphemes: 64,
+                    },
+                },
+            },
+            byteSlice: {
+                type: 'object',
+                description: 'Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.',
+                required: ['byteStart', 'byteEnd'],
+                properties: {
+                    byteStart: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                    byteEnd: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                },
+            },
+        },
+    },
     AppCertifiedActorOrganization: {
         lexicon: 1,
         id: 'app.certified.actor.organization',
@@ -173,8 +250,8 @@ const schemaDict = {
                     properties: {
                         badge: {
                             type: 'ref',
-                            ref: 'lex:app.certified.badge.definition',
-                            description: 'Reference to the badge definition for this award.',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Strong reference to the badge definition at the time of award. The record referenced must conform with the lexicon app.certified.badge.definition.',
                         },
                         subject: {
                             type: 'union',
@@ -215,11 +292,19 @@ const schemaDict = {
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['title', 'badgeType', 'icon', 'createdAt'],
+                    required: ['title', 'badgeType', 'createdAt'],
                     properties: {
                         badgeType: {
                             type: 'string',
-                            description: 'Category of the badge (e.g. endorsement, participation, affiliation).',
+                            description: 'Category of the badge. Values beyond the known set are permitted.',
+                            knownValues: [
+                                'endorsement',
+                                'verification',
+                                'participation',
+                                'certification',
+                                'affiliation',
+                                'recognition',
+                            ],
                             maxLength: 100,
                         },
                         title: {
@@ -277,8 +362,8 @@ const schemaDict = {
                     properties: {
                         badgeAward: {
                             type: 'ref',
-                            ref: 'lex:app.certified.badge.award',
-                            description: 'Reference to the badge award.',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Strong reference to the badge award being responded to. The record referenced must conform with the lexicon app.certified.badge.award.',
                         },
                         response: {
                             type: 'string',
@@ -320,6 +405,94 @@ const schemaDict = {
             },
         },
     },
+    AppCertifiedLinkEvm: {
+        lexicon: 1,
+        id: 'app.certified.link.evm',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A verifiable link between an ATProto DID and an EVM wallet address, proven via a cryptographic signature. Currently supports EOA wallets via EIP-712 typed data signatures; the proof field is an open union to allow future signature methods.',
+                key: 'any',
+                record: {
+                    type: 'object',
+                    required: ['address', 'proof', 'createdAt'],
+                    properties: {
+                        address: {
+                            type: 'string',
+                            description: 'EVM wallet address (0x-prefixed, with EIP-55 checksum recommended).',
+                            minLength: 42,
+                            maxLength: 42,
+                        },
+                        proof: {
+                            type: 'union',
+                            refs: ['lex:app.certified.link.evm#eip712Proof'],
+                            description: 'Cryptographic proof of wallet ownership. The union is open to allow future proof methods (e.g. ERC-1271, ERC-6492). Each variant bundles its signature with the corresponding message format.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
+                        },
+                    },
+                },
+            },
+            eip712Proof: {
+                type: 'object',
+                description: 'EOA wallet ownership proof via EIP-712 typed data signature. Contains both the structured message that was signed and the resulting signature.',
+                required: ['signature', 'message'],
+                properties: {
+                    signature: {
+                        type: 'string',
+                        description: 'ECDSA signature over the EIP-712 hash (hex-encoded with 0x prefix, 64 or 65 bytes).',
+                        minLength: 130,
+                        maxLength: 132,
+                    },
+                    message: {
+                        type: 'ref',
+                        ref: 'lex:app.certified.link.evm#eip712Message',
+                        description: 'The EIP-712 structured message fields that were signed.',
+                    },
+                },
+            },
+            eip712Message: {
+                type: 'object',
+                description: 'The EIP-712 typed data message that was signed by the wallet. Contains the fields binding an ATProto DID to an EVM address on a specific chain.',
+                required: ['did', 'evmAddress', 'chainId', 'timestamp', 'nonce'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                        description: 'The ATProto DID being linked to the EVM address.',
+                        maxLength: 256,
+                    },
+                    evmAddress: {
+                        type: 'string',
+                        description: 'The EVM wallet address (must match the top-level address field).',
+                        minLength: 42,
+                        maxLength: 42,
+                    },
+                    chainId: {
+                        type: 'string',
+                        description: 'EVM chain ID as string (bigint serialized). Identifies which chain was used for signing; for EOA wallets the identity link applies across all EVM-compatible chains.',
+                        minLength: 1,
+                        maxLength: 78,
+                    },
+                    timestamp: {
+                        type: 'string',
+                        description: 'Unix timestamp when the attestation was created (bigint serialized).',
+                        minLength: 1,
+                        maxLength: 78,
+                    },
+                    nonce: {
+                        type: 'string',
+                        description: 'Replay-protection nonce (bigint serialized).',
+                        minLength: 1,
+                        maxLength: 78,
+                    },
+                },
+            },
+        },
+    },
     AppCertifiedLocation: {
         lexicon: 1,
         id: 'app.certified.location',
@@ -689,9 +862,13 @@ const schemaDict = {
                             },
                         },
                         description: {
-                            type: 'ref',
-                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
-                            description: 'Rich-text description, represented as a Leaflet linear document.',
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#descriptionString',
+                                'lex:pub.leaflet.pages.linearDocument',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            description: 'Long-form description of the activity. An inline string for plain text or markdown, a Leaflet linear document for rich-text content, or a strong reference to an external description record.',
                         },
                         image: {
                             type: 'union',
@@ -704,7 +881,6 @@ const schemaDict = {
                         contributors: {
                             type: 'array',
                             description: 'An array of contributor objects, each containing contributor information, weight, and contribution details.',
-                            maxLength: 1000,
                             items: {
                                 type: 'ref',
                                 ref: 'lex:org.hypercerts.claim.activity#contributor',
@@ -752,6 +928,7 @@ const schemaDict = {
             },
             contributor: {
                 type: 'object',
+                description: 'A contributor to the activity, with identity, weight, and contribution details.',
                 required: ['contributorIdentity'],
                 properties: {
                     contributorIdentity: {
@@ -966,7 +1143,8 @@ const schemaDict = {
                     properties: {
                         type: {
                             type: 'string',
-                            description: "The type of this collection. Possible fields can be 'favorites', 'project', or any other type of collection.",
+                            description: 'The type of this collection. Values beyond the known set are permitted.',
+                            knownValues: ['favorites', 'project', 'portfolio', 'program'],
                             maxLength: 64,
                         },
                         title: {
@@ -979,12 +1157,24 @@ const schemaDict = {
                             type: 'string',
                             maxLength: 3000,
                             maxGraphemes: 300,
-                            description: 'Short summary of this collection, suitable for previews and list views',
+                            description: 'Short summary of this collection, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
+                        },
+                        shortDescriptionFacets: {
+                            type: 'array',
+                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
+                            },
                         },
                         description: {
-                            type: 'ref',
-                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
-                            description: 'Rich-text description, represented as a Leaflet linear document.',
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#descriptionString',
+                                'lex:pub.leaflet.pages.linearDocument',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            description: 'Long-form description of the collection. An inline string for plain text or markdown, a Leaflet linear document for rich-text content, or a strong reference to an external description record.',
                         },
                         avatar: {
                             type: 'union',
@@ -1026,6 +1216,7 @@ const schemaDict = {
             },
             item: {
                 type: 'object',
+                description: 'An item in a collection, with an identifier and optional weight.',
                 required: ['itemIdentifier'],
                 properties: {
                     itemIdentifier: {
@@ -1110,8 +1301,15 @@ const schemaDict = {
                         },
                         contentType: {
                             type: 'string',
+                            description: 'The type of attachment. Values beyond the known set are permitted.',
+                            knownValues: [
+                                'report',
+                                'audit',
+                                'evidence',
+                                'testimonial',
+                                'methodology',
+                            ],
                             maxLength: 64,
-                            description: 'The type of attachment, e.g. report, audit, evidence, testimonial, methodology, etc.',
                         },
                         content: {
                             type: 'array',
@@ -1145,9 +1343,13 @@ const schemaDict = {
                             },
                         },
                         description: {
-                            type: 'ref',
-                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
-                            description: 'Rich-text description, represented as a Leaflet linear document.',
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#descriptionString',
+                                'lex:pub.leaflet.pages.linearDocument',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            description: 'Long-form description of the attachment. An inline string for plain text or markdown, a Leaflet linear document for rich-text content, or a strong reference to an external description record.',
                         },
                         location: {
                             type: 'ref',
@@ -1241,16 +1443,19 @@ const schemaDict = {
                 required: ['min', 'max', 'value'],
                 properties: {
                     min: {
-                        type: 'integer',
-                        description: 'Minimum value of the scale, e.g. 0 or 1.',
+                        type: 'string',
+                        description: "Minimum value of the scale as a numeric string (e.g. '0', '1').",
+                        maxLength: 50,
                     },
                     max: {
-                        type: 'integer',
-                        description: 'Maximum value of the scale, e.g. 5 or 10.',
+                        type: 'string',
+                        description: "Maximum value of the scale as a numeric string (e.g. '5', '10').",
+                        maxLength: 50,
                     },
                     value: {
-                        type: 'integer',
-                        description: 'Score within the inclusive range [min, max].',
+                        type: 'string',
+                        description: "Score within the inclusive range [min, max] as a numeric string (e.g. '3.7').",
+                        maxLength: 50,
                     },
                 },
             },
@@ -1368,6 +1573,27 @@ const schemaDict = {
         id: 'org.hypercerts.defs',
         description: 'Common type definitions used across all Hypercerts protocols.',
         defs: {
+            descriptionString: {
+                type: 'object',
+                description: 'An inline long-form description as plain text or markdown, with optional rich-text annotations.',
+                required: ['value'],
+                properties: {
+                    value: {
+                        type: 'string',
+                        description: 'The description text (plain text or markdown).',
+                        maxLength: 250000,
+                        maxGraphemes: 25000,
+                    },
+                    facets: {
+                        type: 'array',
+                        description: 'Rich text annotations for the description (mentions, URLs, hashtags, etc).',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:app.bsky.richtext.facet',
+                        },
+                    },
+                },
+            },
             uri: {
                 type: 'object',
                 required: ['uri'],
@@ -1457,17 +1683,25 @@ const schemaDict = {
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['from', 'to', 'amount', 'currency', 'createdAt'],
+                    required: ['to', 'amount', 'currency', 'createdAt'],
                     properties: {
                         from: {
-                            type: 'ref',
-                            ref: 'lex:app.certified.defs#did',
-                            description: 'DID of the sender who transferred the funds. Leave empty if sender wants to stay anonymous.',
+                            type: 'union',
+                            description: 'The sender of the funds (a free-text string, an account DID, or a strong reference to a record). Optional — omit to represent anonymity.',
+                            refs: [
+                                'lex:org.hypercerts.funding.receipt#text',
+                                'lex:app.certified.defs#did',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
                         },
                         to: {
-                            type: 'string',
-                            description: 'The recipient of the funds. Can be identified by DID or a clear-text name.',
-                            maxLength: 2048,
+                            type: 'union',
+                            description: 'The recipient of the funds (a free-text string, an account DID, or a strong reference to a record).',
+                            refs: [
+                                'lex:org.hypercerts.funding.receipt#text',
+                                'lex:app.certified.defs#did',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
                         },
                         amount: {
                             type: 'string',
@@ -1495,9 +1729,9 @@ const schemaDict = {
                             maxLength: 256,
                         },
                         for: {
-                            type: 'string',
-                            format: 'at-uri',
-                            description: 'Optional reference to the activity, project, or organization this funding relates to.',
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Optional strong reference to the activity, project, or organization this funding relates to.',
                         },
                         notes: {
                             type: 'string',
@@ -1517,6 +1751,18 @@ const schemaDict = {
                     },
                 },
             },
+            text: {
+                type: 'object',
+                description: 'A free-text string value (e.g. a display name, wallet address, or other identifier).',
+                required: ['value'],
+                properties: {
+                    value: {
+                        type: 'string',
+                        description: 'The string value.',
+                        maxLength: 2048,
+                    },
+                },
+            },
         },
     },
     OrgHypercertsWorkscopeCel: {
@@ -1645,6 +1891,633 @@ const schemaDict = {
             },
         },
     },
+    PubLeafletBlocksBlockquote: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.blockquote',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    plaintext: {
+                        type: 'string',
+                    },
+                    facets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksBskyPost: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.bskyPost',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['postRef'],
+                properties: {
+                    postRef: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                    },
+                    clientHost: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksButton: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.button',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['text', 'url'],
+                properties: {
+                    text: {
+                        type: 'string',
+                    },
+                    url: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksCode: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.code',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    plaintext: {
+                        type: 'string',
+                    },
+                    language: {
+                        type: 'string',
+                    },
+                    syntaxHighlightingTheme: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksHeader: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.header',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    level: {
+                        type: 'integer',
+                        minimum: 1,
+                        maximum: 6,
+                    },
+                    plaintext: {
+                        type: 'string',
+                    },
+                    facets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksHorizontalRule: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.horizontalRule',
+        defs: {
+            main: {
+                type: 'object',
+                required: [],
+                properties: {},
+            },
+        },
+    },
+    PubLeafletBlocksIframe: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.iframe',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['url'],
+                properties: {
+                    url: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                    height: {
+                        type: 'integer',
+                        minimum: 16,
+                        maximum: 1600,
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksImage: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.image',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['image', 'aspectRatio'],
+                properties: {
+                    image: {
+                        type: 'blob',
+                        accept: ['image/*'],
+                        maxSize: 1000000,
+                    },
+                    alt: {
+                        type: 'string',
+                        description: 'Alt text description of the image, for accessibility.',
+                    },
+                    aspectRatio: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.blocks.image#aspectRatio',
+                    },
+                },
+            },
+            aspectRatio: {
+                type: 'object',
+                required: ['width', 'height'],
+                properties: {
+                    width: {
+                        type: 'integer',
+                    },
+                    height: {
+                        type: 'integer',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksMath: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.math',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['tex'],
+                properties: {
+                    tex: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksOrderedList: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.orderedList',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['children'],
+                properties: {
+                    startIndex: {
+                        type: 'integer',
+                        description: 'The starting number for this ordered list. Defaults to 1 if not specified.',
+                    },
+                    children: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.orderedList#listItem',
+                        },
+                    },
+                },
+            },
+            listItem: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    checked: {
+                        type: 'boolean',
+                        description: 'If present, this item is a checklist item. true = checked, false = unchecked. If absent, this is a normal list item.',
+                    },
+                    content: {
+                        type: 'union',
+                        refs: [
+                            'lex:pub.leaflet.blocks.text',
+                            'lex:pub.leaflet.blocks.header',
+                            'lex:pub.leaflet.blocks.image',
+                        ],
+                    },
+                    children: {
+                        type: 'array',
+                        description: 'Nested ordered list items. Mutually exclusive with unorderedListChildren; if both are present, children takes precedence.',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.orderedList#listItem',
+                        },
+                    },
+                    unorderedListChildren: {
+                        type: 'ref',
+                        description: 'A nested unordered list. Mutually exclusive with children; if both are present, children takes precedence.',
+                        ref: 'lex:pub.leaflet.blocks.unorderedList',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksPage: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.page',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['id'],
+                properties: {
+                    id: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksPoll: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.poll',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['pollRef'],
+                properties: {
+                    pollRef: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksText: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.text',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    plaintext: {
+                        type: 'string',
+                    },
+                    textSize: {
+                        type: 'string',
+                        enum: ['default', 'small', 'large'],
+                    },
+                    facets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksUnorderedList: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.unorderedList',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['children'],
+                properties: {
+                    children: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.unorderedList#listItem',
+                        },
+                    },
+                },
+            },
+            listItem: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    checked: {
+                        type: 'boolean',
+                        description: 'If present, this item is a checklist item. true = checked, false = unchecked. If absent, this is a normal list item.',
+                    },
+                    content: {
+                        type: 'union',
+                        refs: [
+                            'lex:pub.leaflet.blocks.text',
+                            'lex:pub.leaflet.blocks.header',
+                            'lex:pub.leaflet.blocks.image',
+                        ],
+                    },
+                    children: {
+                        type: 'array',
+                        description: 'Nested unordered list items. Mutually exclusive with orderedListChildren; if both are present, children takes precedence.',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.unorderedList#listItem',
+                        },
+                    },
+                    orderedListChildren: {
+                        type: 'ref',
+                        description: 'Nested ordered list items. Mutually exclusive with children; if both are present, children takes precedence.',
+                        ref: 'lex:pub.leaflet.blocks.orderedList',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksWebsite: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.website',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['src'],
+                properties: {
+                    previewImage: {
+                        type: 'blob',
+                        accept: ['image/*'],
+                        maxSize: 1000000,
+                    },
+                    title: {
+                        type: 'string',
+                    },
+                    description: {
+                        type: 'string',
+                    },
+                    src: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletPagesLinearDocument: {
+        lexicon: 1,
+        id: 'pub.leaflet.pages.linearDocument',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['blocks'],
+                properties: {
+                    id: {
+                        type: 'string',
+                    },
+                    blocks: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.pages.linearDocument#block',
+                        },
+                    },
+                },
+            },
+            block: {
+                type: 'object',
+                required: ['block'],
+                properties: {
+                    block: {
+                        type: 'union',
+                        refs: [
+                            'lex:pub.leaflet.blocks.iframe',
+                            'lex:pub.leaflet.blocks.text',
+                            'lex:pub.leaflet.blocks.blockquote',
+                            'lex:pub.leaflet.blocks.header',
+                            'lex:pub.leaflet.blocks.image',
+                            'lex:pub.leaflet.blocks.unorderedList',
+                            'lex:pub.leaflet.blocks.orderedList',
+                            'lex:pub.leaflet.blocks.website',
+                            'lex:pub.leaflet.blocks.math',
+                            'lex:pub.leaflet.blocks.code',
+                            'lex:pub.leaflet.blocks.horizontalRule',
+                            'lex:pub.leaflet.blocks.bskyPost',
+                            'lex:pub.leaflet.blocks.page',
+                            'lex:pub.leaflet.blocks.poll',
+                            'lex:pub.leaflet.blocks.button',
+                        ],
+                    },
+                    alignment: {
+                        type: 'string',
+                        knownValues: [
+                            'lex:pub.leaflet.pages.linearDocument#textAlignLeft',
+                            'lex:pub.leaflet.pages.linearDocument#textAlignCenter',
+                            'lex:pub.leaflet.pages.linearDocument#textAlignRight',
+                            'lex:pub.leaflet.pages.linearDocument#textAlignJustify',
+                        ],
+                    },
+                },
+            },
+            textAlignLeft: {
+                type: 'token',
+            },
+            textAlignCenter: {
+                type: 'token',
+            },
+            textAlignRight: {
+                type: 'token',
+            },
+            textAlignJustify: {
+                type: 'token',
+            },
+            quote: {
+                type: 'object',
+                required: ['start', 'end'],
+                properties: {
+                    start: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.pages.linearDocument#position',
+                    },
+                    end: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.pages.linearDocument#position',
+                    },
+                },
+            },
+            position: {
+                type: 'object',
+                required: ['block', 'offset'],
+                properties: {
+                    block: {
+                        type: 'array',
+                        items: {
+                            type: 'integer',
+                        },
+                    },
+                    offset: {
+                        type: 'integer',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletRichtextFacet: {
+        lexicon: 1,
+        id: 'pub.leaflet.richtext.facet',
+        defs: {
+            main: {
+                type: 'object',
+                description: 'Annotation of a sub-string within rich text.',
+                required: ['index', 'features'],
+                properties: {
+                    index: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.richtext.facet#byteSlice',
+                    },
+                    features: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:pub.leaflet.richtext.facet#link',
+                                'lex:pub.leaflet.richtext.facet#didMention',
+                                'lex:pub.leaflet.richtext.facet#atMention',
+                                'lex:pub.leaflet.richtext.facet#code',
+                                'lex:pub.leaflet.richtext.facet#highlight',
+                                'lex:pub.leaflet.richtext.facet#underline',
+                                'lex:pub.leaflet.richtext.facet#strikethrough',
+                                'lex:pub.leaflet.richtext.facet#id',
+                                'lex:pub.leaflet.richtext.facet#bold',
+                                'lex:pub.leaflet.richtext.facet#italic',
+                                'lex:pub.leaflet.richtext.facet#footnote',
+                            ],
+                        },
+                    },
+                },
+            },
+            byteSlice: {
+                type: 'object',
+                description: 'Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.',
+                required: ['byteStart', 'byteEnd'],
+                properties: {
+                    byteStart: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                    byteEnd: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                },
+            },
+            link: {
+                type: 'object',
+                description: 'Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.',
+                required: ['uri'],
+                properties: {
+                    uri: {
+                        type: 'string',
+                    },
+                },
+            },
+            didMention: {
+                type: 'object',
+                description: 'Facet feature for mentioning a did.',
+                required: ['did'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                    },
+                },
+            },
+            atMention: {
+                type: 'object',
+                description: 'Facet feature for mentioning an AT URI.',
+                required: ['atURI'],
+                properties: {
+                    atURI: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+            code: {
+                type: 'object',
+                description: 'Facet feature for inline code.',
+                required: [],
+                properties: {},
+            },
+            highlight: {
+                type: 'object',
+                description: 'Facet feature for highlighted text.',
+                required: [],
+                properties: {},
+            },
+            underline: {
+                type: 'object',
+                description: 'Facet feature for underline markup',
+                required: [],
+                properties: {},
+            },
+            strikethrough: {
+                type: 'object',
+                description: 'Facet feature for strikethrough markup',
+                required: [],
+                properties: {},
+            },
+            id: {
+                type: 'object',
+                description: 'Facet feature for an identifier. Used for linking to a segment',
+                required: [],
+                properties: {
+                    id: {
+                        type: 'string',
+                    },
+                },
+            },
+            bold: {
+                type: 'object',
+                description: 'Facet feature for bold text',
+                required: [],
+                properties: {},
+            },
+            italic: {
+                type: 'object',
+                description: 'Facet feature for italic text',
+                required: [],
+                properties: {},
+            },
+            footnote: {
+                type: 'object',
+                description: 'Facet feature for a footnote reference',
+                required: ['footnoteId', 'contentPlaintext'],
+                properties: {
+                    footnoteId: {
+                        type: 'string',
+                    },
+                    contentPlaintext: {
+                        type: 'string',
+                    },
+                    contentFacets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet#main',
+                        },
+                    },
+                },
+            },
+        },
+    },
 };
 const schemas = Object.values(schemaDict);
 const lexicons = new Lexicons(schemas);
@@ -1657,12 +2530,14 @@ function validate(v, id, hash, requiredType) {
         };
 }
 const ids = {
+    AppBskyRichtextFacet: 'app.bsky.richtext.facet',
     AppCertifiedActorOrganization: 'app.certified.actor.organization',
     AppCertifiedActorProfile: 'app.certified.actor.profile',
     AppCertifiedBadgeAward: 'app.certified.badge.award',
     AppCertifiedBadgeDefinition: 'app.certified.badge.definition',
     AppCertifiedBadgeResponse: 'app.certified.badge.response',
     AppCertifiedDefs: 'app.certified.defs',
+    AppCertifiedLinkEvm: 'app.certified.link.evm',
     AppCertifiedLocation: 'app.certified.location',
     ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
     OrgHyperboardsBoard: 'org.hyperboards.board',
@@ -1680,6 +2555,23 @@ const ids = {
     OrgHypercertsFundingReceipt: 'org.hypercerts.funding.receipt',
     OrgHypercertsWorkscopeCel: 'org.hypercerts.workscope.cel',
     OrgHypercertsWorkscopeTag: 'org.hypercerts.workscope.tag',
+    PubLeafletBlocksBlockquote: 'pub.leaflet.blocks.blockquote',
+    PubLeafletBlocksBskyPost: 'pub.leaflet.blocks.bskyPost',
+    PubLeafletBlocksButton: 'pub.leaflet.blocks.button',
+    PubLeafletBlocksCode: 'pub.leaflet.blocks.code',
+    PubLeafletBlocksHeader: 'pub.leaflet.blocks.header',
+    PubLeafletBlocksHorizontalRule: 'pub.leaflet.blocks.horizontalRule',
+    PubLeafletBlocksIframe: 'pub.leaflet.blocks.iframe',
+    PubLeafletBlocksImage: 'pub.leaflet.blocks.image',
+    PubLeafletBlocksMath: 'pub.leaflet.blocks.math',
+    PubLeafletBlocksOrderedList: 'pub.leaflet.blocks.orderedList',
+    PubLeafletBlocksPage: 'pub.leaflet.blocks.page',
+    PubLeafletBlocksPoll: 'pub.leaflet.blocks.poll',
+    PubLeafletBlocksText: 'pub.leaflet.blocks.text',
+    PubLeafletBlocksUnorderedList: 'pub.leaflet.blocks.unorderedList',
+    PubLeafletBlocksWebsite: 'pub.leaflet.blocks.website',
+    PubLeafletPagesLinearDocument: 'pub.leaflet.pages.linearDocument',
+    PubLeafletRichtextFacet: 'pub.leaflet.richtext.facet',
 };
 
 export { ids, lexicons, schemaDict, schemas, validate };