• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16/// <reference path='./import.ts' />
17
18class ArkBorderStyle {
19  type: boolean | undefined;
20  style: BorderStyle | undefined;
21  top: BorderStyle | undefined;
22  right: BorderStyle | undefined;
23  bottom: BorderStyle | undefined;
24  left: BorderStyle | undefined;
25
26  constructor() {
27    this.type = undefined;
28    this.style = undefined;
29    this.top = undefined;
30    this.right = undefined;
31    this.bottom = undefined;
32    this.left = undefined;
33  }
34  isEqual(another: ArkBorderStyle): boolean {
35    return (
36      this.type === another.type &&
37      this.style === another.style &&
38      this.top === another.top &&
39      this.right === another.right &&
40      this.bottom === another.bottom &&
41      this.left === another.left
42    );
43  }
44  parseBorderStyle(value: BorderStyle | EdgeStyles): boolean {
45    if (typeof value === 'number') {
46      this.style = value;
47      this.type = true;
48      return true;
49    } else if (typeof value === 'object') {
50      return this.parseEdgeStyles(value as EdgeStyles);
51    }
52    return false;
53  }
54  parseEdgeStyles(options: EdgeStyles): boolean {
55    this.top = options.top;
56    this.right = options.right;
57    this.bottom = options.bottom;
58    this.left = options.left;
59    this.type = true;
60    return true;
61  }
62}
63
64class ArkBorderColor {
65  startColor: LocalizedEdgeColors;
66  endColor: LocalizedEdgeColors;
67  leftColor: EdgeColors | ResourceColor;
68  rightColor: EdgeColors | ResourceColor;
69  topColor: EdgeColors | ResourceColor | LocalizedEdgeColors;
70  bottomColor: EdgeColors | ResourceColor | LocalizedEdgeColors;
71
72  constructor() {
73    this.startColor = undefined;
74    this.endColor = undefined;
75    this.leftColor = undefined;
76    this.rightColor = undefined;
77    this.topColor = undefined;
78    this.bottomColor = undefined;
79  }
80
81  isEqual(another: ArkBorderColor): boolean {
82    return (
83      this.startColor === another.startColor &&
84      this.endColor === another.endColor &&
85      this.leftColor === another.leftColor &&
86      this.rightColor === another.rightColor &&
87      this.topColor === another.topColor &&
88      this.bottomColor === another.bottomColor
89    );
90  }
91}
92
93class ArkBorderWidth {
94  left: EdgeWidths | Length;
95  right: EdgeWidths | Length;
96  top: EdgeWidths | Length | LocalizedEdgeWidths;
97  bottom: EdgeWidths | Length | LocalizedEdgeWidths;
98  start: LocalizedEdgeWidths;
99  end: LocalizedEdgeWidths;
100
101  constructor() {
102    this.left = undefined;
103    this.right = undefined;
104    this.top = undefined;
105    this.bottom = undefined;
106    this.start = undefined;
107    this.end = undefined;
108  }
109
110  isEqual(another: ArkBorderWidth): boolean {
111    return (
112      this.left === another.left &&
113      this.right === another.right &&
114      this.top === another.top &&
115      this.bottom === another.bottom &&
116      this.start === another.start &&
117      this.end === another.end
118    );
119  }
120}
121
122class ArkBorderRadius {
123  topLeft: BorderRadiuses | Length;
124  topRight: BorderRadiuses | Length;
125  bottomLeft: BorderRadiuses | Length;
126  bottomRight: BorderRadiuses | Length;
127  topStart: LocalizedBorderRadius;
128  topEnd: LocalizedBorderRadius;
129  bottomStart: LocalizedBorderRadius;
130  bottomEnd: LocalizedBorderRadius;
131
132  constructor() {
133    this.topLeft = undefined;
134    this.topRight = undefined;
135    this.bottomLeft = undefined;
136    this.bottomRight = undefined;
137    this.topStart = undefined;
138    this.topEnd = undefined;
139    this.bottomStart = undefined;
140    this.bottomEnd = undefined;
141  }
142
143  isEqual(another: ArkBorderRadius): boolean {
144    return (
145      (this.topLeft === another.topLeft &&
146        this.topRight === another.topRight &&
147        this.bottomLeft === another.bottomLeft &&
148        this.bottomRight === another.bottomRight) ||
149      (this.topStart === another.topStart &&
150        this.topEnd === another.topEnd &&
151        this.bottomStart === another.bottomStart &&
152        this.bottomEnd === another.bottomEnd)
153    );
154  }
155}
156
157class ArkLabelFont {
158  size: number | string | undefined | Resource;
159  weight: FontWeight | number | string | undefined;
160  family: string | undefined | Resource;
161  style: FontStyle | number | undefined;
162  constructor() {
163    this.size = undefined;
164    this.weight = undefined;
165    this.family = undefined;
166    this.style = undefined;
167  }
168
169  isEqual(another: ArkLabelFont): boolean {
170    return (
171      this.size === another.size &&
172      this.weight === another.weight &&
173      this.family === another.family &&
174      this.style === another.style
175    );
176  }
177}
178
179function deepCompareArrays(arr1: Array<any>, arr2: Array<any>): boolean {
180  return (
181    Array.isArray(arr1) &&
182    Array.isArray(arr2) &&
183    arr1.length === arr2.length &&
184    arr1.every((value, index) => {
185      if (Array.isArray(value) && Array.isArray(arr2[index])) {
186        return deepCompareArrays(value, arr2[index]);
187      } else {
188        return value === arr2[index];
189      }
190    })
191  );
192}
193
194class ArkLinearGradient {
195  angle: number | string | undefined;
196  direction: number | undefined;
197  colors: Array<any>;
198  repeating: boolean | undefined;
199
200  constructor(angle: number | string | undefined,
201    direction: number | undefined,
202    colors: Array<any>,
203    repeating: boolean | undefined) {
204    this.angle = angle;
205    this.direction = direction;
206    this.colors = colors;
207    this.repeating = repeating;
208  }
209
210  isEqual(another: ArkLinearGradient): boolean {
211    return (
212      this.angle === another.angle &&
213      this.direction === another.direction &&
214      deepCompareArrays(this.colors, another.colors) &&
215      this.repeating === another.repeating
216    );
217  }
218}
219
220class ArkSweepGradient {
221  center: Array<any>;
222  start: number | string | undefined;
223  end: number | string | undefined;
224  rotation: number | string | undefined;
225  colors: Array<any>;
226  repeating: boolean | undefined;
227
228  constructor(center: Array<any>,
229    start: number | string | undefined,
230    end: number | string | undefined,
231    rotation: number | string | undefined,
232    colors: Array<any>,
233    repeating: boolean | undefined) {
234    this.center = center;
235    this.start = start;
236    this.end = end;
237    this.rotation = rotation;
238    this.colors = colors;
239    this.repeating = repeating;
240  }
241
242  isEqual(another: ArkSweepGradient): boolean {
243    return (
244      deepCompareArrays(this.center, another.center) &&
245      this.start === another.start &&
246      this.end === another.end &&
247      this.rotation === another.rotation &&
248      deepCompareArrays(this.colors, another.colors) &&
249      this.repeating === another.repeating
250    );
251  }
252}
253
254class ArkForegroundBlurStyle {
255  blurStyle: number | undefined;
256  colorMode: number | undefined;
257  adaptiveColor: number | undefined;
258  scale: number | undefined;
259  blurOptions: BlurOptions | undefined;
260
261  constructor() {
262    this.blurStyle = undefined;
263    this.colorMode = undefined;
264    this.adaptiveColor = undefined;
265    this.scale = undefined;
266    this.blurOptions = undefined;
267  }
268
269  isEqual(another: ArkForegroundBlurStyle): boolean {
270    return (
271      this.blurStyle === another.blurStyle &&
272      this.colorMode === another.colorMode &&
273      this.adaptiveColor === another.adaptiveColor &&
274      this.scale === another.scale &&
275      this.blurOptions === another.blurOptions
276    );
277  }
278}
279
280class ArkLinearGradientBlur {
281  blurRadius: number | undefined;
282  fractionStops: FractionStop[] | undefined;
283  direction: number | undefined;
284
285  constructor() {
286    this.blurRadius = undefined;
287    this.fractionStops = undefined;
288    this.direction = undefined;
289  }
290
291  isEqual(another: ArkLinearGradientBlur): boolean {
292    return (
293      this.blurRadius === another.blurRadius &&
294      deepCompareArrays(this.fractionStops, another.fractionStops) &&
295      this.direction === another.direction
296    );
297  }
298}
299
300class ArkOverlay {
301  value: string | CustomBuilder | undefined;
302  align: number | undefined;
303  offsetX: number | undefined;
304  offsetY: number | undefined;
305  hasOptions: boolean | undefined;
306  hasOffset: boolean | undefined;
307
308  constructor() {
309    this.value = undefined;
310    this.align = undefined;
311    this.offsetX = undefined;
312    this.offsetY = undefined;
313    this.hasOptions = undefined;
314    this.hasOffset = undefined;
315  }
316
317  private splitOption(options?: { align?: Alignment; offset?: { x?: number; y?: number } }): boolean {
318    if (isUndefined(options)) {
319      return true;
320    }
321    this.hasOptions = true;
322    this.align = options.align;
323    if (isUndefined(options.offset)) {
324      return true;
325    }
326    this.hasOffset = true;
327    this.offsetX = options.offset.x;
328    this.offsetY = options.offset.y;
329    return true;
330  }
331
332  splitOverlayValue(value: string | CustomBuilder,
333    options?: { align?: Alignment; offset?: { x?: number; y?: number } }): boolean {
334    if (typeof value === 'string') {
335      this.value = value;
336      return this.splitOption(options);
337    }
338    return false;
339  }
340
341  private isEqual(another: ArkOverlay): boolean {
342    return ((this.value === another.value) && (this.align === another.align) &&
343      (this.offsetX === another.offsetX) && (this.offsetY === another.offsetY) &&
344      (this.hasOptions === another.hasOptions) && (this.hasOffset === another.hasOffset));
345  }
346
347  checkObjectDiff(another: ArkOverlay): boolean {
348    return !this.isEqual(another);
349  }
350}
351
352class ArkSharedTransition {
353  id: string | undefined;
354  options: sharedTransitionOptions | undefined;
355  constructor() {
356    this.id = undefined;
357    this.options = undefined;
358  }
359  isEqual(another: ArkSharedTransition): boolean {
360    return (this.id === another.id) && (this.options === another.options);
361  }
362}
363
364class ArkBindTipsOptions {
365  message: ResourceStr | StyledString | undefined;
366  options: TipsOptions | undefined;
367  constructor() {
368    this.message = undefined;
369    this.options = undefined;
370  }
371  isEqual(another: ArkBindTipsOptions): boolean {
372    return (this.options === another.options) && (this.options === another.options);
373  }
374}
375
376class ArkChainMode {
377  direction: Axis | undefined;
378  style: ChainStyle | undefined;
379  constructor() {
380    this.direction = undefined;
381    this.style = undefined;
382  }
383  isEqual(another: ArkChainMode): boolean {
384    return (this.direction === another.direction) && (this.style === another.style);
385  }
386}
387
388class ArkEdgeEffect {
389  value: EdgeEffect;
390  options?: EdgeEffectOptions | undefined;
391  constructor() {
392    this.value = undefined;
393    this.options = undefined;
394  }
395  isEqual(another: ArkEdgeEffect): boolean {
396    return (this.value === another.value) &&
397      (this.options === another.options);
398  }
399}
400
401class ArkFadingEdge {
402  value: boolean;
403  options?: FadingEdgeOptions | undefined;
404  constructor() {
405    this.value = undefined;
406    this.options = undefined;
407  }
408  isEqual(another: ArkFadingEdge): boolean {
409    return (this.value === another.value) &&
410      (this.options === another.options);
411  }
412}
413
414class ArkBlurOptions {
415  value: number;
416  options?: BlurOptions | undefined;
417  constructor() {
418    this.value = undefined;
419    this.options = undefined;
420  }
421}
422
423class InvertOptions {
424  high: number;
425  low: number;
426  threshold: number;
427  thresholdRange: number;
428  constructor() {
429    this.high = undefined;
430    this.low = undefined;
431    this.threshold = undefined;
432    this.thresholdRange = undefined;
433  }
434}
435
436class ArkMenuAlignType {
437  alignType: number | MenuAlignType;
438  dx: Length;
439  dy: Length;
440
441  constructor(alignType: MenuAlignType, offset?: Offset) {
442    this.alignType = alignType;
443    if (!isUndefined(offset) && isObject(offset)) {
444      this.dx = offset.dx;
445      this.dy = offset.dy;
446    }
447  }
448
449  isEqual(another: ArkMenuAlignType): boolean {
450    return this.alignType === another.alignType && this.dx === another.dx && this.dy === another.dy;
451  }
452}
453
454class ArkSliderTips {
455  showTip: boolean;
456  tipText: string | ResourceStr;
457
458  constructor(value: boolean, content?: string | ResourceStr) {
459    this.showTip = value;
460    this.tipText = content;
461  }
462
463  isEqual(another: ArkSliderTips): boolean {
464    return this.showTip === another.showTip && this.tipText === another.tipText;
465  }
466}
467
468class ArkStarStyle {
469  backgroundUri: string | undefined;
470  foregroundUri: string | undefined;
471  secondaryUri: string | undefined;
472
473  constructor() {
474    this.backgroundUri = undefined;
475    this.foregroundUri = undefined;
476    this.secondaryUri = undefined;
477  }
478
479  isEqual(another: ArkStarStyle): boolean {
480    return (
481      this.backgroundUri === another.backgroundUri &&
482      this.foregroundUri === another.foregroundUri &&
483      this.secondaryUri === another.secondaryUri
484    );
485  }
486}
487
488class ArkBackgroundBlurStyle {
489  blurStyle: number | undefined;
490  colorMode: number | undefined;
491  adaptiveColor: number | undefined;
492  scale: number | undefined;
493  blurOptions: BlurOptions | undefined;
494  policy?: number;
495  inactiveColor?: ResourceColor;
496  type?: number;
497
498  constructor() {
499    this.blurStyle = undefined;
500    this.colorMode = undefined;
501    this.adaptiveColor = undefined;
502    this.scale = undefined;
503    this.blurOptions = undefined;
504    this.policy = undefined;
505    this.inactiveColor = undefined;
506    this.type = undefined;
507  }
508
509  isEqual(another: ArkBackgroundBlurStyle): boolean {
510    return (
511      this.blurStyle === another.blurStyle &&
512      this.colorMode === another.colorMode &&
513      this.adaptiveColor === another.adaptiveColor &&
514      this.scale === another.scale &&
515      this.blurOptions === another.blurOptions &&
516      this.policy === another.policy &&
517      this.inactiveColor === another.inactiveColor &&
518      this.type === another.type
519    );
520  }
521}
522
523class ArkBorderDashGap {
524  left: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
525  right: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
526  top: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
527  bottom: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
528  start: LocalizedEdgeWidths;
529  end: LocalizedEdgeWidths;
530
531  constructor() {
532    this.left = undefined;
533    this.right = undefined;
534    this.top = undefined;
535    this.bottom = undefined;
536    this.start = undefined;
537    this.end = undefined;
538  }
539
540  isEqual(another: ArkBorderDashGap): boolean {
541    return (
542      this.left === another.left &&
543      this.right === another.right &&
544      this.top === another.top &&
545      this.bottom === another.bottom &&
546      this.start === another.start &&
547      this.end === another.end
548    );
549  }
550}
551
552class ArkBorderDashWidth {
553  left: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
554  right: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
555  top: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
556  bottom: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
557  start: LocalizedEdgeWidths;
558  end: LocalizedEdgeWidths;
559
560  constructor() {
561    this.left = undefined;
562    this.right = undefined;
563    this.top = undefined;
564    this.bottom = undefined;
565    this.start = undefined;
566    this.end = undefined;
567  }
568
569  isEqual(another: ArkBorderDashWidth): boolean {
570    return (
571      this.left === another.left &&
572      this.right === another.right &&
573      this.top === another.top &&
574      this.bottom === another.bottom &&
575      this.start === another.start &&
576      this.end === another.end
577    );
578  }
579}
580
581class ArkBorder {
582  arkWidth: ArkBorderWidth;
583  arkColor: ArkBorderColor;
584  arkRadius: ArkBorderRadius;
585  arkStyle: ArkBorderStyle;
586  arkDashGap: ArkBorderDashGap;
587  arkDashWidth: ArkBorderDashWidth;
588
589  constructor() {
590    this.arkWidth = new ArkBorderWidth();
591    this.arkColor = new ArkBorderColor();
592    this.arkRadius = new ArkBorderRadius();
593    this.arkStyle = new ArkBorderStyle();
594    this.arkDashGap = new ArkBorderDashGap();
595    this.arkDashWidth = new ArkBorderDashWidth();
596  }
597  isEqual(another: ArkBorder): boolean {
598    return (
599      this.arkWidth.isEqual(another.arkWidth) &&
600      this.arkColor.isEqual(another.arkColor) &&
601      this.arkRadius.isEqual(another.arkRadius) &&
602      this.arkStyle.isEqual(another.arkStyle) &&
603      this.arkDashGap.isEqual(another.arkDashGap) &&
604      this.arkDashWidth.isEqual(another.arkDashWidth)
605    );
606  }
607
608  checkObjectDiff(another: ArkBorder): boolean {
609    return !this.isEqual(another);
610  }
611}
612
613class ArkBackgroundImageSize {
614  imageSize: ImageSize | undefined | SizeOptions;
615  width: number | string | undefined | Resource;
616  height: number | string | undefined | Resource;
617  constructor() {
618    this.imageSize = undefined;
619    this.width = undefined;
620    this.height = undefined;
621  }
622  isEqual(another: ArkBackgroundImageSize): boolean {
623    return this.imageSize === another.imageSize && this.width === another.width && this.height === another.height;
624  }
625}
626
627class ArkBackgroundImage {
628  src: string | undefined | Resource | PixelMap;
629  repeat: number | undefined | object;
630  constructor() {
631    this.src = undefined;
632    this.repeat = undefined;
633  }
634  isEqual(another: ArkBackgroundImage): boolean {
635    return this.src === another.src && this.repeat === another.repeat;
636  }
637}
638
639class ArkGridColColumnOption implements Equable {
640  xs?: number;
641  sm?: number;
642  md?: number;
643  lg?: number;
644  xl?: number;
645  xxl?: number;
646  constructor() {
647    this.xs = undefined;
648    this.sm = undefined;
649    this.md = undefined;
650    this.lg = undefined;
651    this.xl = undefined;
652    this.xxl = undefined;
653  }
654  isEqual(another: ArkGridColColumnOption): boolean {
655    return (this.xs === another.xs &&
656      this.sm === another.sm &&
657      this.md === another.md &&
658      this.lg === another.lg &&
659      this.xl === another.xl &&
660      this.xxl === another.xxl);
661  }
662}
663
664class ArkPadding {
665  top: Length | undefined;
666  right: Length | undefined;
667  bottom: Length | undefined;
668  left: Length | undefined;
669  constructor() {
670    this.top = undefined;
671    this.right = undefined;
672    this.bottom = undefined;
673    this.left = undefined;
674  }
675  isEqual(another: ArkPadding) {
676    return (
677      this.top === another.top &&
678      this.right === another.right &&
679      this.bottom === another.bottom &&
680      this.left === another.left
681    );
682  }
683}
684
685class ArkBarMode {
686  barMode: number;
687  options?: ScrollableBarModeOptions | undefined;
688
689  isEqual(another: ArkBarMode): boolean {
690    return (this.barMode === another.barMode) && (this.options === another.options);
691  }
692}
693
694class ArkDivider {
695  divider: DividerStyle;
696
697  isEqual(another: ArkDivider): boolean {
698    return (this.divider === another.divider);
699  }
700}
701
702class ArkBarGridAlign {
703  barGridAlign: BarGridColumnOptions;
704
705  isEqual(another: ArkBarGridAlign): boolean {
706    return (this.barGridAlign === another.barGridAlign);
707  }
708}
709
710
711class ArkScrollableBarModeOptions {
712  value: ScrollableBarModeOptions;
713
714  isEqual(another: ArkScrollableBarModeOptions): boolean {
715    return (this.value === another.value);
716  }
717}
718
719class ArkTabsCachedMaxCount {
720  count: number;
721  mode: TabsCacheMode;
722
723  isEqual(another: ArkTabsCachedMaxCount): boolean {
724    return (this.count === another.count && this.mode === another.mode);
725  }
726}
727
728class ArkAlignRules {
729  left: string | undefined;
730  middle: string | undefined;
731  right: string | undefined;
732  top: string | undefined;
733  center: string | undefined;
734  bottom: string | undefined;
735  constructor() {
736    this.left = undefined;
737    this.middle = undefined;
738    this.right = undefined;
739    this.top = undefined;
740    this.center = undefined;
741    this.bottom = undefined;
742  }
743  isEqual(another: ArkAlignRules) {
744    return (
745      this.left === another.left &&
746      this.middle === another.middle &&
747      this.right === another.right &&
748      this.top === another.top &&
749      this.center === another.center &&
750      this.bottom === another.bottom
751    );
752  }
753}
754
755class ArkSafeAreaExpandOpts {
756  type: string | number | undefined = undefined;
757  edges: string | number | undefined = undefined;
758  isEqual(another: ArkSafeAreaExpandOpts): boolean {
759    return (this.type === another.type) && (this.edges === another.edges);
760  }
761}
762
763class ArkButtonStyle {
764  left?: number;
765  top?: number;
766  width?: number;
767  height?: number;
768  icons?: {
769    shown?: string;
770    hidden?: string;
771    switching?: string;
772  };
773  constructor() {
774    this.left = 16;
775    this.top = 48;
776    this.width = 24;
777    this.height = 24;
778    this.icons = {
779      shown: undefined,
780      hidden: undefined,
781      switching: undefined
782    };
783  }
784  isEqual(another: ArkButtonStyle): boolean {
785    return (
786      this.left === another.left &&
787      this.top === another.top &&
788      this.width === another.width &&
789      this.height === another.height &&
790      this.icons === another.icons
791    );
792  }
793}
794
795class ArkShadowInfoToArray {
796  radius: (number | string)[];
797  type: ShadowType[];
798  color: (Color | string | Resource | ColoringStrategy)[];
799  offsetX: (number | string)[];
800  offsetY: (number | string)[];
801  fill: boolean[];
802  constructor() {
803    this.radius = [];
804    this.type = [];
805    this.color = [];
806    this.offsetX = [];
807    this.offsetX = [];
808    this.offsetY = [];
809    this.fill = [];
810  }
811  isEqual(another: ArkShadowInfoToArray): boolean {
812    return (this.radius === another.radius) &&
813      (this.color === another.color) &&
814      (this.offsetX === another.offsetX) &&
815      (this.offsetY === another.offsetY) &&
816      (this.fill === another.fill);
817  }
818
819  convertShadowOptions(value: ShadowOptions | Array<ShadowOptions>): boolean {
820    if (Object.getPrototypeOf(value).constructor === Object) {
821      if ((<ShadowOptions>value).radius === null || (<ShadowOptions>value).radius === undefined) {
822        return false;
823      } else {
824        this.radius.push(<number | string>(<ShadowOptions>value).radius);
825        this.type.push((<ShadowOptions>value).type);
826        this.color.push((<ShadowOptions>value).color);
827        this.offsetX.push(((<ShadowOptions>value).offsetX === undefined ||
828          (<ShadowOptions>value).offsetX === null) ? 0 : <number | string>(<ShadowOptions>value).offsetX);
829        this.offsetY.push(((<ShadowOptions>value).offsetY === undefined ||
830          (<ShadowOptions>value).offsetY === null) ? 0 : <number | string>(<ShadowOptions>value).offsetY);
831        this.fill.push(((<ShadowOptions>value).fill === undefined ||
832          (<ShadowOptions>value).fill === null) ? false : (<ShadowOptions>value).fill);
833        return true;
834      }
835    } else if (Object.getPrototypeOf(value).constructor === Array) {
836      let isFlag: boolean = true;
837      for (let item of (value as Array<ShadowOptions>)) {
838        if (item.radius === undefined || item.radius === null) {
839          isFlag = false;
840          break;
841        }
842      }
843      if (isFlag) {
844        for (let objValue of (value as Array<ShadowOptions>)) {
845          this.radius.push(<number | string>objValue.radius);
846          this.type.push(objValue.type);
847          this.color.push(objValue.color);
848          this.offsetX.push((objValue.offsetX === undefined || objValue.offsetX === null) ? 0 : <number | string>objValue.offsetX);
849          this.offsetY.push((objValue.offsetY === undefined || objValue.offsetY === null) ? 0 : <number | string>objValue.offsetY);
850          this.fill.push((objValue.fill === undefined || objValue.fill === null) ? false : objValue.fill);
851        }
852        return true;
853      } else {
854        return false;
855      }
856    }
857  }
858
859  checkDiff(value: ShadowOptions, stageValue: ShadowOptions): boolean {
860    if (!value || !stageValue || !value.radius || !stageValue.radius) {
861      return true;
862    }
863    if (!((isResource(stageValue.radius) && isResource(value.radius) &&
864      isResourceEqual(stageValue.radius, value.radius)) ||
865      (isNumber(stageValue.radius) && isNumber(value.radius) &&
866        stageValue.radius === value.radius))) {
867      return true;
868    }
869    if (!(isNumber(stageValue.type) && isNumber(value.type) &&
870      stageValue.type === value.type)) {
871      return true;
872    }
873    if (!((isResource(stageValue.color) && isResource(value.color) &&
874      isResourceEqual(stageValue.color, value.color)) ||
875      (!isResource(stageValue.color) && !isResource(value.color) &&
876        stageValue.color === value.color))) {
877      return true;
878    }
879    if (!((isResource(stageValue.offsetX) && isResource(value.offsetX) &&
880      isResourceEqual(stageValue.offsetX, value.offsetX)) ||
881      (isNumber(stageValue.offsetX) && isNumber(value.offsetX) &&
882        stageValue.offsetX === value.offsetX))) {
883      return true;
884    }
885    if (!((isResource(stageValue.offsetY) && isResource(value.offsetY) &&
886      isResourceEqual(stageValue.offsetY, value.offsetY)) ||
887      (isNumber(stageValue.offsetY) && isNumber(value.offsetY) &&
888        stageValue.offsetY === value.offsetY))) {
889      return true;
890    }
891    if (!(isBoolean(stageValue.fill) && isBoolean(value.fill) &&
892      stageValue.fill === value.fill)) {
893      return true;
894    }
895    return false;
896  }
897}
898
899class ArkSearchButton {
900  value: string | undefined;
901  fontSize: Length | undefined;
902  fontColor: ResourceColor | undefined;
903  autoDisable: boolean | undefined;
904  constructor() {
905    this.value = undefined;
906    this.fontSize = undefined;
907    this.fontColor = undefined;
908    this.autoDisable = undefined;
909  }
910  isEqual(another: ArkSearchButton): boolean {
911    return (this.value === another.value) &&
912      (this.fontSize === another.fontSize) &&
913      (this.fontColor === another.fontColor) &&
914      (this.autoDisable === another.autoDisable);
915  }
916}
917
918class ArkSearchInputFilter {
919  value: ResourceStr | undefined;
920  error?: (value: string) => void;
921  constructor() {
922    this.value = undefined;
923    this.error = undefined;
924  }
925  isEqual(another: ArkSearchInputFilter): boolean {
926    return (this.value === another.value);
927  }
928}
929class ArkImageFrameInfoToArray {
930  arrSrc: Array<string> | undefined;
931  arrWidth: Array<number | string> | undefined;
932  arrHeight: Array<number | string> | undefined;
933  arrTop: Array<number | string> | undefined;
934  arrLeft: Array<number | string> | undefined;
935  arrDuration: Array<number> | undefined;
936  constructor() {
937    this.arrSrc = [];
938    this.arrWidth = [];
939    this.arrHeight = [];
940    this.arrTop = [];
941    this.arrLeft = [];
942    this.arrDuration = [];
943  }
944  isEqual(another: ArkImageFrameInfoToArray): boolean {
945    return (this.arrSrc.toString() === another.arrSrc.toString()) &&
946      (this.arrWidth.toString() === another.arrWidth.toString()) &&
947      (this.arrHeight.toString() === another.arrHeight.toString()) &&
948      (this.arrTop.toString() === another.arrTop.toString()) &&
949      (this.arrLeft.toString() === another.arrLeft.toString()) &&
950      (this.arrDuration.toString() === another.arrDuration.toString());
951  }
952}
953
954class ArkEdgeAlign {
955  alignType: number;
956  offset?: Offset | undefined;
957
958  constructor() {
959    this.alignType = undefined;
960    this.offset = undefined;
961  }
962
963  isEqual(another: ArkEdgeAlign): boolean {
964    return (this.alignType === another.alignType && this.offset === another.offset);
965  }
966}
967
968class ArkKeyBoardShortCut {
969  value: string | number;
970  keys: Array<ModifierKey>;
971  action: () => void | undefined;
972
973  constructor() {
974    this.value = undefined;
975    this.keys = undefined;
976    this.action = undefined;
977  }
978
979  isEqual(another: ArkKeyBoardShortCut): boolean {
980    return (this.value === another.value) && (this.keys === another.keys) &&
981      (this.action === another.action);
982  }
983}
984
985class ArkCustomProperty {
986  key: string;
987  value: object;
988
989  constructor() {
990    this.key = undefined;
991    this.value = undefined;
992  }
993}
994
995class ArkUseEffect {
996  useEffect: boolean;
997  effectType: EffectType;
998  constructor() {
999    this.useEffect = undefined;
1000    this.effectType = undefined;
1001  }
1002  isEqual(another: ArkUseEffect): boolean {
1003    return (this.useEffect === another.useEffect) && (this.effectType === another.effectType);
1004  }
1005}
1006
1007class ArkBlendMode {
1008  blendMode: number | Blender;
1009  blendApplyType: number;
1010  constructor() {
1011    this.blendMode = undefined;
1012    this.blendApplyType = undefined;
1013  }
1014  isEqual(another: ArkBlendMode): boolean {
1015    return (this.blendMode === another.blendMode) && (this.blendApplyType === another.blendApplyType);
1016  }
1017}
1018
1019class ArkAlignStyle {
1020  indexerAlign: number;
1021  offset?: number | string | undefined | Resource;
1022
1023  constructor() {
1024    this.indexerAlign = undefined;
1025    this.offset = undefined;
1026  }
1027
1028  isEqual(another: ArkAlignStyle): boolean {
1029    return (this.indexerAlign === another.indexerAlign && this.offset === another.offset);
1030  }
1031}
1032
1033class ArkNestedScrollOptions {
1034  scrollForward: NestedScrollMode | undefined;
1035  scrollBackward: NestedScrollMode | undefined;
1036  constructor() {
1037    this.scrollForward = undefined;
1038    this.scrollBackward = undefined;
1039  }
1040  isEqual(another: ArkNestedScrollOptions): boolean {
1041    return ((this.scrollForward === another.scrollForward) && (this.scrollBackward === another.scrollBackward));
1042  }
1043}
1044
1045class ArkConstraintSizeOptions {
1046  minWidth?: Length | undefined;
1047  maxWidth?: Length | undefined;
1048  minHeight?: Length | undefined;
1049  maxHeight?: Length | undefined;
1050
1051  constructor() {
1052    this.minWidth = undefined;
1053    this.maxWidth = undefined;
1054    this.minHeight = undefined;
1055    this.maxHeight = undefined;
1056  }
1057
1058  isEqual(another: ArkConstraintSizeOptions): boolean {
1059    return (
1060      this.minWidth === another.minWidth &&
1061      this.maxWidth === another.maxWidth &&
1062      this.minHeight === another.minHeight &&
1063      this.maxHeight === another.maxHeight
1064    );
1065  }
1066}
1067
1068class ArkTextFieldShowCounter {
1069  value: boolean;
1070  highlightBorder?: boolean;
1071  thresholdPercentage?: number;
1072  constructor() {
1073    this.value = undefined;
1074    this.highlightBorder = undefined;
1075    this.thresholdPercentage = undefined;
1076  }
1077  isEqual(another: ArkTextFieldShowCounter): boolean {
1078    return (this.value === another.value) &&
1079      (this.highlightBorder === another.highlightBorder) &&
1080      (this.thresholdPercentage === another.thresholdPercentage);
1081  }
1082}
1083
1084class ArkTextInputFilter {
1085  value: ResourceStr | undefined;
1086  error?: (value: string) => void;
1087  constructor() {
1088    this.value = undefined;
1089    this.error = undefined;
1090  }
1091  isEqual(another: ArkSearchInputFilter): boolean {
1092    return (this.value === another.value);
1093  }
1094}
1095
1096class ArkDotIndicator extends DotIndicator {
1097  type: string | undefined;
1098  leftValue: Length | undefined;
1099  topValue: Length | undefined;
1100  rightValue: Length | undefined;
1101  bottomValue: Length | LengthMetrics | undefined;
1102  itemWidthValue: Length | undefined;
1103  itemHeightValue: Length | undefined;
1104  selectedItemWidthValue: Length | undefined;
1105  selectedItemHeightValue: Length | undefined;
1106  maskValue: boolean | undefined;
1107  colorValue: ResourceColor | undefined;
1108  selectedColorValue: ResourceColor | undefined;
1109  maxDisplayCountValue: ResourceColor | undefined;
1110  spaceValue: LengthMetrics | undefined;
1111  ignoreSizeValue: boolean | undefined;
1112  setIgnoreSizeValue : boolean;
1113
1114  constructor() {
1115    super();
1116    this.type = undefined;
1117    this.leftValue = undefined;
1118    this.topValue = undefined;
1119    this.rightValue = undefined;
1120    this.bottomValue = undefined;
1121    this.itemWidthValue = undefined;
1122    this.itemHeightValue = undefined;
1123    this.selectedItemWidthValue = undefined;
1124    this.selectedItemHeightValue = undefined;
1125    this.maskValue = undefined;
1126    this.colorValue = undefined;
1127    this.selectedColorValue = undefined;
1128    this.maxDisplayCountValue = undefined;
1129    this.spaceValue = undefined;
1130    this.ignoreSizeValue = undefined;
1131    this.setIgnoreSizeValue = undefined;
1132  }
1133
1134  isEqual(another: ArkDotIndicator): boolean {
1135    return (
1136      this.type === another.type &&
1137      this.leftValue === another.leftValue &&
1138      this.topValue === another.topValue &&
1139      this.rightValue === another.rightValue &&
1140      this.bottomValue === another.bottomValue &&
1141      this.itemWidthValue === another.itemWidthValue &&
1142      this.itemHeightValue === another.itemHeightValue &&
1143      this.selectedItemWidthValue === another.selectedItemWidthValue &&
1144      this.selectedItemHeightValue === another.selectedItemHeightValue &&
1145      this.maskValue === another.maskValue &&
1146      this.colorValue === another.colorValue &&
1147      this.selectedColorValue === another.selectedColorValue &&
1148      this.maxDisplayCountValue === another.maxDisplayCountValue &&
1149      this.spaceValue === another.spaceValue &&
1150      this.ignoreSizeValue === another.ignoreSizeValue &&
1151      this.setIgnoreSizeValue === another.setIgnoreSizeValue
1152    );
1153  }
1154}
1155
1156class ArkDigitIndicator extends DigitIndicator {
1157  type: string | undefined;
1158  leftValue: Length | undefined;
1159  topValue: Length | undefined;
1160  rightValue: Length | undefined;
1161  bottomValue: Length | LengthMetrics | undefined;
1162  fontColorValue: ResourceColor | undefined;
1163  selectedFontColorValue: ResourceColor | undefined;
1164  digitFontValue: ArkDigitFont | undefined;
1165  selectedDigitFontValue: ArkDigitFont | undefined;
1166  ignoreSizeValue: boolean | undefined;
1167  setIgnoreSizeValue : boolean;
1168
1169  constructor() {
1170    super();
1171    this.type = undefined;
1172    this.leftValue = undefined;
1173    this.topValue = undefined;
1174    this.rightValue = undefined;
1175    this.bottomValue = undefined;
1176    this.fontColorValue = undefined;
1177    this.selectedFontColorValue = undefined;
1178    this.digitFontValue = undefined;
1179    this.selectedDigitFontValue = undefined;
1180    this.ignoreSizeValue = undefined;
1181    this.setIgnoreSizeValue = undefined;
1182  }
1183
1184  isEqual(another: ArkDigitIndicator): boolean {
1185    return (
1186      this.type === another.type &&
1187      this.leftValue === another.leftValue &&
1188      this.topValue === another.topValue &&
1189      this.rightValue === another.rightValue &&
1190      this.bottomValue === another.bottomValue &&
1191      this.digitFontValue === another.digitFontValue &&
1192      this.selectedDigitFontValue === another.selectedDigitFontValue &&
1193      this.ignoreSizeValue === another.ignoreSizeValue &&
1194      this.setIgnoreSizeValue === another.setIgnoreSizeValue
1195    );
1196  }
1197}
1198
1199class ArkDigitFont {
1200  size: Length | undefined;
1201  weight: number | FontWeight | string | undefined;
1202
1203  constructor() {
1204    this.size = undefined;
1205    this.weight = undefined;
1206  }
1207
1208  isEqual(another: ArkDigitFont): boolean {
1209    return this.size === another.size && this.weight === another.weight;
1210  }
1211
1212  parseFontWeight(value: string | number | undefined) {
1213    const valueWeightMap = {
1214      [0]: 'lighter',
1215      [1]: 'normal',
1216      [2]: 'regular',
1217      [3]: 'medium',
1218      [4]: 'bold',
1219      [5]: 'bolder'
1220    };
1221    if (isUndefined(value)) {
1222      this.weight = '-';
1223    } else if (value in valueWeightMap) {
1224      this.weight = valueWeightMap[value];
1225    } else {
1226      this.weight = value.toString();
1227    }
1228    return this.weight;
1229  }
1230}
1231
1232class ArkDisplayArrow {
1233  value: boolean | ArrowStyle;
1234  isHoverShow: boolean | undefined;
1235
1236  constructor() {
1237    this.value = undefined;
1238    this.isHoverShow = undefined;
1239  }
1240
1241  isEqual(another: ArkDisplayArrow): boolean {
1242    return this.value === another.value && this.isHoverShow === another.isHoverShow;
1243  }
1244}
1245
1246class ArkDisplayCount {
1247  value: string | number | SwiperAutoFill;
1248  swipeByGroup: boolean | undefined;
1249
1250  constructor() {
1251    this.value = undefined;
1252    this.swipeByGroup = undefined;
1253  }
1254
1255  isEqual(another: ArkDisplayCount): boolean {
1256    return this.value === another.value && this.swipeByGroup === another.swipeByGroup;
1257  }
1258}
1259
1260class ArkSwiperCachedCount {
1261  value: number;
1262  isShown: boolean;
1263
1264  constructor() {
1265    this.value = undefined;
1266    this.isShown = undefined;
1267  }
1268
1269  isEqual(another: ArkSwiperCachedCount): boolean {
1270    return this.value === another.value && this.isShown === another.isShown;
1271  }
1272}
1273
1274class ArkPlaceholder {
1275  value: ResourceStr | undefined;
1276  style?: PlaceholderStyle | undefined;
1277  constructor() {
1278    this.value = undefined;
1279    this.style = undefined;
1280  }
1281  isEqual(another: ArkPlaceholder): boolean {
1282    return (this.value === another.value) &&
1283      (this.style === another.style);
1284  }
1285}
1286
1287class ArkMesh {
1288  value: Array<any> | undefined;
1289  column: number | undefined;
1290  row: number | undefined;
1291
1292  constructor() {
1293    this.value = undefined;
1294    this.column = undefined;
1295    this.row = undefined;
1296  }
1297  isEqual(another: ArkMesh): boolean {
1298    return (
1299      deepCompareArrays(this.value, another.value) &&
1300      this.column === another.column &&
1301      this.row === another.row
1302    );
1303  }
1304}
1305
1306class ArkLanesOpt {
1307  lanesNum: number | undefined;
1308  minLength: Length | undefined;
1309  maxLength: Length | undefined;
1310  gutter?: undefined;
1311  constructor() {
1312    this.lanesNum = undefined;
1313    this.minLength = undefined;
1314    this.maxLength = undefined;
1315    this.gutter = undefined;
1316  }
1317
1318  isEqual(another: ArkLanesOpt): boolean {
1319    return (this.lanesNum === another.lanesNum && this.minLength === another.minLength
1320      && this.maxLength === another.maxLength && this.gutter === another.gutter);
1321  }
1322}
1323
1324class ArkScrollSnapOptions {
1325  snapAlign: ScrollSnapAlign;
1326  snapPagination: Dimension | Array<Dimension>;
1327  enableSnapToStart: boolean;
1328  enableSnapToEnd: boolean;
1329  constructor() {
1330    this.snapAlign = undefined;
1331    this.snapPagination = undefined;
1332    this.enableSnapToStart = undefined;
1333    this.enableSnapToEnd = undefined;
1334  }
1335  isEqual(another: ArkScrollSnapOptions): boolean {
1336    return ((this.snapAlign === another.snapAlign) &&
1337      (this.snapPagination === another.snapPagination) &&
1338      (this.enableSnapToStart === another.enableSnapToStart) &&
1339      (this.enableSnapToEnd === another.enableSnapToEnd));
1340  }
1341}
1342
1343class ArkGeometryTransition {
1344  id: string | undefined;
1345  options: GeometryTransitionOptions | undefined;
1346
1347  constructor() {
1348    this.id = undefined;
1349    this.options = undefined;
1350  }
1351
1352  isEqual(another: ArkGeometryTransition): boolean {
1353    return (this.id === another.id && this.options === another.options);
1354  }
1355}
1356
1357class ArkSymbolEffect {
1358  symbolEffect: SymbolEffect;
1359  action: boolean | number | undefined;
1360
1361  constructor() {
1362    this.symbolEffect = undefined;
1363    this.action = undefined;
1364  }
1365  isEqual(another: ArkSymbolEffect): boolean {
1366    return (this.symbolEffect === another.symbolEffect) && (this.action === another.action);
1367  }
1368}
1369
1370class ArkBindMenu{
1371  content: Array<MenuElement> | CustomBuilder | undefined;
1372  options: MenuOptions | undefined;
1373
1374  constructor() {
1375    this.content = undefined;
1376    this.options = undefined;
1377  }
1378
1379  isEqual(another: ArkBindMenu): boolean {
1380    return (this.content === another.content && this.options === another.options);
1381  }
1382}
1383
1384class ArkTextBackGroundStyle {
1385  color: ResourceColor;
1386  radius: Dimension | BorderRadiuses;
1387  constructor() {
1388    this.color = undefined;
1389    this.radius = new ArkBorderRadius();
1390  }
1391  isEqual(another: ArkTextBackGroundStyle): boolean {
1392    return (this.color === another.color &&
1393      this.radius.isEqual(another.radius));
1394  }
1395  checkObjectDiff(another: ArkTextBackGroundStyle): boolean {
1396    return !this.isEqual(another);
1397  }
1398  convertTextBackGroundStyleOptions(value: TextBackgroundStyle): boolean {
1399    if (isUndefined(value)) {
1400      return false;
1401    }
1402    if (!isUndefined(value?.color) && value?.color !== null) {
1403      if (isNumber(value.color) || isString(value.color) || isResource(value.color)) {
1404        this.color = value.color;
1405      }
1406    }
1407
1408    if (!isUndefined(value?.radius) && value?.radius !== null) {
1409      if (isNumber(value.radius) || isString(value.radius) || isResource(value.radius)) {
1410        this.radius.topLeft = value.radius;
1411        this.radius.topRight = value.radius;
1412        this.radius.bottomLeft = value.radius;
1413        this.radius.bottomRight = value.radius;
1414      }
1415      else {
1416        this.radius.topLeft = (value.radius as BorderRadiuses)?.topLeft;
1417        this.radius.topRight = (value.radius as BorderRadiuses)?.topRight;
1418        this.radius.bottomLeft = (value.radius as BorderRadiuses)?.bottomLeft;
1419        this.radius.bottomRight = (value.radius as BorderRadiuses)?.bottomRight;
1420      }
1421    }
1422    return true;
1423  }
1424}
1425
1426class ArkScrollOffsetOptions {
1427  xOffset: Dimension;
1428  yOffset: Dimension;
1429  constructor() {
1430    this.xOffset = undefined;
1431    this.yOffset = undefined;
1432  }
1433  isEqual(another: ArkScrollOffsetOptions): boolean {
1434    return this.xOffset === another.xOffset && this.yOffset === another.yOffset;
1435  }
1436}
1437
1438class ArkScrollableCacheOptions {
1439  count: number;
1440  show: boolean;
1441  constructor(count: number, show: boolean) {
1442    this.count = count;
1443    this.show = show;
1444  }
1445  isEqual(other: ArkScrollableCacheOptions): boolean {
1446    return (this.count === other.count) &&
1447      (this.show === other.show);
1448  }
1449}
1450
1451class ArkSelection {
1452  selectionStart: number;
1453  selectionEnd: number;
1454  constructor() {
1455    this.selectionStart = undefined;
1456    this.selectionEnd = undefined;
1457  }
1458  isEqual(another: ArkSelection): boolean {
1459    return this.selectionStart === another.selectionStart &&
1460      this.selectionEnd === another.selectionEnd;
1461  }
1462}
1463
1464class TextDataDetectorConfig {
1465  types: TextDataDetectorType;
1466  onDetectResultUpdate: (result: string) => void;
1467  constructor() {
1468    this.types = undefined;
1469    this.onDetectResultUpdate = undefined;
1470  }
1471  isEqual(another: TextDataDetectorConfig): boolean {
1472    return (this.types === another.types) &&
1473      (this.onDetectResultUpdate === another.onDetectResultUpdate);
1474  }
1475}
1476
1477class ArkDragPreviewOptions {
1478  mode: DragPreviewMode | Array<DragPreviewMode> | undefined;
1479  sizeChangeEffect: DraggingSizeChangeEffect | undefined;
1480  numberBadge: boolean | number | undefined;
1481  isMultiSelectionEnabled: boolean | undefined;
1482  defaultAnimationBeforeLifting: boolean | undefined;
1483  enableEdgeAutoScroll: boolean | undefined;
1484  enableHapticFeedback: boolean | undefined;
1485  isLiftingDisabled: boolean | undefined;
1486
1487  constructor() {
1488    this.mode = undefined;
1489    this.numberBadge = undefined;
1490    this.sizeChangeEffect = undefined;
1491    this.isMultiSelectionEnabled = undefined;
1492    this.defaultAnimationBeforeLifting = undefined;
1493    this.enableEdgeAutoScroll = undefined;
1494    this.enableHapticFeedback = undefined;
1495    this.isLiftingDisabled = undefined;
1496  }
1497
1498  isEqual(another: ArkDragPreviewOptions): boolean {
1499    return (
1500      this.mode === another.mode &&
1501      this.numberBadge === another.numberBadge &&
1502      this.sizeChangeEffect === another.sizeChangeEffect &&
1503      this.isMultiSelectionEnabled === another.isMultiSelectionEnabled &&
1504      this.defaultAnimationBeforeLifting === another.defaultAnimationBeforeLifting &&
1505      this.enableEdgeAutoScroll === another.enableEdgeAutoScroll &&
1506      this.enableHapticFeedback === another.enableHapticFeedback &&
1507      this.isLiftingDisabled === another.isLiftingDisabled
1508    );
1509  }
1510}
1511
1512class ArkDragPreview {
1513  inspetorId: string;
1514  onlyForLifting: boolean | undefined;
1515  pixelMap: PixelMap | undefined;
1516  extraInfo: string;
1517  constructor() {
1518    this.inspetorId = undefined;
1519    this.onlyForLifting = undefined;
1520    this.pixelMap = undefined;
1521    this.extraInfo = undefined;
1522  }
1523
1524  isEqual(another: ArkDragPreview): boolean {
1525    return (
1526      this.inspetorId === another.inspetorId &&
1527      this.onlyForLifting === another.onlyForLifting &&
1528      this.pixelMap === another.pixelMap &&
1529      this.extraInfo === another.extraInfo
1530    );
1531  }
1532}
1533
1534class ArkRelativeContainerGuideLine {
1535  ids: Array<string> | undefined;
1536  directions: Array<Axis> | undefined;
1537  positions: Array<GuideLinePosition> | undefined;
1538
1539  constructor() {
1540    this.ids = undefined;
1541    this.directions = undefined;
1542    this.positions = undefined;
1543  }
1544
1545  isEqual(another: ArkRelativeContainerGuideLine): boolean {
1546    return (
1547      this.ids === another.ids &&
1548      this.directions === another.directions &&
1549      this.positions === another.positions
1550    );
1551  }
1552}
1553
1554class ArkRelativeContainerBarrier {
1555  ids: Array<string> | undefined;
1556  directions: Array<BarrierDirection> | undefined;
1557  referencedIds: Array<Array<string>> | undefined;
1558
1559  constructor() {
1560    this.ids = undefined;
1561    this.directions = undefined;
1562    this.referencedIds = undefined;
1563  }
1564
1565  isEqual(another: ArkRelativeContainerGuideLine): boolean {
1566    return (
1567      this.ids === another.ids &&
1568      this.directions === another.directions &&
1569      this.referencedIds === another.positions
1570    );
1571  }
1572}
1573
1574class ArkFocusScopeId {
1575  id: string | undefined;
1576  isGroup: boolean | undefined;
1577  arrowStepOut: boolean | undefined;
1578  constructor() {
1579    this.id = undefined;
1580    this.isGroup = undefined;
1581    this.arrowStepOut = undefined;
1582  }
1583  isEqual(another: ArkFocusScopeId): boolean {
1584    return ((this.id === another.id) && (this.isGroup === another.isGroup) &&
1585      (this.arrowStepOut === another.arrowStepOut));
1586  }
1587}
1588
1589class ArkFocusScopePriority {
1590  scopeId: string | undefined;
1591  priority: number | undefined;
1592  constructor() {
1593    this.scopeId = undefined;
1594    this.priority = undefined;
1595  }
1596  isEqual(another: ArkFocusScopePriority): boolean {
1597    return (this.scopeId === another.scopeId) && (this.priority === another.priority);
1598  }
1599}
1600
1601class ArkTextFont {
1602  value: Font;
1603  enableVariableFontWeight: boolean;
1604
1605  constructor() {
1606    this.value = undefined;
1607    this.enableVariableFontWeight = undefined;
1608  }
1609
1610  isEqual(another: ArkTextFont): boolean {
1611    return (this.value === another.value && this.enableVariableFontWeight === another.enableVariableFontWeight);
1612  }
1613
1614  checkObjectDiff(another: ArkTextFont): boolean {
1615    return !this.isEqual(another);
1616  }
1617}
1618
1619class ArkFontWeight {
1620  value: number | FontWeight | string;
1621  enableVariableFontWeight: boolean;
1622
1623  constructor() {
1624    this.value = undefined;
1625    this.enableVariableFontWeight = undefined;
1626  }
1627
1628  isEqual(another: ArkTextFont): boolean {
1629    return (this.value === another.value && this.enableVariableFontWeight === another.enableVariableFontWeight);
1630  }
1631
1632  checkObjectDiff(another: ArkTextFont): boolean {
1633    return !this.isEqual(another);
1634  }
1635}
1636
1637class ArkNavigationTitle {
1638  value: ResourceStr | CustomBuilder | NavigationCommonTitle | NavigationCustomTitle | undefined;
1639  navigationTitleOptions?: NavigationTitleOptions | undefined;
1640
1641  constructor() {
1642    this.value = undefined;
1643    this.navigationTitleOptions = undefined;
1644  }
1645  isEqual(another: ArkNavigationTitle): boolean {
1646    return (this.value === another.value) && (this.navigationTitleOptions === another.navigationTitleOptions);
1647  }
1648}
1649
1650class ArkNavHideTitleBarOrToolBar {
1651  isHide: boolean;
1652  animated: boolean;
1653
1654  constructor() {
1655    this.isHide = undefined;
1656    this.animated = undefined;
1657  }
1658  isEqual(another: ArkNavHideTitleBarOrToolBar): boolean {
1659    return (this.isHide === another.isHide) && (this.animated === another.animated);
1660  }
1661}
1662
1663class ArkAutoPlay {
1664  autoPlay: boolean;
1665  needStopWhenTouched: boolean;
1666
1667  constructor() {
1668    this.autoPlay = undefined;
1669    this.needStopWhenTouched = undefined;
1670  }
1671
1672  isEqual(another: ArkAutoPlay): boolean {
1673    return this.autoPlay === another.autoPlay && this.needStopWhenTouched === another.needStopWhenTouched;
1674  }
1675}