mary.my.id
+1
README.md
+1
README.md
···
55
55
| [`lexicon-community`](./packages/definitions/lexicon-community): `community.lexicon.*` schema definitions |
56
56
| [`microcosm`](./packages/definitions/microcosm): `blue.microcosm.*` and `com.bad-example.*` schema definitions |
57
57
| [`ozone`](./packages/definitions/ozone): `tools.ozone.*` schema definitions |
58
+
| [`pckt`](./packages/definitions/pckt): `blog.pckt.*` schema definitions |
58
59
| [`tangled`](./packages/definitions/tangled): `sh.tangled.*` schema definitions |
59
60
| [`whitewind`](./packages/definitions/whitewind): `com.whtwnd.*` schema definitions |
60
61
| **Identity packages** |
+1
packages/clients/client/README.md
+1
packages/clients/client/README.md
···
118
118
- [`@atcute/microcosm`](../../definitions/microcosm): `blue.microcosm.*` and `com.bad-example.*`
119
119
schema definitions
120
120
- [`@atcute/ozone`](../../definitions/ozone): `tools.ozone.*` schema definitions
121
+
- [`@atcute/pckt`](../../definitions/pckt): `blog.pckt.*` schema definitions
121
122
- [`@atcute/tangled`](../../definitions/tangled): `sh.tangled.*` schema definitions
122
123
- [`@atcute/whitewind`](../../definitions/whitewind): `com.whtwnd.*` schema definitions
+59
packages/definitions/pckt/README.md
+59
packages/definitions/pckt/README.md
···
1
+
# @atcute/pckt
2
+
3
+
[pckt](https://pckt.blog) (blog.pckt.\*) schema definitions
4
+
5
+
## usage
6
+
7
+
```ts
8
+
import { BlogPcktPublication } from '@atcute/pckt';
9
+
import { is } from '@atcute/lexicons';
10
+
11
+
const publication: BlogPcktPublication.Main = {
12
+
$type: 'blog.pckt.publication',
13
+
name: 'my blog',
14
+
basePath: 'https://example.pckt.blog',
15
+
createdAt: new Date().toISOString(),
16
+
};
17
+
18
+
is(BlogPcktPublication.mainSchema, publication);
19
+
// -> true
20
+
```
21
+
22
+
### with `@atcute/client`
23
+
24
+
pick either one of these 3 options to register the ambient declarations
25
+
26
+
```jsonc
27
+
// file: tsconfig.json
28
+
{
29
+
"compilerOptions": {
30
+
"types": ["@atcute/pckt"],
31
+
},
32
+
}
33
+
```
34
+
35
+
```ts
36
+
// file: env.d.ts
37
+
/// <reference types="@atcute/pckt" />
38
+
```
39
+
40
+
```ts
41
+
// file: index.ts
42
+
import type {} from '@atcute/pckt';
43
+
```
44
+
45
+
### with `@atcute/lex-cli`
46
+
47
+
when building your own lexicons that reference pckt types, configure lex-cli to import from this
48
+
package:
49
+
50
+
```ts
51
+
// file: lex.config.js
52
+
import { defineLexiconConfig } from '@atcute/lex-cli';
53
+
54
+
export default defineLexiconConfig({
55
+
files: ['lexicons/**/*.json'],
56
+
outdir: 'src/lexicons/',
57
+
imports: ['@atcute/pckt'],
58
+
});
59
+
```
+19
packages/definitions/pckt/lex.config.js
+19
packages/definitions/pckt/lex.config.js
···
1
+
import { defineLexiconConfig } from '@atcute/lex-cli';
2
+
3
+
export default defineLexiconConfig({
4
+
files: ['lexicons/**/*.json'],
5
+
outdir: 'lib/lexicons/',
6
+
imports: ['@atcute/atproto'],
7
+
8
+
pull: {
9
+
outdir: 'lexicons/',
10
+
clean: true,
11
+
sources: [
12
+
{
13
+
type: 'atproto',
14
+
mode: 'authority',
15
+
authority: 'pckt.blog',
16
+
},
17
+
],
18
+
},
19
+
});
+5
packages/definitions/pckt/lexicons/README.md
+5
packages/definitions/pckt/lexicons/README.md
+23
packages/definitions/pckt/lexicons/blog/pckt/block/blockquote.json
+23
packages/definitions/pckt/lexicons/blog/pckt/block/blockquote.json
···
1
+
{
2
+
"id": "blog.pckt.block.blockquote",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["content"],
7
+
"properties": {
8
+
"content": {
9
+
"type": "array",
10
+
"items": {
11
+
"refs": ["blog.pckt.block.paragraph"],
12
+
"type": "union",
13
+
"closed": false
14
+
},
15
+
"description": "Array of paragraph content"
16
+
}
17
+
}
18
+
}
19
+
},
20
+
"$type": "com.atproto.lexicon.schema",
21
+
"lexicon": 1,
22
+
"description": "Blockquote for quoted text or citations. Typically rendered with distinct visual styling to set quoted content apart from the main text."
23
+
}
+19
packages/definitions/pckt/lexicons/blog/pckt/block/blueskyEmbed.json
+19
packages/definitions/pckt/lexicons/blog/pckt/block/blueskyEmbed.json
···
1
+
{
2
+
"id": "blog.pckt.block.blueskyEmbed",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["postRef"],
7
+
"properties": {
8
+
"postRef": {
9
+
"ref": "com.atproto.repo.strongRef",
10
+
"type": "ref",
11
+
"description": "Strong reference to the Bluesky post"
12
+
}
13
+
}
14
+
}
15
+
},
16
+
"$type": "com.atproto.lexicon.schema",
17
+
"lexicon": 1,
18
+
"description": "Embedded Bluesky social media post. References a Bluesky post via AT Protocol strongRef."
19
+
}
+22
packages/definitions/pckt/lexicons/blog/pckt/block/bulletList.json
+22
packages/definitions/pckt/lexicons/blog/pckt/block/bulletList.json
···
1
+
{
2
+
"id": "blog.pckt.block.bulletList",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["content"],
7
+
"properties": {
8
+
"content": {
9
+
"type": "array",
10
+
"items": {
11
+
"ref": "blog.pckt.block.listItem",
12
+
"type": "ref"
13
+
},
14
+
"description": "Array of list items"
15
+
}
16
+
}
17
+
}
18
+
},
19
+
"$type": "com.atproto.lexicon.schema",
20
+
"lexicon": 1,
21
+
"description": "Unordered list with bullet points. Each item can contain rich content including nested lists."
22
+
}
+37
packages/definitions/pckt/lexicons/blog/pckt/block/codeBlock.json
+37
packages/definitions/pckt/lexicons/blog/pckt/block/codeBlock.json
···
1
+
{
2
+
"id": "blog.pckt.block.codeBlock",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"properties": {
7
+
"attrs": {
8
+
"ref": "#codeBlockAttrs",
9
+
"type": "ref",
10
+
"description": "Code block attributes"
11
+
},
12
+
"content": {
13
+
"type": "array",
14
+
"items": {
15
+
"ref": "blog.pckt.block.text",
16
+
"type": "ref"
17
+
},
18
+
"description": "Array of text nodes containing the code"
19
+
}
20
+
}
21
+
},
22
+
"codeBlockAttrs": {
23
+
"type": "object",
24
+
"properties": {
25
+
"language": {
26
+
"type": "string",
27
+
"maxLength": 50,
28
+
"description": "Programming language for syntax highlighting (e.g., 'javascript', 'python', 'php')"
29
+
}
30
+
},
31
+
"description": "Code block attributes"
32
+
}
33
+
},
34
+
"$type": "com.atproto.lexicon.schema",
35
+
"lexicon": 1,
36
+
"description": "Preformatted code block with optional syntax highlighting. Preserves whitespace and displays code in a monospace font."
37
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/block/hardBreak.json
+11
packages/definitions/pckt/lexicons/blog/pckt/block/hardBreak.json
···
1
+
{
2
+
"id": "blog.pckt.block.hardBreak",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Hard line break within inline content. Forces text to continue on a new line without creating a new paragraph."
11
+
}
+41
packages/definitions/pckt/lexicons/blog/pckt/block/heading.json
+41
packages/definitions/pckt/lexicons/blog/pckt/block/heading.json
···
1
+
{
2
+
"id": "blog.pckt.block.heading",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["attrs"],
7
+
"properties": {
8
+
"attrs": {
9
+
"ref": "#headingAttrs",
10
+
"type": "ref",
11
+
"description": "Heading attributes"
12
+
},
13
+
"content": {
14
+
"type": "array",
15
+
"items": {
16
+
"refs": ["blog.pckt.block.text", "blog.pckt.block.hardBreak"],
17
+
"type": "union",
18
+
"closed": false
19
+
},
20
+
"description": "Inline content of the heading (text with optional formatting)"
21
+
}
22
+
}
23
+
},
24
+
"headingAttrs": {
25
+
"type": "object",
26
+
"required": ["level"],
27
+
"properties": {
28
+
"level": {
29
+
"type": "integer",
30
+
"maximum": 6,
31
+
"minimum": 1,
32
+
"description": "Heading level from 1 (most important) to 6 (least important)"
33
+
}
34
+
},
35
+
"description": "Heading attributes"
36
+
}
37
+
},
38
+
"$type": "com.atproto.lexicon.schema",
39
+
"lexicon": 1,
40
+
"description": "A heading block with hierarchical levels (H1-H6). Headings provide document structure and semantic meaning for accessibility and navigation."
41
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/block/horizontalRule.json
+11
packages/definitions/pckt/lexicons/blog/pckt/block/horizontalRule.json
···
1
+
{
2
+
"id": "blog.pckt.block.horizontalRule",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Horizontal line that visually separates sections of content. Creates a thematic break between blocks."
11
+
}
+25
packages/definitions/pckt/lexicons/blog/pckt/block/iframe.json
+25
packages/definitions/pckt/lexicons/blog/pckt/block/iframe.json
···
1
+
{
2
+
"id": "blog.pckt.block.iframe",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["url"],
7
+
"properties": {
8
+
"url": {
9
+
"type": "string",
10
+
"format": "uri",
11
+
"description": "The URL of the content to embed"
12
+
},
13
+
"height": {
14
+
"type": "integer",
15
+
"maximum": 1600,
16
+
"minimum": 16,
17
+
"description": "Height of the embed in pixels"
18
+
}
19
+
}
20
+
}
21
+
},
22
+
"$type": "com.atproto.lexicon.schema",
23
+
"lexicon": 1,
24
+
"description": "Embedded content via iframe (e.g. YouTube, Vimeo, etc.)"
25
+
}
+76
packages/definitions/pckt/lexicons/blog/pckt/block/image.json
+76
packages/definitions/pckt/lexicons/blog/pckt/block/image.json
···
1
+
{
2
+
"id": "blog.pckt.block.image",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["attrs"],
7
+
"properties": {
8
+
"attrs": {
9
+
"ref": "#imageAttrs",
10
+
"type": "ref",
11
+
"description": "Image attributes"
12
+
}
13
+
}
14
+
},
15
+
"imageAttrs": {
16
+
"type": "object",
17
+
"required": ["src"],
18
+
"properties": {
19
+
"alt": {
20
+
"type": "string",
21
+
"maxLength": 1000,
22
+
"description": "Alternative text description for accessibility and screen readers",
23
+
"maxGraphemes": 300
24
+
},
25
+
"src": {
26
+
"type": "string",
27
+
"maxLength": 2000,
28
+
"description": "Image source URL or blob reference (blob:CID format for AT Protocol blobs)"
29
+
},
30
+
"blob": {
31
+
"type": "blob",
32
+
"accept": ["image/*"],
33
+
"maxSize": 10000000,
34
+
"description": "AT Protocol blob reference (10MB max). Used when image is uploaded to PDS."
35
+
},
36
+
"align": {
37
+
"enum": ["left", "center", "right"],
38
+
"type": "string",
39
+
"description": "Horizontal alignment of the image within its container"
40
+
},
41
+
"title": {
42
+
"type": "string",
43
+
"maxLength": 500,
44
+
"description": "Optional image title displayed on hover",
45
+
"maxGraphemes": 200
46
+
},
47
+
"aspectRatio": {
48
+
"ref": "#aspectRatio",
49
+
"type": "ref",
50
+
"description": "Image aspect ratio for proper layout before loading"
51
+
}
52
+
},
53
+
"description": "Image attributes"
54
+
},
55
+
"aspectRatio": {
56
+
"type": "object",
57
+
"required": ["width", "height"],
58
+
"properties": {
59
+
"width": {
60
+
"type": "integer",
61
+
"minimum": 1,
62
+
"description": "Width component of aspect ratio"
63
+
},
64
+
"height": {
65
+
"type": "integer",
66
+
"minimum": 1,
67
+
"description": "Height component of aspect ratio"
68
+
}
69
+
},
70
+
"description": "Image aspect ratio represented as width and height dimensions"
71
+
}
72
+
},
73
+
"$type": "com.atproto.lexicon.schema",
74
+
"lexicon": 1,
75
+
"description": "An image block for displaying visual content. Supports both external URLs and AT Protocol blob storage with automatic aspect ratio preservation."
76
+
}
+27
packages/definitions/pckt/lexicons/blog/pckt/block/listItem.json
+27
packages/definitions/pckt/lexicons/blog/pckt/block/listItem.json
···
1
+
{
2
+
"id": "blog.pckt.block.listItem",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["content"],
7
+
"properties": {
8
+
"content": {
9
+
"type": "array",
10
+
"items": {
11
+
"refs": [
12
+
"blog.pckt.block.paragraph",
13
+
"blog.pckt.block.bulletList",
14
+
"blog.pckt.block.orderedList"
15
+
],
16
+
"type": "union",
17
+
"closed": false
18
+
},
19
+
"description": "Array of block content (paragraphs or nested lists)"
20
+
}
21
+
}
22
+
}
23
+
},
24
+
"$type": "com.atproto.lexicon.schema",
25
+
"lexicon": 1,
26
+
"description": "List item within ordered or unordered lists. Can contain paragraphs and nested lists."
27
+
}
+19
packages/definitions/pckt/lexicons/blog/pckt/block/mention.json
+19
packages/definitions/pckt/lexicons/blog/pckt/block/mention.json
···
1
+
{
2
+
"id": "blog.pckt.block.mention",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["did"],
7
+
"properties": {
8
+
"did": {
9
+
"type": "string",
10
+
"format": "did",
11
+
"description": "The DID of the mentioned user (e.g., did:plc:abc123xyz). This is the canonical reference that persists even if the user changes their handle, following app.bsky.richtext.facet#mention"
12
+
}
13
+
}
14
+
}
15
+
},
16
+
"$type": "com.atproto.lexicon.schema",
17
+
"lexicon": 1,
18
+
"description": "An inline mention node that references an ATProto user, following the app.bsky.richtext.facet#mention structure. Mentions create interactive references to Bluesky users within text content."
19
+
}
+38
packages/definitions/pckt/lexicons/blog/pckt/block/orderedList.json
+38
packages/definitions/pckt/lexicons/blog/pckt/block/orderedList.json
···
1
+
{
2
+
"id": "blog.pckt.block.orderedList",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["content"],
7
+
"properties": {
8
+
"attrs": {
9
+
"ref": "#orderedListAttrs",
10
+
"type": "ref",
11
+
"description": "Optional attributes for the ordered list"
12
+
},
13
+
"content": {
14
+
"type": "array",
15
+
"items": {
16
+
"ref": "blog.pckt.block.listItem",
17
+
"type": "ref"
18
+
},
19
+
"description": "Array of list items"
20
+
}
21
+
}
22
+
},
23
+
"orderedListAttrs": {
24
+
"type": "object",
25
+
"properties": {
26
+
"start": {
27
+
"type": "integer",
28
+
"minimum": 1,
29
+
"description": "Starting number for the ordered list"
30
+
}
31
+
},
32
+
"description": "Ordered list attributes"
33
+
}
34
+
},
35
+
"$type": "com.atproto.lexicon.schema",
36
+
"lexicon": 1,
37
+
"description": "Ordered numbered list. Each item can contain rich content including nested lists. Numbering can start at any positive integer."
38
+
}
+22
packages/definitions/pckt/lexicons/blog/pckt/block/paragraph.json
+22
packages/definitions/pckt/lexicons/blog/pckt/block/paragraph.json
···
1
+
{
2
+
"id": "blog.pckt.block.paragraph",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"properties": {
7
+
"content": {
8
+
"type": "array",
9
+
"items": {
10
+
"refs": ["blog.pckt.block.text", "blog.pckt.block.hardBreak", "blog.pckt.block.mention"],
11
+
"type": "union",
12
+
"closed": false
13
+
},
14
+
"description": "Array of inline content nodes (text, hard breaks, and mentions)"
15
+
}
16
+
}
17
+
}
18
+
},
19
+
"$type": "com.atproto.lexicon.schema",
20
+
"lexicon": 1,
21
+
"description": "A paragraph block containing inline text content with optional formatting. Paragraphs are the basic unit of text content in documents."
22
+
}
+39
packages/definitions/pckt/lexicons/blog/pckt/block/taskItem.json
+39
packages/definitions/pckt/lexicons/blog/pckt/block/taskItem.json
···
1
+
{
2
+
"id": "blog.pckt.block.taskItem",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["attrs", "content"],
7
+
"properties": {
8
+
"attrs": {
9
+
"ref": "#taskItemAttrs",
10
+
"type": "ref",
11
+
"description": "Task item attributes"
12
+
},
13
+
"content": {
14
+
"type": "array",
15
+
"items": {
16
+
"refs": ["blog.pckt.block.paragraph"],
17
+
"type": "union",
18
+
"closed": false
19
+
},
20
+
"description": "Array of paragraph content"
21
+
}
22
+
}
23
+
},
24
+
"taskItemAttrs": {
25
+
"type": "object",
26
+
"required": ["checked"],
27
+
"properties": {
28
+
"checked": {
29
+
"type": "boolean",
30
+
"description": "Whether the task is checked or unchecked"
31
+
}
32
+
},
33
+
"description": "Task item attributes"
34
+
}
35
+
},
36
+
"$type": "com.atproto.lexicon.schema",
37
+
"lexicon": 1,
38
+
"description": "Individual task item with checkbox state. Contains rich text content that describes the task."
39
+
}
+22
packages/definitions/pckt/lexicons/blog/pckt/block/taskList.json
+22
packages/definitions/pckt/lexicons/blog/pckt/block/taskList.json
···
1
+
{
2
+
"id": "blog.pckt.block.taskList",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["content"],
7
+
"properties": {
8
+
"content": {
9
+
"type": "array",
10
+
"items": {
11
+
"ref": "blog.pckt.block.taskItem",
12
+
"type": "ref"
13
+
},
14
+
"description": "Array of task items"
15
+
}
16
+
}
17
+
}
18
+
},
19
+
"$type": "com.atproto.lexicon.schema",
20
+
"lexicon": 1,
21
+
"description": "Interactive task list with checkable items. Each item displays a checkbox that can be toggled between checked and unchecked states."
22
+
}
+36
packages/definitions/pckt/lexicons/blog/pckt/block/text.json
+36
packages/definitions/pckt/lexicons/blog/pckt/block/text.json
···
1
+
{
2
+
"id": "blog.pckt.block.text",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["text"],
7
+
"properties": {
8
+
"text": {
9
+
"type": "string",
10
+
"maxLength": 10000,
11
+
"description": "The actual text content",
12
+
"maxGraphemes": 5000
13
+
},
14
+
"marks": {
15
+
"type": "array",
16
+
"items": {
17
+
"refs": [
18
+
"blog.pckt.mark.bold",
19
+
"blog.pckt.mark.italic",
20
+
"blog.pckt.mark.underline",
21
+
"blog.pckt.mark.strike",
22
+
"blog.pckt.mark.code",
23
+
"blog.pckt.mark.link"
24
+
],
25
+
"type": "union",
26
+
"closed": false
27
+
},
28
+
"description": "Optional array of formatting marks applied to this text (bold, italic, links, etc.)"
29
+
}
30
+
}
31
+
}
32
+
},
33
+
"$type": "com.atproto.lexicon.schema",
34
+
"lexicon": 1,
35
+
"description": "An inline text node with optional formatting marks. Text nodes are the leaf nodes containing actual textual content within paragraphs and other container blocks."
36
+
}
+32
packages/definitions/pckt/lexicons/blog/pckt/block/website.json
+32
packages/definitions/pckt/lexicons/blog/pckt/block/website.json
···
1
+
{
2
+
"id": "blog.pckt.block.website",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["src"],
7
+
"properties": {
8
+
"src": {
9
+
"type": "string",
10
+
"format": "uri",
11
+
"description": "The URL of the website"
12
+
},
13
+
"title": {
14
+
"type": "string",
15
+
"description": "The title of the website or page"
16
+
},
17
+
"description": {
18
+
"type": "string",
19
+
"description": "A brief description of the website or page"
20
+
},
21
+
"previewImage": {
22
+
"type": "string",
23
+
"format": "uri",
24
+
"description": "URL of the preview image"
25
+
}
26
+
}
27
+
}
28
+
},
29
+
"$type": "com.atproto.lexicon.schema",
30
+
"lexicon": 1,
31
+
"description": "A website link preview with title, description, and optional preview image"
32
+
}
+97
packages/definitions/pckt/lexicons/blog/pckt/document.json
+97
packages/definitions/pckt/lexicons/blog/pckt/document.json
···
1
+
{
2
+
"id": "blog.pckt.document",
3
+
"defs": {
4
+
"main": {
5
+
"key": "tid",
6
+
"type": "record",
7
+
"record": {
8
+
"type": "object",
9
+
"required": ["title", "blocks", "publication"],
10
+
"properties": {
11
+
"slug": {
12
+
"type": "string",
13
+
"maxLength": 500,
14
+
"description": "URL-friendly slug for the document (used to construct canonical URL)"
15
+
},
16
+
"tags": {
17
+
"type": "array",
18
+
"items": {
19
+
"type": "string",
20
+
"maxLength": 100,
21
+
"maxGraphemes": 50
22
+
},
23
+
"maxLength": 20,
24
+
"description": "Optional tags for categorization and discovery"
25
+
},
26
+
"cover": {
27
+
"type": "blob",
28
+
"accept": ["image/*"],
29
+
"maxSize": 10000000,
30
+
"description": "Optional cover/featured image (10MB max)"
31
+
},
32
+
"title": {
33
+
"type": "string",
34
+
"maxLength": 1280,
35
+
"description": "Document title/headline",
36
+
"maxGraphemes": 128
37
+
},
38
+
"blocks": {
39
+
"type": "array",
40
+
"items": {
41
+
"refs": [
42
+
"blog.pckt.block.paragraph",
43
+
"blog.pckt.block.heading",
44
+
"blog.pckt.block.image",
45
+
"blog.pckt.block.bulletList",
46
+
"blog.pckt.block.orderedList",
47
+
"blog.pckt.block.listItem",
48
+
"blog.pckt.block.taskList",
49
+
"blog.pckt.block.taskItem",
50
+
"blog.pckt.block.blockquote",
51
+
"blog.pckt.block.codeBlock",
52
+
"blog.pckt.block.horizontalRule",
53
+
"blog.pckt.block.blueskyEmbed"
54
+
],
55
+
"type": "union",
56
+
"closed": false
57
+
},
58
+
"description": "Structured content blocks composing the document body"
59
+
},
60
+
"images": {
61
+
"type": "array",
62
+
"items": {
63
+
"type": "blob",
64
+
"accept": ["image/*"],
65
+
"maxSize": 10000000
66
+
},
67
+
"description": "Blob references for images used within the document content"
68
+
},
69
+
"bodyPlain": {
70
+
"type": "string",
71
+
"maxLength": 100000,
72
+
"description": "Plain text representation of the document content for search and preview",
73
+
"maxGraphemes": 50000
74
+
},
75
+
"updatedAt": {
76
+
"type": "string",
77
+
"format": "datetime",
78
+
"description": "Timestamp when the document was last modified"
79
+
},
80
+
"publication": {
81
+
"ref": "com.atproto.repo.strongRef",
82
+
"type": "ref",
83
+
"description": "Reference to the parent publication this document belongs to"
84
+
},
85
+
"publishedAt": {
86
+
"type": "string",
87
+
"format": "datetime",
88
+
"description": "Timestamp when the document was first published"
89
+
}
90
+
}
91
+
}
92
+
}
93
+
},
94
+
"$type": "com.atproto.lexicon.schema",
95
+
"lexicon": 1,
96
+
"description": "A long-form blog document with rich content. Documents belong to a publication (blog) and contain structured content blocks, metadata, and optional media. This is the primary record type for blog posts."
97
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/bold.json
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/bold.json
···
1
+
{
2
+
"id": "blog.pckt.mark.bold",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Bold text formatting. Renders text with a heavier weight, typically used for emphasis or to highlight important content."
11
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/code.json
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/code.json
···
1
+
{
2
+
"id": "blog.pckt.mark.code",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Inline code formatting. Renders text in a monospace font with distinct styling, used for code snippets within regular text."
11
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/italic.json
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/italic.json
···
1
+
{
2
+
"id": "blog.pckt.mark.italic",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Italic text formatting. Renders text in a slanted style, typically used for emphasis, titles, or foreign words."
11
+
}
+47
packages/definitions/pckt/lexicons/blog/pckt/mark/link.json
+47
packages/definitions/pckt/lexicons/blog/pckt/mark/link.json
···
1
+
{
2
+
"id": "blog.pckt.mark.link",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["attrs"],
7
+
"properties": {
8
+
"attrs": {
9
+
"ref": "#linkAttrs",
10
+
"type": "ref",
11
+
"description": "Link attributes that define the hyperlink behavior and destination"
12
+
}
13
+
}
14
+
},
15
+
"linkAttrs": {
16
+
"type": "object",
17
+
"required": ["href"],
18
+
"properties": {
19
+
"rel": {
20
+
"type": "string",
21
+
"maxLength": 100,
22
+
"description": "Defines the relationship between the current document and the linked resource (e.g., nofollow, noopener)"
23
+
},
24
+
"href": {
25
+
"type": "string",
26
+
"format": "uri",
27
+
"maxLength": 2000,
28
+
"description": "The URL destination of the hyperlink"
29
+
},
30
+
"title": {
31
+
"type": "string",
32
+
"maxLength": 500,
33
+
"description": "Additional information about the link, typically shown as a tooltip on hover"
34
+
},
35
+
"target": {
36
+
"type": "string",
37
+
"maxLength": 50,
38
+
"description": "Specifies where to open the linked document (e.g., _blank, _self)"
39
+
}
40
+
},
41
+
"description": "Link attributes"
42
+
}
43
+
},
44
+
"$type": "com.atproto.lexicon.schema",
45
+
"lexicon": 1,
46
+
"description": "Hyperlink formatting. Creates a clickable link to an external or internal resource."
47
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/strike.json
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/strike.json
···
1
+
{
2
+
"id": "blog.pckt.mark.strike",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Strikethrough text formatting. Renders text with a line through it, typically used to indicate deleted or outdated content."
11
+
}
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/underline.json
+11
packages/definitions/pckt/lexicons/blog/pckt/mark/underline.json
···
1
+
{
2
+
"id": "blog.pckt.mark.underline",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object"
6
+
}
7
+
},
8
+
"$type": "com.atproto.lexicon.schema",
9
+
"lexicon": 1,
10
+
"description": "Underline text formatting. Adds a line beneath the text, typically used for emphasis or to indicate hyperlinks."
11
+
}
+86
packages/definitions/pckt/lexicons/blog/pckt/publication.json
+86
packages/definitions/pckt/lexicons/blog/pckt/publication.json
···
1
+
{
2
+
"id": "blog.pckt.publication",
3
+
"defs": {
4
+
"main": {
5
+
"key": "tid",
6
+
"type": "record",
7
+
"record": {
8
+
"type": "object",
9
+
"required": ["name", "basePath", "createdAt"],
10
+
"properties": {
11
+
"icon": {
12
+
"type": "blob",
13
+
"accept": ["image/png", "image/jpeg", "image/webp", "image/gif"],
14
+
"maxSize": 500000,
15
+
"description": "Publication icon/avatar image"
16
+
},
17
+
"name": {
18
+
"type": "string",
19
+
"maxLength": 200,
20
+
"description": "Publication name/title",
21
+
"maxGraphemes": 100
22
+
},
23
+
"theme": {
24
+
"refs": ["blog.pckt.theme"],
25
+
"type": "union",
26
+
"closed": false,
27
+
"description": "Theme configuration as an open union; accepts blog.pckt.theme and future types."
28
+
},
29
+
"basePath": {
30
+
"type": "string",
31
+
"format": "uri",
32
+
"maxLength": 2000,
33
+
"description": "Base URL path for the publication (e.g., https://blog.pckt.blog)"
34
+
},
35
+
"createdAt": {
36
+
"type": "string",
37
+
"format": "datetime",
38
+
"description": "Timestamp when the publication was first created"
39
+
},
40
+
"updatedAt": {
41
+
"type": "string",
42
+
"format": "datetime",
43
+
"description": "Timestamp when the publication was last updated (optional)"
44
+
},
45
+
"extensions": {
46
+
"type": "array",
47
+
"items": {
48
+
"refs": [],
49
+
"type": "union",
50
+
"closed": false,
51
+
"description": "Open union of extension objects identified by $type (NSID)."
52
+
},
53
+
"maxLength": 10,
54
+
"description": "Extension objects (open union) for additional features"
55
+
},
56
+
"description": {
57
+
"type": "string",
58
+
"maxLength": 2000,
59
+
"description": "Publication description or tagline",
60
+
"maxGraphemes": 500
61
+
},
62
+
"preferences": {
63
+
"ref": "#preferences",
64
+
"type": "ref",
65
+
"description": "Publication preferences and settings"
66
+
}
67
+
}
68
+
},
69
+
"description": "Record declaring a publication"
70
+
},
71
+
"preferences": {
72
+
"type": "object",
73
+
"properties": {
74
+
"showInDiscover": {
75
+
"type": "boolean",
76
+
"default": true,
77
+
"description": "Whether documents from this publication should appear in public discover feeds"
78
+
}
79
+
},
80
+
"description": "Publication preferences and discovery settings"
81
+
}
82
+
},
83
+
"$type": "com.atproto.lexicon.schema",
84
+
"lexicon": 1,
85
+
"description": "A publication (blog) record representing a collection of documents. Contains metadata, branding, theme configuration, and optional extensions. Publications serve as the parent container for blog documents."
86
+
}
+62
packages/definitions/pckt/lexicons/blog/pckt/theme.json
+62
packages/definitions/pckt/lexicons/blog/pckt/theme.json
···
1
+
{
2
+
"id": "blog.pckt.theme",
3
+
"defs": {
4
+
"main": {
5
+
"type": "object",
6
+
"required": ["light", "dark"],
7
+
"properties": {
8
+
"dark": {
9
+
"ref": "#palette",
10
+
"type": "ref",
11
+
"description": "Dark mode color palette"
12
+
},
13
+
"font": {
14
+
"type": "string",
15
+
"maxLength": 100,
16
+
"description": "Font family name (optional)"
17
+
},
18
+
"light": {
19
+
"ref": "#palette",
20
+
"type": "ref",
21
+
"description": "Light mode color palette"
22
+
}
23
+
},
24
+
"description": "Theme configuration for a blog publication"
25
+
},
26
+
"palette": {
27
+
"type": "object",
28
+
"required": ["link", "text", "accent", "background", "surfaceHover"],
29
+
"properties": {
30
+
"link": {
31
+
"type": "string",
32
+
"maxLength": 7,
33
+
"description": "Link color (hex value)"
34
+
},
35
+
"text": {
36
+
"type": "string",
37
+
"maxLength": 7,
38
+
"description": "Primary text color (hex value)"
39
+
},
40
+
"accent": {
41
+
"type": "string",
42
+
"maxLength": 7,
43
+
"description": "Accent color (hex value)"
44
+
},
45
+
"background": {
46
+
"type": "string",
47
+
"maxLength": 7,
48
+
"description": "Background color (hex value)"
49
+
},
50
+
"surfaceHover": {
51
+
"type": "string",
52
+
"maxLength": 7,
53
+
"description": "Surface hover color (hex value)"
54
+
}
55
+
},
56
+
"description": "Color palette with CSS hex values"
57
+
}
58
+
},
59
+
"$type": "com.atproto.lexicon.schema",
60
+
"lexicon": 1,
61
+
"description": "Theme record for blog publications with light and dark mode color schemes."
62
+
}
+1
packages/definitions/pckt/lib/index.ts
+1
packages/definitions/pckt/lib/index.ts
···
1
+
export * from './lexicons/index.js';
+26
packages/definitions/pckt/lib/lexicons/index.ts
+26
packages/definitions/pckt/lib/lexicons/index.ts
···
1
+
export * as BlogPcktBlockBlockquote from './types/blog/pckt/block/blockquote.js';
2
+
export * as BlogPcktBlockBlueskyEmbed from './types/blog/pckt/block/blueskyEmbed.js';
3
+
export * as BlogPcktBlockBulletList from './types/blog/pckt/block/bulletList.js';
4
+
export * as BlogPcktBlockCodeBlock from './types/blog/pckt/block/codeBlock.js';
5
+
export * as BlogPcktBlockHardBreak from './types/blog/pckt/block/hardBreak.js';
6
+
export * as BlogPcktBlockHeading from './types/blog/pckt/block/heading.js';
7
+
export * as BlogPcktBlockHorizontalRule from './types/blog/pckt/block/horizontalRule.js';
8
+
export * as BlogPcktBlockIframe from './types/blog/pckt/block/iframe.js';
9
+
export * as BlogPcktBlockImage from './types/blog/pckt/block/image.js';
10
+
export * as BlogPcktBlockListItem from './types/blog/pckt/block/listItem.js';
11
+
export * as BlogPcktBlockMention from './types/blog/pckt/block/mention.js';
12
+
export * as BlogPcktBlockOrderedList from './types/blog/pckt/block/orderedList.js';
13
+
export * as BlogPcktBlockParagraph from './types/blog/pckt/block/paragraph.js';
14
+
export * as BlogPcktBlockTaskItem from './types/blog/pckt/block/taskItem.js';
15
+
export * as BlogPcktBlockTaskList from './types/blog/pckt/block/taskList.js';
16
+
export * as BlogPcktBlockText from './types/blog/pckt/block/text.js';
17
+
export * as BlogPcktBlockWebsite from './types/blog/pckt/block/website.js';
18
+
export * as BlogPcktDocument from './types/blog/pckt/document.js';
19
+
export * as BlogPcktMarkBold from './types/blog/pckt/mark/bold.js';
20
+
export * as BlogPcktMarkCode from './types/blog/pckt/mark/code.js';
21
+
export * as BlogPcktMarkItalic from './types/blog/pckt/mark/italic.js';
22
+
export * as BlogPcktMarkLink from './types/blog/pckt/mark/link.js';
23
+
export * as BlogPcktMarkStrike from './types/blog/pckt/mark/strike.js';
24
+
export * as BlogPcktMarkUnderline from './types/blog/pckt/mark/underline.js';
25
+
export * as BlogPcktPublication from './types/blog/pckt/publication.js';
26
+
export * as BlogPcktTheme from './types/blog/pckt/theme.js';
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/blockquote.ts
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/blockquote.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockParagraph from './paragraph.js';
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.blockquote')),
7
+
/**
8
+
* Array of paragraph content
9
+
*/
10
+
get content() {
11
+
return /*#__PURE__*/ v.array(/*#__PURE__*/ v.variant([BlogPcktBlockParagraph.mainSchema]));
12
+
},
13
+
});
14
+
15
+
type main$schematype = typeof _mainSchema;
16
+
17
+
export interface mainSchema extends main$schematype {}
18
+
19
+
export const mainSchema = _mainSchema as mainSchema;
20
+
21
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/blueskyEmbed.ts
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/blueskyEmbed.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as ComAtprotoRepoStrongRef from '@atcute/atproto/types/repo/strongRef';
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.blueskyEmbed')),
7
+
/**
8
+
* Strong reference to the Bluesky post
9
+
*/
10
+
get postRef() {
11
+
return ComAtprotoRepoStrongRef.mainSchema;
12
+
},
13
+
});
14
+
15
+
type main$schematype = typeof _mainSchema;
16
+
17
+
export interface mainSchema extends main$schematype {}
18
+
19
+
export const mainSchema = _mainSchema as mainSchema;
20
+
21
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/bulletList.ts
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/bulletList.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockListItem from './listItem.js';
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.bulletList')),
7
+
/**
8
+
* Array of list items
9
+
*/
10
+
get content() {
11
+
return /*#__PURE__*/ v.array(BlogPcktBlockListItem.mainSchema);
12
+
},
13
+
});
14
+
15
+
type main$schematype = typeof _mainSchema;
16
+
17
+
export interface mainSchema extends main$schematype {}
18
+
19
+
export const mainSchema = _mainSchema as mainSchema;
20
+
21
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+41
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/codeBlock.ts
+41
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/codeBlock.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockText from './text.js';
4
+
5
+
const _codeBlockAttrsSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.codeBlock#codeBlockAttrs')),
7
+
/**
8
+
* Programming language for syntax highlighting (e.g., 'javascript', 'python', 'php')
9
+
* @maxLength 50
10
+
*/
11
+
language: /*#__PURE__*/ v.optional(
12
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 50)]),
13
+
),
14
+
});
15
+
const _mainSchema = /*#__PURE__*/ v.object({
16
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.codeBlock')),
17
+
/**
18
+
* Code block attributes
19
+
*/
20
+
get attrs() {
21
+
return /*#__PURE__*/ v.optional(codeBlockAttrsSchema);
22
+
},
23
+
/**
24
+
* Array of text nodes containing the code
25
+
*/
26
+
get content() {
27
+
return /*#__PURE__*/ v.optional(/*#__PURE__*/ v.array(BlogPcktBlockText.mainSchema));
28
+
},
29
+
});
30
+
31
+
type codeBlockAttrs$schematype = typeof _codeBlockAttrsSchema;
32
+
type main$schematype = typeof _mainSchema;
33
+
34
+
export interface codeBlockAttrsSchema extends codeBlockAttrs$schematype {}
35
+
export interface mainSchema extends main$schematype {}
36
+
37
+
export const codeBlockAttrsSchema = _codeBlockAttrsSchema as codeBlockAttrsSchema;
38
+
export const mainSchema = _mainSchema as mainSchema;
39
+
40
+
export interface CodeBlockAttrs extends v.InferInput<typeof codeBlockAttrsSchema> {}
41
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/hardBreak.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/hardBreak.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.hardBreak')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+45
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/heading.ts
+45
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/heading.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockHardBreak from './hardBreak.js';
4
+
import * as BlogPcktBlockText from './text.js';
5
+
6
+
const _headingAttrsSchema = /*#__PURE__*/ v.object({
7
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.heading#headingAttrs')),
8
+
/**
9
+
* Heading level from 1 (most important) to 6 (least important)
10
+
* @minimum 1
11
+
* @maximum 6
12
+
*/
13
+
level: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [/*#__PURE__*/ v.integerRange(1, 6)]),
14
+
});
15
+
const _mainSchema = /*#__PURE__*/ v.object({
16
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.heading')),
17
+
/**
18
+
* Heading attributes
19
+
*/
20
+
get attrs() {
21
+
return headingAttrsSchema;
22
+
},
23
+
/**
24
+
* Inline content of the heading (text with optional formatting)
25
+
*/
26
+
get content() {
27
+
return /*#__PURE__*/ v.optional(
28
+
/*#__PURE__*/ v.array(
29
+
/*#__PURE__*/ v.variant([BlogPcktBlockHardBreak.mainSchema, BlogPcktBlockText.mainSchema]),
30
+
),
31
+
);
32
+
},
33
+
});
34
+
35
+
type headingAttrs$schematype = typeof _headingAttrsSchema;
36
+
type main$schematype = typeof _mainSchema;
37
+
38
+
export interface headingAttrsSchema extends headingAttrs$schematype {}
39
+
export interface mainSchema extends main$schematype {}
40
+
41
+
export const headingAttrsSchema = _headingAttrsSchema as headingAttrsSchema;
42
+
export const mainSchema = _mainSchema as mainSchema;
43
+
44
+
export interface HeadingAttrs extends v.InferInput<typeof headingAttrsSchema> {}
45
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/horizontalRule.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/horizontalRule.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.horizontalRule')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+26
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/iframe.ts
+26
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/iframe.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.iframe')),
6
+
/**
7
+
* Height of the embed in pixels
8
+
* @minimum 16
9
+
* @maximum 1600
10
+
*/
11
+
height: /*#__PURE__*/ v.optional(
12
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [/*#__PURE__*/ v.integerRange(16, 1600)]),
13
+
),
14
+
/**
15
+
* The URL of the content to embed
16
+
*/
17
+
url: /*#__PURE__*/ v.genericUriString(),
18
+
});
19
+
20
+
type main$schematype = typeof _mainSchema;
21
+
22
+
export interface mainSchema extends main$schematype {}
23
+
24
+
export const mainSchema = _mainSchema as mainSchema;
25
+
26
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+87
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/image.ts
+87
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/image.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _aspectRatioSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.image#aspectRatio')),
6
+
/**
7
+
* Height component of aspect ratio
8
+
* @minimum 1
9
+
*/
10
+
height: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [/*#__PURE__*/ v.integerRange(1)]),
11
+
/**
12
+
* Width component of aspect ratio
13
+
* @minimum 1
14
+
*/
15
+
width: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [/*#__PURE__*/ v.integerRange(1)]),
16
+
});
17
+
const _imageAttrsSchema = /*#__PURE__*/ v.object({
18
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.image#imageAttrs')),
19
+
/**
20
+
* Horizontal alignment of the image within its container
21
+
*/
22
+
align: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literalEnum(['center', 'left', 'right'])),
23
+
/**
24
+
* Alternative text description for accessibility and screen readers
25
+
* @maxLength 1000
26
+
* @maxGraphemes 300
27
+
*/
28
+
alt: /*#__PURE__*/ v.optional(
29
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
30
+
/*#__PURE__*/ v.stringLength(0, 1000),
31
+
/*#__PURE__*/ v.stringGraphemes(0, 300),
32
+
]),
33
+
),
34
+
/**
35
+
* Image aspect ratio for proper layout before loading
36
+
*/
37
+
get aspectRatio() {
38
+
return /*#__PURE__*/ v.optional(aspectRatioSchema);
39
+
},
40
+
/**
41
+
* AT Protocol blob reference (10MB max). Used when image is uploaded to PDS.
42
+
* @accept image/*
43
+
* @maxSize 10000000
44
+
*/
45
+
blob: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.blob()),
46
+
/**
47
+
* Image source URL or blob reference (blob:CID format for AT Protocol blobs)
48
+
* @maxLength 2000
49
+
*/
50
+
src: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 2000)]),
51
+
/**
52
+
* Optional image title displayed on hover
53
+
* @maxLength 500
54
+
* @maxGraphemes 200
55
+
*/
56
+
title: /*#__PURE__*/ v.optional(
57
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
58
+
/*#__PURE__*/ v.stringLength(0, 500),
59
+
/*#__PURE__*/ v.stringGraphemes(0, 200),
60
+
]),
61
+
),
62
+
});
63
+
const _mainSchema = /*#__PURE__*/ v.object({
64
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.image')),
65
+
/**
66
+
* Image attributes
67
+
*/
68
+
get attrs() {
69
+
return imageAttrsSchema;
70
+
},
71
+
});
72
+
73
+
type aspectRatio$schematype = typeof _aspectRatioSchema;
74
+
type imageAttrs$schematype = typeof _imageAttrsSchema;
75
+
type main$schematype = typeof _mainSchema;
76
+
77
+
export interface aspectRatioSchema extends aspectRatio$schematype {}
78
+
export interface imageAttrsSchema extends imageAttrs$schematype {}
79
+
export interface mainSchema extends main$schematype {}
80
+
81
+
export const aspectRatioSchema = _aspectRatioSchema as aspectRatioSchema;
82
+
export const imageAttrsSchema = _imageAttrsSchema as imageAttrsSchema;
83
+
export const mainSchema = _mainSchema as mainSchema;
84
+
85
+
export interface AspectRatio extends v.InferInput<typeof aspectRatioSchema> {}
86
+
export interface ImageAttrs extends v.InferInput<typeof imageAttrsSchema> {}
87
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+29
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/listItem.ts
+29
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/listItem.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockBulletList from './bulletList.js';
4
+
import * as BlogPcktBlockOrderedList from './orderedList.js';
5
+
import * as BlogPcktBlockParagraph from './paragraph.js';
6
+
7
+
const _mainSchema = /*#__PURE__*/ v.object({
8
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.listItem')),
9
+
/**
10
+
* Array of block content (paragraphs or nested lists)
11
+
*/
12
+
get content() {
13
+
return /*#__PURE__*/ v.array(
14
+
/*#__PURE__*/ v.variant([
15
+
BlogPcktBlockBulletList.mainSchema,
16
+
BlogPcktBlockOrderedList.mainSchema,
17
+
BlogPcktBlockParagraph.mainSchema,
18
+
]),
19
+
);
20
+
},
21
+
});
22
+
23
+
type main$schematype = typeof _mainSchema;
24
+
25
+
export interface mainSchema extends main$schematype {}
26
+
27
+
export const mainSchema = _mainSchema as mainSchema;
28
+
29
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+18
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/mention.ts
+18
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/mention.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.mention')),
6
+
/**
7
+
* The DID of the mentioned user (e.g., did:plc:abc123xyz). This is the canonical reference that persists even if the user changes their handle, following app.bsky.richtext.facet#mention
8
+
*/
9
+
did: /*#__PURE__*/ v.didString(),
10
+
});
11
+
12
+
type main$schematype = typeof _mainSchema;
13
+
14
+
export interface mainSchema extends main$schematype {}
15
+
16
+
export const mainSchema = _mainSchema as mainSchema;
17
+
18
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+41
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/orderedList.ts
+41
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/orderedList.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockListItem from './listItem.js';
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.orderedList')),
7
+
/**
8
+
* Optional attributes for the ordered list
9
+
*/
10
+
get attrs() {
11
+
return /*#__PURE__*/ v.optional(orderedListAttrsSchema);
12
+
},
13
+
/**
14
+
* Array of list items
15
+
*/
16
+
get content() {
17
+
return /*#__PURE__*/ v.array(BlogPcktBlockListItem.mainSchema);
18
+
},
19
+
});
20
+
const _orderedListAttrsSchema = /*#__PURE__*/ v.object({
21
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.orderedList#orderedListAttrs')),
22
+
/**
23
+
* Starting number for the ordered list
24
+
* @minimum 1
25
+
*/
26
+
start: /*#__PURE__*/ v.optional(
27
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [/*#__PURE__*/ v.integerRange(1)]),
28
+
),
29
+
});
30
+
31
+
type main$schematype = typeof _mainSchema;
32
+
type orderedListAttrs$schematype = typeof _orderedListAttrsSchema;
33
+
34
+
export interface mainSchema extends main$schematype {}
35
+
export interface orderedListAttrsSchema extends orderedListAttrs$schematype {}
36
+
37
+
export const mainSchema = _mainSchema as mainSchema;
38
+
export const orderedListAttrsSchema = _orderedListAttrsSchema as orderedListAttrsSchema;
39
+
40
+
export interface Main extends v.InferInput<typeof mainSchema> {}
41
+
export interface OrderedListAttrs extends v.InferInput<typeof orderedListAttrsSchema> {}
+31
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/paragraph.ts
+31
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/paragraph.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockHardBreak from './hardBreak.js';
4
+
import * as BlogPcktBlockMention from './mention.js';
5
+
import * as BlogPcktBlockText from './text.js';
6
+
7
+
const _mainSchema = /*#__PURE__*/ v.object({
8
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.paragraph')),
9
+
/**
10
+
* Array of inline content nodes (text, hard breaks, and mentions)
11
+
*/
12
+
get content() {
13
+
return /*#__PURE__*/ v.optional(
14
+
/*#__PURE__*/ v.array(
15
+
/*#__PURE__*/ v.variant([
16
+
BlogPcktBlockHardBreak.mainSchema,
17
+
BlogPcktBlockMention.mainSchema,
18
+
BlogPcktBlockText.mainSchema,
19
+
]),
20
+
),
21
+
);
22
+
},
23
+
});
24
+
25
+
type main$schematype = typeof _mainSchema;
26
+
27
+
export interface mainSchema extends main$schematype {}
28
+
29
+
export const mainSchema = _mainSchema as mainSchema;
30
+
31
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+38
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/taskItem.ts
+38
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/taskItem.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockParagraph from './paragraph.js';
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.taskItem')),
7
+
/**
8
+
* Task item attributes
9
+
*/
10
+
get attrs() {
11
+
return taskItemAttrsSchema;
12
+
},
13
+
/**
14
+
* Array of paragraph content
15
+
*/
16
+
get content() {
17
+
return /*#__PURE__*/ v.array(/*#__PURE__*/ v.variant([BlogPcktBlockParagraph.mainSchema]));
18
+
},
19
+
});
20
+
const _taskItemAttrsSchema = /*#__PURE__*/ v.object({
21
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.taskItem#taskItemAttrs')),
22
+
/**
23
+
* Whether the task is checked or unchecked
24
+
*/
25
+
checked: /*#__PURE__*/ v.boolean(),
26
+
});
27
+
28
+
type main$schematype = typeof _mainSchema;
29
+
type taskItemAttrs$schematype = typeof _taskItemAttrsSchema;
30
+
31
+
export interface mainSchema extends main$schematype {}
32
+
export interface taskItemAttrsSchema extends taskItemAttrs$schematype {}
33
+
34
+
export const mainSchema = _mainSchema as mainSchema;
35
+
export const taskItemAttrsSchema = _taskItemAttrsSchema as taskItemAttrsSchema;
36
+
37
+
export interface Main extends v.InferInput<typeof mainSchema> {}
38
+
export interface TaskItemAttrs extends v.InferInput<typeof taskItemAttrsSchema> {}
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/taskList.ts
+21
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/taskList.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktBlockTaskItem from './taskItem.js';
4
+
5
+
const _mainSchema = /*#__PURE__*/ v.object({
6
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.taskList')),
7
+
/**
8
+
* Array of task items
9
+
*/
10
+
get content() {
11
+
return /*#__PURE__*/ v.array(BlogPcktBlockTaskItem.mainSchema);
12
+
},
13
+
});
14
+
15
+
type main$schematype = typeof _mainSchema;
16
+
17
+
export interface mainSchema extends main$schematype {}
18
+
19
+
export const mainSchema = _mainSchema as mainSchema;
20
+
21
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+46
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/text.ts
+46
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/text.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import * as BlogPcktMarkBold from '../mark/bold.js';
4
+
import * as BlogPcktMarkCode from '../mark/code.js';
5
+
import * as BlogPcktMarkItalic from '../mark/italic.js';
6
+
import * as BlogPcktMarkLink from '../mark/link.js';
7
+
import * as BlogPcktMarkStrike from '../mark/strike.js';
8
+
import * as BlogPcktMarkUnderline from '../mark/underline.js';
9
+
10
+
const _mainSchema = /*#__PURE__*/ v.object({
11
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.text')),
12
+
/**
13
+
* Optional array of formatting marks applied to this text (bold, italic, links, etc.)
14
+
*/
15
+
get marks() {
16
+
return /*#__PURE__*/ v.optional(
17
+
/*#__PURE__*/ v.array(
18
+
/*#__PURE__*/ v.variant([
19
+
BlogPcktMarkBold.mainSchema,
20
+
BlogPcktMarkCode.mainSchema,
21
+
BlogPcktMarkItalic.mainSchema,
22
+
BlogPcktMarkLink.mainSchema,
23
+
BlogPcktMarkStrike.mainSchema,
24
+
BlogPcktMarkUnderline.mainSchema,
25
+
]),
26
+
),
27
+
);
28
+
},
29
+
/**
30
+
* The actual text content
31
+
* @maxLength 10000
32
+
* @maxGraphemes 5000
33
+
*/
34
+
text: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
35
+
/*#__PURE__*/ v.stringLength(0, 10000),
36
+
/*#__PURE__*/ v.stringGraphemes(0, 5000),
37
+
]),
38
+
});
39
+
40
+
type main$schematype = typeof _mainSchema;
41
+
42
+
export interface mainSchema extends main$schematype {}
43
+
44
+
export const mainSchema = _mainSchema as mainSchema;
45
+
46
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+30
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/website.ts
+30
packages/definitions/pckt/lib/lexicons/types/blog/pckt/block/website.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.block.website')),
6
+
/**
7
+
* A brief description of the website or page
8
+
*/
9
+
description: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
10
+
/**
11
+
* URL of the preview image
12
+
*/
13
+
previewImage: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.genericUriString()),
14
+
/**
15
+
* The URL of the website
16
+
*/
17
+
src: /*#__PURE__*/ v.genericUriString(),
18
+
/**
19
+
* The title of the website or page
20
+
*/
21
+
title: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
22
+
});
23
+
24
+
type main$schematype = typeof _mainSchema;
25
+
26
+
export interface mainSchema extends main$schematype {}
27
+
28
+
export const mainSchema = _mainSchema as mainSchema;
29
+
30
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+124
packages/definitions/pckt/lib/lexicons/types/blog/pckt/document.ts
+124
packages/definitions/pckt/lib/lexicons/types/blog/pckt/document.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import type {} from '@atcute/lexicons/ambient';
4
+
import * as BlogPcktBlockBlockquote from './block/blockquote.js';
5
+
import * as BlogPcktBlockBlueskyEmbed from './block/blueskyEmbed.js';
6
+
import * as BlogPcktBlockBulletList from './block/bulletList.js';
7
+
import * as BlogPcktBlockCodeBlock from './block/codeBlock.js';
8
+
import * as BlogPcktBlockHeading from './block/heading.js';
9
+
import * as BlogPcktBlockHorizontalRule from './block/horizontalRule.js';
10
+
import * as BlogPcktBlockImage from './block/image.js';
11
+
import * as BlogPcktBlockListItem from './block/listItem.js';
12
+
import * as BlogPcktBlockOrderedList from './block/orderedList.js';
13
+
import * as BlogPcktBlockParagraph from './block/paragraph.js';
14
+
import * as BlogPcktBlockTaskItem from './block/taskItem.js';
15
+
import * as BlogPcktBlockTaskList from './block/taskList.js';
16
+
import * as ComAtprotoRepoStrongRef from '@atcute/atproto/types/repo/strongRef';
17
+
18
+
const _mainSchema = /*#__PURE__*/ v.record(
19
+
/*#__PURE__*/ v.tidString(),
20
+
/*#__PURE__*/ v.object({
21
+
$type: /*#__PURE__*/ v.literal('blog.pckt.document'),
22
+
/**
23
+
* Structured content blocks composing the document body
24
+
*/
25
+
get blocks() {
26
+
return /*#__PURE__*/ v.array(
27
+
/*#__PURE__*/ v.variant([
28
+
BlogPcktBlockBlockquote.mainSchema,
29
+
BlogPcktBlockBlueskyEmbed.mainSchema,
30
+
BlogPcktBlockBulletList.mainSchema,
31
+
BlogPcktBlockCodeBlock.mainSchema,
32
+
BlogPcktBlockHeading.mainSchema,
33
+
BlogPcktBlockHorizontalRule.mainSchema,
34
+
BlogPcktBlockImage.mainSchema,
35
+
BlogPcktBlockListItem.mainSchema,
36
+
BlogPcktBlockOrderedList.mainSchema,
37
+
BlogPcktBlockParagraph.mainSchema,
38
+
BlogPcktBlockTaskItem.mainSchema,
39
+
BlogPcktBlockTaskList.mainSchema,
40
+
]),
41
+
);
42
+
},
43
+
/**
44
+
* Plain text representation of the document content for search and preview
45
+
* @maxLength 100000
46
+
* @maxGraphemes 50000
47
+
*/
48
+
bodyPlain: /*#__PURE__*/ v.optional(
49
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
50
+
/*#__PURE__*/ v.stringLength(0, 100000),
51
+
/*#__PURE__*/ v.stringGraphemes(0, 50000),
52
+
]),
53
+
),
54
+
/**
55
+
* Optional cover/featured image (10MB max)
56
+
* @accept image/*
57
+
* @maxSize 10000000
58
+
*/
59
+
cover: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.blob()),
60
+
/**
61
+
* Blob references for images used within the document content
62
+
*/
63
+
images: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.array(/*#__PURE__*/ v.blob())),
64
+
/**
65
+
* Reference to the parent publication this document belongs to
66
+
*/
67
+
get publication() {
68
+
return ComAtprotoRepoStrongRef.mainSchema;
69
+
},
70
+
/**
71
+
* Timestamp when the document was first published
72
+
*/
73
+
publishedAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
74
+
/**
75
+
* URL-friendly slug for the document (used to construct canonical URL)
76
+
* @maxLength 500
77
+
*/
78
+
slug: /*#__PURE__*/ v.optional(
79
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 500)]),
80
+
),
81
+
/**
82
+
* Optional tags for categorization and discovery
83
+
* @maxLength 20
84
+
*/
85
+
tags: /*#__PURE__*/ v.optional(
86
+
/*#__PURE__*/ v.constrain(
87
+
/*#__PURE__*/ v.array(
88
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
89
+
/*#__PURE__*/ v.stringLength(0, 100),
90
+
/*#__PURE__*/ v.stringGraphemes(0, 50),
91
+
]),
92
+
),
93
+
[/*#__PURE__*/ v.arrayLength(0, 20)],
94
+
),
95
+
),
96
+
/**
97
+
* Document title/headline
98
+
* @maxLength 1280
99
+
* @maxGraphemes 128
100
+
*/
101
+
title: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
102
+
/*#__PURE__*/ v.stringLength(0, 1280),
103
+
/*#__PURE__*/ v.stringGraphemes(0, 128),
104
+
]),
105
+
/**
106
+
* Timestamp when the document was last modified
107
+
*/
108
+
updatedAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
109
+
}),
110
+
);
111
+
112
+
type main$schematype = typeof _mainSchema;
113
+
114
+
export interface mainSchema extends main$schematype {}
115
+
116
+
export const mainSchema = _mainSchema as mainSchema;
117
+
118
+
export interface Main extends v.InferInput<typeof mainSchema> {}
119
+
120
+
declare module '@atcute/lexicons/ambient' {
121
+
interface Records {
122
+
'blog.pckt.document': mainSchema;
123
+
}
124
+
}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/bold.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/bold.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.bold')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/code.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/code.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.code')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/italic.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/italic.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.italic')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+55
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/link.ts
+55
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/link.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _linkAttrsSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.link#linkAttrs')),
6
+
/**
7
+
* The URL destination of the hyperlink
8
+
* @maxLength 2000
9
+
*/
10
+
href: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.genericUriString(), [
11
+
/*#__PURE__*/ v.stringLength(0, 2000),
12
+
]),
13
+
/**
14
+
* Defines the relationship between the current document and the linked resource (e.g., nofollow, noopener)
15
+
* @maxLength 100
16
+
*/
17
+
rel: /*#__PURE__*/ v.optional(
18
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 100)]),
19
+
),
20
+
/**
21
+
* Specifies where to open the linked document (e.g., _blank, _self)
22
+
* @maxLength 50
23
+
*/
24
+
target: /*#__PURE__*/ v.optional(
25
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 50)]),
26
+
),
27
+
/**
28
+
* Additional information about the link, typically shown as a tooltip on hover
29
+
* @maxLength 500
30
+
*/
31
+
title: /*#__PURE__*/ v.optional(
32
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 500)]),
33
+
),
34
+
});
35
+
const _mainSchema = /*#__PURE__*/ v.object({
36
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.link')),
37
+
/**
38
+
* Link attributes that define the hyperlink behavior and destination
39
+
*/
40
+
get attrs() {
41
+
return linkAttrsSchema;
42
+
},
43
+
});
44
+
45
+
type linkAttrs$schematype = typeof _linkAttrsSchema;
46
+
type main$schematype = typeof _mainSchema;
47
+
48
+
export interface linkAttrsSchema extends linkAttrs$schematype {}
49
+
export interface mainSchema extends main$schematype {}
50
+
51
+
export const linkAttrsSchema = _linkAttrsSchema as linkAttrsSchema;
52
+
export const mainSchema = _mainSchema as mainSchema;
53
+
54
+
export interface LinkAttrs extends v.InferInput<typeof linkAttrsSchema> {}
55
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/strike.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/strike.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.strike')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/underline.ts
+14
packages/definitions/pckt/lib/lexicons/types/blog/pckt/mark/underline.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.mark.underline')),
6
+
});
7
+
8
+
type main$schematype = typeof _mainSchema;
9
+
10
+
export interface mainSchema extends main$schematype {}
11
+
12
+
export const mainSchema = _mainSchema as mainSchema;
13
+
14
+
export interface Main extends v.InferInput<typeof mainSchema> {}
+101
packages/definitions/pckt/lib/lexicons/types/blog/pckt/publication.ts
+101
packages/definitions/pckt/lib/lexicons/types/blog/pckt/publication.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
import type {} from '@atcute/lexicons/ambient';
4
+
import * as BlogPcktTheme from './theme.js';
5
+
6
+
const _mainSchema = /*#__PURE__*/ v.record(
7
+
/*#__PURE__*/ v.tidString(),
8
+
/*#__PURE__*/ v.object({
9
+
$type: /*#__PURE__*/ v.literal('blog.pckt.publication'),
10
+
/**
11
+
* Base URL path for the publication (e.g., https://blog.pckt.blog)
12
+
* @maxLength 2000
13
+
*/
14
+
basePath: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.genericUriString(), [
15
+
/*#__PURE__*/ v.stringLength(0, 2000),
16
+
]),
17
+
/**
18
+
* Timestamp when the publication was first created
19
+
*/
20
+
createdAt: /*#__PURE__*/ v.datetimeString(),
21
+
/**
22
+
* Publication description or tagline
23
+
* @maxLength 2000
24
+
* @maxGraphemes 500
25
+
*/
26
+
description: /*#__PURE__*/ v.optional(
27
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
28
+
/*#__PURE__*/ v.stringLength(0, 2000),
29
+
/*#__PURE__*/ v.stringGraphemes(0, 500),
30
+
]),
31
+
),
32
+
/**
33
+
* Extension objects (open union) for additional features
34
+
* @maxLength 10
35
+
*/
36
+
get extensions() {
37
+
return /*#__PURE__*/ v.optional(
38
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.array(/*#__PURE__*/ v.variant([])), [
39
+
/*#__PURE__*/ v.arrayLength(0, 10),
40
+
]),
41
+
);
42
+
},
43
+
/**
44
+
* Publication icon/avatar image
45
+
* @accept image/png, image/jpeg, image/webp, image/gif
46
+
* @maxSize 500000
47
+
*/
48
+
icon: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.blob()),
49
+
/**
50
+
* Publication name/title
51
+
* @maxLength 200
52
+
* @maxGraphemes 100
53
+
*/
54
+
name: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
55
+
/*#__PURE__*/ v.stringLength(0, 200),
56
+
/*#__PURE__*/ v.stringGraphemes(0, 100),
57
+
]),
58
+
/**
59
+
* Publication preferences and settings
60
+
*/
61
+
get preferences() {
62
+
return /*#__PURE__*/ v.optional(preferencesSchema);
63
+
},
64
+
/**
65
+
* Theme configuration as an open union; accepts blog.pckt.theme and future types.
66
+
*/
67
+
get theme() {
68
+
return /*#__PURE__*/ v.optional(/*#__PURE__*/ v.variant([BlogPcktTheme.mainSchema]));
69
+
},
70
+
/**
71
+
* Timestamp when the publication was last updated (optional)
72
+
*/
73
+
updatedAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
74
+
}),
75
+
);
76
+
const _preferencesSchema = /*#__PURE__*/ v.object({
77
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.publication#preferences')),
78
+
/**
79
+
* Whether documents from this publication should appear in public discover feeds
80
+
* @default true
81
+
*/
82
+
showInDiscover: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.boolean(), true),
83
+
});
84
+
85
+
type main$schematype = typeof _mainSchema;
86
+
type preferences$schematype = typeof _preferencesSchema;
87
+
88
+
export interface mainSchema extends main$schematype {}
89
+
export interface preferencesSchema extends preferences$schematype {}
90
+
91
+
export const mainSchema = _mainSchema as mainSchema;
92
+
export const preferencesSchema = _preferencesSchema as preferencesSchema;
93
+
94
+
export interface Main extends v.InferInput<typeof mainSchema> {}
95
+
export interface Preferences extends v.InferInput<typeof preferencesSchema> {}
96
+
97
+
declare module '@atcute/lexicons/ambient' {
98
+
interface Records {
99
+
'blog.pckt.publication': mainSchema;
100
+
}
101
+
}
+65
packages/definitions/pckt/lib/lexicons/types/blog/pckt/theme.ts
+65
packages/definitions/pckt/lib/lexicons/types/blog/pckt/theme.ts
···
1
+
import type {} from '@atcute/lexicons';
2
+
import * as v from '@atcute/lexicons/validations';
3
+
4
+
const _mainSchema = /*#__PURE__*/ v.object({
5
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.theme')),
6
+
/**
7
+
* Dark mode color palette
8
+
*/
9
+
get dark() {
10
+
return paletteSchema;
11
+
},
12
+
/**
13
+
* Font family name (optional)
14
+
* @maxLength 100
15
+
*/
16
+
font: /*#__PURE__*/ v.optional(
17
+
/*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 100)]),
18
+
),
19
+
/**
20
+
* Light mode color palette
21
+
*/
22
+
get light() {
23
+
return paletteSchema;
24
+
},
25
+
});
26
+
const _paletteSchema = /*#__PURE__*/ v.object({
27
+
$type: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.literal('blog.pckt.theme#palette')),
28
+
/**
29
+
* Accent color (hex value)
30
+
* @maxLength 7
31
+
*/
32
+
accent: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 7)]),
33
+
/**
34
+
* Background color (hex value)
35
+
* @maxLength 7
36
+
*/
37
+
background: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 7)]),
38
+
/**
39
+
* Link color (hex value)
40
+
* @maxLength 7
41
+
*/
42
+
link: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 7)]),
43
+
/**
44
+
* Surface hover color (hex value)
45
+
* @maxLength 7
46
+
*/
47
+
surfaceHover: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 7)]),
48
+
/**
49
+
* Primary text color (hex value)
50
+
* @maxLength 7
51
+
*/
52
+
text: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [/*#__PURE__*/ v.stringLength(0, 7)]),
53
+
});
54
+
55
+
type main$schematype = typeof _mainSchema;
56
+
type palette$schematype = typeof _paletteSchema;
57
+
58
+
export interface mainSchema extends main$schematype {}
59
+
export interface paletteSchema extends palette$schematype {}
60
+
61
+
export const mainSchema = _mainSchema as mainSchema;
62
+
export const paletteSchema = _paletteSchema as paletteSchema;
63
+
64
+
export interface Main extends v.InferInput<typeof mainSchema> {}
65
+
export interface Palette extends v.InferInput<typeof paletteSchema> {}
+47
packages/definitions/pckt/package.json
+47
packages/definitions/pckt/package.json
···
1
+
{
2
+
"type": "module",
3
+
"name": "@atcute/pckt",
4
+
"version": "0.1.0",
5
+
"description": "pckt (blog.pckt.*) schema definitions",
6
+
"keywords": [
7
+
"atcute",
8
+
"atproto",
9
+
"pckt"
10
+
],
11
+
"license": "0BSD",
12
+
"repository": {
13
+
"url": "https://github.com/mary-ext/atcute",
14
+
"directory": "packages/definitions/pckt"
15
+
},
16
+
"files": [
17
+
"dist/",
18
+
"lib/",
19
+
"!lib/**/*.bench.ts",
20
+
"!lib/**/*.test.ts"
21
+
],
22
+
"exports": {
23
+
".": "./dist/index.js",
24
+
"./types/*": "./dist/lexicons/types/blog/pckt/*.js"
25
+
},
26
+
"scripts": {
27
+
"build": "tsc",
28
+
"pull": "lex-cli pull",
29
+
"generate": "rm -r ./lib/lexicons/; lex-cli generate",
30
+
"prepublish": "rm -rf dist; pnpm run build"
31
+
},
32
+
"dependencies": {
33
+
"@atcute/atproto": "workspace:^",
34
+
"@atcute/lexicons": "workspace:^"
35
+
},
36
+
"devDependencies": {
37
+
"@atcute/lex-cli": "workspace:^"
38
+
},
39
+
"atcute:lexicons": {
40
+
"mappings": {
41
+
"blog.pckt.*": {
42
+
"type": "namespace",
43
+
"path": "./types/{{nsid_remainder}}"
44
+
}
45
+
}
46
+
}
47
+
}
+23
packages/definitions/pckt/tsconfig.json
+23
packages/definitions/pckt/tsconfig.json
···
1
+
{
2
+
"compilerOptions": {
3
+
"outDir": "dist/",
4
+
"esModuleInterop": true,
5
+
"skipLibCheck": true,
6
+
"target": "ESNext",
7
+
"allowJs": true,
8
+
"resolveJsonModule": true,
9
+
"moduleDetection": "force",
10
+
"isolatedModules": true,
11
+
"verbatimModuleSyntax": true,
12
+
"strict": true,
13
+
"noImplicitOverride": true,
14
+
"noUnusedLocals": true,
15
+
"noUnusedParameters": true,
16
+
"noFallthroughCasesInSwitch": true,
17
+
"module": "NodeNext",
18
+
"sourceMap": true,
19
+
"declaration": true,
20
+
"declarationMap": true
21
+
},
22
+
"include": ["lib"]
23
+
}
+13
pnpm-lock.yaml
+13
pnpm-lock.yaml
···
321
321
specifier: 'file:'
322
322
version: file:packages/definitions/ozone
323
323
324
+
packages/definitions/pckt:
325
+
dependencies:
326
+
'@atcute/atproto':
327
+
specifier: workspace:^
328
+
version: link:../atproto
329
+
'@atcute/lexicons':
330
+
specifier: workspace:^
331
+
version: link:../../lexicons/lexicons
332
+
devDependencies:
333
+
'@atcute/lex-cli':
334
+
specifier: workspace:^
335
+
version: link:../../lexicons/lex-cli
336
+
324
337
packages/definitions/tangled:
325
338
dependencies:
326
339
'@atcute/atproto':