css_ast/values/logical/
mod.rs

1// AUTO-GENERATED from w3c/csswg-drafts
2// Commit: https://github.com/w3c/csswg-drafts/commit/7e27ad7484307dfdbe9d0e18ad19d02859389688
3// Do not edit this file directly.
4#![allow(warnings)]
5//! https://drafts.csswg.org/css-logical-1/
6
7mod impls;
8use super::prelude::*;
9use impls::*;
10/// Represents the style value for `block-size` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#block-size).
11///
12/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
13///
14/// The grammar is defined as:
15///
16/// ```text,ignore
17/// <'width'>
18/// ```
19///
20/// https://drafts.csswg.org/css-logical-1/#block-size
21#[syntax(" <'width'> ")]
22#[derive(
23	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
24)]
25#[declaration_metadata(
26    initial = "auto",
27    applies_to = Unknown,
28    animation_type = ByComputedValue,
29    percentages = Unknown,
30    property_group = Logical,
31    computed_value_type = Unknown,
32    canonical_order = "per grammar",
33    logical_property_group = Size,
34    box_portion = Size,
35)]
36#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
37#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.block-size"))]
38#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
39#[derive(csskit_derives::NodeWithMetadata)]
40pub struct BlockSizeStyleValue;
41
42/// Represents the style value for `inline-size` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#inline-size).
43///
44/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
45///
46/// The grammar is defined as:
47///
48/// ```text,ignore
49/// <'width'>
50/// ```
51///
52/// https://drafts.csswg.org/css-logical-1/#inline-size
53#[syntax(" <'width'> ")]
54#[derive(
55	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
56)]
57#[declaration_metadata(
58    initial = "auto",
59    applies_to = Unknown,
60    animation_type = ByComputedValue,
61    percentages = Unknown,
62    property_group = Logical,
63    computed_value_type = Unknown,
64    canonical_order = "per grammar",
65    logical_property_group = Size,
66    box_portion = Size,
67)]
68#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
69#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.inline-size"))]
70#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
71#[derive(csskit_derives::NodeWithMetadata)]
72pub struct InlineSizeStyleValue;
73
74/// Represents the style value for `margin-block` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#margin-block).
75///
76/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
77///
78/// The grammar is defined as:
79///
80/// ```text,ignore
81/// <'margin-top'>{1,2}
82/// ```
83///
84/// https://drafts.csswg.org/css-logical-1/#margin-block
85#[syntax(" <'margin-top'>{1,2} ")]
86#[derive(
87	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
88)]
89#[declaration_metadata(
90    initial = "see individual properties",
91    inherits = Unknown,
92    applies_to = Unknown,
93    animation_type = Unknown,
94    percentages = Unknown,
95    longhands = MarginBlockEnd|MarginBlockStart,
96    property_group = Logical,
97    computed_value_type = Unknown,
98    canonical_order = "per grammar",
99    box_side = BlockStart|BlockEnd,
100    box_portion = Margin,
101)]
102#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
103#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.margin-block"))]
104#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
105#[derive(csskit_derives::NodeWithMetadata)]
106pub struct MarginBlockStyleValue;
107
108/// Represents the style value for `margin-block-end` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#margin-block-end).
109///
110/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
111///
112/// The grammar is defined as:
113///
114/// ```text,ignore
115/// <'margin-top'>
116/// ```
117///
118/// https://drafts.csswg.org/css-logical-1/#margin-block-end
119#[syntax(" <'margin-top'> ")]
120#[derive(
121	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
122)]
123#[declaration_metadata(
124    initial = "0",
125    applies_to = Unknown,
126    animation_type = ByComputedValue,
127    percentages = Unknown,
128    shorthand_group = MarginBlock,
129    property_group = Logical,
130    computed_value_type = Unknown,
131    canonical_order = "per grammar",
132    logical_property_group = Margin,
133    box_side = BlockEnd,
134    box_portion = Margin,
135)]
136#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
137#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.margin-block-end"))]
138#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
139#[derive(csskit_derives::NodeWithMetadata)]
140pub struct MarginBlockEndStyleValue;
141
142/// Represents the style value for `margin-block-start` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#margin-block-start).
143///
144/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
145///
146/// The grammar is defined as:
147///
148/// ```text,ignore
149/// <'margin-top'>
150/// ```
151///
152/// https://drafts.csswg.org/css-logical-1/#margin-block-start
153#[syntax(" <'margin-top'> ")]
154#[derive(
155	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
156)]
157#[declaration_metadata(
158    initial = "0",
159    applies_to = Unknown,
160    animation_type = ByComputedValue,
161    percentages = Unknown,
162    shorthand_group = MarginBlock,
163    property_group = Logical,
164    computed_value_type = Unknown,
165    canonical_order = "per grammar",
166    logical_property_group = Margin,
167    box_side = BlockStart,
168    box_portion = Margin,
169)]
170#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
171#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.margin-block-start"))]
172#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
173#[derive(csskit_derives::NodeWithMetadata)]
174pub struct MarginBlockStartStyleValue;
175
176/// Represents the style value for `margin-inline` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#margin-inline).
177///
178/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
179///
180/// The grammar is defined as:
181///
182/// ```text,ignore
183/// <'margin-top'>{1,2}
184/// ```
185///
186/// https://drafts.csswg.org/css-logical-1/#margin-inline
187#[syntax(" <'margin-top'>{1,2} ")]
188#[derive(
189	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
190)]
191#[declaration_metadata(
192    initial = "see individual properties",
193    inherits = Unknown,
194    applies_to = Unknown,
195    animation_type = Unknown,
196    percentages = Unknown,
197    longhands = MarginInlineEnd|MarginInlineStart,
198    property_group = Logical,
199    computed_value_type = Unknown,
200    canonical_order = "per grammar",
201    box_side = InlineStart|InlineEnd,
202    box_portion = Margin,
203)]
204#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
205#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.margin-inline"))]
206#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
207#[derive(csskit_derives::NodeWithMetadata)]
208pub struct MarginInlineStyleValue;
209
210/// Represents the style value for `margin-inline-end` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#margin-inline-end).
211///
212/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
213///
214/// The grammar is defined as:
215///
216/// ```text,ignore
217/// <'margin-top'>
218/// ```
219///
220/// https://drafts.csswg.org/css-logical-1/#margin-inline-end
221#[syntax(" <'margin-top'> ")]
222#[derive(
223	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
224)]
225#[declaration_metadata(
226    initial = "0",
227    applies_to = Unknown,
228    animation_type = ByComputedValue,
229    percentages = Unknown,
230    shorthand_group = MarginInline,
231    property_group = Logical,
232    computed_value_type = Unknown,
233    canonical_order = "per grammar",
234    logical_property_group = Margin,
235    box_side = InlineEnd,
236    box_portion = Margin,
237)]
238#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
239#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.margin-inline-end"))]
240#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
241#[derive(csskit_derives::NodeWithMetadata)]
242pub struct MarginInlineEndStyleValue;
243
244/// Represents the style value for `margin-inline-start` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#margin-inline-start).
245///
246/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
247///
248/// The grammar is defined as:
249///
250/// ```text,ignore
251/// <'margin-top'>
252/// ```
253///
254/// https://drafts.csswg.org/css-logical-1/#margin-inline-start
255#[syntax(" <'margin-top'> ")]
256#[derive(
257	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
258)]
259#[declaration_metadata(
260    initial = "0",
261    applies_to = Unknown,
262    animation_type = ByComputedValue,
263    percentages = Unknown,
264    shorthand_group = MarginInline,
265    property_group = Logical,
266    computed_value_type = Unknown,
267    canonical_order = "per grammar",
268    logical_property_group = Margin,
269    box_side = InlineStart,
270    box_portion = Margin,
271)]
272#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
273#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.margin-inline-start"))]
274#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
275#[derive(csskit_derives::NodeWithMetadata)]
276pub struct MarginInlineStartStyleValue;
277
278/// Represents the style value for `max-block-size` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#max-block-size).
279///
280/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
281///
282/// The grammar is defined as:
283///
284/// ```text,ignore
285/// <'max-width'>
286/// ```
287///
288/// https://drafts.csswg.org/css-logical-1/#max-block-size
289#[syntax(" <'max-width'> ")]
290#[derive(
291	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
292)]
293#[declaration_metadata(
294    initial = "none",
295    applies_to = Unknown,
296    animation_type = ByComputedValue,
297    percentages = Unknown,
298    property_group = Logical,
299    computed_value_type = Unknown,
300    canonical_order = "per grammar",
301    logical_property_group = MaxSize,
302    box_side = BlockStart|BlockEnd,
303    box_portion = Size,
304)]
305#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
306#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.max-block-size"))]
307#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
308#[derive(csskit_derives::NodeWithMetadata)]
309pub struct MaxBlockSizeStyleValue;
310
311/// Represents the style value for `max-inline-size` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#max-inline-size).
312///
313/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
314///
315/// The grammar is defined as:
316///
317/// ```text,ignore
318/// <'max-width'>
319/// ```
320///
321/// https://drafts.csswg.org/css-logical-1/#max-inline-size
322#[syntax(" <'max-width'> ")]
323#[derive(
324	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
325)]
326#[declaration_metadata(
327    initial = "none",
328    applies_to = Unknown,
329    animation_type = ByComputedValue,
330    percentages = Unknown,
331    property_group = Logical,
332    computed_value_type = Unknown,
333    canonical_order = "per grammar",
334    logical_property_group = MaxSize,
335    box_side = InlineStart|InlineEnd,
336    box_portion = Size,
337)]
338#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
339#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.max-inline-size"))]
340#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
341#[derive(csskit_derives::NodeWithMetadata)]
342pub struct MaxInlineSizeStyleValue;
343
344/// Represents the style value for `min-block-size` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#min-block-size).
345///
346/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
347///
348/// The grammar is defined as:
349///
350/// ```text,ignore
351/// <'min-width'>
352/// ```
353///
354/// https://drafts.csswg.org/css-logical-1/#min-block-size
355#[syntax(" <'min-width'> ")]
356#[derive(
357	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
358)]
359#[declaration_metadata(
360    initial = "0",
361    applies_to = Unknown,
362    animation_type = ByComputedValue,
363    percentages = Unknown,
364    property_group = Logical,
365    computed_value_type = Unknown,
366    canonical_order = "per grammar",
367    logical_property_group = MinSize,
368    box_side = BlockStart|BlockEnd,
369    box_portion = Size,
370)]
371#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
372#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.min-block-size"))]
373#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
374#[derive(csskit_derives::NodeWithMetadata)]
375pub struct MinBlockSizeStyleValue;
376
377/// Represents the style value for `min-inline-size` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#min-inline-size).
378///
379/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
380///
381/// The grammar is defined as:
382///
383/// ```text,ignore
384/// <'min-width'>
385/// ```
386///
387/// https://drafts.csswg.org/css-logical-1/#min-inline-size
388#[syntax(" <'min-width'> ")]
389#[derive(
390	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
391)]
392#[declaration_metadata(
393    initial = "0",
394    applies_to = Unknown,
395    animation_type = ByComputedValue,
396    percentages = Unknown,
397    property_group = Logical,
398    computed_value_type = Unknown,
399    canonical_order = "per grammar",
400    logical_property_group = MinSize,
401    box_side = InlineStart|InlineEnd,
402    box_portion = Size,
403)]
404#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
405#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.min-inline-size"))]
406#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
407#[derive(csskit_derives::NodeWithMetadata)]
408pub struct MinInlineSizeStyleValue;
409
410/// Represents the style value for `padding-block` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#padding-block).
411///
412/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
413///
414/// The grammar is defined as:
415///
416/// ```text,ignore
417/// <'padding-top'>{1,2}
418/// ```
419///
420/// https://drafts.csswg.org/css-logical-1/#padding-block
421#[syntax(" <'padding-top'>{1,2} ")]
422#[derive(
423	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
424)]
425#[declaration_metadata(
426    initial = "see individual properties",
427    inherits = Unknown,
428    applies_to = Unknown,
429    animation_type = Unknown,
430    percentages = Unknown,
431    longhands = PaddingBlockEnd|PaddingBlockStart,
432    property_group = Logical,
433    computed_value_type = Unknown,
434    canonical_order = "per grammar",
435    box_side = BlockStart|BlockEnd,
436    box_portion = Padding,
437)]
438#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
439#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.padding-block"))]
440#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
441#[derive(csskit_derives::NodeWithMetadata)]
442pub struct PaddingBlockStyleValue;
443
444/// Represents the style value for `padding-block-end` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#padding-block-end).
445///
446/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
447///
448/// The grammar is defined as:
449///
450/// ```text,ignore
451/// <'padding-top'>
452/// ```
453///
454/// https://drafts.csswg.org/css-logical-1/#padding-block-end
455#[syntax(" <'padding-top'> ")]
456#[derive(
457	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
458)]
459#[declaration_metadata(
460    initial = "0",
461    applies_to = Unknown,
462    animation_type = ByComputedValue,
463    percentages = Unknown,
464    shorthand_group = PaddingBlock,
465    property_group = Logical,
466    computed_value_type = Unknown,
467    canonical_order = "per grammar",
468    logical_property_group = Padding,
469    box_side = BlockEnd,
470    box_portion = Padding,
471)]
472#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
473#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.padding-block-end"))]
474#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
475#[derive(csskit_derives::NodeWithMetadata)]
476pub struct PaddingBlockEndStyleValue;
477
478/// Represents the style value for `padding-block-start` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#padding-block-start).
479///
480/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
481///
482/// The grammar is defined as:
483///
484/// ```text,ignore
485/// <'padding-top'>
486/// ```
487///
488/// https://drafts.csswg.org/css-logical-1/#padding-block-start
489#[syntax(" <'padding-top'> ")]
490#[derive(
491	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
492)]
493#[declaration_metadata(
494    initial = "0",
495    applies_to = Unknown,
496    animation_type = ByComputedValue,
497    percentages = Unknown,
498    shorthand_group = PaddingBlock,
499    property_group = Logical,
500    computed_value_type = Unknown,
501    canonical_order = "per grammar",
502    logical_property_group = Padding,
503    box_side = BlockStart,
504    box_portion = Padding,
505)]
506#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
507#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.padding-block-start"))]
508#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
509#[derive(csskit_derives::NodeWithMetadata)]
510pub struct PaddingBlockStartStyleValue;
511
512/// Represents the style value for `padding-inline` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#padding-inline).
513///
514/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
515///
516/// The grammar is defined as:
517///
518/// ```text,ignore
519/// <'padding-top'>{1,2}
520/// ```
521///
522/// https://drafts.csswg.org/css-logical-1/#padding-inline
523#[syntax(" <'padding-top'>{1,2} ")]
524#[derive(
525	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
526)]
527#[declaration_metadata(
528    initial = "see individual properties",
529    inherits = Unknown,
530    applies_to = Unknown,
531    animation_type = Unknown,
532    percentages = Unknown,
533    longhands = PaddingInlineEnd|PaddingInlineStart,
534    property_group = Logical,
535    computed_value_type = Unknown,
536    canonical_order = "per grammar",
537    box_side = InlineStart|InlineEnd,
538    box_portion = Padding,
539)]
540#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
541#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.padding-inline"))]
542#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
543#[derive(csskit_derives::NodeWithMetadata)]
544pub struct PaddingInlineStyleValue;
545
546/// Represents the style value for `padding-inline-end` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#padding-inline-end).
547///
548/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
549///
550/// The grammar is defined as:
551///
552/// ```text,ignore
553/// <'padding-top'>
554/// ```
555///
556/// https://drafts.csswg.org/css-logical-1/#padding-inline-end
557#[syntax(" <'padding-top'> ")]
558#[derive(
559	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
560)]
561#[declaration_metadata(
562    initial = "0",
563    applies_to = Unknown,
564    animation_type = ByComputedValue,
565    percentages = Unknown,
566    shorthand_group = PaddingInline,
567    property_group = Logical,
568    computed_value_type = Unknown,
569    canonical_order = "per grammar",
570    logical_property_group = Padding,
571    box_side = InlineEnd,
572    box_portion = Padding,
573)]
574#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
575#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.padding-inline-end"))]
576#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
577#[derive(csskit_derives::NodeWithMetadata)]
578pub struct PaddingInlineEndStyleValue;
579
580/// Represents the style value for `padding-inline-start` as defined in [css-logical-1](https://drafts.csswg.org/css-logical-1/#padding-inline-start).
581///
582/// CSS logical properties control borders, size, margin, and padding with directions and dimensions relative to the writing mode. For example, in a left to right, top to bottom writing mode, block-end refers to the bottom. Also known as flow relative.
583///
584/// The grammar is defined as:
585///
586/// ```text,ignore
587/// <'padding-top'>
588/// ```
589///
590/// https://drafts.csswg.org/css-logical-1/#padding-inline-start
591#[syntax(" <'padding-top'> ")]
592#[derive(
593	Parse, Peek, ToSpan, ToCursors, DeclarationMetadata, SemanticEq, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash,
594)]
595#[declaration_metadata(
596    initial = "0",
597    applies_to = Unknown,
598    animation_type = ByComputedValue,
599    percentages = Unknown,
600    shorthand_group = PaddingInline,
601    property_group = Logical,
602    computed_value_type = Unknown,
603    canonical_order = "per grammar",
604    logical_property_group = Padding,
605    box_side = InlineStart,
606    box_portion = Padding,
607)]
608#[cfg_attr(feature = "serde", derive(serde::Serialize), serde())]
609#[cfg_attr(feature = "css_feature_data", derive(ToCSSFeature), css_feature("css.properties.padding-inline-start"))]
610#[cfg_attr(feature = "visitable", derive(Visitable), visit)]
611#[derive(csskit_derives::NodeWithMetadata)]
612pub struct PaddingInlineStartStyleValue;