@atlaskit/adf-schema 37.0.0 → 37.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/CHANGELOG.md +6 -0
  2. package/dist/cjs/next-schema/generated/markTypes.js +77 -77
  3. package/dist/cjs/next-schema/generated/nodeTypes.js +555 -555
  4. package/dist/es2019/next-schema/generated/markTypes.js +77 -77
  5. package/dist/es2019/next-schema/generated/nodeTypes.js +555 -555
  6. package/dist/esm/next-schema/generated/markTypes.js +77 -77
  7. package/dist/esm/next-schema/generated/nodeTypes.js +555 -555
  8. package/dist/types/next-schema/generated/markTypes.d.ts +122 -122
  9. package/dist/types/next-schema/generated/nodeGroupTypes.d.ts +2 -2
  10. package/dist/types/next-schema/generated/nodeTypes.d.ts +478 -478
  11. package/package.json +2 -2
package/dist/types/next-schema/generated/nodeTypes.d.ts CHANGED
@@ -6,30 +6,6 @@
6
6
  import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
7
7
  import { InlineDefinition, BlockDefinition, BlockRootOnlyDefinition } from './nodeGroupTypes';
8
8
  import { UnsupportedNodeAttributeMark, UnsupportedMarkMark, LinkMark, EmMark, StrongMark, StrikeMark, SubsupMark, UnderlineMark, TextColorMark, AnnotationMark, BackgroundColorMark, TypeAheadQueryMark, ConfluenceInlineCommentMark, CodeMark, DataConsumerMark, FragmentMark, BorderMark, AlignmentMark, IndentationMark, BreakoutMark } from './markTypes';
9
- export interface TextDefinition {
10
- type: 'text';
11
- }
12
- export type TextNode = PMNode & TextDefinition;
13
- export declare const text: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TextNode>) => import("prosemirror-model").NodeSpec;
14
- export interface UnsupportedInlineDefinition {
15
- type: 'unsupportedInline';
16
- attrs: {
17
- originalValue: Record<string, unknown>;
18
- };
19
- }
20
- export type UnsupportedInlineNode = PMNode & UnsupportedInlineDefinition;
21
- export declare const unsupportedInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<UnsupportedInlineNode>) => import("prosemirror-model").NodeSpec;
22
- export interface CodeBlockWithNoMarksDefinition {
23
- type: 'codeBlock';
24
- content: Array<TextDefinition | UnsupportedInlineDefinition>;
25
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
26
- attrs: {
27
- language?: string;
28
- uniqueId?: string;
29
- };
30
- }
31
- export type CodeBlockWithNoMarksNode = PMNode & CodeBlockWithNoMarksDefinition;
32
- export declare const codeBlockWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<CodeBlockWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
33
9
  export interface BlockCardNodeAttributes0 {
34
10
  url?: string;
35
11
  datasource: Record<string, unknown>;
@@ -49,140 +25,86 @@ export interface BlockCardDefinition {
49
25
  }
50
26
  export type BlockCardNode = PMNode & BlockCardDefinition;
51
27
  export declare const blockCard: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BlockCardNode>) => import("prosemirror-model").NodeSpec;
52
- export interface TextFormattedDefinition {
53
- type: 'text';
54
- marks: Array<LinkMark | EmMark | StrongMark | StrikeMark | SubsupMark | UnderlineMark | TextColorMark | AnnotationMark | BackgroundColorMark | TypeAheadQueryMark | ConfluenceInlineCommentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
55
- }
56
- export type TextFormattedNode = PMNode & TextFormattedDefinition;
57
- export declare const textFormatted: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TextFormattedNode>) => import("prosemirror-model").NodeSpec;
58
- export interface TextCodeInlineDefinition {
59
- type: 'text';
60
- marks: Array<CodeMark | LinkMark | AnnotationMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
61
- }
62
- export type TextCodeInlineNode = PMNode & TextCodeInlineDefinition;
63
- export declare const textCodeInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TextCodeInlineNode>) => import("prosemirror-model").NodeSpec;
64
- export interface DateDefinition {
65
- type: 'date';
66
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
67
- attrs: {
68
- timestamp: string;
69
- };
70
- }
71
- export type DateNode = PMNode & DateDefinition;
72
- export declare const date: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DateNode>) => import("prosemirror-model").NodeSpec;
73
- export interface EmojiDefinition {
74
- type: 'emoji';
75
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
76
- attrs: {
77
- shortName: string;
78
- id?: string;
79
- text?: string;
80
- };
81
- }
82
- export type EmojiNode = PMNode & EmojiDefinition;
83
- export declare const emoji: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<EmojiNode>) => import("prosemirror-model").NodeSpec;
84
- export interface HardBreakDefinition {
85
- type: 'hardBreak';
28
+ export interface BlockquoteDefinition {
29
+ type: 'blockquote';
30
+ content: Array<ParagraphWithNoMarksDefinition | BulletListDefinition | OrderedListDefinition | UnsupportedBlockDefinition>;
86
31
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
87
- attrs: {
88
- text?: '\n';
89
- };
90
32
  }
91
- export type HardBreakNode = PMNode & HardBreakDefinition;
92
- export declare const hardBreak: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HardBreakNode>) => import("prosemirror-model").NodeSpec;
93
- export interface InlineCardNodeAttributes0 {
94
- url: string;
95
- }
96
- export interface InlineCardNodeAttributes1 {
97
- data: Record<string, unknown>;
98
- }
99
- export interface InlineCardDefinition {
100
- type: 'inlineCard';
33
+ export type BlockquoteNode = PMNode & BlockquoteDefinition;
34
+ export declare const blockquote: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BlockquoteNode>) => import("prosemirror-model").NodeSpec;
35
+ export interface BlockquoteWithListDefinition {
36
+ type: 'blockquote';
37
+ content: Array<ParagraphDefinition | OrderedListDefinition | BulletListDefinition | UnsupportedBlockDefinition>;
101
38
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
102
- attrs: InlineCardNodeAttributes0 | InlineCardNodeAttributes1;
103
39
  }
104
- export type InlineCardNode = PMNode & InlineCardDefinition;
105
- export declare const inlineCard: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<InlineCardNode>) => import("prosemirror-model").NodeSpec;
106
- export interface MentionDefinition {
107
- type: 'mention';
40
+ export type BlockquoteWithListNode = PMNode & BlockquoteWithListDefinition;
41
+ export declare const blockquoteWithList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BlockquoteWithListNode>) => import("prosemirror-model").NodeSpec;
42
+ export interface BodiedExtensionDefinition {
43
+ type: 'bodiedExtension';
44
+ content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | TableDefinition | UnsupportedBlockDefinition>;
108
45
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
109
46
  attrs: {
110
- id: string;
111
- localId?: string;
47
+ extensionKey: string;
48
+ extensionType: string;
49
+ parameters?: Record<string, unknown>;
112
50
  text?: string;
113
- accessLevel?: string;
114
- userType?: 'DEFAULT' | 'SPECIAL' | 'APP';
115
- };
116
- }
117
- export type MentionNode = PMNode & MentionDefinition;
118
- export declare const mention: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MentionNode>) => import("prosemirror-model").NodeSpec;
119
- export interface PlaceholderDefinition {
120
- type: 'placeholder';
121
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
122
- attrs: {
123
- text: string;
124
- };
125
- }
126
- export type PlaceholderNode = PMNode & PlaceholderDefinition;
127
- export declare const placeholder: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<PlaceholderNode>) => import("prosemirror-model").NodeSpec;
128
- export interface StatusDefinition {
129
- type: 'status';
130
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
131
- attrs: {
132
- text: string;
133
- color: 'neutral' | 'purple' | 'blue' | 'red' | 'yellow' | 'green';
51
+ layout?: 'wide' | 'full-width' | 'default';
134
52
  localId?: string;
135
- style?: string;
136
53
  };
137
54
  }
138
- export type StatusNode = PMNode & StatusDefinition;
139
- export declare const status: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<StatusNode>) => import("prosemirror-model").NodeSpec;
140
- export interface InlineExtensionWithMarksDefinition {
141
- type: 'inlineExtension';
55
+ export type BodiedExtensionNode = PMNode & BodiedExtensionDefinition;
56
+ export declare const bodiedExtension: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BodiedExtensionNode>) => import("prosemirror-model").NodeSpec;
57
+ export interface BodiedExtensionWithMarksDefinition {
58
+ type: 'bodiedExtension';
59
+ content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | TableDefinition | UnsupportedBlockDefinition>;
142
60
  marks: Array<DataConsumerMark | FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
143
61
  attrs: {
144
62
  extensionKey: string;
145
63
  extensionType: string;
146
64
  parameters?: Record<string, unknown>;
147
65
  text?: string;
66
+ layout?: 'wide' | 'full-width' | 'default';
148
67
  localId?: string;
149
68
  };
150
69
  }
151
- export type InlineExtensionWithMarksNode = PMNode & InlineExtensionWithMarksDefinition;
152
- export declare const inlineExtensionWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<InlineExtensionWithMarksNode>) => import("prosemirror-model").NodeSpec;
153
- export interface MediaInlineDefinition {
154
- type: 'mediaInline';
155
- marks: Array<LinkMark | AnnotationMark | BorderMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
70
+ export type BodiedExtensionWithMarksNode = PMNode & BodiedExtensionWithMarksDefinition;
71
+ export declare const bodiedExtensionWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BodiedExtensionWithMarksNode>) => import("prosemirror-model").NodeSpec;
72
+ export interface BulletListDefinition {
73
+ type: 'bulletList';
74
+ content: Array<ListItemDefinition>;
75
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
76
+ }
77
+ export type BulletListNode = PMNode & BulletListDefinition;
78
+ export declare const bulletList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BulletListNode>) => import("prosemirror-model").NodeSpec;
79
+ export interface CaptionDefinition {
80
+ type: 'caption';
81
+ content: Array<HardBreakDefinition | MentionDefinition | EmojiDefinition | DateDefinition | PlaceholderDefinition | InlineCardDefinition | StatusDefinition | TextFormattedDefinition | TextCodeInlineDefinition | UnsupportedInlineDefinition>;
82
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
83
+ }
84
+ export type CaptionNode = PMNode & CaptionDefinition;
85
+ export declare const caption: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<CaptionNode>) => import("prosemirror-model").NodeSpec;
86
+ export interface CodeBlockDefinition {
87
+ type: 'codeBlock';
88
+ content: Array<TextDefinition | UnsupportedInlineDefinition>;
89
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
156
90
  attrs: {
157
- type?: 'link' | 'file' | 'image';
158
- url: string;
159
- id: string;
160
- alt?: string;
161
- collection: string;
162
- occurrenceKey?: string;
163
- width?: number;
164
- height?: number;
165
- __fileName?: string;
166
- __fileSize?: number;
167
- __fileMimeType?: string;
168
- __displayType?: 'file' | 'thumbnail';
169
- __contextId?: string;
170
- __mediaTraceId?: string;
171
- __external?: boolean;
91
+ language?: string;
92
+ uniqueId?: string;
172
93
  };
173
94
  }
174
- export type MediaInlineNode = PMNode & MediaInlineDefinition;
175
- export declare const mediaInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaInlineNode>) => import("prosemirror-model").NodeSpec;
176
- export interface ImageDefinition {
177
- type: 'image';
95
+ export type CodeBlockNode = PMNode & CodeBlockDefinition;
96
+ export declare const codeBlock: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<CodeBlockNode>) => import("prosemirror-model").NodeSpec;
97
+ export interface CodeBlockWithNoMarksDefinition {
98
+ type: 'codeBlock';
99
+ content: Array<TextDefinition | UnsupportedInlineDefinition>;
100
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
178
101
  attrs: {
179
- src: string;
180
- alt?: string;
181
- title?: string;
102
+ language?: string;
103
+ uniqueId?: string;
182
104
  };
183
105
  }
184
- export type ImageNode = PMNode & ImageDefinition;
185
- export declare const image: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ImageNode>) => import("prosemirror-model").NodeSpec;
106
+ export type CodeBlockWithNoMarksNode = PMNode & CodeBlockWithNoMarksDefinition;
107
+ export declare const codeBlockWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<CodeBlockWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
186
108
  export interface ConfluenceJiraIssueDefinition {
187
109
  type: 'confluenceJiraIssue';
188
110
  attrs: {
@@ -195,6 +117,14 @@ export interface ConfluenceJiraIssueDefinition {
195
117
  }
196
118
  export type ConfluenceJiraIssueNode = PMNode & ConfluenceJiraIssueDefinition;
197
119
  export declare const confluenceJiraIssue: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ConfluenceJiraIssueNode>) => import("prosemirror-model").NodeSpec;
120
+ export interface ConfluenceUnsupportedBlockDefinition {
121
+ type: 'confluenceUnsupportedBlock';
122
+ attrs: {
123
+ cxhtml: string;
124
+ };
125
+ }
126
+ export type ConfluenceUnsupportedBlockNode = PMNode & ConfluenceUnsupportedBlockDefinition;
127
+ export declare const confluenceUnsupportedBlock: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ConfluenceUnsupportedBlockNode>) => import("prosemirror-model").NodeSpec;
198
128
  export interface ConfluenceUnsupportedInlineDefinition {
199
129
  type: 'confluenceUnsupportedInline';
200
130
  attrs: {
@@ -203,227 +133,132 @@ export interface ConfluenceUnsupportedInlineDefinition {
203
133
  }
204
134
  export type ConfluenceUnsupportedInlineNode = PMNode & ConfluenceUnsupportedInlineDefinition;
205
135
  export declare const confluenceUnsupportedInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ConfluenceUnsupportedInlineNode>) => import("prosemirror-model").NodeSpec;
206
- export interface ParagraphWithNoMarksDefinition {
207
- type: 'paragraph';
208
- content: Array<InlineDefinition>;
136
+ export interface DateDefinition {
137
+ type: 'date';
209
138
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
210
139
  attrs: {
211
- localId?: string;
140
+ timestamp: string;
212
141
  };
213
142
  }
214
- export type ParagraphWithNoMarksNode = PMNode & ParagraphWithNoMarksDefinition;
215
- export declare const paragraphWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
216
- export interface MediaNodeAttributes0 {
217
- type: 'link' | 'file';
218
- id: string;
219
- alt?: string;
220
- collection: string;
221
- height?: number;
222
- occurrenceKey?: string;
223
- width?: number;
224
- __contextId?: string;
225
- __displayType?: string;
226
- __external?: boolean;
227
- __fileMimeType?: string;
228
- __fileName?: string;
229
- __fileSize?: string;
230
- __mediaTraceId?: string;
231
- }
232
- export interface MediaNodeAttributes1 {
233
- type: 'external';
234
- alt?: string;
235
- height?: number;
236
- width?: number;
237
- url: string;
238
- }
239
- export interface MediaDefinition {
240
- type: 'media';
241
- marks: Array<LinkMark | AnnotationMark | BorderMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
242
- attrs: MediaNodeAttributes0 | MediaNodeAttributes1;
243
- }
244
- export type MediaNode = PMNode & MediaDefinition;
245
- export declare const media: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaNode>) => import("prosemirror-model").NodeSpec;
246
- export interface UnsupportedBlockDefinition {
247
- type: 'unsupportedBlock';
143
+ export type DateNode = PMNode & DateDefinition;
144
+ export declare const date: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DateNode>) => import("prosemirror-model").NodeSpec;
145
+ export interface DecisionItemDefinition {
146
+ type: 'decisionItem';
147
+ content: Array<InlineDefinition>;
148
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
248
149
  attrs: {
249
- originalValue: Record<string, unknown>;
150
+ localId: string;
151
+ state: string;
250
152
  };
251
153
  }
252
- export type UnsupportedBlockNode = PMNode & UnsupportedBlockDefinition;
253
- export declare const unsupportedBlock: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<UnsupportedBlockNode>) => import("prosemirror-model").NodeSpec;
254
- export interface CaptionDefinition {
255
- type: 'caption';
256
- content: Array<HardBreakDefinition | MentionDefinition | EmojiDefinition | DateDefinition | PlaceholderDefinition | InlineCardDefinition | StatusDefinition | TextFormattedDefinition | TextCodeInlineDefinition | UnsupportedInlineDefinition>;
257
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
258
- }
259
- export type CaptionNode = PMNode & CaptionDefinition;
260
- export declare const caption: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<CaptionNode>) => import("prosemirror-model").NodeSpec;
261
- export interface MediaSingleCaptionNodeAttributes0 {
262
- width?: number;
263
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
264
- widthType?: 'percentage';
265
- }
266
- export interface MediaSingleCaptionNodeAttributes1 {
267
- width: number;
268
- widthType: 'pixel';
269
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
270
- }
271
- export interface MediaSingleCaptionDefinition {
272
- type: 'mediaSingle';
273
- content: Array<MediaDefinition | UnsupportedBlockDefinition | CaptionDefinition | UnsupportedBlockDefinition>;
274
- marks: Array<LinkMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
275
- attrs: MediaSingleCaptionNodeAttributes0 | MediaSingleCaptionNodeAttributes1;
276
- }
277
- export type MediaSingleCaptionNode = PMNode & MediaSingleCaptionDefinition;
278
- export declare const mediaSingleCaption: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaSingleCaptionNode>) => import("prosemirror-model").NodeSpec;
279
- export interface MediaSingleFullNodeAttributes0 {
280
- width?: number;
281
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
282
- widthType?: 'percentage';
283
- }
284
- export interface MediaSingleFullNodeAttributes1 {
285
- width: number;
286
- widthType: 'pixel';
287
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
288
- }
289
- export interface MediaSingleFullDefinition {
290
- type: 'mediaSingle';
291
- content: Array<MediaDefinition>;
292
- marks: Array<LinkMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
293
- attrs: MediaSingleFullNodeAttributes0 | MediaSingleFullNodeAttributes1;
294
- }
295
- export type MediaSingleFullNode = PMNode & MediaSingleFullDefinition;
296
- export declare const mediaSingleFull: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaSingleFullNode>) => import("prosemirror-model").NodeSpec;
297
- export interface TaskItemDefinition {
298
- type: 'taskItem';
299
- content: Array<InlineDefinition>;
154
+ export type DecisionItemNode = PMNode & DecisionItemDefinition;
155
+ export declare const decisionItem: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DecisionItemNode>) => import("prosemirror-model").NodeSpec;
156
+ export interface DecisionListDefinition {
157
+ type: 'decisionList';
158
+ content: Array<DecisionItemDefinition | UnsupportedBlockDefinition>;
300
159
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
301
160
  attrs: {
302
161
  localId: string;
303
- state: 'TODO' | 'DONE';
304
162
  };
305
163
  }
306
- export type TaskItemNode = PMNode & TaskItemDefinition;
307
- export declare const taskItem: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TaskItemNode>) => import("prosemirror-model").NodeSpec;
308
- export interface TaskListDefinition {
309
- type: 'taskList';
310
- content: Array<TaskItemDefinition | UnsupportedBlockDefinition | TaskItemDefinition | TaskListDefinition | UnsupportedBlockDefinition>;
164
+ export type DecisionListNode = PMNode & DecisionListDefinition;
165
+ export declare const decisionList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DecisionListNode>) => import("prosemirror-model").NodeSpec;
166
+ export interface DocDefinition {
167
+ type: 'doc';
168
+ content: Array<BlockDefinition | LayoutSectionDefinition | BlockRootOnlyDefinition>;
169
+ }
170
+ export type DocNode = PMNode & DocDefinition;
171
+ export declare const doc: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DocNode>) => import("prosemirror-model").NodeSpec;
172
+ export interface EmbedCardDefinition {
173
+ type: 'embedCard';
311
174
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
312
175
  attrs: {
313
- localId: string;
176
+ url: string;
177
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
178
+ width?: number;
179
+ originalHeight?: number;
180
+ originalWidth?: number;
314
181
  };
315
182
  }
316
- export type TaskListNode = PMNode & TaskListDefinition;
317
- export declare const taskList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TaskListNode>) => import("prosemirror-model").NodeSpec;
318
- export interface OrderedListDefinition {
319
- type: 'orderedList';
320
- content: Array<ListItemDefinition>;
183
+ export type EmbedCardNode = PMNode & EmbedCardDefinition;
184
+ export declare const embedCard: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<EmbedCardNode>) => import("prosemirror-model").NodeSpec;
185
+ export interface EmojiDefinition {
186
+ type: 'emoji';
321
187
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
322
188
  attrs: {
323
- order?: number;
189
+ shortName: string;
190
+ id?: string;
191
+ text?: string;
324
192
  };
325
193
  }
326
- export type OrderedListNode = PMNode & OrderedListDefinition;
327
- export declare const orderedList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<OrderedListNode>) => import("prosemirror-model").NodeSpec;
328
- export interface ListItemDefinition {
329
- type: 'listItem';
330
- content: Array<CodeBlockWithNoMarksDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | UnsupportedBlockDefinition | CodeBlockWithNoMarksDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | UnsupportedBlockDefinition>;
331
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
332
- }
333
- export type ListItemNode = PMNode & ListItemDefinition;
334
- export declare const listItem: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ListItemNode>) => import("prosemirror-model").NodeSpec;
335
- export interface BulletListDefinition {
336
- type: 'bulletList';
337
- content: Array<ListItemDefinition>;
338
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
339
- }
340
- export type BulletListNode = PMNode & BulletListDefinition;
341
- export declare const bulletList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BulletListNode>) => import("prosemirror-model").NodeSpec;
342
- export interface HeadingWithNoMarksDefinition {
343
- type: 'heading';
344
- content: Array<InlineDefinition>;
194
+ export type EmojiNode = PMNode & EmojiDefinition;
195
+ export declare const emoji: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<EmojiNode>) => import("prosemirror-model").NodeSpec;
196
+ export interface ExpandWithNoMarkDefinition {
197
+ type: 'expand';
198
+ content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | TableDefinition | UnsupportedBlockDefinition>;
345
199
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
346
200
  attrs: {
347
- level: number;
348
- localId?: string;
201
+ title?: string;
202
+ __expanded?: boolean;
349
203
  };
350
204
  }
351
- export type HeadingWithNoMarksNode = PMNode & HeadingWithNoMarksDefinition;
352
- export declare const headingWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HeadingWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
353
- export interface MediaGroupDefinition {
354
- type: 'mediaGroup';
355
- content: Array<MediaDefinition | UnsupportedBlockDefinition>;
356
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
357
- }
358
- export type MediaGroupNode = PMNode & MediaGroupDefinition;
359
- export declare const mediaGroup: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaGroupNode>) => import("prosemirror-model").NodeSpec;
360
- export interface DecisionItemDefinition {
361
- type: 'decisionItem';
362
- content: Array<InlineDefinition>;
205
+ export type ExpandWithNoMarkNode = PMNode & ExpandWithNoMarkDefinition;
206
+ export declare const expandWithNoMark: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExpandWithNoMarkNode>) => import("prosemirror-model").NodeSpec;
207
+ export interface ExtensionDefinition {
208
+ type: 'extension';
363
209
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
364
210
  attrs: {
365
- localId: string;
366
- state: string;
211
+ extensionKey: string;
212
+ extensionType: string;
213
+ parameters?: Record<string, unknown>;
214
+ text?: string;
215
+ layout?: 'wide' | 'full-width' | 'default';
216
+ localId?: string;
367
217
  };
368
218
  }
369
- export type DecisionItemNode = PMNode & DecisionItemDefinition;
370
- export declare const decisionItem: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DecisionItemNode>) => import("prosemirror-model").NodeSpec;
371
- export interface DecisionListDefinition {
372
- type: 'decisionList';
373
- content: Array<DecisionItemDefinition | UnsupportedBlockDefinition>;
374
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
219
+ export type ExtensionNode = PMNode & ExtensionDefinition;
220
+ export declare const extension: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExtensionNode>) => import("prosemirror-model").NodeSpec;
221
+ export interface ExtensionWithMarksDefinition {
222
+ type: 'extension';
223
+ marks: Array<DataConsumerMark | FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
375
224
  attrs: {
376
- localId: string;
225
+ extensionKey: string;
226
+ extensionType: string;
227
+ parameters?: Record<string, unknown>;
228
+ text?: string;
229
+ layout?: 'wide' | 'full-width' | 'default';
230
+ localId?: string;
377
231
  };
378
232
  }
379
- export type DecisionListNode = PMNode & DecisionListDefinition;
380
- export declare const decisionList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DecisionListNode>) => import("prosemirror-model").NodeSpec;
381
- export interface RuleDefinition {
382
- type: 'rule';
233
+ export type ExtensionWithMarksNode = PMNode & ExtensionWithMarksDefinition;
234
+ export declare const extensionWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExtensionWithMarksNode>) => import("prosemirror-model").NodeSpec;
235
+ export interface ExtensionFrameDefinition {
236
+ type: 'extensionFrame';
237
+ content: Array<BodiedExtensionDefinition | PanelDefinition | ParagraphDefinition | BlockquoteDefinition | OrderedListDefinition | BulletListDefinition | RuleDefinition | HeadingDefinition | CodeBlockDefinition | MediaGroupDefinition | MediaSingleDefinition | DecisionListDefinition | TaskListDefinition | TableDefinition | ExtensionDefinition | BlockCardDefinition | EmbedCardDefinition | UnsupportedBlockDefinition>;
238
+ marks: Array<DataConsumerMark | FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
383
239
  }
384
- export type RuleNode = PMNode & RuleDefinition;
385
- export declare const rule: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<RuleNode>) => import("prosemirror-model").NodeSpec;
386
- export interface PanelDefinition {
387
- type: 'panel';
388
- content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | UnsupportedBlockDefinition>;
240
+ export type ExtensionFrameNode = PMNode & ExtensionFrameDefinition;
241
+ export declare const extensionFrame: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExtensionFrameNode>) => import("prosemirror-model").NodeSpec;
242
+ export interface HardBreakDefinition {
243
+ type: 'hardBreak';
389
244
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
390
245
  attrs: {
391
- panelType: 'info' | 'note' | 'tip' | 'warning' | 'error' | 'success' | 'custom';
392
- panelIcon?: string;
393
- panelIconId?: string;
394
- panelIconText?: string;
395
- panelColor?: string;
246
+ text?: '\n';
396
247
  };
397
248
  }
398
- export type PanelNode = PMNode & PanelDefinition;
399
- export declare const panel: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<PanelNode>) => import("prosemirror-model").NodeSpec;
400
- export interface ParagraphDefinition {
401
- type: 'paragraph';
249
+ export type HardBreakNode = PMNode & HardBreakDefinition;
250
+ export declare const hardBreak: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HardBreakNode>) => import("prosemirror-model").NodeSpec;
251
+ export interface HeadingDefinition {
252
+ type: 'heading';
402
253
  content: Array<InlineDefinition>;
403
254
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
404
255
  attrs: {
256
+ level: number;
405
257
  localId?: string;
406
258
  };
407
259
  }
408
- export type ParagraphNode = PMNode & ParagraphDefinition;
409
- export declare const paragraph: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphNode>) => import("prosemirror-model").NodeSpec;
410
- export interface ParagraphWithMarksDefinition {
411
- type: 'paragraph';
412
- content: Array<InlineDefinition>;
413
- marks: Array<AlignmentMark | IndentationMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
414
- attrs: {
415
- localId?: string;
416
- };
417
- }
418
- export type ParagraphWithMarksNode = PMNode & ParagraphWithMarksDefinition;
419
- export declare const paragraphWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphWithMarksNode>) => import("prosemirror-model").NodeSpec;
420
- export interface BlockquoteWithListDefinition {
421
- type: 'blockquote';
422
- content: Array<ParagraphDefinition | OrderedListDefinition | BulletListDefinition | UnsupportedBlockDefinition>;
423
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
424
- }
425
- export type BlockquoteWithListNode = PMNode & BlockquoteWithListDefinition;
426
- export declare const blockquoteWithList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BlockquoteWithListNode>) => import("prosemirror-model").NodeSpec;
260
+ export type HeadingNode = PMNode & HeadingDefinition;
261
+ export declare const heading: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HeadingNode>) => import("prosemirror-model").NodeSpec;
427
262
  export interface HeadingWithAlignmentDefinition {
428
263
  type: 'heading';
429
264
  content: Array<InlineDefinition>;
@@ -446,50 +281,219 @@ export interface HeadingWithIndentationDefinition {
446
281
  }
447
282
  export type HeadingWithIndentationNode = PMNode & HeadingWithIndentationDefinition;
448
283
  export declare const headingWithIndentation: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HeadingWithIndentationNode>) => import("prosemirror-model").NodeSpec;
449
- export interface ParagraphWithAlignmentDefinition {
450
- type: 'paragraph';
284
+ export interface HeadingWithNoMarksDefinition {
285
+ type: 'heading';
451
286
  content: Array<InlineDefinition>;
452
- marks: Array<AlignmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
287
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
453
288
  attrs: {
289
+ level: number;
454
290
  localId?: string;
455
291
  };
456
292
  }
457
- export type ParagraphWithAlignmentNode = PMNode & ParagraphWithAlignmentDefinition;
458
- export declare const paragraphWithAlignment: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphWithAlignmentNode>) => import("prosemirror-model").NodeSpec;
459
- export interface BlockquoteDefinition {
460
- type: 'blockquote';
461
- content: Array<ParagraphWithNoMarksDefinition | BulletListDefinition | OrderedListDefinition | UnsupportedBlockDefinition>;
293
+ export type HeadingWithNoMarksNode = PMNode & HeadingWithNoMarksDefinition;
294
+ export declare const headingWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HeadingWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
295
+ export interface ImageDefinition {
296
+ type: 'image';
297
+ attrs: {
298
+ src: string;
299
+ alt?: string;
300
+ title?: string;
301
+ };
302
+ }
303
+ export type ImageNode = PMNode & ImageDefinition;
304
+ export declare const image: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ImageNode>) => import("prosemirror-model").NodeSpec;
305
+ export interface InlineCardNodeAttributes0 {
306
+ url: string;
307
+ }
308
+ export interface InlineCardNodeAttributes1 {
309
+ data: Record<string, unknown>;
310
+ }
311
+ export interface InlineCardDefinition {
312
+ type: 'inlineCard';
462
313
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
314
+ attrs: InlineCardNodeAttributes0 | InlineCardNodeAttributes1;
463
315
  }
464
- export type BlockquoteNode = PMNode & BlockquoteDefinition;
465
- export declare const blockquote: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BlockquoteNode>) => import("prosemirror-model").NodeSpec;
466
- export interface ExtensionWithMarksDefinition {
467
- type: 'extension';
316
+ export type InlineCardNode = PMNode & InlineCardDefinition;
317
+ export declare const inlineCard: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<InlineCardNode>) => import("prosemirror-model").NodeSpec;
318
+ export interface InlineExtensionWithMarksDefinition {
319
+ type: 'inlineExtension';
468
320
  marks: Array<DataConsumerMark | FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
469
321
  attrs: {
470
322
  extensionKey: string;
471
323
  extensionType: string;
472
324
  parameters?: Record<string, unknown>;
473
325
  text?: string;
474
- layout?: 'wide' | 'full-width' | 'default';
475
326
  localId?: string;
476
327
  };
477
328
  }
478
- export type ExtensionWithMarksNode = PMNode & ExtensionWithMarksDefinition;
479
- export declare const extensionWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExtensionWithMarksNode>) => import("prosemirror-model").NodeSpec;
480
- export interface EmbedCardDefinition {
481
- type: 'embedCard';
329
+ export type InlineExtensionWithMarksNode = PMNode & InlineExtensionWithMarksDefinition;
330
+ export declare const inlineExtensionWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<InlineExtensionWithMarksNode>) => import("prosemirror-model").NodeSpec;
331
+ export interface LayoutColumnDefinition {
332
+ type: 'layoutColumn';
333
+ content: Array<BlockDefinition | UnsupportedBlockDefinition>;
482
334
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
483
335
  attrs: {
484
- url: string;
485
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
336
+ width: number;
337
+ };
338
+ }
339
+ export type LayoutColumnNode = PMNode & LayoutColumnDefinition;
340
+ export declare const layoutColumn: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<LayoutColumnNode>) => import("prosemirror-model").NodeSpec;
341
+ export interface LayoutSectionDefinition {
342
+ type: 'layoutSection';
343
+ content: Array<LayoutColumnDefinition | UnsupportedBlockDefinition>;
344
+ marks: Array<BreakoutMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
345
+ }
346
+ export type LayoutSectionNode = PMNode & LayoutSectionDefinition;
347
+ export declare const layoutSection: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<LayoutSectionNode>) => import("prosemirror-model").NodeSpec;
348
+ export interface ListItemDefinition {
349
+ type: 'listItem';
350
+ content: Array<CodeBlockWithNoMarksDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | UnsupportedBlockDefinition | CodeBlockWithNoMarksDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | UnsupportedBlockDefinition>;
351
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
352
+ }
353
+ export type ListItemNode = PMNode & ListItemDefinition;
354
+ export declare const listItem: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ListItemNode>) => import("prosemirror-model").NodeSpec;
355
+ export interface MediaNodeAttributes0 {
356
+ type: 'link' | 'file';
357
+ id: string;
358
+ alt?: string;
359
+ collection: string;
360
+ height?: number;
361
+ occurrenceKey?: string;
362
+ width?: number;
363
+ __contextId?: string;
364
+ __displayType?: string;
365
+ __external?: boolean;
366
+ __fileMimeType?: string;
367
+ __fileName?: string;
368
+ __fileSize?: string;
369
+ __mediaTraceId?: string;
370
+ }
371
+ export interface MediaNodeAttributes1 {
372
+ type: 'external';
373
+ alt?: string;
374
+ height?: number;
375
+ width?: number;
376
+ url: string;
377
+ }
378
+ export interface MediaDefinition {
379
+ type: 'media';
380
+ marks: Array<LinkMark | AnnotationMark | BorderMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
381
+ attrs: MediaNodeAttributes0 | MediaNodeAttributes1;
382
+ }
383
+ export type MediaNode = PMNode & MediaDefinition;
384
+ export declare const media: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaNode>) => import("prosemirror-model").NodeSpec;
385
+ export interface MediaGroupDefinition {
386
+ type: 'mediaGroup';
387
+ content: Array<MediaDefinition | UnsupportedBlockDefinition>;
388
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
389
+ }
390
+ export type MediaGroupNode = PMNode & MediaGroupDefinition;
391
+ export declare const mediaGroup: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaGroupNode>) => import("prosemirror-model").NodeSpec;
392
+ export interface MediaInlineDefinition {
393
+ type: 'mediaInline';
394
+ marks: Array<LinkMark | AnnotationMark | BorderMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
395
+ attrs: {
396
+ type?: 'link' | 'file' | 'image';
397
+ url: string;
398
+ id: string;
399
+ alt?: string;
400
+ collection: string;
401
+ occurrenceKey?: string;
486
402
  width?: number;
487
- originalHeight?: number;
488
- originalWidth?: number;
403
+ height?: number;
404
+ __fileName?: string;
405
+ __fileSize?: number;
406
+ __fileMimeType?: string;
407
+ __displayType?: 'file' | 'thumbnail';
408
+ __contextId?: string;
409
+ __mediaTraceId?: string;
410
+ __external?: boolean;
489
411
  };
490
412
  }
491
- export type EmbedCardNode = PMNode & EmbedCardDefinition;
492
- export declare const embedCard: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<EmbedCardNode>) => import("prosemirror-model").NodeSpec;
413
+ export type MediaInlineNode = PMNode & MediaInlineDefinition;
414
+ export declare const mediaInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaInlineNode>) => import("prosemirror-model").NodeSpec;
415
+ export interface MediaSingleNodeAttributes0 {
416
+ width?: number;
417
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
418
+ widthType?: 'percentage';
419
+ }
420
+ export interface MediaSingleNodeAttributes1 {
421
+ width: number;
422
+ widthType: 'pixel';
423
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
424
+ }
425
+ export interface MediaSingleDefinition {
426
+ type: 'mediaSingle';
427
+ content: Array<MediaDefinition>;
428
+ marks: Array<LinkMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
429
+ attrs: MediaSingleNodeAttributes0 | MediaSingleNodeAttributes1;
430
+ }
431
+ export type MediaSingleNode = PMNode & MediaSingleDefinition;
432
+ export declare const mediaSingle: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaSingleNode>) => import("prosemirror-model").NodeSpec;
433
+ export interface MediaSingleCaptionNodeAttributes0 {
434
+ width?: number;
435
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
436
+ widthType?: 'percentage';
437
+ }
438
+ export interface MediaSingleCaptionNodeAttributes1 {
439
+ width: number;
440
+ widthType: 'pixel';
441
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
442
+ }
443
+ export interface MediaSingleCaptionDefinition {
444
+ type: 'mediaSingle';
445
+ content: Array<MediaDefinition | UnsupportedBlockDefinition | CaptionDefinition | UnsupportedBlockDefinition>;
446
+ marks: Array<LinkMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
447
+ attrs: MediaSingleCaptionNodeAttributes0 | MediaSingleCaptionNodeAttributes1;
448
+ }
449
+ export type MediaSingleCaptionNode = PMNode & MediaSingleCaptionDefinition;
450
+ export declare const mediaSingleCaption: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaSingleCaptionNode>) => import("prosemirror-model").NodeSpec;
451
+ export interface MediaSingleFullNodeAttributes0 {
452
+ width?: number;
453
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
454
+ widthType?: 'percentage';
455
+ }
456
+ export interface MediaSingleFullNodeAttributes1 {
457
+ width: number;
458
+ widthType: 'pixel';
459
+ layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
460
+ }
461
+ export interface MediaSingleFullDefinition {
462
+ type: 'mediaSingle';
463
+ content: Array<MediaDefinition>;
464
+ marks: Array<LinkMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
465
+ attrs: MediaSingleFullNodeAttributes0 | MediaSingleFullNodeAttributes1;
466
+ }
467
+ export type MediaSingleFullNode = PMNode & MediaSingleFullDefinition;
468
+ export declare const mediaSingleFull: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaSingleFullNode>) => import("prosemirror-model").NodeSpec;
469
+ export interface MentionDefinition {
470
+ type: 'mention';
471
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
472
+ attrs: {
473
+ id: string;
474
+ localId?: string;
475
+ text?: string;
476
+ accessLevel?: string;
477
+ userType?: 'DEFAULT' | 'SPECIAL' | 'APP';
478
+ };
479
+ }
480
+ export type MentionNode = PMNode & MentionDefinition;
481
+ export declare const mention: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MentionNode>) => import("prosemirror-model").NodeSpec;
482
+ export interface MultiBodiedExtensionDefinition {
483
+ type: 'multiBodiedExtension';
484
+ content: Array<ExtensionFrameDefinition>;
485
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
486
+ attrs: {
487
+ extensionKey: string;
488
+ extensionType: string;
489
+ parameters?: Record<string, unknown>;
490
+ text?: string;
491
+ layout?: 'default' | 'wide' | 'full-width';
492
+ localId?: string;
493
+ };
494
+ }
495
+ export type MultiBodiedExtensionNode = PMNode & MultiBodiedExtensionDefinition;
496
+ export declare const multiBodiedExtension: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MultiBodiedExtensionNode>) => import("prosemirror-model").NodeSpec;
493
497
  export interface NestedExpandWithNoMarksDefinition {
494
498
  type: 'nestedExpand';
495
499
  content: Array<CodeBlockWithNoMarksDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | UnsupportedBlockDefinition>;
@@ -501,199 +505,195 @@ export interface NestedExpandWithNoMarksDefinition {
501
505
  }
502
506
  export type NestedExpandWithNoMarksNode = PMNode & NestedExpandWithNoMarksDefinition;
503
507
  export declare const nestedExpandWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<NestedExpandWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
504
- export interface TableCellDefinition {
505
- type: 'tableCell';
506
- content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | ParagraphWithAlignmentDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | HeadingWithAlignmentDefinition | HeadingWithIndentationDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | NestedExpandWithNoMarksDefinition | UnsupportedBlockDefinition>;
508
+ export interface OrderedListDefinition {
509
+ type: 'orderedList';
510
+ content: Array<ListItemDefinition>;
507
511
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
508
512
  attrs: {
509
- colspan?: number;
510
- rowspan?: number;
511
- colwidth?: number[];
512
- background?: string;
513
+ order?: number;
513
514
  };
514
515
  }
515
- export type TableCellNode = PMNode & TableCellDefinition;
516
- export declare const tableCell: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableCellNode>) => import("prosemirror-model").NodeSpec;
517
- export interface TableHeaderDefinition {
518
- type: 'tableHeader';
519
- content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | ParagraphWithAlignmentDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | HeadingWithAlignmentDefinition | HeadingWithIndentationDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | NestedExpandWithNoMarksDefinition>;
516
+ export type OrderedListNode = PMNode & OrderedListDefinition;
517
+ export declare const orderedList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<OrderedListNode>) => import("prosemirror-model").NodeSpec;
518
+ export interface PanelDefinition {
519
+ type: 'panel';
520
+ content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | UnsupportedBlockDefinition>;
520
521
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
521
522
  attrs: {
522
- colspan?: number;
523
- rowspan?: number;
524
- colwidth?: number[];
525
- background?: string;
523
+ panelType: 'info' | 'note' | 'tip' | 'warning' | 'error' | 'success' | 'custom';
524
+ panelIcon?: string;
525
+ panelIconId?: string;
526
+ panelIconText?: string;
527
+ panelColor?: string;
526
528
  };
527
529
  }
528
- export type TableHeaderNode = PMNode & TableHeaderDefinition;
529
- export declare const tableHeader: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableHeaderNode>) => import("prosemirror-model").NodeSpec;
530
- export interface TableRowDefinition {
531
- type: 'tableRow';
532
- content: Array<TableCellDefinition | TableHeaderDefinition>;
530
+ export type PanelNode = PMNode & PanelDefinition;
531
+ export declare const panel: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<PanelNode>) => import("prosemirror-model").NodeSpec;
532
+ export interface ParagraphDefinition {
533
+ type: 'paragraph';
534
+ content: Array<InlineDefinition>;
533
535
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
534
- }
535
- export type TableRowNode = PMNode & TableRowDefinition;
536
- export declare const tableRow: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableRowNode>) => import("prosemirror-model").NodeSpec;
537
- export interface TableDefinition {
538
- type: 'table';
539
- content: Array<TableRowDefinition>;
540
- marks: Array<FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
541
536
  attrs: {
542
- displayMode?: 'default' | 'fixed';
543
- isNumberColumnEnabled?: boolean;
544
- layout?: 'wide' | 'full-width' | 'center' | 'align-end' | 'align-start' | 'default';
545
537
  localId?: string;
546
- width?: number;
547
- __autoSize?: boolean;
548
538
  };
549
539
  }
550
- export type TableNode = PMNode & TableDefinition;
551
- export declare const table: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableNode>) => import("prosemirror-model").NodeSpec;
552
- export interface ExpandWithNoMarkDefinition {
553
- type: 'expand';
554
- content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | TableDefinition | UnsupportedBlockDefinition>;
555
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
540
+ export type ParagraphNode = PMNode & ParagraphDefinition;
541
+ export declare const paragraph: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphNode>) => import("prosemirror-model").NodeSpec;
542
+ export interface ParagraphWithAlignmentDefinition {
543
+ type: 'paragraph';
544
+ content: Array<InlineDefinition>;
545
+ marks: Array<AlignmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
556
546
  attrs: {
557
- title?: string;
558
- __expanded?: boolean;
547
+ localId?: string;
559
548
  };
560
549
  }
561
- export type ExpandWithNoMarkNode = PMNode & ExpandWithNoMarkDefinition;
562
- export declare const expandWithNoMark: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExpandWithNoMarkNode>) => import("prosemirror-model").NodeSpec;
563
- export interface BodiedExtensionWithMarksDefinition {
564
- type: 'bodiedExtension';
565
- content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | TableDefinition | UnsupportedBlockDefinition>;
566
- marks: Array<DataConsumerMark | FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
550
+ export type ParagraphWithAlignmentNode = PMNode & ParagraphWithAlignmentDefinition;
551
+ export declare const paragraphWithAlignment: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphWithAlignmentNode>) => import("prosemirror-model").NodeSpec;
552
+ export interface ParagraphWithMarksDefinition {
553
+ type: 'paragraph';
554
+ content: Array<InlineDefinition>;
555
+ marks: Array<AlignmentMark | IndentationMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
567
556
  attrs: {
568
- extensionKey: string;
569
- extensionType: string;
570
- parameters?: Record<string, unknown>;
571
- text?: string;
572
- layout?: 'wide' | 'full-width' | 'default';
573
557
  localId?: string;
574
558
  };
575
559
  }
576
- export type BodiedExtensionWithMarksNode = PMNode & BodiedExtensionWithMarksDefinition;
577
- export declare const bodiedExtensionWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BodiedExtensionWithMarksNode>) => import("prosemirror-model").NodeSpec;
578
- export interface ConfluenceUnsupportedBlockDefinition {
579
- type: 'confluenceUnsupportedBlock';
560
+ export type ParagraphWithMarksNode = PMNode & ParagraphWithMarksDefinition;
561
+ export declare const paragraphWithMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphWithMarksNode>) => import("prosemirror-model").NodeSpec;
562
+ export interface ParagraphWithNoMarksDefinition {
563
+ type: 'paragraph';
564
+ content: Array<InlineDefinition>;
565
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
580
566
  attrs: {
581
- cxhtml: string;
567
+ localId?: string;
582
568
  };
583
569
  }
584
- export type ConfluenceUnsupportedBlockNode = PMNode & ConfluenceUnsupportedBlockDefinition;
585
- export declare const confluenceUnsupportedBlock: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ConfluenceUnsupportedBlockNode>) => import("prosemirror-model").NodeSpec;
586
- export interface LayoutColumnDefinition {
587
- type: 'layoutColumn';
588
- content: Array<BlockDefinition | UnsupportedBlockDefinition>;
570
+ export type ParagraphWithNoMarksNode = PMNode & ParagraphWithNoMarksDefinition;
571
+ export declare const paragraphWithNoMarks: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ParagraphWithNoMarksNode>) => import("prosemirror-model").NodeSpec;
572
+ export interface PlaceholderDefinition {
573
+ type: 'placeholder';
589
574
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
590
575
  attrs: {
591
- width: number;
576
+ text: string;
592
577
  };
593
578
  }
594
- export type LayoutColumnNode = PMNode & LayoutColumnDefinition;
595
- export declare const layoutColumn: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<LayoutColumnNode>) => import("prosemirror-model").NodeSpec;
596
- export interface LayoutSectionDefinition {
597
- type: 'layoutSection';
598
- content: Array<LayoutColumnDefinition | UnsupportedBlockDefinition>;
599
- marks: Array<BreakoutMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
579
+ export type PlaceholderNode = PMNode & PlaceholderDefinition;
580
+ export declare const placeholder: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<PlaceholderNode>) => import("prosemirror-model").NodeSpec;
581
+ export interface RuleDefinition {
582
+ type: 'rule';
600
583
  }
601
- export type LayoutSectionNode = PMNode & LayoutSectionDefinition;
602
- export declare const layoutSection: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<LayoutSectionNode>) => import("prosemirror-model").NodeSpec;
603
- export interface BodiedExtensionDefinition {
604
- type: 'bodiedExtension';
605
- content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | TableDefinition | UnsupportedBlockDefinition>;
584
+ export type RuleNode = PMNode & RuleDefinition;
585
+ export declare const rule: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<RuleNode>) => import("prosemirror-model").NodeSpec;
586
+ export interface StatusDefinition {
587
+ type: 'status';
606
588
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
607
589
  attrs: {
608
- extensionKey: string;
609
- extensionType: string;
610
- parameters?: Record<string, unknown>;
611
- text?: string;
612
- layout?: 'wide' | 'full-width' | 'default';
590
+ text: string;
591
+ color: 'neutral' | 'purple' | 'blue' | 'red' | 'yellow' | 'green';
613
592
  localId?: string;
593
+ style?: string;
614
594
  };
615
595
  }
616
- export type BodiedExtensionNode = PMNode & BodiedExtensionDefinition;
617
- export declare const bodiedExtension: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<BodiedExtensionNode>) => import("prosemirror-model").NodeSpec;
618
- export interface HeadingDefinition {
619
- type: 'heading';
620
- content: Array<InlineDefinition>;
621
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
596
+ export type StatusNode = PMNode & StatusDefinition;
597
+ export declare const status: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<StatusNode>) => import("prosemirror-model").NodeSpec;
598
+ export interface TableDefinition {
599
+ type: 'table';
600
+ content: Array<TableRowDefinition>;
601
+ marks: Array<FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
622
602
  attrs: {
623
- level: number;
603
+ displayMode?: 'default' | 'fixed';
604
+ isNumberColumnEnabled?: boolean;
605
+ layout?: 'wide' | 'full-width' | 'center' | 'align-end' | 'align-start' | 'default';
624
606
  localId?: string;
607
+ width?: number;
608
+ __autoSize?: boolean;
625
609
  };
626
610
  }
627
- export type HeadingNode = PMNode & HeadingDefinition;
628
- export declare const heading: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<HeadingNode>) => import("prosemirror-model").NodeSpec;
629
- export interface CodeBlockDefinition {
630
- type: 'codeBlock';
631
- content: Array<TextDefinition | UnsupportedInlineDefinition>;
611
+ export type TableNode = PMNode & TableDefinition;
612
+ export declare const table: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableNode>) => import("prosemirror-model").NodeSpec;
613
+ export interface TableCellDefinition {
614
+ type: 'tableCell';
615
+ content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | ParagraphWithAlignmentDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | HeadingWithAlignmentDefinition | HeadingWithIndentationDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | NestedExpandWithNoMarksDefinition | UnsupportedBlockDefinition>;
632
616
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
633
617
  attrs: {
634
- language?: string;
635
- uniqueId?: string;
618
+ colspan?: number;
619
+ rowspan?: number;
620
+ colwidth?: number[];
621
+ background?: string;
636
622
  };
637
623
  }
638
- export type CodeBlockNode = PMNode & CodeBlockDefinition;
639
- export declare const codeBlock: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<CodeBlockNode>) => import("prosemirror-model").NodeSpec;
640
- export interface MediaSingleNodeAttributes0 {
641
- width?: number;
642
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
643
- widthType?: 'percentage';
624
+ export type TableCellNode = PMNode & TableCellDefinition;
625
+ export declare const tableCell: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableCellNode>) => import("prosemirror-model").NodeSpec;
626
+ export interface TableHeaderDefinition {
627
+ type: 'tableHeader';
628
+ content: Array<CodeBlockWithNoMarksDefinition | BlockCardDefinition | ParagraphWithNoMarksDefinition | ParagraphWithAlignmentDefinition | MediaSingleCaptionDefinition | MediaSingleFullDefinition | TaskListDefinition | BulletListDefinition | OrderedListDefinition | HeadingWithNoMarksDefinition | HeadingWithAlignmentDefinition | HeadingWithIndentationDefinition | MediaGroupDefinition | DecisionListDefinition | RuleDefinition | PanelDefinition | BlockquoteDefinition | ExtensionWithMarksDefinition | EmbedCardDefinition | NestedExpandWithNoMarksDefinition>;
629
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
630
+ attrs: {
631
+ colspan?: number;
632
+ rowspan?: number;
633
+ colwidth?: number[];
634
+ background?: string;
635
+ };
644
636
  }
645
- export interface MediaSingleNodeAttributes1 {
646
- width: number;
647
- widthType: 'pixel';
648
- layout: 'wide' | 'full-width' | 'center' | 'wrap-right' | 'wrap-left' | 'align-end' | 'align-start';
637
+ export type TableHeaderNode = PMNode & TableHeaderDefinition;
638
+ export declare const tableHeader: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableHeaderNode>) => import("prosemirror-model").NodeSpec;
639
+ export interface TableRowDefinition {
640
+ type: 'tableRow';
641
+ content: Array<TableCellDefinition | TableHeaderDefinition>;
642
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
649
643
  }
650
- export interface MediaSingleDefinition {
651
- type: 'mediaSingle';
652
- content: Array<MediaDefinition>;
653
- marks: Array<LinkMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
654
- attrs: MediaSingleNodeAttributes0 | MediaSingleNodeAttributes1;
644
+ export type TableRowNode = PMNode & TableRowDefinition;
645
+ export declare const tableRow: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TableRowNode>) => import("prosemirror-model").NodeSpec;
646
+ export interface TaskItemDefinition {
647
+ type: 'taskItem';
648
+ content: Array<InlineDefinition>;
649
+ marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
650
+ attrs: {
651
+ localId: string;
652
+ state: 'TODO' | 'DONE';
653
+ };
655
654
  }
656
- export type MediaSingleNode = PMNode & MediaSingleDefinition;
657
- export declare const mediaSingle: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MediaSingleNode>) => import("prosemirror-model").NodeSpec;
658
- export interface ExtensionDefinition {
659
- type: 'extension';
655
+ export type TaskItemNode = PMNode & TaskItemDefinition;
656
+ export declare const taskItem: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TaskItemNode>) => import("prosemirror-model").NodeSpec;
657
+ export interface TaskListDefinition {
658
+ type: 'taskList';
659
+ content: Array<TaskItemDefinition | UnsupportedBlockDefinition | TaskItemDefinition | TaskListDefinition | UnsupportedBlockDefinition>;
660
660
  marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
661
661
  attrs: {
662
- extensionKey: string;
663
- extensionType: string;
664
- parameters?: Record<string, unknown>;
665
- text?: string;
666
- layout?: 'wide' | 'full-width' | 'default';
667
- localId?: string;
662
+ localId: string;
668
663
  };
669
664
  }
670
- export type ExtensionNode = PMNode & ExtensionDefinition;
671
- export declare const extension: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExtensionNode>) => import("prosemirror-model").NodeSpec;
672
- export interface ExtensionFrameDefinition {
673
- type: 'extensionFrame';
674
- content: Array<BodiedExtensionDefinition | PanelDefinition | ParagraphDefinition | BlockquoteDefinition | OrderedListDefinition | BulletListDefinition | RuleDefinition | HeadingDefinition | CodeBlockDefinition | MediaGroupDefinition | MediaSingleDefinition | DecisionListDefinition | TaskListDefinition | TableDefinition | ExtensionDefinition | BlockCardDefinition | EmbedCardDefinition | UnsupportedBlockDefinition>;
675
- marks: Array<DataConsumerMark | FragmentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
665
+ export type TaskListNode = PMNode & TaskListDefinition;
666
+ export declare const taskList: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TaskListNode>) => import("prosemirror-model").NodeSpec;
667
+ export interface TextDefinition {
668
+ type: 'text';
676
669
  }
677
- export type ExtensionFrameNode = PMNode & ExtensionFrameDefinition;
678
- export declare const extensionFrame: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<ExtensionFrameNode>) => import("prosemirror-model").NodeSpec;
679
- export interface MultiBodiedExtensionDefinition {
680
- type: 'multiBodiedExtension';
681
- content: Array<ExtensionFrameDefinition>;
682
- marks: Array<UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
670
+ export type TextNode = PMNode & TextDefinition;
671
+ export declare const text: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TextNode>) => import("prosemirror-model").NodeSpec;
672
+ export interface TextCodeInlineDefinition {
673
+ type: 'text';
674
+ marks: Array<CodeMark | LinkMark | AnnotationMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
675
+ }
676
+ export type TextCodeInlineNode = PMNode & TextCodeInlineDefinition;
677
+ export declare const textCodeInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TextCodeInlineNode>) => import("prosemirror-model").NodeSpec;
678
+ export interface TextFormattedDefinition {
679
+ type: 'text';
680
+ marks: Array<LinkMark | EmMark | StrongMark | StrikeMark | SubsupMark | UnderlineMark | TextColorMark | AnnotationMark | BackgroundColorMark | TypeAheadQueryMark | ConfluenceInlineCommentMark | UnsupportedNodeAttributeMark | UnsupportedMarkMark>;
681
+ }
682
+ export type TextFormattedNode = PMNode & TextFormattedDefinition;
683
+ export declare const textFormatted: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<TextFormattedNode>) => import("prosemirror-model").NodeSpec;
684
+ export interface UnsupportedBlockDefinition {
685
+ type: 'unsupportedBlock';
683
686
  attrs: {
684
- extensionKey: string;
685
- extensionType: string;
686
- parameters?: Record<string, unknown>;
687
- text?: string;
688
- layout?: 'default' | 'wide' | 'full-width';
689
- localId?: string;
687
+ originalValue: Record<string, unknown>;
690
688
  };
691
689
  }
692
- export type MultiBodiedExtensionNode = PMNode & MultiBodiedExtensionDefinition;
693
- export declare const multiBodiedExtension: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<MultiBodiedExtensionNode>) => import("prosemirror-model").NodeSpec;
694
- export interface DocDefinition {
695
- type: 'doc';
696
- content: Array<BlockDefinition | LayoutSectionDefinition | BlockRootOnlyDefinition>;
690
+ export type UnsupportedBlockNode = PMNode & UnsupportedBlockDefinition;
691
+ export declare const unsupportedBlock: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<UnsupportedBlockNode>) => import("prosemirror-model").NodeSpec;
692
+ export interface UnsupportedInlineDefinition {
693
+ type: 'unsupportedInline';
694
+ attrs: {
695
+ originalValue: Record<string, unknown>;
696
+ };
697
697
  }
698
- export type DocNode = PMNode & DocDefinition;
699
- export declare const doc: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<DocNode>) => import("prosemirror-model").NodeSpec;
698
+ export type UnsupportedInlineNode = PMNode & UnsupportedInlineDefinition;
699
+ export declare const unsupportedInline: ({ parseDOM, toDOM }: import("@atlaskit/adf-schema-generator").NodeSpecOptions<UnsupportedInlineNode>) => import("prosemirror-model").NodeSpec;