• 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 ArkChainMode {
365  direction: Axis | undefined;
366  style: ChainStyle | undefined;
367  constructor() {
368    this.direction = undefined;
369    this.style = undefined;
370  }
371  isEqual(another: ArkChainMode): boolean {
372    return (this.direction === another.direction) && (this.style === another.style);
373  }
374}
375
376class ArkListEdgeEffect {
377  value: EdgeEffect;
378  options?: EdgeEffectOptions | undefined;
379  constructor() {
380    this.value = undefined;
381    this.options = undefined;
382  }
383  isEqual(another: ArkListEdgeEffect): boolean {
384    return (this.value === another.value) &&
385      (this.options === another.options);
386  }
387}
388
389class ArkFadingEdge {
390  value: boolean;
391  options?: FadingEdgeOptions | undefined;
392  constructor() {
393    this.value = undefined;
394    this.options = undefined;
395  }
396  isEqual(another: ArkFadingEdge): boolean {
397    return (this.value === another.value) &&
398      (this.options === another.options);
399  }
400}
401
402class ArkScrollEdgeEffect {
403  value: EdgeEffect;
404  options?: EdgeEffectOptions | undefined;
405  constructor() {
406    this.value = undefined;
407    this.options = undefined;
408  }
409  isEqual(another: ArkScrollEdgeEffect): boolean {
410    return (this.value === another.value) &&
411      (this.options === another.options);
412  }
413}
414
415class ArkBlurOptions {
416  value: number;
417  options?: BlurOptions | undefined;
418  constructor() {
419    this.value = undefined;
420    this.options = undefined;
421  }
422}
423
424class InvertOptions {
425  high: number;
426  low: number;
427  threshold: number;
428  thresholdRange: number;
429  constructor() {
430    this.high = undefined;
431    this.low = undefined;
432    this.threshold = undefined;
433    this.thresholdRange = undefined;
434  }
435}
436
437class ArkMenuAlignType {
438  alignType: number | MenuAlignType;
439  dx: Length;
440  dy: Length;
441
442  constructor(alignType: MenuAlignType, offset?: Offset) {
443    this.alignType = alignType;
444    if (!isUndefined(offset) && isObject(offset)) {
445      this.dx = offset.dx;
446      this.dy = offset.dy;
447    }
448  }
449
450  isEqual(another: ArkMenuAlignType): boolean {
451    return this.alignType === another.alignType && this.dx === another.dx && this.dy === another.dy;
452  }
453}
454
455class ArkSliderTips {
456  showTip: boolean;
457  tipText: string | ResourceStr;
458
459  constructor(value: boolean, content?: string | ResourceStr) {
460    this.showTip = value;
461    this.tipText = content;
462  }
463
464  isEqual(another: ArkSliderTips): boolean {
465    return this.showTip === another.showTip && this.tipText === another.tipText;
466  }
467}
468
469class ArkStarStyle {
470  backgroundUri: string | undefined;
471  foregroundUri: string | undefined;
472  secondaryUri: string | undefined;
473
474  constructor() {
475    this.backgroundUri = undefined;
476    this.foregroundUri = undefined;
477    this.secondaryUri = undefined;
478  }
479
480  isEqual(another: ArkStarStyle): boolean {
481    return (
482      this.backgroundUri === another.backgroundUri &&
483      this.foregroundUri === another.foregroundUri &&
484      this.secondaryUri === another.secondaryUri
485    );
486  }
487}
488
489class ArkBackgroundBlurStyle {
490  blurStyle: number | undefined;
491  colorMode: number | undefined;
492  adaptiveColor: number | undefined;
493  scale: number | undefined;
494  blurOptions: BlurOptions | undefined;
495  policy?: number;
496  inactiveColor?: ResourceColor;
497  type?: number;
498
499  constructor() {
500    this.blurStyle = undefined;
501    this.colorMode = undefined;
502    this.adaptiveColor = undefined;
503    this.scale = undefined;
504    this.blurOptions = undefined;
505    this.policy = undefined;
506    this.inactiveColor = undefined;
507    this.type = undefined;
508  }
509
510  isEqual(another: ArkBackgroundBlurStyle): boolean {
511    return (
512      this.blurStyle === another.blurStyle &&
513      this.colorMode === another.colorMode &&
514      this.adaptiveColor === another.adaptiveColor &&
515      this.scale === another.scale &&
516      this.blurOptions === another.blurOptions &&
517      this.policy === another.policy &&
518      this.inactiveColor === another.inactiveColor &&
519      this.type === another.type
520    );
521  }
522}
523
524class ArkBorderDashGap {
525  left: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
526  right: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
527  top: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
528  bottom: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
529  start: LocalizedEdgeWidths;
530  end: LocalizedEdgeWidths;
531
532  constructor() {
533    this.left = undefined;
534    this.right = undefined;
535    this.top = undefined;
536    this.bottom = undefined;
537    this.start = undefined;
538    this.end = undefined;
539  }
540
541  isEqual(another: ArkBorderDashGap): boolean {
542    return (
543      this.left === another.left &&
544      this.right === another.right &&
545      this.top === another.top &&
546      this.bottom === another.bottom &&
547      this.start === another.start &&
548      this.end === another.end
549    );
550  }
551}
552
553class ArkBorderDashWidth {
554  left: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
555  right: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
556  top: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
557  bottom: EdgeWidths | LengthMetrics | LocalizedEdgeWidths;
558  start: LocalizedEdgeWidths;
559  end: LocalizedEdgeWidths;
560
561  constructor() {
562    this.left = undefined;
563    this.right = undefined;
564    this.top = undefined;
565    this.bottom = undefined;
566    this.start = undefined;
567    this.end = undefined;
568  }
569
570  isEqual(another: ArkBorderDashWidth): boolean {
571    return (
572      this.left === another.left &&
573      this.right === another.right &&
574      this.top === another.top &&
575      this.bottom === another.bottom &&
576      this.start === another.start &&
577      this.end === another.end
578    );
579  }
580}
581
582class ArkBorder {
583  arkWidth: ArkBorderWidth;
584  arkColor: ArkBorderColor;
585  arkRadius: ArkBorderRadius;
586  arkStyle: ArkBorderStyle;
587  arkDashGap: ArkBorderDashGap;
588  arkDashWidth: ArkBorderDashWidth;
589
590  constructor() {
591    this.arkWidth = new ArkBorderWidth();
592    this.arkColor = new ArkBorderColor();
593    this.arkRadius = new ArkBorderRadius();
594    this.arkStyle = new ArkBorderStyle();
595    this.arkDashGap = new ArkBorderDashGap();
596    this.arkDashWidth = new ArkBorderDashWidth();
597  }
598  isEqual(another: ArkBorder): boolean {
599    return (
600      this.arkWidth.isEqual(another.arkWidth) &&
601      this.arkColor.isEqual(another.arkColor) &&
602      this.arkRadius.isEqual(another.arkRadius) &&
603      this.arkStyle.isEqual(another.arkStyle) &&
604      this.arkDashGap.isEqual(another.arkDashGap) &&
605      this.arkDashWidth.isEqual(another.arkDashWidth)
606    );
607  }
608
609  checkObjectDiff(another: ArkBorder): boolean {
610    return !this.isEqual(another);
611  }
612}
613
614class ArkBackgroundImageSize {
615  imageSize: ImageSize | undefined | SizeOptions;
616  width: number | string | undefined | Resource;
617  height: number | string | undefined | Resource;
618  constructor() {
619    this.imageSize = undefined;
620    this.width = undefined;
621    this.height = undefined;
622  }
623  isEqual(another: ArkBackgroundImageSize): boolean {
624    return this.imageSize === another.imageSize && this.width === another.width && this.height === another.height;
625  }
626}
627
628class ArkBackgroundImage {
629  src: string | undefined | Resource | PixelMap;
630  repeat: number | undefined;
631  constructor() {
632    this.src = undefined;
633    this.repeat = undefined;
634  }
635  isEqual(another: ArkBackgroundImage): boolean {
636    return this.src === another.src && this.repeat === another.repeat;
637  }
638}
639
640class ArkGridColColumnOption implements Equable {
641  xs?: number;
642  sm?: number;
643  md?: number;
644  lg?: number;
645  xl?: number;
646  xxl?: number;
647  constructor() {
648    this.xs = undefined;
649    this.sm = undefined;
650    this.md = undefined;
651    this.lg = undefined;
652    this.xl = undefined;
653    this.xxl = undefined;
654  }
655  isEqual(another: ArkGridColColumnOption): boolean {
656    return (this.xs === another.xs &&
657      this.sm === another.sm &&
658      this.md === another.md &&
659      this.lg === another.lg &&
660      this.xl === another.xl &&
661      this.xxl === another.xxl);
662  }
663}
664
665class ArkPadding {
666  top: Length | undefined;
667  right: Length | undefined;
668  bottom: Length | undefined;
669  left: Length | undefined;
670  constructor() {
671    this.top = undefined;
672    this.right = undefined;
673    this.bottom = undefined;
674    this.left = undefined;
675  }
676  isEqual(another: ArkPadding) {
677    return (
678      this.top === another.top &&
679      this.right === another.right &&
680      this.bottom === another.bottom &&
681      this.left === another.left
682    );
683  }
684}
685
686class ArkBarMode {
687  barMode: number;
688  options?: ScrollableBarModeOptions | undefined;
689
690  isEqual(another: ArkBarMode): boolean {
691    return (this.barMode === another.barMode) && (this.options === another.options);
692  }
693}
694
695class ArkDivider {
696  divider: DividerStyle;
697
698  isEqual(another: ArkDivider): boolean {
699    return (this.divider === another.divider);
700  }
701}
702
703class ArkBarGridAlign {
704  barGridAlign: BarGridColumnOptions;
705
706  isEqual(another: ArkBarGridAlign): boolean {
707    return (this.barGridAlign === another.barGridAlign);
708  }
709}
710
711
712class ArkScrollableBarModeOptions {
713  value: ScrollableBarModeOptions;
714
715  isEqual(another: ArkScrollableBarModeOptions): boolean {
716    return (this.value === another.value);
717  }
718}
719
720class ArkAlignRules {
721  left: string | undefined;
722  middle: string | undefined;
723  right: string | undefined;
724  top: string | undefined;
725  center: string | undefined;
726  bottom: string | undefined;
727  constructor() {
728    this.left = undefined;
729    this.middle = undefined;
730    this.right = undefined;
731    this.top = undefined;
732    this.center = undefined;
733    this.bottom = undefined;
734  }
735  isEqual(another: ArkAlignRules) {
736    return (
737      this.left === another.left &&
738      this.middle === another.middle &&
739      this.right === another.right &&
740      this.top === another.top &&
741      this.center === another.center &&
742      this.bottom === another.bottom
743    );
744  }
745}
746
747class ArkSafeAreaExpandOpts {
748  type: string | number | undefined = undefined;
749  edges: string | number | undefined = undefined;
750  isEqual(another: ArkSafeAreaExpandOpts): boolean {
751    return (this.type === another.type) && (this.edges === another.edges);
752  }
753}
754
755class ArkButtonStyle {
756  left?: number;
757  top?: number;
758  width?: number;
759  height?: number;
760  icons?: {
761    shown?: string;
762    hidden?: string;
763    switching?: string;
764  };
765  constructor() {
766    this.left = 16;
767    this.top = 48;
768    this.width = 24;
769    this.height = 24;
770    this.icons = {
771      shown: undefined,
772      hidden: undefined,
773      switching: undefined
774    };
775  }
776  isEqual(another: ArkButtonStyle): boolean {
777    return (
778      this.left === another.left &&
779      this.top === another.top &&
780      this.width === another.width &&
781      this.height === another.height &&
782      this.icons === another.icons
783    );
784  }
785}
786
787class ArkShadowInfoToArray {
788  radius: (number | string)[];
789  type: ShadowType[];
790  color: (Color | string | Resource | ColoringStrategy)[];
791  offsetX: (number | string)[];
792  offsetY: (number | string)[];
793  fill: boolean[];
794  constructor() {
795    this.radius = [];
796    this.type = [];
797    this.color = [];
798    this.offsetX = [];
799    this.offsetX = [];
800    this.offsetY = [];
801    this.fill = [];
802  }
803  isEqual(another: ArkShadowInfoToArray): boolean {
804    return (this.radius === another.radius) &&
805      (this.color === another.color) &&
806      (this.offsetX === another.offsetX) &&
807      (this.offsetY === another.offsetY) &&
808      (this.fill === another.fill);
809  }
810
811  convertShadowOptions(value: ShadowOptions | Array<ShadowOptions>): boolean {
812    if (Object.getPrototypeOf(value).constructor === Object) {
813      if ((<ShadowOptions>value).radius === null || (<ShadowOptions>value).radius === undefined) {
814        return false;
815      } else {
816        this.radius.push(<number | string>(<ShadowOptions>value).radius);
817        this.type.push((<ShadowOptions>value).type);
818        this.color.push((<ShadowOptions>value).color);
819        this.offsetX.push(((<ShadowOptions>value).offsetX === undefined ||
820          (<ShadowOptions>value).offsetX === null) ? 0 : <number | string>(<ShadowOptions>value).offsetX);
821        this.offsetY.push(((<ShadowOptions>value).offsetY === undefined ||
822          (<ShadowOptions>value).offsetY === null) ? 0 : <number | string>(<ShadowOptions>value).offsetY);
823        this.fill.push(((<ShadowOptions>value).fill === undefined ||
824          (<ShadowOptions>value).fill === null) ? false : (<ShadowOptions>value).fill);
825        return true;
826      }
827    } else if (Object.getPrototypeOf(value).constructor === Array) {
828      let isFlag: boolean = true;
829      for (let item of (value as Array<ShadowOptions>)) {
830        if (item.radius === undefined || item.radius === null) {
831          isFlag = false;
832          break;
833        }
834      }
835      if (isFlag) {
836        for (let objValue of (value as Array<ShadowOptions>)) {
837          this.radius.push(<number | string>objValue.radius);
838          this.type.push(objValue.type);
839          this.color.push(objValue.color);
840          this.offsetX.push((objValue.offsetX === undefined || objValue.offsetX === null) ? 0 : <number | string>objValue.offsetX);
841          this.offsetY.push((objValue.offsetY === undefined || objValue.offsetY === null) ? 0 : <number | string>objValue.offsetY);
842          this.fill.push((objValue.fill === undefined || objValue.fill === null) ? false : objValue.fill);
843        }
844        return true;
845      } else {
846        return false;
847      }
848    }
849  }
850
851  checkDiff(value: ShadowOptions, stageValue: ShadowOptions): boolean {
852    if (!value || !stageValue || !value.radius || !stageValue.radius) {
853      return true;
854    }
855    if (!((isResource(stageValue.radius) && isResource(value.radius) &&
856      isResourceEqual(stageValue.radius, value.radius)) ||
857      (isNumber(stageValue.radius) && isNumber(value.radius) &&
858        stageValue.radius === value.radius))) {
859      return true;
860    }
861    if (!(isNumber(stageValue.type) && isNumber(value.type) &&
862      stageValue.type === value.type)) {
863      return true;
864    }
865    if (!((isResource(stageValue.color) && isResource(value.color) &&
866      isResourceEqual(stageValue.color, value.color)) ||
867      (!isResource(stageValue.color) && !isResource(value.color) &&
868        stageValue.color === value.color))) {
869      return true;
870    }
871    if (!((isResource(stageValue.offsetX) && isResource(value.offsetX) &&
872      isResourceEqual(stageValue.offsetX, value.offsetX)) ||
873      (isNumber(stageValue.offsetX) && isNumber(value.offsetX) &&
874        stageValue.offsetX === value.offsetX))) {
875      return true;
876    }
877    if (!((isResource(stageValue.offsetY) && isResource(value.offsetY) &&
878      isResourceEqual(stageValue.offsetY, value.offsetY)) ||
879      (isNumber(stageValue.offsetY) && isNumber(value.offsetY) &&
880        stageValue.offsetY === value.offsetY))) {
881      return true;
882    }
883    if (!(isBoolean(stageValue.fill) && isBoolean(value.fill) &&
884      stageValue.fill === value.fill)) {
885      return true;
886    }
887    return false;
888  }
889}
890
891class ArkSearchButton {
892  value: string | undefined;
893  fontSize: Length | undefined;
894  fontColor: ResourceColor | undefined;
895  constructor() {
896    this.value = undefined;
897    this.fontSize = undefined;
898    this.fontColor = undefined;
899  }
900  isEqual(another: ArkSearchButton): boolean {
901    return (this.value === another.value) &&
902      (this.fontSize === another.fontSize) &&
903      (this.fontColor === another.fontColor);
904  }
905}
906
907class ArkSearchInputFilter {
908  value: ResourceStr | undefined;
909  error?: (value: string) => void;
910  constructor() {
911    this.value = undefined;
912    this.error = undefined;
913  }
914  isEqual(another: ArkSearchInputFilter): boolean {
915    return (this.value === another.value);
916  }
917}
918class ArkImageFrameInfoToArray {
919  arrSrc: Array<string> | undefined;
920  arrWidth: Array<number | string> | undefined;
921  arrHeight: Array<number | string> | undefined;
922  arrTop: Array<number | string> | undefined;
923  arrLeft: Array<number | string> | undefined;
924  arrDuration: Array<number> | undefined;
925  constructor() {
926    this.arrSrc = [];
927    this.arrWidth = [];
928    this.arrHeight = [];
929    this.arrTop = [];
930    this.arrLeft = [];
931    this.arrDuration = [];
932  }
933  isEqual(another: ArkImageFrameInfoToArray): boolean {
934    return (this.arrSrc.toString() === another.arrSrc.toString()) &&
935      (this.arrWidth.toString() === another.arrWidth.toString()) &&
936      (this.arrHeight.toString() === another.arrHeight.toString()) &&
937      (this.arrTop.toString() === another.arrTop.toString()) &&
938      (this.arrLeft.toString() === another.arrLeft.toString()) &&
939      (this.arrDuration.toString() === another.arrDuration.toString());
940  }
941}
942
943class ArkEdgeAlign {
944  alignType: number;
945  offset?: Offset | undefined;
946
947  constructor() {
948    this.alignType = undefined;
949    this.offset = undefined;
950  }
951
952  isEqual(another: ArkEdgeAlign): boolean {
953    return (this.alignType === another.alignType && this.offset === another.offset);
954  }
955}
956
957class ArkKeyBoardShortCut {
958  value: string | number;
959  keys: Array<ModifierKey>;
960  action: () => void | undefined;
961
962  constructor() {
963    this.value = undefined;
964    this.keys = undefined;
965    this.action = undefined;
966  }
967
968  isEqual(another: ArkKeyBoardShortCut): boolean {
969    return (this.value === another.value) && (this.keys === another.keys) &&
970      (this.action === another.action);
971  }
972}
973
974class ArkCustomProperty {
975  key: string;
976  value: object;
977
978  constructor() {
979    this.key = undefined;
980    this.value = undefined;
981  }
982}
983
984class ArkUseEffect {
985  useEffect: boolean;
986  effectType: EffectType;
987  constructor() {
988    this.useEffect = undefined;
989    this.effectType = undefined;
990  }
991  isEqual(another: ArkUseEffect): boolean {
992    return (this.useEffect === another.useEffect) && (this.effectType === another.effectType);
993  }
994}
995
996class ArkBlendMode {
997  blendMode: number | Blender;
998  blendApplyType: number;
999  constructor() {
1000    this.blendMode = undefined;
1001    this.blendApplyType = undefined;
1002  }
1003  isEqual(another: ArkBlendMode): boolean {
1004    return (this.blendMode === another.blendMode) && (this.blendApplyType === another.blendApplyType);
1005  }
1006}
1007
1008class ArkAlignStyle {
1009  indexerAlign: number;
1010  offset?: number | string | undefined | Resource;
1011
1012  constructor() {
1013    this.indexerAlign = undefined;
1014    this.offset = undefined;
1015  }
1016
1017  isEqual(another: ArkAlignStyle): boolean {
1018    return (this.indexerAlign === another.indexerAlign && this.offset === another.offset);
1019  }
1020}
1021
1022class ArkNestedScrollOptions {
1023  scrollForward: NestedScrollMode | undefined;
1024  scrollBackward: NestedScrollMode | undefined;
1025  constructor() {
1026    this.scrollForward = undefined;
1027    this.scrollBackward = undefined;
1028  }
1029  isEqual(another: ArkNestedScrollOptions): boolean {
1030    return ((this.scrollForward === another.scrollForward) && (this.scrollBackward === another.scrollBackward));
1031  }
1032}
1033
1034class ArkConstraintSizeOptions {
1035  minWidth?: Length | undefined;
1036  maxWidth?: Length | undefined;
1037  minHeight?: Length | undefined;
1038  maxHeight?: Length | undefined;
1039
1040  constructor() {
1041    this.minWidth = undefined;
1042    this.maxWidth = undefined;
1043    this.minHeight = undefined;
1044    this.maxHeight = undefined;
1045  }
1046
1047  isEqual(another: ArkConstraintSizeOptions): boolean {
1048    return (
1049      this.minWidth === another.minWidth &&
1050      this.maxWidth === another.maxWidth &&
1051      this.minHeight === another.minHeight &&
1052      this.maxHeight === another.maxHeight
1053    );
1054  }
1055}
1056
1057class ArkTextFieldShowCounter {
1058  value: boolean;
1059  highlightBorder?: boolean;
1060  thresholdPercentage?: number;
1061  constructor() {
1062    this.value = undefined;
1063    this.highlightBorder = undefined;
1064    this.thresholdPercentage = undefined;
1065  }
1066  isEqual(another: ArkTextFieldShowCounter): boolean {
1067    return (this.value === another.value) &&
1068      (this.highlightBorder === another.highlightBorder) &&
1069      (this.thresholdPercentage === another.thresholdPercentage);
1070  }
1071}
1072
1073class ArkTextInputFilter {
1074  value: ResourceStr | undefined;
1075  error?: (value: string) => void;
1076  constructor() {
1077    this.value = undefined;
1078    this.error = undefined;
1079  }
1080  isEqual(another: ArkSearchInputFilter): boolean {
1081    return (this.value === another.value);
1082  }
1083}
1084
1085class ArkDotIndicator extends DotIndicator {
1086  type: string | undefined;
1087  leftValue: Length | undefined;
1088  topValue: Length | undefined;
1089  rightValue: Length | undefined;
1090  bottomValue: Length | undefined;
1091  itemWidthValue: Length | undefined;
1092  itemHeightValue: Length | undefined;
1093  selectedItemWidthValue: Length | undefined;
1094  selectedItemHeightValue: Length | undefined;
1095  maskValue: boolean | undefined;
1096  colorValue: ResourceColor | undefined;
1097  selectedColorValue: ResourceColor | undefined;
1098  maxDisplayCountValue: ResourceColor | undefined;
1099
1100  constructor() {
1101    super();
1102    this.type = undefined;
1103    this.leftValue = undefined;
1104    this.topValue = undefined;
1105    this.rightValue = undefined;
1106    this.bottomValue = undefined;
1107    this.itemWidthValue = undefined;
1108    this.itemHeightValue = undefined;
1109    this.selectedItemWidthValue = undefined;
1110    this.selectedItemHeightValue = undefined;
1111    this.maskValue = undefined;
1112    this.colorValue = undefined;
1113    this.selectedColorValue = undefined;
1114    this.maxDisplayCountValue = undefined;
1115  }
1116
1117  isEqual(another: ArkDotIndicator): boolean {
1118    return (
1119      this.type === another.type &&
1120      this.leftValue === another.leftValue &&
1121      this.topValue === another.topValue &&
1122      this.rightValue === another.rightValue &&
1123      this.bottomValue === another.bottomValue &&
1124      this.itemWidthValue === another.itemWidthValue &&
1125      this.itemHeightValue === another.itemHeightValue &&
1126      this.selectedItemWidthValue === another.selectedItemWidthValue &&
1127      this.selectedItemHeightValue === another.selectedItemHeightValue &&
1128      this.maskValue === another.maskValue &&
1129      this.colorValue === another.colorValue &&
1130      this.selectedColorValue === another.selectedColorValue &&
1131      this.maxDisplayCountValue === another.maxDisplayCountValue
1132    );
1133  }
1134}
1135
1136class ArkDigitIndicator extends DigitIndicator {
1137  type: string | undefined;
1138  leftValue: Length | undefined;
1139  topValue: Length | undefined;
1140  rightValue: Length | undefined;
1141  bottomValue: Length | undefined;
1142  fontColorValue: ResourceColor | undefined;
1143  selectedFontColorValue: ResourceColor | undefined;
1144  digitFontValue: ArkDigitFont | undefined;
1145  selectedDigitFontValue: ArkDigitFont | undefined;
1146
1147  constructor() {
1148    super();
1149    this.type = undefined;
1150    this.leftValue = undefined;
1151    this.topValue = undefined;
1152    this.rightValue = undefined;
1153    this.bottomValue = undefined;
1154    this.fontColorValue = undefined;
1155    this.selectedFontColorValue = undefined;
1156    this.digitFontValue = undefined;
1157    this.selectedDigitFontValue = undefined;
1158  }
1159
1160  isEqual(another: ArkDigitIndicator): boolean {
1161    return (
1162      this.type === another.type &&
1163      this.leftValue === another.leftValue &&
1164      this.topValue === another.topValue &&
1165      this.rightValue === another.rightValue &&
1166      this.bottomValue === another.bottomValue &&
1167      this.digitFontValue === another.digitFontValue &&
1168      this.selectedDigitFontValue === another.selectedDigitFontValue
1169    );
1170  }
1171}
1172
1173class ArkDigitFont {
1174  size: Length | undefined;
1175  weight: number | FontWeight | string | undefined;
1176
1177  constructor() {
1178    this.size = undefined;
1179    this.weight = undefined;
1180  }
1181
1182  isEqual(another: ArkDigitFont): boolean {
1183    return this.size === another.size && this.weight === another.weight;
1184  }
1185
1186  parseFontWeight(value: string | number | undefined) {
1187    const valueWeightMap = {
1188      [0]: 'lighter',
1189      [1]: 'normal',
1190      [2]: 'regular',
1191      [3]: 'medium',
1192      [4]: 'bold',
1193      [5]: 'bolder'
1194    };
1195    if (isUndefined(value)) {
1196      this.weight = '-';
1197    } else if (value in valueWeightMap) {
1198      this.weight = valueWeightMap[value];
1199    } else {
1200      this.weight = value.toString();
1201    }
1202    return this.weight;
1203  }
1204}
1205
1206class ArkDisplayArrow {
1207  value: boolean | ArrowStyle;
1208  isHoverShow: boolean | undefined;
1209
1210  constructor() {
1211    this.value = undefined;
1212    this.isHoverShow = undefined;
1213  }
1214
1215  isEqual(another: ArkDisplayArrow): boolean {
1216    return this.value === another.value && this.isHoverShow === another.isHoverShow;
1217  }
1218}
1219
1220class ArkDisplayCount {
1221  value: string | number | SwiperAutoFill;
1222  swipeByGroup: boolean | undefined;
1223
1224  constructor() {
1225    this.value = undefined;
1226    this.swipeByGroup = undefined;
1227  }
1228
1229  isEqual(another: ArkDisplayCount): boolean {
1230    return this.value === another.value && this.swipeByGroup === another.swipeByGroup;
1231  }
1232}
1233
1234class ArkGridEdgeEffect {
1235  value: EdgeEffect;
1236  options?: EdgeEffectOptions | undefined;
1237  constructor() {
1238    this.value = undefined;
1239    this.options = undefined;
1240  }
1241  isEqual(another: ArkGridEdgeEffect): boolean {
1242    return (this.value === another.value) &&
1243      (this.options === another.options);
1244  }
1245}
1246
1247class ArkMesh {
1248  value: Array<any> | undefined;
1249  column: number | undefined;
1250  row: number | undefined;
1251
1252  constructor() {
1253    this.value = undefined;
1254    this.column = undefined;
1255    this.row = undefined;
1256  }
1257  isEqual(another: ArkMesh): boolean {
1258    return (
1259      deepCompareArrays(this.value, another.value) &&
1260      this.column === another.column &&
1261      this.row === another.row
1262    );
1263  }
1264}
1265
1266class ArkLanesOpt {
1267  lanesNum: number | undefined;
1268  minLength: Length | undefined;
1269  maxLength: Length | undefined;
1270  gutter?: undefined;
1271  constructor() {
1272    this.lanesNum = undefined;
1273    this.minLength = undefined;
1274    this.maxLength = undefined;
1275    this.gutter = undefined;
1276  }
1277
1278  isEqual(another: ArkLanesOpt): boolean {
1279    return (this.lanesNum === another.lanesNum && this.minLength === another.minLength
1280      && this.maxLength === another.maxLength && this.gutter === another.gutter);
1281  }
1282}
1283
1284class ArkScrollSnapOptions {
1285  snapAlign: ScrollSnapAlign;
1286  snapPagination: Dimension | Array<Dimension>;
1287  enableSnapToStart: boolean;
1288  enableSnapToEnd: boolean;
1289  constructor() {
1290    this.snapAlign = undefined;
1291    this.snapPagination = undefined;
1292    this.enableSnapToStart = undefined;
1293    this.enableSnapToEnd = undefined;
1294  }
1295  isEqual(another: ArkScrollSnapOptions): boolean {
1296    return ((this.snapAlign === another.snapAlign) &&
1297      (this.snapPagination === another.snapPagination) &&
1298      (this.enableSnapToStart === another.enableSnapToStart) &&
1299      (this.enableSnapToEnd === another.enableSnapToEnd));
1300  }
1301}
1302
1303class ArkGeometryTransition {
1304  id: string | undefined;
1305  options: GeometryTransitionOptions | undefined;
1306
1307  constructor() {
1308    this.id = undefined;
1309    this.options = undefined;
1310  }
1311
1312  isEqual(another: ArkGeometryTransition): boolean {
1313    return (this.id === another.id && this.options === another.options);
1314  }
1315}
1316
1317class ArkSymbolEffect {
1318  symbolEffect: SymbolEffect;
1319  action: boolean | number | undefined;
1320
1321  constructor() {
1322    this.symbolEffect = undefined;
1323    this.action = undefined;
1324  }
1325  isEqual(another: ArkSymbolEffect): boolean {
1326    return (this.symbolEffect === another.symbolEffect) && (this.action === another.action);
1327  }
1328}
1329
1330class ArkTextBackGroundStyle {
1331  color: ResourceColor;
1332  radius: Dimension | BorderRadiuses;
1333  constructor() {
1334    this.color = undefined;
1335    this.radius = new ArkBorderRadius();
1336  }
1337  isEqual(another: ArkTextBackGroundStyle): boolean {
1338    return (this.color === another.color &&
1339      this.radius.isEqual(another.radius));
1340  }
1341  checkObjectDiff(another: ArkTextBackGroundStyle): boolean {
1342    return !this.isEqual(another);
1343  }
1344  convertTextBackGroundStyleOptions(value: TextBackgroundStyle): boolean {
1345    if (isUndefined(value)) {
1346      return false;
1347    }
1348    if (!isUndefined(value?.color) && value?.color !== null) {
1349      if (isNumber(value.color) || isString(value.color) || isResource(value.color)) {
1350        this.color = value.color;
1351      }
1352    }
1353
1354    if (!isUndefined(value?.radius) && value?.radius !== null) {
1355      if (isNumber(value.radius) || isString(value.radius) || isResource(value.radius)) {
1356        this.radius.topLeft = value.radius;
1357        this.radius.topRight = value.radius;
1358        this.radius.bottomLeft = value.radius;
1359        this.radius.bottomRight = value.radius;
1360      }
1361      else {
1362        this.radius.topLeft = (value.radius as BorderRadiuses)?.topLeft;
1363        this.radius.topRight = (value.radius as BorderRadiuses)?.topRight;
1364        this.radius.bottomLeft = (value.radius as BorderRadiuses)?.bottomLeft;
1365        this.radius.bottomRight = (value.radius as BorderRadiuses)?.bottomRight;
1366      }
1367    }
1368    return true;
1369  }
1370}
1371
1372class ArkScrollOffsetOptions {
1373  xOffset: Dimension;
1374  yOffset: Dimension;
1375  constructor() {
1376    this.xOffset = undefined;
1377    this.yOffset = undefined;
1378  }
1379  isEqual(another: ArkScrollOffsetOptions): boolean {
1380    return this.xOffset === another.xOffset && this.yOffset === another.yOffset;
1381  }
1382}
1383
1384class ArkWaterFlowEdgeEffect {
1385  value: EdgeEffect;
1386  options?: EdgeEffectOptions | undefined;
1387  constructor() {
1388    this.value = undefined;
1389    this.options = undefined;
1390  }
1391  isEqual(another: ArkWaterFlowEdgeEffect): boolean {
1392    return (this.value === another.value) &&
1393      (this.options === another.options);
1394  }
1395}
1396
1397class ArkScrollableCacheOptions {
1398  count: number;
1399  show: boolean;
1400  constructor(count: number, show: boolean) {
1401    this.count = count;
1402    this.show = show;
1403  }
1404  isEqual(other: ArkScrollableCacheOptions): boolean {
1405    return (this.count === other.count) &&
1406      (this.show === other.show);
1407  }
1408}
1409
1410class ArkSelection {
1411  selectionStart: number;
1412  selectionEnd: number;
1413  constructor() {
1414    this.selectionStart = undefined;
1415    this.selectionEnd = undefined;
1416  }
1417  isEqual(another: ArkSelection): boolean {
1418    return this.selectionStart === another.selectionStart &&
1419      this.selectionEnd === another.selectionEnd;
1420  }
1421}
1422
1423class TextDataDetectorConfig {
1424  types: TextDataDetectorType;
1425  onDetectResultUpdate: (result: string) => void;
1426  constructor() {
1427    this.types = undefined;
1428    this.onDetectResultUpdate = undefined;
1429  }
1430  isEqual(another: TextDataDetectorConfig): boolean {
1431    return (this.types === another.types) &&
1432      (this.onDetectResultUpdate === another.onDetectResultUpdate);
1433  }
1434}
1435
1436class ArkDragPreviewOptions {
1437  mode: DragPreviewMode | Array<DragPreviewMode> | undefined;
1438  numberBadge: boolean | number | undefined;
1439  isMultiSelectionEnabled: boolean | undefined;
1440  defaultAnimationBeforeLifting: boolean | undefined;
1441
1442  constructor() {
1443    this.mode = undefined;
1444    this.numberBadge = undefined;
1445    this.isMultiSelectionEnabled = undefined;
1446    this.defaultAnimationBeforeLifting = undefined;
1447  }
1448
1449  isEqual(another: ArkDragPreviewOptions): boolean {
1450    return (
1451      this.mode === another.mode &&
1452      this.numberBadge === another.numberBadge &&
1453      this.isMultiSelectionEnabled === another.isMultiSelectionEnabled &&
1454      this.defaultAnimationBeforeLifting === another.defaultAnimationBeforeLifting
1455    );
1456  }
1457}
1458
1459class ArkDragPreview {
1460  inspetorId: string;
1461  constructor() {
1462    this.inspetorId = undefined;
1463  }
1464
1465  isEqual(another: ArkDragPreview): boolean {
1466    return this.inspetorId === another.inspetorId;
1467  }
1468}
1469
1470class ArkRelativeContainerGuideLine {
1471  ids: Array<string> | undefined;
1472  directions: Array<Axis> | undefined;
1473  positions: Array<GuideLinePosition> | undefined;
1474
1475  constructor() {
1476    this.ids = undefined;
1477    this.directions = undefined;
1478    this.positions = undefined;
1479  }
1480
1481  isEqual(another: ArkRelativeContainerGuideLine): boolean {
1482    return (
1483      this.ids === another.ids &&
1484      this.directions === another.directions &&
1485      this.positions === another.positions
1486    );
1487  }
1488}
1489
1490class ArkRelativeContainerBarrier {
1491  ids: Array<string> | undefined;
1492  directions: Array<BarrierDirection> | undefined;
1493  referencedIds: Array<Array<string>> | undefined;
1494
1495  constructor() {
1496    this.ids = undefined;
1497    this.directions = undefined;
1498    this.referencedIds = undefined;
1499  }
1500
1501  isEqual(another: ArkRelativeContainerGuideLine): boolean {
1502    return (
1503      this.ids === another.ids &&
1504      this.directions === another.directions &&
1505      this.referencedIds === another.positions
1506    );
1507  }
1508}
1509
1510class ArkFocusScopeId {
1511  id: string | undefined;
1512  isGroup: boolean | undefined;
1513  arrowStepOut: boolean | undefined;
1514  constructor() {
1515    this.id = undefined;
1516    this.isGroup = undefined;
1517    this.arrowStepOut = undefined;
1518  }
1519  isEqual(another: ArkFocusScopeId): boolean {
1520    return ((this.id === another.id) && (this.isGroup === another.isGroup) &&
1521      (this.arrowStepOut === another.arrowStepOut));
1522  }
1523}
1524
1525class ArkFocusScopePriority {
1526  scopeId: string | undefined;
1527  priority: number | undefined;
1528  constructor() {
1529    this.scopeId = undefined;
1530    this.priority = undefined;
1531  }
1532  isEqual(another: ArkFocusScopePriority): boolean {
1533    return (this.scopeId === another.scopeId) && (this.priority === another.priority);
1534  }
1535}
1536
1537class ArkTextFont {
1538  value: Font;
1539  enableVariableFontWeight: boolean;
1540
1541  constructor() {
1542    this.value = undefined;
1543    this.enableVariableFontWeight = undefined;
1544  }
1545
1546  isEqual(another: ArkTextFont): boolean {
1547    return (this.value === another.value && this.enableVariableFontWeight === another.enableVariableFontWeight);
1548  }
1549
1550  checkObjectDiff(another: ArkTextFont): boolean {
1551    return !this.isEqual(another);
1552  }
1553}
1554
1555class ArkFontWeight {
1556  value: number | FontWeight | string;
1557  enableVariableFontWeight: boolean;
1558
1559  constructor() {
1560    this.value = undefined;
1561    this.enableVariableFontWeight = undefined;
1562  }
1563
1564  isEqual(another: ArkTextFont): boolean {
1565    return (this.value === another.value && this.enableVariableFontWeight === another.enableVariableFontWeight);
1566  }
1567
1568  checkObjectDiff(another: ArkTextFont): boolean {
1569    return !this.isEqual(another);
1570  }
1571}
1572
1573class ArkNavigationTitle {
1574  value: ResourceStr | CustomBuilder | NavigationCommonTitle | NavigationCustomTitle | undefined;
1575  navigationTitleOptions?: NavigationTitleOptions | undefined;
1576
1577  constructor() {
1578    this.value = undefined;
1579    this.navigationTitleOptions = undefined;
1580  }
1581  isEqual(another: ArkNavigationTitle): boolean {
1582    return (this.value === another.value) && (this.navigationTitleOptions === another.navigationTitleOptions);
1583  }
1584}
1585
1586class ArkNavHideTitleBarOrToolBar {
1587  isHide: boolean;
1588  animated: boolean;
1589
1590  constructor() {
1591    this.isHide = undefined;
1592    this.animated = undefined;
1593  }
1594  isEqual(another: ArkNavHideTitleBarOrToolBar): boolean {
1595    return (this.isHide === another.isHide) && (this.animated === another.animated);
1596  }
1597}