npoi

1
using NPOI.OpenXml4Net.Util;
2
using System;
3
using System.IO;
4
using System.Xml;
5
using System.Xml.Serialization;
6

7
namespace NPOI.OpenXmlFormats.Wordprocessing
8
{
9

10
    [Serializable]
11
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
12
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
13
    public class CT_Frameset
14
    {
15

16
        private CT_String szField;
17

18
        private CT_FramesetSplitbar framesetSplitbarField;
19

20
        private CT_FrameLayout frameLayoutField;
21

22
        private object[] itemsField;
23

24
        public CT_Frameset()
25
        {
26
            this.itemsField = new object[0];
27
            this.frameLayoutField = new CT_FrameLayout();
28
            this.framesetSplitbarField = new CT_FramesetSplitbar();
29
            this.szField = new CT_String();
30
        }
31

32
        [XmlElement(Order = 0)]
33
        public CT_String sz
34
        {
35
            get
36
            {
37
                return this.szField;
38
            }
39
            set
40
            {
41
                this.szField = value;
42
            }
43
        }
44

45
        [XmlElement(Order = 1)]
46
        public CT_FramesetSplitbar framesetSplitbar
47
        {
48
            get
49
            {
50
                return this.framesetSplitbarField;
51
            }
52
            set
53
            {
54
                this.framesetSplitbarField = value;
55
            }
56
        }
57

58
        [XmlElement(Order = 2)]
59
        public CT_FrameLayout frameLayout
60
        {
61
            get
62
            {
63
                return this.frameLayoutField;
64
            }
65
            set
66
            {
67
                this.frameLayoutField = value;
68
            }
69
        }
70

71
        [XmlElement("frame", typeof(CT_Frame), Order = 3)]
72
        [XmlElement("frameset", typeof(CT_Frameset), Order = 3)]
73
        public object[] Items
74
        {
75
            get
76
            {
77
                return this.itemsField;
78
            }
79
            set
80
            {
81
                this.itemsField = value;
82
            }
83
        }
84
    }
85

86

87
    [Serializable]
88

89
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
90
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
91
    public class CT_FramesetSplitbar
92
    {
93

94
        private CT_TwipsMeasure wField;
95

96
        private CT_Color colorField;
97

98
        private CT_OnOff noBorderField;
99

100
        private CT_OnOff flatBordersField;
101

102
        public CT_FramesetSplitbar()
103
        {
104
            this.flatBordersField = new CT_OnOff();
105
            this.noBorderField = new CT_OnOff();
106
            this.colorField = new CT_Color();
107
            this.wField = new CT_TwipsMeasure();
108
        }
109

110
        [XmlElement(Order = 0)]
111
        public CT_TwipsMeasure w
112
        {
113
            get
114
            {
115
                return this.wField;
116
            }
117
            set
118
            {
119
                this.wField = value;
120
            }
121
        }
122

123
        [XmlElement(Order = 1)]
124
        public CT_Color color
125
        {
126
            get
127
            {
128
                return this.colorField;
129
            }
130
            set
131
            {
132
                this.colorField = value;
133
            }
134
        }
135

136
        [XmlElement(Order = 2)]
137
        public CT_OnOff noBorder
138
        {
139
            get
140
            {
141
                return this.noBorderField;
142
            }
143
            set
144
            {
145
                this.noBorderField = value;
146
            }
147
        }
148

149
        [XmlElement(Order = 3)]
150
        public CT_OnOff flatBorders
151
        {
152
            get
153
            {
154
                return this.flatBordersField;
155
            }
156
            set
157
            {
158
                this.flatBordersField = value;
159
            }
160
        }
161
    }
162

163

164
    [Serializable]
165

166
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
167
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
168
    public class CT_FrameLayout
169
    {
170

171
        private ST_FrameLayout valField;
172

173
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
174
        public ST_FrameLayout val
175
        {
176
            get
177
            {
178
                return this.valField;
179
            }
180
            set
181
            {
182
                this.valField = value;
183
            }
184
        }
185
    }
186

187

188
    [Serializable]
189
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
190
    public enum ST_FrameLayout
191
    {
192

193
    
194
        rows,
195

196
    
197
        cols,
198

199
    
200
        none,
201
    }
202

203
    
204
    [Serializable]
205

206
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
207
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
208
    public class CT_Frame
209
    {
210

211
        private CT_String szField;
212

213
        private CT_String nameField;
214

215
        private CT_Rel sourceFileNameField;
216

217
        private CT_PixelsMeasure marWField;
218

219
        private CT_PixelsMeasure marHField;
220

221
        private CT_FrameScrollbar scrollbarField;
222

223
        private CT_OnOff noResizeAllowedField;
224

225
        private CT_OnOff linkedToFileField;
226

227
        public CT_Frame()
228
        {
229
            this.linkedToFileField = new CT_OnOff();
230
            this.noResizeAllowedField = new CT_OnOff();
231
            this.scrollbarField = new CT_FrameScrollbar();
232
            this.marHField = new CT_PixelsMeasure();
233
            this.marWField = new CT_PixelsMeasure();
234
            this.sourceFileNameField = new CT_Rel();
235
            this.nameField = new CT_String();
236
            this.szField = new CT_String();
237
        }
238

239
        [XmlElement(Order = 0)]
240
        public CT_String sz
241
        {
242
            get
243
            {
244
                return this.szField;
245
            }
246
            set
247
            {
248
                this.szField = value;
249
            }
250
        }
251

252
        [XmlElement(Order = 1)]
253
        public CT_String name
254
        {
255
            get
256
            {
257
                return this.nameField;
258
            }
259
            set
260
            {
261
                this.nameField = value;
262
            }
263
        }
264

265
        [XmlElement(Order = 2)]
266
        public CT_Rel sourceFileName
267
        {
268
            get
269
            {
270
                return this.sourceFileNameField;
271
            }
272
            set
273
            {
274
                this.sourceFileNameField = value;
275
            }
276
        }
277

278
        [XmlElement(Order = 3)]
279
        public CT_PixelsMeasure marW
280
        {
281
            get
282
            {
283
                return this.marWField;
284
            }
285
            set
286
            {
287
                this.marWField = value;
288
            }
289
        }
290

291
        [XmlElement(Order = 4)]
292
        public CT_PixelsMeasure marH
293
        {
294
            get
295
            {
296
                return this.marHField;
297
            }
298
            set
299
            {
300
                this.marHField = value;
301
            }
302
        }
303

304
        [XmlElement(Order = 5)]
305
        public CT_FrameScrollbar scrollbar
306
        {
307
            get
308
            {
309
                return this.scrollbarField;
310
            }
311
            set
312
            {
313
                this.scrollbarField = value;
314
            }
315
        }
316

317
        [XmlElement(Order = 6)]
318
        public CT_OnOff noResizeAllowed
319
        {
320
            get
321
            {
322
                return this.noResizeAllowedField;
323
            }
324
            set
325
            {
326
                this.noResizeAllowedField = value;
327
            }
328
        }
329

330
        [XmlElement(Order = 7)]
331
        public CT_OnOff linkedToFile
332
        {
333
            get
334
            {
335
                return this.linkedToFileField;
336
            }
337
            set
338
            {
339
                this.linkedToFileField = value;
340
            }
341
        }
342
    }
343

344
    [Serializable]
345
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
346
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
347
    public class CT_FrameScrollbar
348
    {
349

350
        private ST_FrameScrollbar valField;
351

352
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
353
        public ST_FrameScrollbar val
354
        {
355
            get
356
            {
357
                return this.valField;
358
            }
359
            set
360
            {
361
                this.valField = value;
362
            }
363
        }
364
    }
365

366

367
    [Serializable]
368
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
369
    public enum ST_FrameScrollbar
370
    {
371

372
    
373
        on,
374

375
    
376
        off,
377

378
    
379
        auto,
380
    }
381

382
    [Serializable]
383

384
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
385
    [XmlRoot(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", IsNullable = true)]
386
    public class CT_FramePr
387
    {
388

389
        private ST_DropCap dropCapField;
390

391
        private bool dropCapFieldSpecified;
392

393
        private string linesField;
394

395
        private ulong wField;
396

397
        private bool wFieldSpecified;
398

399
        private ulong hField;
400

401
        private bool hFieldSpecified;
402

403
        private ulong vSpaceField;
404

405
        private bool vSpaceFieldSpecified;
406

407
        private ulong hSpaceField;
408

409
        private bool hSpaceFieldSpecified;
410

411
        private ST_Wrap wrapField;
412

413
        private bool wrapFieldSpecified;
414

415
        private ST_HAnchor hAnchorField;
416

417
        private bool hAnchorFieldSpecified;
418

419
        private ST_VAnchor vAnchorField;
420

421
        private bool vAnchorFieldSpecified;
422

423
        private string xField;
424

425
        private ST_XAlign xAlignField;
426

427
        private bool xAlignFieldSpecified;
428

429
        private string yField;
430

431
        private ST_YAlign yAlignField;
432

433
        private bool yAlignFieldSpecified;
434

435
        private ST_HeightRule hRuleField;
436

437
        private bool hRuleFieldSpecified;
438

439
        private ST_OnOff anchorLockField;
440

441
        private bool anchorLockFieldSpecified;
442
        public static CT_FramePr Parse(XmlNode node, XmlNamespaceManager namespaceManager)
443
        {
444
            if (node == null)
445
                return null;
446
            CT_FramePr ctObj = new CT_FramePr();
447
            if (node.Attributes["w:dropCap"] != null)
448
                ctObj.dropCap = (ST_DropCap)Enum.Parse(typeof(ST_DropCap), node.Attributes["w:dropCap"].Value);
449
            ctObj.lines = XmlHelper.ReadString(node.Attributes["w:lines"]);
450
            ctObj.w = XmlHelper.ReadULong(node.Attributes["w:w"]);
451
            ctObj.h = XmlHelper.ReadULong(node.Attributes["w:h"]);
452
            ctObj.vSpace = XmlHelper.ReadULong(node.Attributes["w:vSpace"]);
453
            ctObj.hSpace = XmlHelper.ReadULong(node.Attributes["w:hSpace"]);
454
            if (node.Attributes["w:wrap"] != null)
455
                ctObj.wrap = (ST_Wrap)Enum.Parse(typeof(ST_Wrap), node.Attributes["w:wrap"].Value);
456
            if (node.Attributes["w:hAnchor"] != null)
457
                ctObj.hAnchor = (ST_HAnchor)Enum.Parse(typeof(ST_HAnchor), node.Attributes["w:hAnchor"].Value);
458
            if (node.Attributes["w:vAnchor"] != null)
459
                ctObj.vAnchor = (ST_VAnchor)Enum.Parse(typeof(ST_VAnchor), node.Attributes["w:vAnchor"].Value);
460
            ctObj.x = XmlHelper.ReadString(node.Attributes["w:x"]);
461
            if (node.Attributes["w:xAlign"] != null)
462
                ctObj.xAlign = (ST_XAlign)Enum.Parse(typeof(ST_XAlign), node.Attributes["w:xAlign"].Value);
463
            ctObj.y = XmlHelper.ReadString(node.Attributes["w:y"]);
464
            if (node.Attributes["w:yAlign"] != null)
465
                ctObj.yAlign = (ST_YAlign)Enum.Parse(typeof(ST_YAlign), node.Attributes["w:yAlign"].Value);
466
            if (node.Attributes["w:hRule"] != null)
467
                ctObj.hRule = (ST_HeightRule)Enum.Parse(typeof(ST_HeightRule), node.Attributes["w:hRule"].Value);
468
            if (node.Attributes["w:anchorLock"] != null)
469
                ctObj.anchorLock = (ST_OnOff)Enum.Parse(typeof(ST_OnOff), node.Attributes["w:anchorLock"].Value,true);
470
            return ctObj;
471
        }
472

473

474

475
        internal void Write(StreamWriter sw, string nodeName)
476
        {
477
            sw.Write(string.Format("<w:{0}", nodeName));
478
            XmlHelper.WriteAttribute(sw, "w:dropCap", this.dropCap.ToString());
479
            XmlHelper.WriteAttribute(sw, "w:lines", this.lines);
480
            XmlHelper.WriteAttribute(sw, "w:w", this.w);
481
            XmlHelper.WriteAttribute(sw, "w:h", this.h);
482
            XmlHelper.WriteAttribute(sw, "w:vSpace", this.vSpace);
483
            XmlHelper.WriteAttribute(sw, "w:hSpace", this.hSpace);
484
            XmlHelper.WriteAttribute(sw, "w:wrap", this.wrap.ToString());
485
            XmlHelper.WriteAttribute(sw, "w:hAnchor", this.hAnchor.ToString());
486
            XmlHelper.WriteAttribute(sw, "w:vAnchor", this.vAnchor.ToString());
487
            XmlHelper.WriteAttribute(sw, "w:x", this.x);
488
            XmlHelper.WriteAttribute(sw, "w:xAlign", this.xAlign.ToString());
489
            XmlHelper.WriteAttribute(sw, "w:y", this.y);
490
            XmlHelper.WriteAttribute(sw, "w:yAlign", this.yAlign.ToString());
491
            XmlHelper.WriteAttribute(sw, "w:hRule", this.hRule.ToString());
492
            XmlHelper.WriteAttribute(sw, "w:anchorLock", this.anchorLock.ToString());
493
            sw.Write(">");
494
            sw.WriteEndW(nodeName);
495
        }
496

497

498
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
499
        public ST_DropCap dropCap
500
        {
501
            get
502
            {
503
                return this.dropCapField;
504
            }
505
            set
506
            {
507
                this.dropCapField = value;
508
            }
509
        }
510

511
        [XmlIgnore]
512
        public bool dropCapSpecified
513
        {
514
            get
515
            {
516
                return this.dropCapFieldSpecified;
517
            }
518
            set
519
            {
520
                this.dropCapFieldSpecified = value;
521
            }
522
        }
523

524
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
525
        public string lines
526
        {
527
            get
528
            {
529
                return this.linesField;
530
            }
531
            set
532
            {
533
                this.linesField = value;
534
            }
535
        }
536

537
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
538
        public ulong w
539
        {
540
            get
541
            {
542
                return this.wField;
543
            }
544
            set
545
            {
546
                this.wField = value;
547
            }
548
        }
549

550
        [XmlIgnore]
551
        public bool wSpecified
552
        {
553
            get
554
            {
555
                return this.wFieldSpecified;
556
            }
557
            set
558
            {
559
                this.wFieldSpecified = value;
560
            }
561
        }
562

563
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
564
        public ulong h
565
        {
566
            get
567
            {
568
                return this.hField;
569
            }
570
            set
571
            {
572
                this.hField = value;
573
            }
574
        }
575

576
        [XmlIgnore]
577
        public bool hSpecified
578
        {
579
            get
580
            {
581
                return this.hFieldSpecified;
582
            }
583
            set
584
            {
585
                this.hFieldSpecified = value;
586
            }
587
        }
588

589
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
590
        public ulong vSpace
591
        {
592
            get
593
            {
594
                return this.vSpaceField;
595
            }
596
            set
597
            {
598
                this.vSpaceField = value;
599
            }
600
        }
601

602
        [XmlIgnore]
603
        public bool vSpaceSpecified
604
        {
605
            get
606
            {
607
                return this.vSpaceFieldSpecified;
608
            }
609
            set
610
            {
611
                this.vSpaceFieldSpecified = value;
612
            }
613
        }
614

615
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
616
        public ulong hSpace
617
        {
618
            get
619
            {
620
                return this.hSpaceField;
621
            }
622
            set
623
            {
624
                this.hSpaceField = value;
625
            }
626
        }
627

628
        [XmlIgnore]
629
        public bool hSpaceSpecified
630
        {
631
            get
632
            {
633
                return this.hSpaceFieldSpecified;
634
            }
635
            set
636
            {
637
                this.hSpaceFieldSpecified = value;
638
            }
639
        }
640

641
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
642
        public ST_Wrap wrap
643
        {
644
            get
645
            {
646
                return this.wrapField;
647
            }
648
            set
649
            {
650
                this.wrapField = value;
651
            }
652
        }
653

654
        [XmlIgnore]
655
        public bool wrapSpecified
656
        {
657
            get
658
            {
659
                return this.wrapFieldSpecified;
660
            }
661
            set
662
            {
663
                this.wrapFieldSpecified = value;
664
            }
665
        }
666

667
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
668
        public ST_HAnchor hAnchor
669
        {
670
            get
671
            {
672
                return this.hAnchorField;
673
            }
674
            set
675
            {
676
                this.hAnchorField = value;
677
            }
678
        }
679

680
        [XmlIgnore]
681
        public bool hAnchorSpecified
682
        {
683
            get
684
            {
685
                return this.hAnchorFieldSpecified;
686
            }
687
            set
688
            {
689
                this.hAnchorFieldSpecified = value;
690
            }
691
        }
692

693
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
694
        public ST_VAnchor vAnchor
695
        {
696
            get
697
            {
698
                return this.vAnchorField;
699
            }
700
            set
701
            {
702
                this.vAnchorField = value;
703
            }
704
        }
705

706
        [XmlIgnore]
707
        public bool vAnchorSpecified
708
        {
709
            get
710
            {
711
                return this.vAnchorFieldSpecified;
712
            }
713
            set
714
            {
715
                this.vAnchorFieldSpecified = value;
716
            }
717
        }
718

719
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
720
        public string x
721
        {
722
            get
723
            {
724
                return this.xField;
725
            }
726
            set
727
            {
728
                this.xField = value;
729
            }
730
        }
731

732
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
733
        public ST_XAlign xAlign
734
        {
735
            get
736
            {
737
                return this.xAlignField;
738
            }
739
            set
740
            {
741
                this.xAlignField = value;
742
            }
743
        }
744

745
        [XmlIgnore]
746
        public bool xAlignSpecified
747
        {
748
            get
749
            {
750
                return this.xAlignFieldSpecified;
751
            }
752
            set
753
            {
754
                this.xAlignFieldSpecified = value;
755
            }
756
        }
757

758
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified, DataType = "integer")]
759
        public string y
760
        {
761
            get
762
            {
763
                return this.yField;
764
            }
765
            set
766
            {
767
                this.yField = value;
768
            }
769
        }
770

771
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
772
        public ST_YAlign yAlign
773
        {
774
            get
775
            {
776
                return this.yAlignField;
777
            }
778
            set
779
            {
780
                this.yAlignField = value;
781
            }
782
        }
783

784
        [XmlIgnore]
785
        public bool yAlignSpecified
786
        {
787
            get
788
            {
789
                return this.yAlignFieldSpecified;
790
            }
791
            set
792
            {
793
                this.yAlignFieldSpecified = value;
794
            }
795
        }
796

797
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
798
        public ST_HeightRule hRule
799
        {
800
            get
801
            {
802
                return this.hRuleField;
803
            }
804
            set
805
            {
806
                this.hRuleField = value;
807
            }
808
        }
809

810
        [XmlIgnore]
811
        public bool hRuleSpecified
812
        {
813
            get
814
            {
815
                return this.hRuleFieldSpecified;
816
            }
817
            set
818
            {
819
                this.hRuleFieldSpecified = value;
820
            }
821
        }
822

823
        [XmlAttribute(Form = System.Xml.Schema.XmlSchemaForm.Qualified)]
824
        public ST_OnOff anchorLock
825
        {
826
            get
827
            {
828
                return this.anchorLockField;
829
            }
830
            set
831
            {
832
                this.anchorLockField = value;
833
            }
834
        }
835

836
        [XmlIgnore]
837
        public bool anchorLockSpecified
838
        {
839
            get
840
            {
841
                return this.anchorLockFieldSpecified;
842
            }
843
            set
844
            {
845
                this.anchorLockFieldSpecified = value;
846
            }
847
        }
848
    }
849

850

851
    [Serializable]
852
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
853
    public enum ST_DropCap
854
    {
855

856
    
857
        none,
858

859
    
860
        drop,
861

862
    
863
        margin,
864
    }
865

866

867
    [Serializable]
868
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
869
    public enum ST_Wrap
870
    {
871

872
    
873
        auto,
874

875
    
876
        notBeside,
877

878
    
879
        around,
880

881
    
882
        tight,
883

884
    
885
        through,
886

887
    
888
        none,
889
    }
890

891

892
    [Serializable]
893
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
894
    public enum ST_HAnchor
895
    {
896

897
    
898
        text,
899

900
    
901
        margin,
902

903
    
904
        page,
905
    }
906

907

908
    [Serializable]
909
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
910
    public enum ST_VAnchor
911
    {
912

913
    
914
        text,
915

916
    
917
        margin,
918

919
    
920
        page,
921
    }
922

923

924
    [Serializable]
925
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
926
    public enum ST_XAlign
927
    {
928

929
    
930
        left,
931

932
    
933
        center,
934

935
    
936
        right,
937

938
    
939
        inside,
940

941
    
942
        outside,
943
    }
944

945

946
    [Serializable]
947
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
948
    public enum ST_YAlign
949
    {
950

951
    
952
        inline,
953

954
    
955
        top,
956

957
    
958
        center,
959

960
    
961
        bottom,
962

963
    
964
        inside,
965

966
    
967
        outside,
968
    }
969

970

971
    [Serializable]
972
    [XmlType(Namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main")]
973
    public enum ST_HeightRule
974
    {
975

976
    
977
        auto,
978

979
    
980
        exact,
981

982
    
983
        atLeast,
984
    }
985
}