@tsonic/efcore 10.0.8 → 10.0.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -85,7 +85,6 @@ export interface ICheckConstraint$instance extends IReadOnlyCheckConstraint, IRe
85
85
  readonly ModelName: string;
86
86
  readonly Name: string | undefined;
87
87
  readonly Sql: string;
88
- readonly [name: string]: unknown | undefined;
89
88
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
90
89
  AnnotationsToDebugString(indent?: int): string;
91
90
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -100,7 +99,7 @@ export interface ICheckConstraint$instance extends IReadOnlyCheckConstraint, IRe
100
99
  }
101
100
 
102
101
 
103
- export type ICheckConstraint = ICheckConstraint$instance;
102
+ export type ICheckConstraint = ICheckConstraint$instance & { readonly [name: string]: unknown | undefined; };
104
103
 
105
104
  export interface IClrCollectionAccessor$instance {
106
105
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IClrCollectionAccessor: never;
@@ -173,7 +172,6 @@ export interface IColumn$instance extends IColumnBase, IAnnotatable, IReadOnlyAn
173
172
  readonly StoreTypeMapping: RelationalTypeMapping;
174
173
  readonly IsNullable: boolean;
175
174
  readonly ProviderValueComparer: ValueComparer;
176
- readonly [name: string]: unknown | undefined;
177
175
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
178
176
  AnnotationsToDebugString(indent?: int): string;
179
177
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMapping | undefined;
@@ -189,7 +187,7 @@ export interface IColumn$instance extends IColumnBase, IAnnotatable, IReadOnlyAn
189
187
  }
190
188
 
191
189
 
192
- export type IColumn = IColumn$instance;
190
+ export type IColumn = IColumn$instance & { readonly [name: string]: unknown | undefined; };
193
191
 
194
192
  export interface IColumnBase$instance extends IAnnotatable, IReadOnlyAnnotatable {
195
193
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IColumnBase: never;
@@ -202,7 +200,6 @@ export interface IColumnBase$instance extends IAnnotatable, IReadOnlyAnnotatable
202
200
  readonly Table: ITableBase;
203
201
  readonly PropertyMappings: IReadOnlyList_1<IColumnMappingBase>;
204
202
  readonly ProviderValueComparer: ValueComparer;
205
- readonly [name: string]: unknown | undefined;
206
203
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
207
204
  AnnotationsToDebugString(indent?: int): string;
208
205
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -216,7 +213,7 @@ export interface IColumnBase$instance extends IAnnotatable, IReadOnlyAnnotatable
216
213
  }
217
214
 
218
215
 
219
- export type IColumnBase = IColumnBase$instance;
216
+ export type IColumnBase = IColumnBase$instance & { readonly [name: string]: unknown | undefined; };
220
217
 
221
218
  export interface IColumnMapping$instance extends IColumnMappingBase, IAnnotatable, IReadOnlyAnnotatable {
222
219
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IColumnMapping: never;
@@ -225,7 +222,6 @@ export interface IColumnMapping$instance extends IColumnMappingBase, IAnnotatabl
225
222
  readonly TableMapping: ITableMapping;
226
223
  readonly Property: IProperty;
227
224
  readonly TypeMapping: RelationalTypeMapping;
228
- readonly [name: string]: unknown | undefined;
229
225
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
230
226
  AnnotationsToDebugString(indent?: int): string;
231
227
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -238,7 +234,7 @@ export interface IColumnMapping$instance extends IColumnMappingBase, IAnnotatabl
238
234
  }
239
235
 
240
236
 
241
- export type IColumnMapping = IColumnMapping$instance;
237
+ export type IColumnMapping = IColumnMapping$instance & { readonly [name: string]: unknown | undefined; };
242
238
 
243
239
  export interface IColumnMappingBase$instance extends IAnnotatable, IReadOnlyAnnotatable {
244
240
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IColumnMappingBase: never;
@@ -247,7 +243,6 @@ export interface IColumnMappingBase$instance extends IAnnotatable, IReadOnlyAnno
247
243
  readonly Column: IColumnBase;
248
244
  readonly TypeMapping: RelationalTypeMapping;
249
245
  readonly TableMapping: ITableMappingBase;
250
- readonly [name: string]: unknown | undefined;
251
246
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
252
247
  AnnotationsToDebugString(indent?: int): string;
253
248
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -259,7 +254,7 @@ export interface IColumnMappingBase$instance extends IAnnotatable, IReadOnlyAnno
259
254
  }
260
255
 
261
256
 
262
- export type IColumnMappingBase = IColumnMappingBase$instance;
257
+ export type IColumnMappingBase = IColumnMappingBase$instance & { readonly [name: string]: unknown | undefined; };
263
258
 
264
259
  export interface IComplexProperty$instance extends IReadOnlyComplexProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IPropertyBase, IAnnotatable {
265
260
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IComplexProperty: never;
@@ -273,7 +268,6 @@ export interface IComplexProperty$instance extends IReadOnlyComplexProperty, IRe
273
268
  readonly IsCollection: boolean;
274
269
  readonly PropertyInfo: PropertyInfo | undefined;
275
270
  readonly FieldInfo: FieldInfo | undefined;
276
- readonly [name: string]: unknown | undefined;
277
271
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
278
272
  AnnotationsToDebugString(indent?: int): string;
279
273
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -294,7 +288,7 @@ export interface IComplexProperty$instance extends IReadOnlyComplexProperty, IRe
294
288
  }
295
289
 
296
290
 
297
- export type IComplexProperty = IComplexProperty$instance;
291
+ export type IComplexProperty = IComplexProperty$instance & { readonly [name: string]: unknown | undefined; };
298
292
 
299
293
  export interface IComplexType$instance extends IReadOnlyComplexType, IReadOnlyTypeBase, IReadOnlyAnnotatable, ITypeBase, IAnnotatable {
300
294
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IComplexType: never;
@@ -307,7 +301,6 @@ export interface IComplexType$instance extends IReadOnlyComplexType, IReadOnlyTy
307
301
  readonly ClrType: Type;
308
302
  readonly HasSharedClrType: boolean;
309
303
  readonly IsPropertyBag: boolean;
310
- readonly [name: string]: unknown | undefined;
311
304
  readonly ConstructorBinding: InstantiationBinding | undefined;
312
305
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
313
306
  AnnotationsToDebugString(indent?: int): string;
@@ -360,7 +353,7 @@ export interface IComplexType$instance extends IReadOnlyComplexType, IReadOnlyTy
360
353
  }
361
354
 
362
355
 
363
- export type IComplexType = IComplexType$instance;
356
+ export type IComplexType = IComplexType$instance & { readonly [name: string]: unknown | undefined; };
364
357
 
365
358
  export interface IConstructorBindingFactory$instance {
366
359
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConstructorBindingFactory: never;
@@ -381,7 +374,6 @@ export interface IConventionAnnotatable$instance extends IReadOnlyAnnotatable {
381
374
 
382
375
  readonly Builder: IConventionAnnotatableBuilder;
383
376
  readonly IsInModel: boolean;
384
- readonly [name: string]: unknown | undefined;
385
377
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
386
378
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
387
379
  AnnotationsToDebugString(indent?: int): string;
@@ -392,7 +384,7 @@ export interface IConventionAnnotatable$instance extends IReadOnlyAnnotatable {
392
384
  }
393
385
 
394
386
 
395
- export type IConventionAnnotatable = IConventionAnnotatable$instance;
387
+ export type IConventionAnnotatable = IConventionAnnotatable$instance & { readonly [name: string]: unknown | undefined; };
396
388
 
397
389
  export interface IConventionAnnotation$instance extends IAnnotation {
398
390
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionAnnotation: never;
@@ -415,7 +407,6 @@ export interface IConventionCheckConstraint$instance extends IReadOnlyCheckConst
415
407
  readonly ModelName: string;
416
408
  readonly Name: string | undefined;
417
409
  readonly Sql: string;
418
- readonly [name: string]: unknown | undefined;
419
410
  readonly IsInModel: boolean;
420
411
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
421
412
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -434,7 +425,7 @@ export interface IConventionCheckConstraint$instance extends IReadOnlyCheckConst
434
425
  }
435
426
 
436
427
 
437
- export type IConventionCheckConstraint = IConventionCheckConstraint$instance;
428
+ export type IConventionCheckConstraint = IConventionCheckConstraint$instance & { readonly [name: string]: unknown | undefined; };
438
429
 
439
430
  export interface IConventionComplexProperty$instance extends IReadOnlyComplexProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionPropertyBase, IConventionAnnotatable {
440
431
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionComplexProperty: never;
@@ -449,7 +440,6 @@ export interface IConventionComplexProperty$instance extends IReadOnlyComplexPro
449
440
  readonly IsCollection: boolean;
450
441
  readonly PropertyInfo: PropertyInfo | undefined;
451
442
  readonly FieldInfo: FieldInfo | undefined;
452
- readonly [name: string]: unknown | undefined;
453
443
  readonly IsInModel: boolean;
454
444
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
455
445
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -473,7 +463,7 @@ export interface IConventionComplexProperty$instance extends IReadOnlyComplexPro
473
463
  }
474
464
 
475
465
 
476
- export type IConventionComplexProperty = IConventionComplexProperty$instance;
466
+ export type IConventionComplexProperty = IConventionComplexProperty$instance & { readonly [name: string]: unknown | undefined; };
477
467
 
478
468
  export interface IConventionComplexType$instance extends IReadOnlyComplexType, IReadOnlyTypeBase, IReadOnlyAnnotatable, IConventionTypeBase, IConventionAnnotatable {
479
469
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionComplexType: never;
@@ -487,7 +477,6 @@ export interface IConventionComplexType$instance extends IReadOnlyComplexType, I
487
477
  readonly ClrType: Type;
488
478
  readonly HasSharedClrType: boolean;
489
479
  readonly IsPropertyBag: boolean;
490
- readonly [name: string]: unknown | undefined;
491
480
  readonly IsInModel: boolean;
492
481
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
493
482
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -562,7 +551,7 @@ export interface IConventionComplexType$instance extends IReadOnlyComplexType, I
562
551
  }
563
552
 
564
553
 
565
- export type IConventionComplexType = IConventionComplexType$instance;
554
+ export type IConventionComplexType = IConventionComplexType$instance & { readonly [name: string]: unknown | undefined; };
566
555
 
567
556
  export interface IConventionDbFunction$instance extends IReadOnlyDbFunction, IReadOnlyAnnotatable, IConventionAnnotatable {
568
557
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionDbFunction: never;
@@ -582,7 +571,6 @@ export interface IConventionDbFunction$instance extends IReadOnlyDbFunction, IRe
582
571
  readonly ReturnType: Type;
583
572
  readonly TypeMapping: RelationalTypeMapping | undefined;
584
573
  readonly Translation: Func_2<IReadOnlyList_1<SqlExpression>, SqlExpression> | undefined;
585
- readonly [name: string]: unknown | undefined;
586
574
  readonly IsInModel: boolean;
587
575
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
588
576
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -602,7 +590,7 @@ export interface IConventionDbFunction$instance extends IReadOnlyDbFunction, IRe
602
590
  }
603
591
 
604
592
 
605
- export type IConventionDbFunction = IConventionDbFunction$instance;
593
+ export type IConventionDbFunction = IConventionDbFunction$instance & { readonly [name: string]: unknown | undefined; };
606
594
 
607
595
  export interface IConventionDbFunctionParameter$instance extends IReadOnlyDbFunctionParameter, IReadOnlyAnnotatable, IConventionAnnotatable {
608
596
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionDbFunctionParameter: never;
@@ -614,7 +602,6 @@ export interface IConventionDbFunctionParameter$instance extends IReadOnlyDbFunc
614
602
  readonly StoreType: string;
615
603
  readonly PropagatesNullability: boolean;
616
604
  readonly TypeMapping: RelationalTypeMapping | undefined;
617
- readonly [name: string]: unknown | undefined;
618
605
  readonly IsInModel: boolean;
619
606
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
620
607
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -632,7 +619,7 @@ export interface IConventionDbFunctionParameter$instance extends IReadOnlyDbFunc
632
619
  }
633
620
 
634
621
 
635
- export type IConventionDbFunctionParameter = IConventionDbFunctionParameter$instance;
622
+ export type IConventionDbFunctionParameter = IConventionDbFunctionParameter$instance & { readonly [name: string]: unknown | undefined; };
636
623
 
637
624
  export interface IConventionElementType$instance extends IReadOnlyElementType, IReadOnlyAnnotatable, IConventionAnnotatable {
638
625
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionElementType: never;
@@ -641,7 +628,6 @@ export interface IConventionElementType$instance extends IReadOnlyElementType, I
641
628
  readonly Builder: IConventionElementTypeBuilder;
642
629
  readonly ClrType: Type;
643
630
  readonly IsNullable: boolean;
644
- readonly [name: string]: unknown | undefined;
645
631
  readonly IsInModel: boolean;
646
632
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
647
633
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -668,7 +654,7 @@ export interface IConventionElementType$instance extends IReadOnlyElementType, I
668
654
  }
669
655
 
670
656
 
671
- export type IConventionElementType = IConventionElementType$instance;
657
+ export type IConventionElementType = IConventionElementType$instance & { readonly [name: string]: unknown | undefined; };
672
658
 
673
659
  export interface IConventionEntityType$instance extends IReadOnlyEntityType, IReadOnlyTypeBase, IReadOnlyAnnotatable, IConventionTypeBase, IConventionAnnotatable {
674
660
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionEntityType: never;
@@ -682,7 +668,6 @@ export interface IConventionEntityType$instance extends IReadOnlyEntityType, IRe
682
668
  readonly ClrType: Type;
683
669
  readonly HasSharedClrType: boolean;
684
670
  readonly IsPropertyBag: boolean;
685
- readonly [name: string]: unknown | undefined;
686
671
  readonly IsInModel: boolean;
687
672
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
688
673
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -823,7 +808,7 @@ export interface IConventionEntityType$instance extends IReadOnlyEntityType, IRe
823
808
  }
824
809
 
825
810
 
826
- export type IConventionEntityType = IConventionEntityType$instance;
811
+ export type IConventionEntityType = IConventionEntityType$instance & { readonly [name: string]: unknown | undefined; };
827
812
 
828
813
  export interface IConventionEntityTypeMappingFragment$instance extends IReadOnlyEntityTypeMappingFragment, IReadOnlyAnnotatable, IConventionAnnotatable {
829
814
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionEntityTypeMappingFragment: never;
@@ -832,7 +817,6 @@ export interface IConventionEntityTypeMappingFragment$instance extends IReadOnly
832
817
  readonly Builder: IConventionEntityTypeMappingFragmentBuilder;
833
818
  readonly StoreObject: StoreObjectIdentifier;
834
819
  readonly IsTableExcludedFromMigrations: Nullable_1<System_Internal.Boolean>;
835
- readonly [name: string]: unknown | undefined;
836
820
  readonly IsInModel: boolean;
837
821
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
838
822
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -849,7 +833,7 @@ export interface IConventionEntityTypeMappingFragment$instance extends IReadOnly
849
833
  }
850
834
 
851
835
 
852
- export type IConventionEntityTypeMappingFragment = IConventionEntityTypeMappingFragment$instance;
836
+ export type IConventionEntityTypeMappingFragment = IConventionEntityTypeMappingFragment$instance & { readonly [name: string]: unknown | undefined; };
853
837
 
854
838
  export interface IConventionForeignKey$instance extends IReadOnlyForeignKey, IReadOnlyAnnotatable, IConventionAnnotatable {
855
839
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionForeignKey: never;
@@ -866,7 +850,6 @@ export interface IConventionForeignKey$instance extends IReadOnlyForeignKey, IRe
866
850
  readonly IsRequiredDependent: boolean;
867
851
  readonly IsOwnership: boolean;
868
852
  readonly DeleteBehavior: DeleteBehavior;
869
- readonly [name: string]: unknown | undefined;
870
853
  readonly IsInModel: boolean;
871
854
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
872
855
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -893,7 +876,7 @@ export interface IConventionForeignKey$instance extends IReadOnlyForeignKey, IRe
893
876
  }
894
877
 
895
878
 
896
- export type IConventionForeignKey = IConventionForeignKey$instance;
879
+ export type IConventionForeignKey = IConventionForeignKey$instance & { readonly [name: string]: unknown | undefined; };
897
880
 
898
881
  export interface IConventionIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotatable, IConventionAnnotatable {
899
882
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionIndex: never;
@@ -904,7 +887,6 @@ export interface IConventionIndex$instance extends IReadOnlyIndex, IReadOnlyAnno
904
887
  readonly Name: string | undefined;
905
888
  readonly IsUnique: boolean;
906
889
  readonly IsDescending: IReadOnlyList_1<System_Internal.Boolean> | undefined;
907
- readonly [name: string]: unknown | undefined;
908
890
  readonly IsInModel: boolean;
909
891
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
910
892
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -923,7 +905,7 @@ export interface IConventionIndex$instance extends IReadOnlyIndex, IReadOnlyAnno
923
905
  }
924
906
 
925
907
 
926
- export type IConventionIndex = IConventionIndex$instance;
908
+ export type IConventionIndex = IConventionIndex$instance & { readonly [name: string]: unknown | undefined; };
927
909
 
928
910
  export interface IConventionKey$instance extends IReadOnlyKey, IReadOnlyAnnotatable, IConventionAnnotatable {
929
911
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionKey: never;
@@ -931,7 +913,6 @@ export interface IConventionKey$instance extends IReadOnlyKey, IReadOnlyAnnotata
931
913
  readonly Builder: IConventionKeyBuilder;
932
914
  readonly Properties: IReadOnlyList_1<IConventionProperty>;
933
915
  readonly DeclaringEntityType: IConventionEntityType;
934
- readonly [name: string]: unknown | undefined;
935
916
  readonly IsInModel: boolean;
936
917
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
937
918
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -949,14 +930,13 @@ export interface IConventionKey$instance extends IReadOnlyKey, IReadOnlyAnnotata
949
930
  }
950
931
 
951
932
 
952
- export type IConventionKey = IConventionKey$instance;
933
+ export type IConventionKey = IConventionKey$instance & { readonly [name: string]: unknown | undefined; };
953
934
 
954
935
  export interface IConventionModel$instance extends IReadOnlyModel, IReadOnlyAnnotatable, IConventionAnnotatable {
955
936
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionModel: never;
956
937
 
957
938
  readonly Builder: IConventionModelBuilder;
958
939
  readonly ModelId: Guid;
959
- readonly [name: string]: unknown | undefined;
960
940
  readonly IsInModel: boolean;
961
941
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
962
942
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1008,7 +988,7 @@ export interface IConventionModel$instance extends IReadOnlyModel, IReadOnlyAnno
1008
988
  }
1009
989
 
1010
990
 
1011
- export type IConventionModel = IConventionModel$instance;
991
+ export type IConventionModel = IConventionModel$instance & { readonly [name: string]: unknown | undefined; };
1012
992
 
1013
993
  export interface IConventionNavigation$instance extends IReadOnlyNavigation, IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionNavigationBase, IConventionPropertyBase, IConventionAnnotatable {
1014
994
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionNavigation: never;
@@ -1028,7 +1008,6 @@ export interface IConventionNavigation$instance extends IReadOnlyNavigation, IRe
1028
1008
  readonly IsCollection: boolean;
1029
1009
  readonly PropertyInfo: PropertyInfo | undefined;
1030
1010
  readonly FieldInfo: FieldInfo | undefined;
1031
- readonly [name: string]: unknown | undefined;
1032
1011
  readonly IsInModel: boolean;
1033
1012
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1034
1013
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1055,7 +1034,7 @@ export interface IConventionNavigation$instance extends IReadOnlyNavigation, IRe
1055
1034
  }
1056
1035
 
1057
1036
 
1058
- export type IConventionNavigation = IConventionNavigation$instance;
1037
+ export type IConventionNavigation = IConventionNavigation$instance & { readonly [name: string]: unknown | undefined; };
1059
1038
 
1060
1039
  export interface IConventionNavigationBase$instance extends IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionPropertyBase, IConventionAnnotatable {
1061
1040
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionNavigationBase: never;
@@ -1072,7 +1051,6 @@ export interface IConventionNavigationBase$instance extends IReadOnlyNavigationB
1072
1051
  readonly IsCollection: boolean;
1073
1052
  readonly PropertyInfo: PropertyInfo | undefined;
1074
1053
  readonly FieldInfo: FieldInfo | undefined;
1075
- readonly [name: string]: unknown | undefined;
1076
1054
  readonly Builder: IConventionAnnotatableBuilder;
1077
1055
  readonly IsInModel: boolean;
1078
1056
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
@@ -1096,7 +1074,7 @@ export interface IConventionNavigationBase$instance extends IReadOnlyNavigationB
1096
1074
  }
1097
1075
 
1098
1076
 
1099
- export type IConventionNavigationBase = IConventionNavigationBase$instance;
1077
+ export type IConventionNavigationBase = IConventionNavigationBase$instance & { readonly [name: string]: unknown | undefined; };
1100
1078
 
1101
1079
  export interface IConventionProperty$instance extends IReadOnlyProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionPropertyBase, IConventionAnnotatable {
1102
1080
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionProperty: never;
@@ -1114,7 +1092,6 @@ export interface IConventionProperty$instance extends IReadOnlyProperty, IReadOn
1114
1092
  readonly IsCollection: boolean;
1115
1093
  readonly PropertyInfo: PropertyInfo | undefined;
1116
1094
  readonly FieldInfo: FieldInfo | undefined;
1117
- readonly [name: string]: unknown | undefined;
1118
1095
  readonly IsInModel: boolean;
1119
1096
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1120
1097
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1165,7 +1142,7 @@ export interface IConventionProperty$instance extends IReadOnlyProperty, IReadOn
1165
1142
  }
1166
1143
 
1167
1144
 
1168
- export type IConventionProperty = IConventionProperty$instance;
1145
+ export type IConventionProperty = IConventionProperty$instance & { readonly [name: string]: unknown | undefined; };
1169
1146
 
1170
1147
  export interface IConventionPropertyBase$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionAnnotatable {
1171
1148
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionPropertyBase: never;
@@ -1177,7 +1154,6 @@ export interface IConventionPropertyBase$instance extends IReadOnlyPropertyBase,
1177
1154
  readonly IsCollection: boolean;
1178
1155
  readonly PropertyInfo: PropertyInfo | undefined;
1179
1156
  readonly FieldInfo: FieldInfo | undefined;
1180
- readonly [name: string]: unknown | undefined;
1181
1157
  readonly Builder: IConventionAnnotatableBuilder;
1182
1158
  readonly IsInModel: boolean;
1183
1159
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
@@ -1199,7 +1175,7 @@ export interface IConventionPropertyBase$instance extends IReadOnlyPropertyBase,
1199
1175
  }
1200
1176
 
1201
1177
 
1202
- export type IConventionPropertyBase = IConventionPropertyBase$instance;
1178
+ export type IConventionPropertyBase = IConventionPropertyBase$instance & { readonly [name: string]: unknown | undefined; };
1203
1179
 
1204
1180
  export interface IConventionRelationalPropertyOverrides$instance extends IReadOnlyRelationalPropertyOverrides, IReadOnlyAnnotatable, IConventionAnnotatable {
1205
1181
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionRelationalPropertyOverrides: never;
@@ -1209,7 +1185,6 @@ export interface IConventionRelationalPropertyOverrides$instance extends IReadOn
1209
1185
  readonly StoreObject: StoreObjectIdentifier;
1210
1186
  readonly ColumnName: string | undefined;
1211
1187
  readonly IsColumnNameOverridden: boolean;
1212
- readonly [name: string]: unknown | undefined;
1213
1188
  readonly IsInModel: boolean;
1214
1189
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1215
1190
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1227,7 +1202,7 @@ export interface IConventionRelationalPropertyOverrides$instance extends IReadOn
1227
1202
  }
1228
1203
 
1229
1204
 
1230
- export type IConventionRelationalPropertyOverrides = IConventionRelationalPropertyOverrides$instance;
1205
+ export type IConventionRelationalPropertyOverrides = IConventionRelationalPropertyOverrides$instance & { readonly [name: string]: unknown | undefined; };
1231
1206
 
1232
1207
  export interface IConventionSequence$instance extends IReadOnlySequence, IReadOnlyAnnotatable, IConventionAnnotatable {
1233
1208
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionSequence: never;
@@ -1243,7 +1218,6 @@ export interface IConventionSequence$instance extends IReadOnlySequence, IReadOn
1243
1218
  readonly MaxValue: Nullable_1<System_Internal.Int64>;
1244
1219
  readonly Type: Type;
1245
1220
  readonly IsCyclic: boolean;
1246
- readonly [name: string]: unknown | undefined;
1247
1221
  readonly IsInModel: boolean;
1248
1222
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1249
1223
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1261,7 +1235,7 @@ export interface IConventionSequence$instance extends IReadOnlySequence, IReadOn
1261
1235
  }
1262
1236
 
1263
1237
 
1264
- export type IConventionSequence = IConventionSequence$instance;
1238
+ export type IConventionSequence = IConventionSequence$instance & { readonly [name: string]: unknown | undefined; };
1265
1239
 
1266
1240
  export interface IConventionServiceProperty$instance extends IReadOnlyServiceProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionPropertyBase, IConventionAnnotatable {
1267
1241
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionServiceProperty: never;
@@ -1276,7 +1250,6 @@ export interface IConventionServiceProperty$instance extends IReadOnlyServicePro
1276
1250
  readonly IsCollection: boolean;
1277
1251
  readonly PropertyInfo: PropertyInfo | undefined;
1278
1252
  readonly FieldInfo: FieldInfo | undefined;
1279
- readonly [name: string]: unknown | undefined;
1280
1253
  readonly IsInModel: boolean;
1281
1254
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1282
1255
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1300,7 +1273,7 @@ export interface IConventionServiceProperty$instance extends IReadOnlyServicePro
1300
1273
  }
1301
1274
 
1302
1275
 
1303
- export type IConventionServiceProperty = IConventionServiceProperty$instance;
1276
+ export type IConventionServiceProperty = IConventionServiceProperty$instance & { readonly [name: string]: unknown | undefined; };
1304
1277
 
1305
1278
  export interface IConventionSkipNavigation$instance extends IReadOnlySkipNavigation, IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IConventionNavigationBase, IConventionPropertyBase, IConventionAnnotatable {
1306
1279
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionSkipNavigation: never;
@@ -1321,7 +1294,6 @@ export interface IConventionSkipNavigation$instance extends IReadOnlySkipNavigat
1321
1294
  readonly IsCollection: boolean;
1322
1295
  readonly PropertyInfo: PropertyInfo | undefined;
1323
1296
  readonly FieldInfo: FieldInfo | undefined;
1324
- readonly [name: string]: unknown | undefined;
1325
1297
  readonly IsInModel: boolean;
1326
1298
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1327
1299
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1348,7 +1320,7 @@ export interface IConventionSkipNavigation$instance extends IReadOnlySkipNavigat
1348
1320
  }
1349
1321
 
1350
1322
 
1351
- export type IConventionSkipNavigation = IConventionSkipNavigation$instance;
1323
+ export type IConventionSkipNavigation = IConventionSkipNavigation$instance & { readonly [name: string]: unknown | undefined; };
1352
1324
 
1353
1325
  export interface IConventionStoredProcedure$instance extends IReadOnlyStoredProcedure, IReadOnlyAnnotatable, IConventionAnnotatable {
1354
1326
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionStoredProcedure: never;
@@ -1360,7 +1332,6 @@ export interface IConventionStoredProcedure$instance extends IReadOnlyStoredProc
1360
1332
  readonly Name: string;
1361
1333
  readonly Schema: string | undefined;
1362
1334
  readonly IsRowsAffectedReturned: boolean;
1363
- readonly [name: string]: unknown | undefined;
1364
1335
  readonly IsInModel: boolean;
1365
1336
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1366
1337
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1392,7 +1363,7 @@ export interface IConventionStoredProcedure$instance extends IReadOnlyStoredProc
1392
1363
  }
1393
1364
 
1394
1365
 
1395
- export type IConventionStoredProcedure = IConventionStoredProcedure$instance;
1366
+ export type IConventionStoredProcedure = IConventionStoredProcedure$instance & { readonly [name: string]: unknown | undefined; };
1396
1367
 
1397
1368
  export interface IConventionStoredProcedureParameter$instance extends IReadOnlyStoredProcedureParameter, IReadOnlyAnnotatable, IConventionAnnotatable {
1398
1369
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionStoredProcedureParameter: never;
@@ -1404,7 +1375,6 @@ export interface IConventionStoredProcedureParameter$instance extends IReadOnlyS
1404
1375
  readonly Direction: ParameterDirection;
1405
1376
  readonly ForOriginalValue: Nullable_1<System_Internal.Boolean>;
1406
1377
  readonly ForRowsAffected: boolean;
1407
- readonly [name: string]: unknown | undefined;
1408
1378
  readonly IsInModel: boolean;
1409
1379
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1410
1380
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1421,7 +1391,7 @@ export interface IConventionStoredProcedureParameter$instance extends IReadOnlyS
1421
1391
  }
1422
1392
 
1423
1393
 
1424
- export type IConventionStoredProcedureParameter = IConventionStoredProcedureParameter$instance;
1394
+ export type IConventionStoredProcedureParameter = IConventionStoredProcedureParameter$instance & { readonly [name: string]: unknown | undefined; };
1425
1395
 
1426
1396
  export interface IConventionStoredProcedureResultColumn$instance extends IReadOnlyStoredProcedureResultColumn, IReadOnlyAnnotatable, IConventionAnnotatable {
1427
1397
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionStoredProcedureResultColumn: never;
@@ -1431,7 +1401,6 @@ export interface IConventionStoredProcedureResultColumn$instance extends IReadOn
1431
1401
  readonly Name: string;
1432
1402
  readonly PropertyName: string | undefined;
1433
1403
  readonly ForRowsAffected: boolean;
1434
- readonly [name: string]: unknown | undefined;
1435
1404
  readonly IsInModel: boolean;
1436
1405
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1437
1406
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1447,7 +1416,7 @@ export interface IConventionStoredProcedureResultColumn$instance extends IReadOn
1447
1416
  }
1448
1417
 
1449
1418
 
1450
- export type IConventionStoredProcedureResultColumn = IConventionStoredProcedureResultColumn$instance;
1419
+ export type IConventionStoredProcedureResultColumn = IConventionStoredProcedureResultColumn$instance & { readonly [name: string]: unknown | undefined; };
1451
1420
 
1452
1421
  export interface IConventionTrigger$instance extends IReadOnlyTrigger, IReadOnlyAnnotatable, IConventionAnnotatable {
1453
1422
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionTrigger: never;
@@ -1455,7 +1424,6 @@ export interface IConventionTrigger$instance extends IReadOnlyTrigger, IReadOnly
1455
1424
  readonly Builder: IConventionTriggerBuilder;
1456
1425
  readonly EntityType: IConventionEntityType;
1457
1426
  readonly ModelName: string;
1458
- readonly [name: string]: unknown | undefined;
1459
1427
  readonly IsInModel: boolean;
1460
1428
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1461
1429
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1470,7 +1438,7 @@ export interface IConventionTrigger$instance extends IReadOnlyTrigger, IReadOnly
1470
1438
  }
1471
1439
 
1472
1440
 
1473
- export type IConventionTrigger = IConventionTrigger$instance;
1441
+ export type IConventionTrigger = IConventionTrigger$instance & { readonly [name: string]: unknown | undefined; };
1474
1442
 
1475
1443
  export interface IConventionTypeBase$instance extends IReadOnlyTypeBase, IReadOnlyAnnotatable, IConventionAnnotatable {
1476
1444
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionTypeBase: never;
@@ -1483,7 +1451,6 @@ export interface IConventionTypeBase$instance extends IReadOnlyTypeBase, IReadOn
1483
1451
  readonly ClrType: Type;
1484
1452
  readonly HasSharedClrType: boolean;
1485
1453
  readonly IsPropertyBag: boolean;
1486
- readonly [name: string]: unknown | undefined;
1487
1454
  readonly IsInModel: boolean;
1488
1455
  AddAnnotation(name: string, value: unknown, fromDataAnnotation?: boolean): IConventionAnnotation;
1489
1456
  AddAnnotations(annotations: IEnumerable_1<IConventionAnnotation>, fromDataAnnotation?: boolean): void;
@@ -1545,7 +1512,7 @@ export interface IConventionTypeBase$instance extends IReadOnlyTypeBase, IReadOn
1545
1512
  }
1546
1513
 
1547
1514
 
1548
- export type IConventionTypeBase = IConventionTypeBase$instance;
1515
+ export type IConventionTypeBase = IConventionTypeBase$instance & { readonly [name: string]: unknown | undefined; };
1549
1516
 
1550
1517
  export interface IDbFunction$instance extends IReadOnlyDbFunction, IReadOnlyAnnotatable, IAnnotatable {
1551
1518
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IDbFunction: never;
@@ -1565,7 +1532,6 @@ export interface IDbFunction$instance extends IReadOnlyDbFunction, IReadOnlyAnno
1565
1532
  readonly ReturnType: Type;
1566
1533
  readonly TypeMapping: RelationalTypeMapping | undefined;
1567
1534
  readonly Translation: Func_2<IReadOnlyList_1<SqlExpression>, SqlExpression> | undefined;
1568
- readonly [name: string]: unknown | undefined;
1569
1535
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1570
1536
  AnnotationsToDebugString(indent?: int): string;
1571
1537
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -1578,7 +1544,7 @@ export interface IDbFunction$instance extends IReadOnlyDbFunction, IReadOnlyAnno
1578
1544
  }
1579
1545
 
1580
1546
 
1581
- export type IDbFunction = IDbFunction$instance;
1547
+ export type IDbFunction = IDbFunction$instance & { readonly [name: string]: unknown | undefined; };
1582
1548
 
1583
1549
  export interface IDbFunctionParameter$instance extends IReadOnlyDbFunctionParameter, IReadOnlyAnnotatable, IAnnotatable {
1584
1550
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IDbFunctionParameter: never;
@@ -1590,7 +1556,6 @@ export interface IDbFunctionParameter$instance extends IReadOnlyDbFunctionParame
1590
1556
  readonly ClrType: Type;
1591
1557
  readonly PropagatesNullability: boolean;
1592
1558
  readonly TypeMapping: RelationalTypeMapping | undefined;
1593
- readonly [name: string]: unknown | undefined;
1594
1559
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1595
1560
  AnnotationsToDebugString(indent?: int): string;
1596
1561
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -1603,7 +1568,7 @@ export interface IDbFunctionParameter$instance extends IReadOnlyDbFunctionParame
1603
1568
  }
1604
1569
 
1605
1570
 
1606
- export type IDbFunctionParameter = IDbFunctionParameter$instance;
1571
+ export type IDbFunctionParameter = IDbFunctionParameter$instance & { readonly [name: string]: unknown | undefined; };
1607
1572
 
1608
1573
  export interface IDesignTimeModel$instance {
1609
1574
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IDesignTimeModel: never;
@@ -1620,7 +1585,6 @@ export interface IElementType$instance extends IReadOnlyElementType, IReadOnlyAn
1620
1585
  readonly CollectionProperty: IProperty;
1621
1586
  readonly ClrType: Type;
1622
1587
  readonly IsNullable: boolean;
1623
- readonly [name: string]: unknown | undefined;
1624
1588
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1625
1589
  AnnotationsToDebugString(indent?: int): string;
1626
1590
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -1639,7 +1603,7 @@ export interface IElementType$instance extends IReadOnlyElementType, IReadOnlyAn
1639
1603
  }
1640
1604
 
1641
1605
 
1642
- export type IElementType = IElementType$instance;
1606
+ export type IElementType = IElementType$instance & { readonly [name: string]: unknown | undefined; };
1643
1607
 
1644
1608
  export interface IEntityType$instance extends IReadOnlyEntityType, IReadOnlyTypeBase, IReadOnlyAnnotatable, ITypeBase, IAnnotatable {
1645
1609
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IEntityType: never;
@@ -1652,7 +1616,6 @@ export interface IEntityType$instance extends IReadOnlyEntityType, IReadOnlyType
1652
1616
  readonly ClrType: Type;
1653
1617
  readonly HasSharedClrType: boolean;
1654
1618
  readonly IsPropertyBag: boolean;
1655
- readonly [name: string]: unknown | undefined;
1656
1619
  readonly ConstructorBinding: InstantiationBinding | undefined;
1657
1620
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1658
1621
  AnnotationsToDebugString(indent?: int): string;
@@ -1748,7 +1711,7 @@ export interface IEntityType$instance extends IReadOnlyEntityType, IReadOnlyType
1748
1711
  }
1749
1712
 
1750
1713
 
1751
- export type IEntityType = IEntityType$instance;
1714
+ export type IEntityType = IEntityType$instance & { readonly [name: string]: unknown | undefined; };
1752
1715
 
1753
1716
  export interface IEntityTypeMappingFragment$instance extends IReadOnlyEntityTypeMappingFragment, IReadOnlyAnnotatable, IAnnotatable {
1754
1717
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IEntityTypeMappingFragment: never;
@@ -1756,7 +1719,6 @@ export interface IEntityTypeMappingFragment$instance extends IReadOnlyEntityType
1756
1719
  readonly EntityType: IEntityType;
1757
1720
  readonly StoreObject: StoreObjectIdentifier;
1758
1721
  readonly IsTableExcludedFromMigrations: Nullable_1<System_Internal.Boolean>;
1759
- readonly [name: string]: unknown | undefined;
1760
1722
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1761
1723
  AnnotationsToDebugString(indent?: int): string;
1762
1724
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -1769,7 +1731,7 @@ export interface IEntityTypeMappingFragment$instance extends IReadOnlyEntityType
1769
1731
  }
1770
1732
 
1771
1733
 
1772
- export type IEntityTypeMappingFragment = IEntityTypeMappingFragment$instance;
1734
+ export type IEntityTypeMappingFragment = IEntityTypeMappingFragment$instance & { readonly [name: string]: unknown | undefined; };
1773
1735
 
1774
1736
  export interface IForeignKey$instance extends IReadOnlyForeignKey, IReadOnlyAnnotatable, IAnnotatable {
1775
1737
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IForeignKey: never;
@@ -1785,7 +1747,6 @@ export interface IForeignKey$instance extends IReadOnlyForeignKey, IReadOnlyAnno
1785
1747
  readonly IsRequiredDependent: boolean;
1786
1748
  readonly IsOwnership: boolean;
1787
1749
  readonly DeleteBehavior: DeleteBehavior;
1788
- readonly [name: string]: unknown | undefined;
1789
1750
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1790
1751
  AnnotationsToDebugString(indent?: int): string;
1791
1752
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -1807,7 +1768,7 @@ export interface IForeignKey$instance extends IReadOnlyForeignKey, IReadOnlyAnno
1807
1768
  }
1808
1769
 
1809
1770
 
1810
- export type IForeignKey = IForeignKey$instance;
1771
+ export type IForeignKey = IForeignKey$instance & { readonly [name: string]: unknown | undefined; };
1811
1772
 
1812
1773
  export interface IForeignKeyConstraint$instance extends IAnnotatable, IReadOnlyAnnotatable {
1813
1774
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IForeignKeyConstraint: never;
@@ -1820,7 +1781,6 @@ export interface IForeignKeyConstraint$instance extends IAnnotatable, IReadOnlyA
1820
1781
  readonly PrincipalColumns: IReadOnlyList_1<IColumn>;
1821
1782
  readonly PrincipalUniqueConstraint: IUniqueConstraint;
1822
1783
  readonly OnDeleteAction: ReferentialAction;
1823
- readonly [name: string]: unknown | undefined;
1824
1784
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1825
1785
  AnnotationsToDebugString(indent?: int): string;
1826
1786
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -1833,7 +1793,7 @@ export interface IForeignKeyConstraint$instance extends IAnnotatable, IReadOnlyA
1833
1793
  }
1834
1794
 
1835
1795
 
1836
- export type IForeignKeyConstraint = IForeignKeyConstraint$instance;
1796
+ export type IForeignKeyConstraint = IForeignKeyConstraint$instance & { readonly [name: string]: unknown | undefined; };
1837
1797
 
1838
1798
  export interface IFunctionColumn$instance extends IColumnBase, IAnnotatable, IReadOnlyAnnotatable {
1839
1799
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IFunctionColumn: never;
@@ -1847,7 +1807,6 @@ export interface IFunctionColumn$instance extends IColumnBase, IAnnotatable, IRe
1847
1807
  readonly IsNullable: boolean;
1848
1808
  readonly Table: ITableBase;
1849
1809
  readonly ProviderValueComparer: ValueComparer;
1850
- readonly [name: string]: unknown | undefined;
1851
1810
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1852
1811
  AnnotationsToDebugString(indent?: int): string;
1853
1812
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -1862,7 +1821,7 @@ export interface IFunctionColumn$instance extends IColumnBase, IAnnotatable, IRe
1862
1821
  }
1863
1822
 
1864
1823
 
1865
- export type IFunctionColumn = IFunctionColumn$instance;
1824
+ export type IFunctionColumn = IFunctionColumn$instance & { readonly [name: string]: unknown | undefined; };
1866
1825
 
1867
1826
  export interface IFunctionColumnMapping$instance extends IColumnMappingBase, IAnnotatable, IReadOnlyAnnotatable {
1868
1827
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IFunctionColumnMapping: never;
@@ -1872,7 +1831,6 @@ export interface IFunctionColumnMapping$instance extends IColumnMappingBase, IAn
1872
1831
  readonly Property: IProperty;
1873
1832
  readonly TypeMapping: RelationalTypeMapping;
1874
1833
  readonly TableMapping: ITableMappingBase;
1875
- readonly [name: string]: unknown | undefined;
1876
1834
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1877
1835
  AnnotationsToDebugString(indent?: int): string;
1878
1836
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -1885,7 +1843,7 @@ export interface IFunctionColumnMapping$instance extends IColumnMappingBase, IAn
1885
1843
  }
1886
1844
 
1887
1845
 
1888
- export type IFunctionColumnMapping = IFunctionColumnMapping$instance;
1846
+ export type IFunctionColumnMapping = IFunctionColumnMapping$instance & { readonly [name: string]: unknown | undefined; };
1889
1847
 
1890
1848
  export interface IFunctionMapping$instance extends ITableMappingBase, IAnnotatable, IReadOnlyAnnotatable {
1891
1849
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IFunctionMapping: never;
@@ -1899,7 +1857,6 @@ export interface IFunctionMapping$instance extends ITableMappingBase, IAnnotatab
1899
1857
  readonly IsSharedTablePrincipal: Nullable_1<System_Internal.Boolean>;
1900
1858
  readonly IsSplitEntityTypePrincipal: Nullable_1<System_Internal.Boolean>;
1901
1859
  readonly IncludesDerivedTypes: Nullable_1<System_Internal.Boolean>;
1902
- readonly [name: string]: unknown | undefined;
1903
1860
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1904
1861
  AnnotationsToDebugString(indent?: int): string;
1905
1862
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -1912,7 +1869,7 @@ export interface IFunctionMapping$instance extends ITableMappingBase, IAnnotatab
1912
1869
  }
1913
1870
 
1914
1871
 
1915
- export type IFunctionMapping = IFunctionMapping$instance;
1872
+ export type IFunctionMapping = IFunctionMapping$instance & { readonly [name: string]: unknown | undefined; };
1916
1873
 
1917
1874
  export interface IIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotatable, IAnnotatable {
1918
1875
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IIndex: never;
@@ -1922,7 +1879,6 @@ export interface IIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotatable, I
1922
1879
  readonly Name: string | undefined;
1923
1880
  readonly IsUnique: boolean;
1924
1881
  readonly IsDescending: IReadOnlyList_1<System_Internal.Boolean> | undefined;
1925
- readonly [name: string]: unknown | undefined;
1926
1882
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1927
1883
  AnnotationsToDebugString(indent?: int): string;
1928
1884
  DisplayName(): string;
@@ -1937,14 +1893,13 @@ export interface IIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotatable, I
1937
1893
  }
1938
1894
 
1939
1895
 
1940
- export type IIndex = IIndex$instance;
1896
+ export type IIndex = IIndex$instance & { readonly [name: string]: unknown | undefined; };
1941
1897
 
1942
1898
  export interface IKey$instance extends IReadOnlyKey, IReadOnlyAnnotatable, IAnnotatable {
1943
1899
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IKey: never;
1944
1900
 
1945
1901
  readonly Properties: IReadOnlyList_1<IProperty>;
1946
1902
  readonly DeclaringEntityType: IEntityType;
1947
- readonly [name: string]: unknown | undefined;
1948
1903
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1949
1904
  AnnotationsToDebugString(indent?: int): string;
1950
1905
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -1963,7 +1918,7 @@ export interface IKey$instance extends IReadOnlyKey, IReadOnlyAnnotatable, IAnno
1963
1918
  }
1964
1919
 
1965
1920
 
1966
- export type IKey = IKey$instance;
1921
+ export type IKey = IKey$instance & { readonly [name: string]: unknown | undefined; };
1967
1922
 
1968
1923
  export interface IMetadataReference_1$instance<T> extends IDisposable {
1969
1924
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMetadataReference_1: never;
@@ -1982,7 +1937,6 @@ export interface IModel$instance extends IReadOnlyModel, IReadOnlyAnnotatable, I
1982
1937
  get ModelDependencies(): RuntimeModelDependencies | undefined;
1983
1938
  set ModelDependencies(value: RuntimeModelDependencies | undefined);
1984
1939
  readonly ModelId: Guid;
1985
- readonly [name: string]: unknown | undefined;
1986
1940
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
1987
1941
  AnnotationsToDebugString(indent?: int): string;
1988
1942
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -2016,12 +1970,11 @@ export interface IModel$instance extends IReadOnlyModel, IReadOnlyAnnotatable, I
2016
1970
  }
2017
1971
 
2018
1972
 
2019
- export type IModel = IModel$instance;
1973
+ export type IModel = IModel$instance & { readonly [name: string]: unknown | undefined; };
2020
1974
 
2021
1975
  export interface IMutableAnnotatable$instance extends IReadOnlyAnnotatable {
2022
1976
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableAnnotatable: never;
2023
1977
 
2024
- [name: string]: unknown | undefined;
2025
1978
  AddAnnotation(name: string, value: unknown): IAnnotation;
2026
1979
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2027
1980
  AnnotationsToDebugString(indent?: int): string;
@@ -2032,7 +1985,7 @@ export interface IMutableAnnotatable$instance extends IReadOnlyAnnotatable {
2032
1985
  }
2033
1986
 
2034
1987
 
2035
- export type IMutableAnnotatable = IMutableAnnotatable$instance;
1988
+ export type IMutableAnnotatable = IMutableAnnotatable$instance & { [name: string]: unknown | undefined; };
2036
1989
 
2037
1990
  export interface IMutableCheckConstraint$instance extends IReadOnlyCheckConstraint, IReadOnlyAnnotatable, IMutableAnnotatable {
2038
1991
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableCheckConstraint: never;
@@ -2042,7 +1995,6 @@ export interface IMutableCheckConstraint$instance extends IReadOnlyCheckConstrai
2042
1995
  set Name(value: string | undefined);
2043
1996
  readonly ModelName: string;
2044
1997
  readonly Sql: string;
2045
- readonly [name: string]: unknown | undefined;
2046
1998
  AddAnnotation(name: string, value: unknown): IAnnotation;
2047
1999
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2048
2000
  AnnotationsToDebugString(indent?: int): string;
@@ -2056,7 +2008,7 @@ export interface IMutableCheckConstraint$instance extends IReadOnlyCheckConstrai
2056
2008
  }
2057
2009
 
2058
2010
 
2059
- export type IMutableCheckConstraint = IMutableCheckConstraint$instance;
2011
+ export type IMutableCheckConstraint = IMutableCheckConstraint$instance & { readonly [name: string]: unknown | undefined; };
2060
2012
 
2061
2013
  export interface IMutableComplexProperty$instance extends IReadOnlyComplexProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutablePropertyBase, IMutableAnnotatable {
2062
2014
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableComplexProperty: never;
@@ -2070,7 +2022,6 @@ export interface IMutableComplexProperty$instance extends IReadOnlyComplexProper
2070
2022
  readonly IsCollection: boolean;
2071
2023
  readonly PropertyInfo: PropertyInfo | undefined;
2072
2024
  readonly FieldInfo: FieldInfo | undefined;
2073
- readonly [name: string]: unknown | undefined;
2074
2025
  AddAnnotation(name: string, value: unknown): IAnnotation;
2075
2026
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2076
2027
  AnnotationsToDebugString(indent?: int): string;
@@ -2087,7 +2038,7 @@ export interface IMutableComplexProperty$instance extends IReadOnlyComplexProper
2087
2038
  }
2088
2039
 
2089
2040
 
2090
- export type IMutableComplexProperty = IMutableComplexProperty$instance;
2041
+ export type IMutableComplexProperty = IMutableComplexProperty$instance & { readonly [name: string]: unknown | undefined; };
2091
2042
 
2092
2043
  export interface IMutableComplexType$instance extends IReadOnlyComplexType, IReadOnlyTypeBase, IReadOnlyAnnotatable, IMutableTypeBase, IMutableAnnotatable {
2093
2044
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableComplexType: never;
@@ -2100,7 +2051,6 @@ export interface IMutableComplexType$instance extends IReadOnlyComplexType, IRea
2100
2051
  readonly ClrType: Type;
2101
2052
  readonly HasSharedClrType: boolean;
2102
2053
  readonly IsPropertyBag: boolean;
2103
- readonly [name: string]: unknown | undefined;
2104
2054
  AddAnnotation(name: string, value: unknown): IAnnotation;
2105
2055
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2106
2056
  AddComplexProperty(memberInfo: MemberInfo, complexTypeName?: string, collection?: boolean): IMutableComplexProperty;
@@ -2165,7 +2115,7 @@ export interface IMutableComplexType$instance extends IReadOnlyComplexType, IRea
2165
2115
  }
2166
2116
 
2167
2117
 
2168
- export type IMutableComplexType = IMutableComplexType$instance;
2118
+ export type IMutableComplexType = IMutableComplexType$instance & { readonly [name: string]: unknown | undefined; };
2169
2119
 
2170
2120
  export interface IMutableDbFunction$instance extends IReadOnlyDbFunction, IReadOnlyAnnotatable, IMutableAnnotatable {
2171
2121
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableDbFunction: never;
@@ -2188,7 +2138,6 @@ export interface IMutableDbFunction$instance extends IReadOnlyDbFunction, IReadO
2188
2138
  readonly IsScalar: boolean;
2189
2139
  readonly IsAggregate: boolean;
2190
2140
  readonly ReturnType: Type;
2191
- readonly [name: string]: unknown | undefined;
2192
2141
  AddAnnotation(name: string, value: unknown): IAnnotation;
2193
2142
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2194
2143
  AnnotationsToDebugString(indent?: int): string;
@@ -2200,7 +2149,7 @@ export interface IMutableDbFunction$instance extends IReadOnlyDbFunction, IReadO
2200
2149
  }
2201
2150
 
2202
2151
 
2203
- export type IMutableDbFunction = IMutableDbFunction$instance;
2152
+ export type IMutableDbFunction = IMutableDbFunction$instance & { readonly [name: string]: unknown | undefined; };
2204
2153
 
2205
2154
  export interface IMutableDbFunctionParameter$instance extends IReadOnlyDbFunctionParameter, IReadOnlyAnnotatable, IMutableAnnotatable {
2206
2155
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableDbFunctionParameter: never;
@@ -2212,7 +2161,6 @@ export interface IMutableDbFunctionParameter$instance extends IReadOnlyDbFunctio
2212
2161
  readonly Name: string;
2213
2162
  readonly ClrType: Type;
2214
2163
  readonly PropagatesNullability: boolean;
2215
- readonly [name: string]: unknown | undefined;
2216
2164
  AddAnnotation(name: string, value: unknown): IAnnotation;
2217
2165
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2218
2166
  AnnotationsToDebugString(indent?: int): string;
@@ -2224,7 +2172,7 @@ export interface IMutableDbFunctionParameter$instance extends IReadOnlyDbFunctio
2224
2172
  }
2225
2173
 
2226
2174
 
2227
- export type IMutableDbFunctionParameter = IMutableDbFunctionParameter$instance;
2175
+ export type IMutableDbFunctionParameter = IMutableDbFunctionParameter$instance & { readonly [name: string]: unknown | undefined; };
2228
2176
 
2229
2177
  export interface IMutableElementType$instance extends IReadOnlyElementType, IReadOnlyAnnotatable, IMutableAnnotatable {
2230
2178
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableElementType: never;
@@ -2232,7 +2180,6 @@ export interface IMutableElementType$instance extends IReadOnlyElementType, IRea
2232
2180
  readonly CollectionProperty: IMutableProperty;
2233
2181
  IsNullable: boolean;
2234
2182
  readonly ClrType: Type;
2235
- readonly [name: string]: unknown | undefined;
2236
2183
  AddAnnotation(name: string, value: unknown): IAnnotation;
2237
2184
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2238
2185
  AnnotationsToDebugString(indent?: int): string;
@@ -2255,7 +2202,7 @@ export interface IMutableElementType$instance extends IReadOnlyElementType, IRea
2255
2202
  }
2256
2203
 
2257
2204
 
2258
- export type IMutableElementType = IMutableElementType$instance;
2205
+ export type IMutableElementType = IMutableElementType$instance & { readonly [name: string]: unknown | undefined; };
2259
2206
 
2260
2207
  export interface IMutableEntityType$instance extends IReadOnlyEntityType, IReadOnlyTypeBase, IReadOnlyAnnotatable, IMutableTypeBase, IMutableAnnotatable {
2261
2208
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableEntityType: never;
@@ -2269,7 +2216,6 @@ export interface IMutableEntityType$instance extends IReadOnlyEntityType, IReadO
2269
2216
  readonly ClrType: Type;
2270
2217
  readonly HasSharedClrType: boolean;
2271
2218
  readonly IsPropertyBag: boolean;
2272
- readonly [name: string]: unknown | undefined;
2273
2219
  AddAnnotation(name: string, value: unknown): IAnnotation;
2274
2220
  AddComplexProperty(memberInfo: MemberInfo, complexTypeName?: string, collection?: boolean): IMutableComplexProperty;
2275
2221
  AddComplexProperty(name: string, collection?: boolean): IMutableComplexProperty;
@@ -2394,7 +2340,7 @@ export interface IMutableEntityType$instance extends IReadOnlyEntityType, IReadO
2394
2340
  }
2395
2341
 
2396
2342
 
2397
- export type IMutableEntityType = IMutableEntityType$instance;
2343
+ export type IMutableEntityType = IMutableEntityType$instance & { readonly [name: string]: unknown | undefined; };
2398
2344
 
2399
2345
  export interface IMutableEntityTypeMappingFragment$instance extends IReadOnlyEntityTypeMappingFragment, IReadOnlyAnnotatable, IMutableAnnotatable {
2400
2346
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableEntityTypeMappingFragment: never;
@@ -2402,7 +2348,6 @@ export interface IMutableEntityTypeMappingFragment$instance extends IReadOnlyEnt
2402
2348
  readonly EntityType: IMutableEntityType;
2403
2349
  IsTableExcludedFromMigrations: Nullable_1<System_Internal.Boolean>;
2404
2350
  readonly StoreObject: StoreObjectIdentifier;
2405
- readonly [name: string]: unknown | undefined;
2406
2351
  AddAnnotation(name: string, value: unknown): IAnnotation;
2407
2352
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2408
2353
  AnnotationsToDebugString(indent?: int): string;
@@ -2414,7 +2359,7 @@ export interface IMutableEntityTypeMappingFragment$instance extends IReadOnlyEnt
2414
2359
  }
2415
2360
 
2416
2361
 
2417
- export type IMutableEntityTypeMappingFragment = IMutableEntityTypeMappingFragment$instance;
2362
+ export type IMutableEntityTypeMappingFragment = IMutableEntityTypeMappingFragment$instance & { readonly [name: string]: unknown | undefined; };
2418
2363
 
2419
2364
  export interface IMutableForeignKey$instance extends IReadOnlyForeignKey, IReadOnlyAnnotatable, IMutableAnnotatable {
2420
2365
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableForeignKey: never;
@@ -2430,7 +2375,6 @@ export interface IMutableForeignKey$instance extends IReadOnlyForeignKey, IReadO
2430
2375
  DeleteBehavior: DeleteBehavior;
2431
2376
  readonly DependentToPrincipal: IMutableNavigation | undefined;
2432
2377
  readonly PrincipalToDependent: IMutableNavigation | undefined;
2433
- readonly [name: string]: unknown | undefined;
2434
2378
  AddAnnotation(name: string, value: unknown): IAnnotation;
2435
2379
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2436
2380
  AnnotationsToDebugString(indent?: int): string;
@@ -2452,7 +2396,7 @@ export interface IMutableForeignKey$instance extends IReadOnlyForeignKey, IReadO
2452
2396
  }
2453
2397
 
2454
2398
 
2455
- export type IMutableForeignKey = IMutableForeignKey$instance;
2399
+ export type IMutableForeignKey = IMutableForeignKey$instance & { readonly [name: string]: unknown | undefined; };
2456
2400
 
2457
2401
  export interface IMutableIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotatable, IMutableAnnotatable {
2458
2402
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableIndex: never;
@@ -2463,7 +2407,6 @@ export interface IMutableIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotat
2463
2407
  readonly Properties: IReadOnlyList_1<IMutableProperty>;
2464
2408
  readonly DeclaringEntityType: IMutableEntityType;
2465
2409
  readonly Name: string | undefined;
2466
- readonly [name: string]: unknown | undefined;
2467
2410
  AddAnnotation(name: string, value: unknown): IAnnotation;
2468
2411
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2469
2412
  AnnotationsToDebugString(indent?: int): string;
@@ -2476,14 +2419,13 @@ export interface IMutableIndex$instance extends IReadOnlyIndex, IReadOnlyAnnotat
2476
2419
  }
2477
2420
 
2478
2421
 
2479
- export type IMutableIndex = IMutableIndex$instance;
2422
+ export type IMutableIndex = IMutableIndex$instance & { readonly [name: string]: unknown | undefined; };
2480
2423
 
2481
2424
  export interface IMutableKey$instance extends IReadOnlyKey, IReadOnlyAnnotatable, IMutableAnnotatable {
2482
2425
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableKey: never;
2483
2426
 
2484
2427
  readonly Properties: IReadOnlyList_1<IMutableProperty>;
2485
2428
  readonly DeclaringEntityType: IMutableEntityType;
2486
- readonly [name: string]: unknown | undefined;
2487
2429
  AddAnnotation(name: string, value: unknown): IAnnotation;
2488
2430
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2489
2431
  AnnotationsToDebugString(indent?: int): string;
@@ -2498,13 +2440,12 @@ export interface IMutableKey$instance extends IReadOnlyKey, IReadOnlyAnnotatable
2498
2440
  }
2499
2441
 
2500
2442
 
2501
- export type IMutableKey = IMutableKey$instance;
2443
+ export type IMutableKey = IMutableKey$instance & { readonly [name: string]: unknown | undefined; };
2502
2444
 
2503
2445
  export interface IMutableModel$instance extends IReadOnlyModel, IReadOnlyAnnotatable, IMutableAnnotatable {
2504
2446
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableModel: never;
2505
2447
 
2506
2448
  readonly ModelId: Guid;
2507
- readonly [name: string]: unknown | undefined;
2508
2449
  AddAnnotation(name: string, value: unknown): IAnnotation;
2509
2450
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2510
2451
  AddEntityType(name: string, definingNavigationName: string, definingEntityType: IMutableEntityType): IMutableEntityType;
@@ -2546,7 +2487,7 @@ export interface IMutableModel$instance extends IReadOnlyModel, IReadOnlyAnnotat
2546
2487
  }
2547
2488
 
2548
2489
 
2549
- export type IMutableModel = IMutableModel$instance;
2490
+ export type IMutableModel = IMutableModel$instance & { readonly [name: string]: unknown | undefined; };
2550
2491
 
2551
2492
  export interface IMutableNavigation$instance extends IReadOnlyNavigation, IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutableNavigationBase, IMutablePropertyBase, IMutableAnnotatable {
2552
2493
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableNavigation: never;
@@ -2565,7 +2506,6 @@ export interface IMutableNavigation$instance extends IReadOnlyNavigation, IReadO
2565
2506
  readonly IsCollection: boolean;
2566
2507
  readonly PropertyInfo: PropertyInfo | undefined;
2567
2508
  readonly FieldInfo: FieldInfo | undefined;
2568
- readonly [name: string]: unknown | undefined;
2569
2509
  AddAnnotation(name: string, value: unknown): IAnnotation;
2570
2510
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2571
2511
  AnnotationsToDebugString(indent?: int): string;
@@ -2585,7 +2525,7 @@ export interface IMutableNavigation$instance extends IReadOnlyNavigation, IReadO
2585
2525
  }
2586
2526
 
2587
2527
 
2588
- export type IMutableNavigation = IMutableNavigation$instance;
2528
+ export type IMutableNavigation = IMutableNavigation$instance & { readonly [name: string]: unknown | undefined; };
2589
2529
 
2590
2530
  export interface IMutableNavigationBase$instance extends IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutablePropertyBase, IMutableAnnotatable {
2591
2531
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableNavigationBase: never;
@@ -2602,7 +2542,6 @@ export interface IMutableNavigationBase$instance extends IReadOnlyNavigationBase
2602
2542
  readonly IsCollection: boolean;
2603
2543
  readonly PropertyInfo: PropertyInfo | undefined;
2604
2544
  readonly FieldInfo: FieldInfo | undefined;
2605
- readonly [name: string]: unknown | undefined;
2606
2545
  AddAnnotation(name: string, value: unknown): IAnnotation;
2607
2546
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2608
2547
  AnnotationsToDebugString(indent?: int): string;
@@ -2619,7 +2558,7 @@ export interface IMutableNavigationBase$instance extends IReadOnlyNavigationBase
2619
2558
  }
2620
2559
 
2621
2560
 
2622
- export type IMutableNavigationBase = IMutableNavigationBase$instance;
2561
+ export type IMutableNavigationBase = IMutableNavigationBase$instance & { readonly [name: string]: unknown | undefined; };
2623
2562
 
2624
2563
  export interface IMutableProperty$instance extends IReadOnlyProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutablePropertyBase, IMutableAnnotatable {
2625
2564
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableProperty: never;
@@ -2637,7 +2576,6 @@ export interface IMutableProperty$instance extends IReadOnlyProperty, IReadOnlyP
2637
2576
  readonly IsCollection: boolean;
2638
2577
  readonly PropertyInfo: PropertyInfo | undefined;
2639
2578
  readonly FieldInfo: FieldInfo | undefined;
2640
- readonly [name: string]: unknown | undefined;
2641
2579
  AddAnnotation(name: string, value: unknown): IAnnotation;
2642
2580
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2643
2581
  AnnotationsToDebugString(indent?: int): string;
@@ -2679,7 +2617,7 @@ export interface IMutableProperty$instance extends IReadOnlyProperty, IReadOnlyP
2679
2617
  }
2680
2618
 
2681
2619
 
2682
- export type IMutableProperty = IMutableProperty$instance;
2620
+ export type IMutableProperty = IMutableProperty$instance & { readonly [name: string]: unknown | undefined; };
2683
2621
 
2684
2622
  export interface IMutablePropertyBase$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutableAnnotatable {
2685
2623
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutablePropertyBase: never;
@@ -2692,7 +2630,6 @@ export interface IMutablePropertyBase$instance extends IReadOnlyPropertyBase, IR
2692
2630
  readonly Sentinel: unknown | undefined;
2693
2631
  readonly IsCollection: boolean;
2694
2632
  readonly PropertyInfo: PropertyInfo | undefined;
2695
- readonly [name: string]: unknown | undefined;
2696
2633
  AddAnnotation(name: string, value: unknown): IAnnotation;
2697
2634
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2698
2635
  AnnotationsToDebugString(indent?: int): string;
@@ -2708,7 +2645,7 @@ export interface IMutablePropertyBase$instance extends IReadOnlyPropertyBase, IR
2708
2645
  }
2709
2646
 
2710
2647
 
2711
- export type IMutablePropertyBase = IMutablePropertyBase$instance;
2648
+ export type IMutablePropertyBase = IMutablePropertyBase$instance & { readonly [name: string]: unknown | undefined; };
2712
2649
 
2713
2650
  export interface IMutableRelationalPropertyOverrides$instance extends IReadOnlyRelationalPropertyOverrides, IReadOnlyAnnotatable, IMutableAnnotatable {
2714
2651
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableRelationalPropertyOverrides: never;
@@ -2718,7 +2655,6 @@ export interface IMutableRelationalPropertyOverrides$instance extends IReadOnlyR
2718
2655
  set ColumnName(value: string | undefined);
2719
2656
  readonly StoreObject: StoreObjectIdentifier;
2720
2657
  readonly IsColumnNameOverridden: boolean;
2721
- readonly [name: string]: unknown | undefined;
2722
2658
  AddAnnotation(name: string, value: unknown): IAnnotation;
2723
2659
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2724
2660
  AnnotationsToDebugString(indent?: int): string;
@@ -2731,7 +2667,7 @@ export interface IMutableRelationalPropertyOverrides$instance extends IReadOnlyR
2731
2667
  }
2732
2668
 
2733
2669
 
2734
- export type IMutableRelationalPropertyOverrides = IMutableRelationalPropertyOverrides$instance;
2670
+ export type IMutableRelationalPropertyOverrides = IMutableRelationalPropertyOverrides$instance & { readonly [name: string]: unknown | undefined; };
2735
2671
 
2736
2672
  export interface IMutableSequence$instance extends IReadOnlySequence, IReadOnlyAnnotatable, IMutableAnnotatable {
2737
2673
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableSequence: never;
@@ -2746,7 +2682,6 @@ export interface IMutableSequence$instance extends IReadOnlySequence, IReadOnlyA
2746
2682
  readonly Name: string;
2747
2683
  readonly ModelSchema: string | undefined;
2748
2684
  readonly Schema: string | undefined;
2749
- readonly [name: string]: unknown | undefined;
2750
2685
  AddAnnotation(name: string, value: unknown): IAnnotation;
2751
2686
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2752
2687
  AnnotationsToDebugString(indent?: int): string;
@@ -2758,7 +2693,7 @@ export interface IMutableSequence$instance extends IReadOnlySequence, IReadOnlyA
2758
2693
  }
2759
2694
 
2760
2695
 
2761
- export type IMutableSequence = IMutableSequence$instance;
2696
+ export type IMutableSequence = IMutableSequence$instance & { readonly [name: string]: unknown | undefined; };
2762
2697
 
2763
2698
  export interface IMutableServiceProperty$instance extends IReadOnlyServiceProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutablePropertyBase, IMutableAnnotatable {
2764
2699
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableServiceProperty: never;
@@ -2772,7 +2707,6 @@ export interface IMutableServiceProperty$instance extends IReadOnlyServiceProper
2772
2707
  readonly IsCollection: boolean;
2773
2708
  readonly PropertyInfo: PropertyInfo | undefined;
2774
2709
  readonly FieldInfo: FieldInfo | undefined;
2775
- readonly [name: string]: unknown | undefined;
2776
2710
  AddAnnotation(name: string, value: unknown): IAnnotation;
2777
2711
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2778
2712
  AnnotationsToDebugString(indent?: int): string;
@@ -2789,7 +2723,7 @@ export interface IMutableServiceProperty$instance extends IReadOnlyServiceProper
2789
2723
  }
2790
2724
 
2791
2725
 
2792
- export type IMutableServiceProperty = IMutableServiceProperty$instance;
2726
+ export type IMutableServiceProperty = IMutableServiceProperty$instance & { readonly [name: string]: unknown | undefined; };
2793
2727
 
2794
2728
  export interface IMutableSkipNavigation$instance extends IReadOnlySkipNavigation, IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IMutableNavigationBase, IMutablePropertyBase, IMutableAnnotatable {
2795
2729
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableSkipNavigation: never;
@@ -2809,7 +2743,6 @@ export interface IMutableSkipNavigation$instance extends IReadOnlySkipNavigation
2809
2743
  readonly IsCollection: boolean;
2810
2744
  readonly PropertyInfo: PropertyInfo | undefined;
2811
2745
  readonly FieldInfo: FieldInfo | undefined;
2812
- readonly [name: string]: unknown | undefined;
2813
2746
  AddAnnotation(name: string, value: unknown): IAnnotation;
2814
2747
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2815
2748
  AnnotationsToDebugString(indent?: int): string;
@@ -2829,7 +2762,7 @@ export interface IMutableSkipNavigation$instance extends IReadOnlySkipNavigation
2829
2762
  }
2830
2763
 
2831
2764
 
2832
- export type IMutableSkipNavigation = IMutableSkipNavigation$instance;
2765
+ export type IMutableSkipNavigation = IMutableSkipNavigation$instance & { readonly [name: string]: unknown | undefined; };
2833
2766
 
2834
2767
  export interface IMutableStoredProcedure$instance extends IReadOnlyStoredProcedure, IReadOnlyAnnotatable, IMutableAnnotatable {
2835
2768
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableStoredProcedure: never;
@@ -2841,7 +2774,6 @@ export interface IMutableStoredProcedure$instance extends IReadOnlyStoredProcedu
2841
2774
  IsRowsAffectedReturned: boolean;
2842
2775
  readonly Parameters: IReadOnlyList_1<IMutableStoredProcedureParameter>;
2843
2776
  readonly ResultColumns: IReadOnlyList_1<IMutableStoredProcedureResultColumn>;
2844
- readonly [name: string]: unknown | undefined;
2845
2777
  AddAnnotation(name: string, value: unknown): IAnnotation;
2846
2778
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2847
2779
  AnnotationsToDebugString(indent?: int): string;
@@ -2863,7 +2795,7 @@ export interface IMutableStoredProcedure$instance extends IReadOnlyStoredProcedu
2863
2795
  }
2864
2796
 
2865
2797
 
2866
- export type IMutableStoredProcedure = IMutableStoredProcedure$instance;
2798
+ export type IMutableStoredProcedure = IMutableStoredProcedure$instance & { readonly [name: string]: unknown | undefined; };
2867
2799
 
2868
2800
  export interface IMutableStoredProcedureParameter$instance extends IReadOnlyStoredProcedureParameter, IReadOnlyAnnotatable, IMutableAnnotatable {
2869
2801
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableStoredProcedureParameter: never;
@@ -2874,7 +2806,6 @@ export interface IMutableStoredProcedureParameter$instance extends IReadOnlyStor
2874
2806
  readonly PropertyName: string | undefined;
2875
2807
  readonly ForOriginalValue: Nullable_1<System_Internal.Boolean>;
2876
2808
  readonly ForRowsAffected: boolean;
2877
- readonly [name: string]: unknown | undefined;
2878
2809
  AddAnnotation(name: string, value: unknown): IAnnotation;
2879
2810
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2880
2811
  AnnotationsToDebugString(indent?: int): string;
@@ -2886,7 +2817,7 @@ export interface IMutableStoredProcedureParameter$instance extends IReadOnlyStor
2886
2817
  }
2887
2818
 
2888
2819
 
2889
- export type IMutableStoredProcedureParameter = IMutableStoredProcedureParameter$instance;
2820
+ export type IMutableStoredProcedureParameter = IMutableStoredProcedureParameter$instance & { readonly [name: string]: unknown | undefined; };
2890
2821
 
2891
2822
  export interface IMutableStoredProcedureResultColumn$instance extends IReadOnlyStoredProcedureResultColumn, IReadOnlyAnnotatable, IMutableAnnotatable {
2892
2823
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableStoredProcedureResultColumn: never;
@@ -2895,7 +2826,6 @@ export interface IMutableStoredProcedureResultColumn$instance extends IReadOnlyS
2895
2826
  Name: string;
2896
2827
  readonly PropertyName: string | undefined;
2897
2828
  readonly ForRowsAffected: boolean;
2898
- readonly [name: string]: unknown | undefined;
2899
2829
  AddAnnotation(name: string, value: unknown): IAnnotation;
2900
2830
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2901
2831
  AnnotationsToDebugString(indent?: int): string;
@@ -2907,14 +2837,13 @@ export interface IMutableStoredProcedureResultColumn$instance extends IReadOnlyS
2907
2837
  }
2908
2838
 
2909
2839
 
2910
- export type IMutableStoredProcedureResultColumn = IMutableStoredProcedureResultColumn$instance;
2840
+ export type IMutableStoredProcedureResultColumn = IMutableStoredProcedureResultColumn$instance & { readonly [name: string]: unknown | undefined; };
2911
2841
 
2912
2842
  export interface IMutableTrigger$instance extends IReadOnlyTrigger, IReadOnlyAnnotatable, IMutableAnnotatable {
2913
2843
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableTrigger: never;
2914
2844
 
2915
2845
  readonly EntityType: IMutableEntityType;
2916
2846
  readonly ModelName: string;
2917
- readonly [name: string]: unknown | undefined;
2918
2847
  AddAnnotation(name: string, value: unknown): IAnnotation;
2919
2848
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2920
2849
  AnnotationsToDebugString(indent?: int): string;
@@ -2926,7 +2855,7 @@ export interface IMutableTrigger$instance extends IReadOnlyTrigger, IReadOnlyAnn
2926
2855
  }
2927
2856
 
2928
2857
 
2929
- export type IMutableTrigger = IMutableTrigger$instance;
2858
+ export type IMutableTrigger = IMutableTrigger$instance & { readonly [name: string]: unknown | undefined; };
2930
2859
 
2931
2860
  export interface IMutableTypeBase$instance extends IReadOnlyTypeBase, IReadOnlyAnnotatable, IMutableAnnotatable {
2932
2861
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableTypeBase: never;
@@ -2939,7 +2868,6 @@ export interface IMutableTypeBase$instance extends IReadOnlyTypeBase, IReadOnlyA
2939
2868
  readonly ClrType: Type;
2940
2869
  readonly HasSharedClrType: boolean;
2941
2870
  readonly IsPropertyBag: boolean;
2942
- readonly [name: string]: unknown | undefined;
2943
2871
  AddAnnotation(name: string, value: unknown): IAnnotation;
2944
2872
  AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
2945
2873
  AddComplexProperty(memberInfo: MemberInfo, complexTypeName?: string, collection?: boolean): IMutableComplexProperty;
@@ -2993,7 +2921,7 @@ export interface IMutableTypeBase$instance extends IReadOnlyTypeBase, IReadOnlyA
2993
2921
  }
2994
2922
 
2995
2923
 
2996
- export type IMutableTypeBase = IMutableTypeBase$instance;
2924
+ export type IMutableTypeBase = IMutableTypeBase$instance & { readonly [name: string]: unknown | undefined; };
2997
2925
 
2998
2926
  export interface INavigation$instance extends IReadOnlyNavigation, IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, INavigationBase, IPropertyBase, IAnnotatable {
2999
2927
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_INavigation: never;
@@ -3012,7 +2940,6 @@ export interface INavigation$instance extends IReadOnlyNavigation, IReadOnlyNavi
3012
2940
  readonly IsCollection: boolean;
3013
2941
  readonly PropertyInfo: PropertyInfo | undefined;
3014
2942
  readonly FieldInfo: FieldInfo | undefined;
3015
- readonly [name: string]: unknown | undefined;
3016
2943
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
3017
2944
  AnnotationsToDebugString(indent?: int): string;
3018
2945
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -3034,7 +2961,7 @@ export interface INavigation$instance extends IReadOnlyNavigation, IReadOnlyNavi
3034
2961
  }
3035
2962
 
3036
2963
 
3037
- export type INavigation = INavigation$instance;
2964
+ export type INavigation = INavigation$instance & { readonly [name: string]: unknown | undefined; };
3038
2965
 
3039
2966
  export interface INavigationBase$instance extends IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IPropertyBase, IAnnotatable {
3040
2967
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_INavigationBase: never;
@@ -3051,7 +2978,6 @@ export interface INavigationBase$instance extends IReadOnlyNavigationBase, IRead
3051
2978
  readonly IsCollection: boolean;
3052
2979
  readonly PropertyInfo: PropertyInfo | undefined;
3053
2980
  readonly FieldInfo: FieldInfo | undefined;
3054
- readonly [name: string]: unknown | undefined;
3055
2981
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
3056
2982
  AnnotationsToDebugString(indent?: int): string;
3057
2983
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -3072,7 +2998,7 @@ export interface INavigationBase$instance extends IReadOnlyNavigationBase, IRead
3072
2998
  }
3073
2999
 
3074
3000
 
3075
- export type INavigationBase = INavigationBase$instance;
3001
+ export type INavigationBase = INavigationBase$instance & { readonly [name: string]: unknown | undefined; };
3076
3002
 
3077
3003
  export interface IParameterBindingFactories$instance {
3078
3004
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IParameterBindingFactories: never;
@@ -3102,7 +3028,6 @@ export interface IPrimaryKeyConstraint$instance extends IUniqueConstraint, IAnno
3102
3028
  readonly MappedKeys: IEnumerable_1<IKey>;
3103
3029
  readonly Table: ITable;
3104
3030
  readonly Columns: IReadOnlyList_1<IColumn>;
3105
- readonly [name: string]: unknown | undefined;
3106
3031
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
3107
3032
  AnnotationsToDebugString(indent?: int): string;
3108
3033
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -3116,7 +3041,7 @@ export interface IPrimaryKeyConstraint$instance extends IUniqueConstraint, IAnno
3116
3041
  }
3117
3042
 
3118
3043
 
3119
- export type IPrimaryKeyConstraint = IPrimaryKeyConstraint$instance;
3044
+ export type IPrimaryKeyConstraint = IPrimaryKeyConstraint$instance & { readonly [name: string]: unknown | undefined; };
3120
3045
 
3121
3046
  export interface IProperty$instance extends IReadOnlyProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IPropertyBase, IAnnotatable {
3122
3047
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IProperty: never;
@@ -3133,7 +3058,6 @@ export interface IProperty$instance extends IReadOnlyProperty, IReadOnlyProperty
3133
3058
  readonly IsCollection: boolean;
3134
3059
  readonly PropertyInfo: PropertyInfo | undefined;
3135
3060
  readonly FieldInfo: FieldInfo | undefined;
3136
- readonly [name: string]: unknown | undefined;
3137
3061
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
3138
3062
  AnnotationsToDebugString(indent?: int): string;
3139
3063
  CreateKeyEqualityComparer<TProperty>(): IEqualityComparer_1<TProperty>;
@@ -3174,7 +3098,7 @@ export interface IProperty$instance extends IReadOnlyProperty, IReadOnlyProperty
3174
3098
  }
3175
3099
 
3176
3100
 
3177
- export type IProperty = IProperty$instance;
3101
+ export type IProperty = IProperty$instance & { readonly [name: string]: unknown | undefined; };
3178
3102
 
3179
3103
  export interface IPropertyBase$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable, IAnnotatable {
3180
3104
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IPropertyBase: never;
@@ -3186,7 +3110,6 @@ export interface IPropertyBase$instance extends IReadOnlyPropertyBase, IReadOnly
3186
3110
  readonly IsCollection: boolean;
3187
3111
  readonly PropertyInfo: PropertyInfo | undefined;
3188
3112
  readonly FieldInfo: FieldInfo | undefined;
3189
- readonly [name: string]: unknown | undefined;
3190
3113
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
3191
3114
  AnnotationsToDebugString(indent?: int): string;
3192
3115
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -3206,7 +3129,7 @@ export interface IPropertyBase$instance extends IReadOnlyPropertyBase, IReadOnly
3206
3129
  }
3207
3130
 
3208
3131
 
3209
- export type IPropertyBase = IPropertyBase$instance;
3132
+ export type IPropertyBase = IPropertyBase$instance & { readonly [name: string]: unknown | undefined; };
3210
3133
 
3211
3134
  export interface IPropertyParameterBindingFactory$instance {
3212
3135
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IPropertyParameterBindingFactory: never;
@@ -3236,7 +3159,6 @@ export interface IReadOnlyCheckConstraint$instance extends IReadOnlyAnnotatable
3236
3159
  readonly Name: string | undefined;
3237
3160
  readonly EntityType: IReadOnlyEntityType;
3238
3161
  readonly Sql: string;
3239
- readonly [name: string]: unknown | undefined;
3240
3162
  AnnotationsToDebugString(indent?: int): string;
3241
3163
  FindAnnotation(name: string): IAnnotation | undefined;
3242
3164
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3248,7 +3170,7 @@ export interface IReadOnlyCheckConstraint$instance extends IReadOnlyAnnotatable
3248
3170
 
3249
3171
  export interface IReadOnlyCheckConstraint$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3250
3172
 
3251
- export type IReadOnlyCheckConstraint = IReadOnlyCheckConstraint$instance;
3173
+ export type IReadOnlyCheckConstraint = IReadOnlyCheckConstraint$instance & { readonly [name: string]: unknown | undefined; };
3252
3174
 
3253
3175
  export interface IReadOnlyComplexProperty$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable {
3254
3176
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyComplexProperty: never;
@@ -3262,7 +3184,6 @@ export interface IReadOnlyComplexProperty$instance extends IReadOnlyPropertyBase
3262
3184
  readonly IsCollection: boolean;
3263
3185
  readonly PropertyInfo: PropertyInfo | undefined;
3264
3186
  readonly FieldInfo: FieldInfo | undefined;
3265
- readonly [name: string]: unknown | undefined;
3266
3187
  AnnotationsToDebugString(indent?: int): string;
3267
3188
  FindAnnotation(name: string): IAnnotation | undefined;
3268
3189
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3273,7 +3194,7 @@ export interface IReadOnlyComplexProperty$instance extends IReadOnlyPropertyBase
3273
3194
  }
3274
3195
 
3275
3196
 
3276
- export type IReadOnlyComplexProperty = IReadOnlyComplexProperty$instance;
3197
+ export type IReadOnlyComplexProperty = IReadOnlyComplexProperty$instance & { readonly [name: string]: unknown | undefined; };
3277
3198
 
3278
3199
  export interface IReadOnlyComplexType$instance extends IReadOnlyTypeBase, IReadOnlyAnnotatable {
3279
3200
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyComplexType: never;
@@ -3286,7 +3207,6 @@ export interface IReadOnlyComplexType$instance extends IReadOnlyTypeBase, IReadO
3286
3207
  readonly ClrType: Type;
3287
3208
  readonly HasSharedClrType: boolean;
3288
3209
  readonly IsPropertyBag: boolean;
3289
- readonly [name: string]: unknown | undefined;
3290
3210
  AnnotationsToDebugString(indent?: int): string;
3291
3211
  DisplayName(): string;
3292
3212
  DisplayName(omitSharedType: boolean): string;
@@ -3316,7 +3236,7 @@ export interface IReadOnlyComplexType$instance extends IReadOnlyTypeBase, IReadO
3316
3236
  }
3317
3237
 
3318
3238
 
3319
- export type IReadOnlyComplexType = IReadOnlyComplexType$instance;
3239
+ export type IReadOnlyComplexType = IReadOnlyComplexType$instance & { readonly [name: string]: unknown | undefined; };
3320
3240
 
3321
3241
  export interface IReadOnlyDbFunction$instance extends IReadOnlyAnnotatable {
3322
3242
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyDbFunction: never;
@@ -3335,7 +3255,6 @@ export interface IReadOnlyDbFunction$instance extends IReadOnlyAnnotatable {
3335
3255
  readonly TypeMapping: RelationalTypeMapping | undefined;
3336
3256
  readonly Parameters: IReadOnlyList_1<IReadOnlyDbFunctionParameter>;
3337
3257
  readonly Translation: Func_2<IReadOnlyList_1<SqlExpression>, SqlExpression> | undefined;
3338
- readonly [name: string]: unknown | undefined;
3339
3258
  AnnotationsToDebugString(indent?: int): string;
3340
3259
  FindAnnotation(name: string): IAnnotation | undefined;
3341
3260
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3345,7 +3264,7 @@ export interface IReadOnlyDbFunction$instance extends IReadOnlyAnnotatable {
3345
3264
 
3346
3265
  export interface IReadOnlyDbFunction$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3347
3266
 
3348
- export type IReadOnlyDbFunction = IReadOnlyDbFunction$instance;
3267
+ export type IReadOnlyDbFunction = IReadOnlyDbFunction$instance & { readonly [name: string]: unknown | undefined; };
3349
3268
 
3350
3269
  export interface IReadOnlyDbFunctionParameter$instance extends IReadOnlyAnnotatable {
3351
3270
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyDbFunctionParameter: never;
@@ -3356,7 +3275,6 @@ export interface IReadOnlyDbFunctionParameter$instance extends IReadOnlyAnnotata
3356
3275
  readonly StoreType: string;
3357
3276
  readonly PropagatesNullability: boolean;
3358
3277
  readonly TypeMapping: RelationalTypeMapping | undefined;
3359
- readonly [name: string]: unknown | undefined;
3360
3278
  AnnotationsToDebugString(indent?: int): string;
3361
3279
  FindAnnotation(name: string): IAnnotation | undefined;
3362
3280
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3366,7 +3284,7 @@ export interface IReadOnlyDbFunctionParameter$instance extends IReadOnlyAnnotata
3366
3284
 
3367
3285
  export interface IReadOnlyDbFunctionParameter$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3368
3286
 
3369
- export type IReadOnlyDbFunctionParameter = IReadOnlyDbFunctionParameter$instance;
3287
+ export type IReadOnlyDbFunctionParameter = IReadOnlyDbFunctionParameter$instance & { readonly [name: string]: unknown | undefined; };
3370
3288
 
3371
3289
  export interface IReadOnlyElementType$instance extends IReadOnlyAnnotatable {
3372
3290
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyElementType: never;
@@ -3374,7 +3292,6 @@ export interface IReadOnlyElementType$instance extends IReadOnlyAnnotatable {
3374
3292
  readonly CollectionProperty: IReadOnlyProperty;
3375
3293
  readonly ClrType: Type;
3376
3294
  readonly IsNullable: boolean;
3377
- readonly [name: string]: unknown | undefined;
3378
3295
  AnnotationsToDebugString(indent?: int): string;
3379
3296
  FindAnnotation(name: string): IAnnotation | undefined;
3380
3297
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3390,7 +3307,7 @@ export interface IReadOnlyElementType$instance extends IReadOnlyAnnotatable {
3390
3307
 
3391
3308
  export interface IReadOnlyElementType$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3392
3309
 
3393
- export type IReadOnlyElementType = IReadOnlyElementType$instance;
3310
+ export type IReadOnlyElementType = IReadOnlyElementType$instance & { readonly [name: string]: unknown | undefined; };
3394
3311
 
3395
3312
  export interface IReadOnlyEntityType$instance extends IReadOnlyTypeBase, IReadOnlyAnnotatable {
3396
3313
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyEntityType: never;
@@ -3402,7 +3319,6 @@ export interface IReadOnlyEntityType$instance extends IReadOnlyTypeBase, IReadOn
3402
3319
  readonly ClrType: Type;
3403
3320
  readonly HasSharedClrType: boolean;
3404
3321
  readonly IsPropertyBag: boolean;
3405
- readonly [name: string]: unknown | undefined;
3406
3322
  AnnotationsToDebugString(indent?: int): string;
3407
3323
  DisplayName(): string;
3408
3324
  DisplayName(omitSharedType: boolean): string;
@@ -3456,7 +3372,7 @@ export interface IReadOnlyEntityType$instance extends IReadOnlyTypeBase, IReadOn
3456
3372
  }
3457
3373
 
3458
3374
 
3459
- export type IReadOnlyEntityType = IReadOnlyEntityType$instance;
3375
+ export type IReadOnlyEntityType = IReadOnlyEntityType$instance & { readonly [name: string]: unknown | undefined; };
3460
3376
 
3461
3377
  export interface IReadOnlyEntityTypeMappingFragment$instance extends IReadOnlyAnnotatable {
3462
3378
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyEntityTypeMappingFragment: never;
@@ -3464,7 +3380,6 @@ export interface IReadOnlyEntityTypeMappingFragment$instance extends IReadOnlyAn
3464
3380
  readonly EntityType: IReadOnlyEntityType;
3465
3381
  readonly StoreObject: StoreObjectIdentifier;
3466
3382
  readonly IsTableExcludedFromMigrations: Nullable_1<System_Internal.Boolean>;
3467
- readonly [name: string]: unknown | undefined;
3468
3383
  AnnotationsToDebugString(indent?: int): string;
3469
3384
  FindAnnotation(name: string): IAnnotation | undefined;
3470
3385
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3474,7 +3389,7 @@ export interface IReadOnlyEntityTypeMappingFragment$instance extends IReadOnlyAn
3474
3389
 
3475
3390
  export interface IReadOnlyEntityTypeMappingFragment$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3476
3391
 
3477
- export type IReadOnlyEntityTypeMappingFragment = IReadOnlyEntityTypeMappingFragment$instance;
3392
+ export type IReadOnlyEntityTypeMappingFragment = IReadOnlyEntityTypeMappingFragment$instance & { readonly [name: string]: unknown | undefined; };
3478
3393
 
3479
3394
  export interface IReadOnlyForeignKey$instance extends IReadOnlyAnnotatable {
3480
3395
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyForeignKey: never;
@@ -3490,7 +3405,6 @@ export interface IReadOnlyForeignKey$instance extends IReadOnlyAnnotatable {
3490
3405
  readonly IsRequiredDependent: boolean;
3491
3406
  readonly IsOwnership: boolean;
3492
3407
  readonly DeleteBehavior: DeleteBehavior;
3493
- readonly [name: string]: unknown | undefined;
3494
3408
  AnnotationsToDebugString(indent?: int): string;
3495
3409
  FindAnnotation(name: string): IAnnotation | undefined;
3496
3410
  GetNavigation(pointsToPrincipal: boolean): IReadOnlyNavigation | undefined;
@@ -3504,7 +3418,7 @@ export interface IReadOnlyForeignKey$instance extends IReadOnlyAnnotatable {
3504
3418
 
3505
3419
  export interface IReadOnlyForeignKey$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3506
3420
 
3507
- export type IReadOnlyForeignKey = IReadOnlyForeignKey$instance;
3421
+ export type IReadOnlyForeignKey = IReadOnlyForeignKey$instance & { readonly [name: string]: unknown | undefined; };
3508
3422
 
3509
3423
  export interface IReadOnlyIndex$instance extends IReadOnlyAnnotatable {
3510
3424
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyIndex: never;
@@ -3514,7 +3428,6 @@ export interface IReadOnlyIndex$instance extends IReadOnlyAnnotatable {
3514
3428
  readonly IsUnique: boolean;
3515
3429
  readonly IsDescending: IReadOnlyList_1<System_Internal.Boolean> | undefined;
3516
3430
  readonly DeclaringEntityType: IReadOnlyEntityType;
3517
- readonly [name: string]: unknown | undefined;
3518
3431
  AnnotationsToDebugString(indent?: int): string;
3519
3432
  DisplayName(): string;
3520
3433
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -3525,14 +3438,13 @@ export interface IReadOnlyIndex$instance extends IReadOnlyAnnotatable {
3525
3438
 
3526
3439
  export interface IReadOnlyIndex$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3527
3440
 
3528
- export type IReadOnlyIndex = IReadOnlyIndex$instance;
3441
+ export type IReadOnlyIndex = IReadOnlyIndex$instance & { readonly [name: string]: unknown | undefined; };
3529
3442
 
3530
3443
  export interface IReadOnlyKey$instance extends IReadOnlyAnnotatable {
3531
3444
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyKey: never;
3532
3445
 
3533
3446
  readonly Properties: IReadOnlyList_1<IReadOnlyProperty>;
3534
3447
  readonly DeclaringEntityType: IReadOnlyEntityType;
3535
- readonly [name: string]: unknown | undefined;
3536
3448
  AnnotationsToDebugString(indent?: int): string;
3537
3449
  FindAnnotation(name: string): IAnnotation | undefined;
3538
3450
  GetReferencingForeignKeys(): IEnumerable_1<IReadOnlyForeignKey>;
@@ -3544,13 +3456,12 @@ export interface IReadOnlyKey$instance extends IReadOnlyAnnotatable {
3544
3456
 
3545
3457
  export interface IReadOnlyKey$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3546
3458
 
3547
- export type IReadOnlyKey = IReadOnlyKey$instance;
3459
+ export type IReadOnlyKey = IReadOnlyKey$instance & { readonly [name: string]: unknown | undefined; };
3548
3460
 
3549
3461
  export interface IReadOnlyModel$instance extends IReadOnlyAnnotatable {
3550
3462
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyModel: never;
3551
3463
 
3552
3464
  readonly ModelId: Guid;
3553
- readonly [name: string]: unknown | undefined;
3554
3465
  AnnotationsToDebugString(indent?: int): string;
3555
3466
  FindAnnotation(name: string): IAnnotation | undefined;
3556
3467
  FindEntityType(name: string, definingNavigationName: string, definingEntityType: IReadOnlyEntityType): IReadOnlyEntityType | undefined;
@@ -3571,7 +3482,7 @@ export interface IReadOnlyModel$instance extends IReadOnlyAnnotatable {
3571
3482
 
3572
3483
  export interface IReadOnlyModel$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3573
3484
 
3574
- export type IReadOnlyModel = IReadOnlyModel$instance;
3485
+ export type IReadOnlyModel = IReadOnlyModel$instance & { readonly [name: string]: unknown | undefined; };
3575
3486
 
3576
3487
  export interface IReadOnlyNavigation$instance extends IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable {
3577
3488
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyNavigation: never;
@@ -3590,7 +3501,6 @@ export interface IReadOnlyNavigation$instance extends IReadOnlyNavigationBase, I
3590
3501
  readonly IsCollection: boolean;
3591
3502
  readonly PropertyInfo: PropertyInfo | undefined;
3592
3503
  readonly FieldInfo: FieldInfo | undefined;
3593
- readonly [name: string]: unknown | undefined;
3594
3504
  AnnotationsToDebugString(indent?: int): string;
3595
3505
  FindAnnotation(name: string): IAnnotation | undefined;
3596
3506
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3601,7 +3511,7 @@ export interface IReadOnlyNavigation$instance extends IReadOnlyNavigationBase, I
3601
3511
  }
3602
3512
 
3603
3513
 
3604
- export type IReadOnlyNavigation = IReadOnlyNavigation$instance;
3514
+ export type IReadOnlyNavigation = IReadOnlyNavigation$instance & { readonly [name: string]: unknown | undefined; };
3605
3515
 
3606
3516
  export interface IReadOnlyNavigationBase$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable {
3607
3517
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyNavigationBase: never;
@@ -3618,7 +3528,6 @@ export interface IReadOnlyNavigationBase$instance extends IReadOnlyPropertyBase,
3618
3528
  readonly IsCollection: boolean;
3619
3529
  readonly PropertyInfo: PropertyInfo | undefined;
3620
3530
  readonly FieldInfo: FieldInfo | undefined;
3621
- readonly [name: string]: unknown | undefined;
3622
3531
  AnnotationsToDebugString(indent?: int): string;
3623
3532
  FindAnnotation(name: string): IAnnotation | undefined;
3624
3533
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3628,7 +3537,7 @@ export interface IReadOnlyNavigationBase$instance extends IReadOnlyPropertyBase,
3628
3537
  }
3629
3538
 
3630
3539
 
3631
- export type IReadOnlyNavigationBase = IReadOnlyNavigationBase$instance;
3540
+ export type IReadOnlyNavigationBase = IReadOnlyNavigationBase$instance & { readonly [name: string]: unknown | undefined; };
3632
3541
 
3633
3542
  export interface IReadOnlyProperty$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable {
3634
3543
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyProperty: never;
@@ -3645,7 +3554,6 @@ export interface IReadOnlyProperty$instance extends IReadOnlyPropertyBase, IRead
3645
3554
  readonly IsCollection: boolean;
3646
3555
  readonly PropertyInfo: PropertyInfo | undefined;
3647
3556
  readonly FieldInfo: FieldInfo | undefined;
3648
- readonly [name: string]: unknown | undefined;
3649
3557
  AnnotationsToDebugString(indent?: int): string;
3650
3558
  FindAnnotation(name: string): IAnnotation | undefined;
3651
3559
  FindContainingPrimaryKey(): IReadOnlyKey | undefined;
@@ -3670,7 +3578,7 @@ export interface IReadOnlyProperty$instance extends IReadOnlyPropertyBase, IRead
3670
3578
  }
3671
3579
 
3672
3580
 
3673
- export type IReadOnlyProperty = IReadOnlyProperty$instance;
3581
+ export type IReadOnlyProperty = IReadOnlyProperty$instance & { readonly [name: string]: unknown | undefined; };
3674
3582
 
3675
3583
  export interface IReadOnlyPropertyBase$instance extends IReadOnlyAnnotatable {
3676
3584
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyPropertyBase: never;
@@ -3682,7 +3590,6 @@ export interface IReadOnlyPropertyBase$instance extends IReadOnlyAnnotatable {
3682
3590
  readonly IsCollection: boolean;
3683
3591
  readonly PropertyInfo: PropertyInfo | undefined;
3684
3592
  readonly FieldInfo: FieldInfo | undefined;
3685
- readonly [name: string]: unknown | undefined;
3686
3593
  AnnotationsToDebugString(indent?: int): string;
3687
3594
  FindAnnotation(name: string): IAnnotation | undefined;
3688
3595
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3694,7 +3601,7 @@ export interface IReadOnlyPropertyBase$instance extends IReadOnlyAnnotatable {
3694
3601
 
3695
3602
  export interface IReadOnlyPropertyBase$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3696
3603
 
3697
- export type IReadOnlyPropertyBase = IReadOnlyPropertyBase$instance;
3604
+ export type IReadOnlyPropertyBase = IReadOnlyPropertyBase$instance & { readonly [name: string]: unknown | undefined; };
3698
3605
 
3699
3606
  export interface IReadOnlyRelationalPropertyOverrides$instance extends IReadOnlyAnnotatable {
3700
3607
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyRelationalPropertyOverrides: never;
@@ -3703,7 +3610,6 @@ export interface IReadOnlyRelationalPropertyOverrides$instance extends IReadOnly
3703
3610
  readonly StoreObject: StoreObjectIdentifier;
3704
3611
  readonly ColumnName: string | undefined;
3705
3612
  readonly IsColumnNameOverridden: boolean;
3706
- readonly [name: string]: unknown | undefined;
3707
3613
  AnnotationsToDebugString(indent?: int): string;
3708
3614
  FindAnnotation(name: string): IAnnotation | undefined;
3709
3615
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3713,7 +3619,7 @@ export interface IReadOnlyRelationalPropertyOverrides$instance extends IReadOnly
3713
3619
 
3714
3620
  export interface IReadOnlyRelationalPropertyOverrides$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3715
3621
 
3716
- export type IReadOnlyRelationalPropertyOverrides = IReadOnlyRelationalPropertyOverrides$instance;
3622
+ export type IReadOnlyRelationalPropertyOverrides = IReadOnlyRelationalPropertyOverrides$instance & { readonly [name: string]: unknown | undefined; };
3717
3623
 
3718
3624
  export interface IReadOnlySequence$instance extends IReadOnlyAnnotatable {
3719
3625
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlySequence: never;
@@ -3728,7 +3634,6 @@ export interface IReadOnlySequence$instance extends IReadOnlyAnnotatable {
3728
3634
  readonly MaxValue: Nullable_1<System_Internal.Int64>;
3729
3635
  readonly Type: Type;
3730
3636
  readonly IsCyclic: boolean;
3731
- readonly [name: string]: unknown | undefined;
3732
3637
  AnnotationsToDebugString(indent?: int): string;
3733
3638
  FindAnnotation(name: string): IAnnotation | undefined;
3734
3639
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3738,7 +3643,7 @@ export interface IReadOnlySequence$instance extends IReadOnlyAnnotatable {
3738
3643
 
3739
3644
  export interface IReadOnlySequence$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3740
3645
 
3741
- export type IReadOnlySequence = IReadOnlySequence$instance;
3646
+ export type IReadOnlySequence = IReadOnlySequence$instance & { readonly [name: string]: unknown | undefined; };
3742
3647
 
3743
3648
  export interface IReadOnlyServiceProperty$instance extends IReadOnlyPropertyBase, IReadOnlyAnnotatable {
3744
3649
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyServiceProperty: never;
@@ -3752,7 +3657,6 @@ export interface IReadOnlyServiceProperty$instance extends IReadOnlyPropertyBase
3752
3657
  readonly IsCollection: boolean;
3753
3658
  readonly PropertyInfo: PropertyInfo | undefined;
3754
3659
  readonly FieldInfo: FieldInfo | undefined;
3755
- readonly [name: string]: unknown | undefined;
3756
3660
  AnnotationsToDebugString(indent?: int): string;
3757
3661
  FindAnnotation(name: string): IAnnotation | undefined;
3758
3662
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3763,7 +3667,7 @@ export interface IReadOnlyServiceProperty$instance extends IReadOnlyPropertyBase
3763
3667
  }
3764
3668
 
3765
3669
 
3766
- export type IReadOnlyServiceProperty = IReadOnlyServiceProperty$instance;
3670
+ export type IReadOnlyServiceProperty = IReadOnlyServiceProperty$instance & { readonly [name: string]: unknown | undefined; };
3767
3671
 
3768
3672
  export interface IReadOnlySkipNavigation$instance extends IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable {
3769
3673
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlySkipNavigation: never;
@@ -3783,7 +3687,6 @@ export interface IReadOnlySkipNavigation$instance extends IReadOnlyNavigationBas
3783
3687
  readonly IsCollection: boolean;
3784
3688
  readonly PropertyInfo: PropertyInfo | undefined;
3785
3689
  readonly FieldInfo: FieldInfo | undefined;
3786
- readonly [name: string]: unknown | undefined;
3787
3690
  AnnotationsToDebugString(indent?: int): string;
3788
3691
  FindAnnotation(name: string): IAnnotation | undefined;
3789
3692
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3794,7 +3697,7 @@ export interface IReadOnlySkipNavigation$instance extends IReadOnlyNavigationBas
3794
3697
  }
3795
3698
 
3796
3699
 
3797
- export type IReadOnlySkipNavigation = IReadOnlySkipNavigation$instance;
3700
+ export type IReadOnlySkipNavigation = IReadOnlySkipNavigation$instance & { readonly [name: string]: unknown | undefined; };
3798
3701
 
3799
3702
  export interface IReadOnlyStoredProcedure$instance extends IReadOnlyAnnotatable {
3800
3703
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyStoredProcedure: never;
@@ -3805,7 +3708,6 @@ export interface IReadOnlyStoredProcedure$instance extends IReadOnlyAnnotatable
3805
3708
  readonly IsRowsAffectedReturned: boolean;
3806
3709
  readonly Parameters: IReadOnlyList_1<IReadOnlyStoredProcedureParameter>;
3807
3710
  readonly ResultColumns: IReadOnlyList_1<IReadOnlyStoredProcedureResultColumn>;
3808
- readonly [name: string]: unknown | undefined;
3809
3711
  AnnotationsToDebugString(indent?: int): string;
3810
3712
  FindAnnotation(name: string): IAnnotation | undefined;
3811
3713
  FindParameter(propertyName: string): IReadOnlyStoredProcedureParameter | undefined;
@@ -3821,7 +3723,7 @@ export interface IReadOnlyStoredProcedure$instance extends IReadOnlyAnnotatable
3821
3723
 
3822
3724
  export interface IReadOnlyStoredProcedure$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3823
3725
 
3824
- export type IReadOnlyStoredProcedure = IReadOnlyStoredProcedure$instance;
3726
+ export type IReadOnlyStoredProcedure = IReadOnlyStoredProcedure$instance & { readonly [name: string]: unknown | undefined; };
3825
3727
 
3826
3728
  export interface IReadOnlyStoredProcedureParameter$instance extends IReadOnlyAnnotatable {
3827
3729
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyStoredProcedureParameter: never;
@@ -3832,7 +3734,6 @@ export interface IReadOnlyStoredProcedureParameter$instance extends IReadOnlyAnn
3832
3734
  readonly Direction: ParameterDirection;
3833
3735
  readonly ForOriginalValue: Nullable_1<System_Internal.Boolean>;
3834
3736
  readonly ForRowsAffected: boolean;
3835
- readonly [name: string]: unknown | undefined;
3836
3737
  AnnotationsToDebugString(indent?: int): string;
3837
3738
  FindAnnotation(name: string): IAnnotation | undefined;
3838
3739
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3842,7 +3743,7 @@ export interface IReadOnlyStoredProcedureParameter$instance extends IReadOnlyAnn
3842
3743
 
3843
3744
  export interface IReadOnlyStoredProcedureParameter$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3844
3745
 
3845
- export type IReadOnlyStoredProcedureParameter = IReadOnlyStoredProcedureParameter$instance;
3746
+ export type IReadOnlyStoredProcedureParameter = IReadOnlyStoredProcedureParameter$instance & { readonly [name: string]: unknown | undefined; };
3846
3747
 
3847
3748
  export interface IReadOnlyStoredProcedureResultColumn$instance extends IReadOnlyAnnotatable {
3848
3749
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyStoredProcedureResultColumn: never;
@@ -3851,7 +3752,6 @@ export interface IReadOnlyStoredProcedureResultColumn$instance extends IReadOnly
3851
3752
  readonly Name: string;
3852
3753
  readonly PropertyName: string | undefined;
3853
3754
  readonly ForRowsAffected: boolean;
3854
- readonly [name: string]: unknown | undefined;
3855
3755
  AnnotationsToDebugString(indent?: int): string;
3856
3756
  FindAnnotation(name: string): IAnnotation | undefined;
3857
3757
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3861,7 +3761,7 @@ export interface IReadOnlyStoredProcedureResultColumn$instance extends IReadOnly
3861
3761
 
3862
3762
  export interface IReadOnlyStoredProcedureResultColumn$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3863
3763
 
3864
- export type IReadOnlyStoredProcedureResultColumn = IReadOnlyStoredProcedureResultColumn$instance;
3764
+ export type IReadOnlyStoredProcedureResultColumn = IReadOnlyStoredProcedureResultColumn$instance & { readonly [name: string]: unknown | undefined; };
3865
3765
 
3866
3766
  export interface IReadOnlyStoreObjectDictionary_1$instance<T> {
3867
3767
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyStoreObjectDictionary_1: never;
@@ -3878,7 +3778,6 @@ export interface IReadOnlyTrigger$instance extends IReadOnlyAnnotatable {
3878
3778
 
3879
3779
  readonly ModelName: string;
3880
3780
  readonly EntityType: IReadOnlyEntityType;
3881
- readonly [name: string]: unknown | undefined;
3882
3781
  AnnotationsToDebugString(indent?: int): string;
3883
3782
  FindAnnotation(name: string): IAnnotation | undefined;
3884
3783
  GetAnnotations(): IEnumerable_1<IAnnotation>;
@@ -3888,7 +3787,7 @@ export interface IReadOnlyTrigger$instance extends IReadOnlyAnnotatable {
3888
3787
 
3889
3788
  export interface IReadOnlyTrigger$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3890
3789
 
3891
- export type IReadOnlyTrigger = IReadOnlyTrigger$instance;
3790
+ export type IReadOnlyTrigger = IReadOnlyTrigger$instance & { readonly [name: string]: unknown | undefined; };
3892
3791
 
3893
3792
  export interface IReadOnlyTypeBase$instance extends IReadOnlyAnnotatable {
3894
3793
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IReadOnlyTypeBase: never;
@@ -3900,7 +3799,6 @@ export interface IReadOnlyTypeBase$instance extends IReadOnlyAnnotatable {
3900
3799
  readonly ClrType: Type;
3901
3800
  readonly HasSharedClrType: boolean;
3902
3801
  readonly IsPropertyBag: boolean;
3903
- readonly [name: string]: unknown | undefined;
3904
3802
  AnnotationsToDebugString(indent?: int): string;
3905
3803
  DisplayName(): string;
3906
3804
  DisplayName(omitSharedType: boolean): string;
@@ -3928,7 +3826,7 @@ export interface IReadOnlyTypeBase$instance extends IReadOnlyAnnotatable {
3928
3826
 
3929
3827
  export interface IReadOnlyTypeBase$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IReadOnlyAnnotatable$instance {}
3930
3828
 
3931
- export type IReadOnlyTypeBase = IReadOnlyTypeBase$instance;
3829
+ export type IReadOnlyTypeBase = IReadOnlyTypeBase$instance & { readonly [name: string]: unknown | undefined; };
3932
3830
 
3933
3831
  export interface IRelationalAnnotationProvider$instance {
3934
3832
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IRelationalAnnotationProvider: never;
@@ -3968,7 +3866,6 @@ export interface IRelationalModel$instance extends IAnnotatable, IReadOnlyAnnota
3968
3866
  readonly Functions: IEnumerable_1<IStoreFunction>;
3969
3867
  readonly StoredProcedures: IEnumerable_1<IStoreStoredProcedure>;
3970
3868
  readonly Collation: string | undefined;
3971
- readonly [name: string]: unknown | undefined;
3972
3869
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
3973
3870
  AnnotationsToDebugString(indent?: int): string;
3974
3871
  FindDefaultTable(name: string): TableBase | undefined;
@@ -3988,7 +3885,7 @@ export interface IRelationalModel$instance extends IAnnotatable, IReadOnlyAnnota
3988
3885
  }
3989
3886
 
3990
3887
 
3991
- export type IRelationalModel = IRelationalModel$instance;
3888
+ export type IRelationalModel = IRelationalModel$instance & { readonly [name: string]: unknown | undefined; };
3992
3889
 
3993
3890
  export interface IRelationalPropertyOverrides$instance extends IReadOnlyRelationalPropertyOverrides, IReadOnlyAnnotatable, IAnnotatable {
3994
3891
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IRelationalPropertyOverrides: never;
@@ -3997,7 +3894,6 @@ export interface IRelationalPropertyOverrides$instance extends IReadOnlyRelation
3997
3894
  readonly StoreObject: StoreObjectIdentifier;
3998
3895
  readonly ColumnName: string | undefined;
3999
3896
  readonly IsColumnNameOverridden: boolean;
4000
- readonly [name: string]: unknown | undefined;
4001
3897
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4002
3898
  AnnotationsToDebugString(indent?: int): string;
4003
3899
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4010,7 +3906,7 @@ export interface IRelationalPropertyOverrides$instance extends IReadOnlyRelation
4010
3906
  }
4011
3907
 
4012
3908
 
4013
- export type IRelationalPropertyOverrides = IRelationalPropertyOverrides$instance;
3909
+ export type IRelationalPropertyOverrides = IRelationalPropertyOverrides$instance & { readonly [name: string]: unknown | undefined; };
4014
3910
 
4015
3911
  export interface ISequence$instance extends IReadOnlySequence, IReadOnlyAnnotatable, IAnnotatable {
4016
3912
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ISequence: never;
@@ -4025,7 +3921,6 @@ export interface ISequence$instance extends IReadOnlySequence, IReadOnlyAnnotata
4025
3921
  readonly MaxValue: Nullable_1<System_Internal.Int64>;
4026
3922
  readonly Type: Type;
4027
3923
  readonly IsCyclic: boolean;
4028
- readonly [name: string]: unknown | undefined;
4029
3924
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4030
3925
  AnnotationsToDebugString(indent?: int): string;
4031
3926
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4038,7 +3933,7 @@ export interface ISequence$instance extends IReadOnlySequence, IReadOnlyAnnotata
4038
3933
  }
4039
3934
 
4040
3935
 
4041
- export type ISequence = ISequence$instance;
3936
+ export type ISequence = ISequence$instance & { readonly [name: string]: unknown | undefined; };
4042
3937
 
4043
3938
  export interface IServiceProperty$instance extends IReadOnlyServiceProperty, IReadOnlyPropertyBase, IReadOnlyAnnotatable, IPropertyBase, IAnnotatable {
4044
3939
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IServiceProperty: never;
@@ -4052,7 +3947,6 @@ export interface IServiceProperty$instance extends IReadOnlyServiceProperty, IRe
4052
3947
  readonly IsCollection: boolean;
4053
3948
  readonly PropertyInfo: PropertyInfo | undefined;
4054
3949
  readonly FieldInfo: FieldInfo | undefined;
4055
- readonly [name: string]: unknown | undefined;
4056
3950
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4057
3951
  AnnotationsToDebugString(indent?: int): string;
4058
3952
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4073,7 +3967,7 @@ export interface IServiceProperty$instance extends IReadOnlyServiceProperty, IRe
4073
3967
  }
4074
3968
 
4075
3969
 
4076
- export type IServiceProperty = IServiceProperty$instance;
3970
+ export type IServiceProperty = IServiceProperty$instance & { readonly [name: string]: unknown | undefined; };
4077
3971
 
4078
3972
  export interface ISkipNavigation$instance extends IReadOnlySkipNavigation, IReadOnlyNavigationBase, IReadOnlyPropertyBase, IReadOnlyAnnotatable, INavigationBase, IPropertyBase, IAnnotatable {
4079
3973
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ISkipNavigation: never;
@@ -4093,7 +3987,6 @@ export interface ISkipNavigation$instance extends IReadOnlySkipNavigation, IRead
4093
3987
  readonly IsCollection: boolean;
4094
3988
  readonly PropertyInfo: PropertyInfo | undefined;
4095
3989
  readonly FieldInfo: FieldInfo | undefined;
4096
- readonly [name: string]: unknown | undefined;
4097
3990
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4098
3991
  AnnotationsToDebugString(indent?: int): string;
4099
3992
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4115,7 +4008,7 @@ export interface ISkipNavigation$instance extends IReadOnlySkipNavigation, IRead
4115
4008
  }
4116
4009
 
4117
4010
 
4118
- export type ISkipNavigation = ISkipNavigation$instance;
4011
+ export type ISkipNavigation = ISkipNavigation$instance & { readonly [name: string]: unknown | undefined; };
4119
4012
 
4120
4013
  export interface ISqlQuery$instance extends ITableBase, IAnnotatable, IReadOnlyAnnotatable {
4121
4014
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ISqlQuery: never;
@@ -4129,7 +4022,6 @@ export interface ISqlQuery$instance extends ITableBase, IAnnotatable, IReadOnlyA
4129
4022
  readonly Model: IRelationalModel;
4130
4023
  readonly IsShared: boolean;
4131
4024
  readonly ComplexTypeMappings: IEnumerable_1<ITableMappingBase>;
4132
- readonly [name: string]: unknown | undefined;
4133
4025
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4134
4026
  AnnotationsToDebugString(indent?: int): string;
4135
4027
  FindColumn(property: IProperty): ISqlQueryColumn | undefined;
@@ -4148,7 +4040,7 @@ export interface ISqlQuery$instance extends ITableBase, IAnnotatable, IReadOnlyA
4148
4040
  }
4149
4041
 
4150
4042
 
4151
- export type ISqlQuery = ISqlQuery$instance;
4043
+ export type ISqlQuery = ISqlQuery$instance & { readonly [name: string]: unknown | undefined; };
4152
4044
 
4153
4045
  export interface ISqlQueryColumn$instance extends IColumnBase, IAnnotatable, IReadOnlyAnnotatable {
4154
4046
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ISqlQueryColumn: never;
@@ -4162,7 +4054,6 @@ export interface ISqlQueryColumn$instance extends IColumnBase, IAnnotatable, IRe
4162
4054
  readonly IsNullable: boolean;
4163
4055
  readonly Table: ITableBase;
4164
4056
  readonly ProviderValueComparer: ValueComparer;
4165
- readonly [name: string]: unknown | undefined;
4166
4057
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4167
4058
  AnnotationsToDebugString(indent?: int): string;
4168
4059
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -4177,7 +4068,7 @@ export interface ISqlQueryColumn$instance extends IColumnBase, IAnnotatable, IRe
4177
4068
  }
4178
4069
 
4179
4070
 
4180
- export type ISqlQueryColumn = ISqlQueryColumn$instance;
4071
+ export type ISqlQueryColumn = ISqlQueryColumn$instance & { readonly [name: string]: unknown | undefined; };
4181
4072
 
4182
4073
  export interface ISqlQueryColumnMapping$instance extends IColumnMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4183
4074
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ISqlQueryColumnMapping: never;
@@ -4187,7 +4078,6 @@ export interface ISqlQueryColumnMapping$instance extends IColumnMappingBase, IAn
4187
4078
  readonly Property: IProperty;
4188
4079
  readonly TypeMapping: RelationalTypeMapping;
4189
4080
  readonly TableMapping: ITableMappingBase;
4190
- readonly [name: string]: unknown | undefined;
4191
4081
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4192
4082
  AnnotationsToDebugString(indent?: int): string;
4193
4083
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4200,7 +4090,7 @@ export interface ISqlQueryColumnMapping$instance extends IColumnMappingBase, IAn
4200
4090
  }
4201
4091
 
4202
4092
 
4203
- export type ISqlQueryColumnMapping = ISqlQueryColumnMapping$instance;
4093
+ export type ISqlQueryColumnMapping = ISqlQueryColumnMapping$instance & { readonly [name: string]: unknown | undefined; };
4204
4094
 
4205
4095
  export interface ISqlQueryMapping$instance extends ITableMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4206
4096
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ISqlQueryMapping: never;
@@ -4213,7 +4103,6 @@ export interface ISqlQueryMapping$instance extends ITableMappingBase, IAnnotatab
4213
4103
  readonly IsSharedTablePrincipal: Nullable_1<System_Internal.Boolean>;
4214
4104
  readonly IsSplitEntityTypePrincipal: Nullable_1<System_Internal.Boolean>;
4215
4105
  readonly IncludesDerivedTypes: Nullable_1<System_Internal.Boolean>;
4216
- readonly [name: string]: unknown | undefined;
4217
4106
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4218
4107
  AnnotationsToDebugString(indent?: int): string;
4219
4108
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4226,7 +4115,7 @@ export interface ISqlQueryMapping$instance extends ITableMappingBase, IAnnotatab
4226
4115
  }
4227
4116
 
4228
4117
 
4229
- export type ISqlQueryMapping = ISqlQueryMapping$instance;
4118
+ export type ISqlQueryMapping = ISqlQueryMapping$instance & { readonly [name: string]: unknown | undefined; };
4230
4119
 
4231
4120
  export interface IStoredProcedure$instance extends IReadOnlyStoredProcedure, IReadOnlyAnnotatable, IAnnotatable {
4232
4121
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoredProcedure: never;
@@ -4238,7 +4127,6 @@ export interface IStoredProcedure$instance extends IReadOnlyStoredProcedure, IRe
4238
4127
  readonly ResultColumns: IReadOnlyList_1<IStoredProcedureResultColumn>;
4239
4128
  readonly Schema: string | undefined;
4240
4129
  readonly IsRowsAffectedReturned: boolean;
4241
- readonly [name: string]: unknown | undefined;
4242
4130
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4243
4131
  AnnotationsToDebugString(indent?: int): string;
4244
4132
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4262,7 +4150,7 @@ export interface IStoredProcedure$instance extends IReadOnlyStoredProcedure, IRe
4262
4150
  }
4263
4151
 
4264
4152
 
4265
- export type IStoredProcedure = IStoredProcedure$instance;
4153
+ export type IStoredProcedure = IStoredProcedure$instance & { readonly [name: string]: unknown | undefined; };
4266
4154
 
4267
4155
  export interface IStoredProcedureMapping$instance extends ITableMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4268
4156
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoredProcedureMapping: never;
@@ -4279,7 +4167,6 @@ export interface IStoredProcedureMapping$instance extends ITableMappingBase, IAn
4279
4167
  readonly IsSharedTablePrincipal: Nullable_1<System_Internal.Boolean>;
4280
4168
  readonly IsSplitEntityTypePrincipal: Nullable_1<System_Internal.Boolean>;
4281
4169
  readonly IncludesDerivedTypes: Nullable_1<System_Internal.Boolean>;
4282
- readonly [name: string]: unknown | undefined;
4283
4170
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4284
4171
  AnnotationsToDebugString(indent?: int): string;
4285
4172
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4292,7 +4179,7 @@ export interface IStoredProcedureMapping$instance extends ITableMappingBase, IAn
4292
4179
  }
4293
4180
 
4294
4181
 
4295
- export type IStoredProcedureMapping = IStoredProcedureMapping$instance;
4182
+ export type IStoredProcedureMapping = IStoredProcedureMapping$instance & { readonly [name: string]: unknown | undefined; };
4296
4183
 
4297
4184
  export interface IStoredProcedureParameter$instance extends IReadOnlyStoredProcedureParameter, IReadOnlyAnnotatable, IAnnotatable {
4298
4185
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoredProcedureParameter: never;
@@ -4304,7 +4191,6 @@ export interface IStoredProcedureParameter$instance extends IReadOnlyStoredProce
4304
4191
  readonly Direction: ParameterDirection;
4305
4192
  readonly ForOriginalValue: Nullable_1<System_Internal.Boolean>;
4306
4193
  readonly ForRowsAffected: boolean;
4307
- readonly [name: string]: unknown | undefined;
4308
4194
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4309
4195
  AnnotationsToDebugString(indent?: int): string;
4310
4196
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4317,7 +4203,7 @@ export interface IStoredProcedureParameter$instance extends IReadOnlyStoredProce
4317
4203
  }
4318
4204
 
4319
4205
 
4320
- export type IStoredProcedureParameter = IStoredProcedureParameter$instance;
4206
+ export type IStoredProcedureParameter = IStoredProcedureParameter$instance & { readonly [name: string]: unknown | undefined; };
4321
4207
 
4322
4208
  export interface IStoredProcedureParameterMapping$instance extends IColumnMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4323
4209
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoredProcedureParameterMapping: never;
@@ -4329,7 +4215,6 @@ export interface IStoredProcedureParameterMapping$instance extends IColumnMappin
4329
4215
  readonly Column: IColumnBase;
4330
4216
  readonly TypeMapping: RelationalTypeMapping;
4331
4217
  readonly TableMapping: ITableMappingBase;
4332
- readonly [name: string]: unknown | undefined;
4333
4218
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4334
4219
  AnnotationsToDebugString(indent?: int): string;
4335
4220
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4342,7 +4227,7 @@ export interface IStoredProcedureParameterMapping$instance extends IColumnMappin
4342
4227
  }
4343
4228
 
4344
4229
 
4345
- export type IStoredProcedureParameterMapping = IStoredProcedureParameterMapping$instance;
4230
+ export type IStoredProcedureParameterMapping = IStoredProcedureParameterMapping$instance & { readonly [name: string]: unknown | undefined; };
4346
4231
 
4347
4232
  export interface IStoredProcedureResultColumn$instance extends IReadOnlyStoredProcedureResultColumn, IReadOnlyAnnotatable, IAnnotatable {
4348
4233
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoredProcedureResultColumn: never;
@@ -4352,7 +4237,6 @@ export interface IStoredProcedureResultColumn$instance extends IReadOnlyStoredPr
4352
4237
  readonly Name: string;
4353
4238
  readonly PropertyName: string | undefined;
4354
4239
  readonly ForRowsAffected: boolean;
4355
- readonly [name: string]: unknown | undefined;
4356
4240
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4357
4241
  AnnotationsToDebugString(indent?: int): string;
4358
4242
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4365,7 +4249,7 @@ export interface IStoredProcedureResultColumn$instance extends IReadOnlyStoredPr
4365
4249
  }
4366
4250
 
4367
4251
 
4368
- export type IStoredProcedureResultColumn = IStoredProcedureResultColumn$instance;
4252
+ export type IStoredProcedureResultColumn = IStoredProcedureResultColumn$instance & { readonly [name: string]: unknown | undefined; };
4369
4253
 
4370
4254
  export interface IStoredProcedureResultColumnMapping$instance extends IColumnMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4371
4255
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoredProcedureResultColumnMapping: never;
@@ -4377,7 +4261,6 @@ export interface IStoredProcedureResultColumnMapping$instance extends IColumnMap
4377
4261
  readonly Column: IColumnBase;
4378
4262
  readonly TypeMapping: RelationalTypeMapping;
4379
4263
  readonly TableMapping: ITableMappingBase;
4380
- readonly [name: string]: unknown | undefined;
4381
4264
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4382
4265
  AnnotationsToDebugString(indent?: int): string;
4383
4266
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4390,7 +4273,7 @@ export interface IStoredProcedureResultColumnMapping$instance extends IColumnMap
4390
4273
  }
4391
4274
 
4392
4275
 
4393
- export type IStoredProcedureResultColumnMapping = IStoredProcedureResultColumnMapping$instance;
4276
+ export type IStoredProcedureResultColumnMapping = IStoredProcedureResultColumnMapping$instance & { readonly [name: string]: unknown | undefined; };
4394
4277
 
4395
4278
  export interface IStoreFunction$instance extends ITableBase, IAnnotatable, IReadOnlyAnnotatable {
4396
4279
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoreFunction: never;
@@ -4407,7 +4290,6 @@ export interface IStoreFunction$instance extends ITableBase, IAnnotatable, IRead
4407
4290
  readonly Model: IRelationalModel;
4408
4291
  readonly IsShared: boolean;
4409
4292
  readonly ComplexTypeMappings: IEnumerable_1<ITableMappingBase>;
4410
- readonly [name: string]: unknown | undefined;
4411
4293
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4412
4294
  AnnotationsToDebugString(indent?: int): string;
4413
4295
  FindColumn(property: IProperty): IFunctionColumn | undefined;
@@ -4426,7 +4308,7 @@ export interface IStoreFunction$instance extends ITableBase, IAnnotatable, IRead
4426
4308
  }
4427
4309
 
4428
4310
 
4429
- export type IStoreFunction = IStoreFunction$instance;
4311
+ export type IStoreFunction = IStoreFunction$instance & { readonly [name: string]: unknown | undefined; };
4430
4312
 
4431
4313
  export interface IStoreFunctionParameter$instance extends IAnnotatable, IReadOnlyAnnotatable {
4432
4314
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoreFunctionParameter: never;
@@ -4436,7 +4318,6 @@ export interface IStoreFunctionParameter$instance extends IAnnotatable, IReadOnl
4436
4318
  readonly Name: string;
4437
4319
  readonly StoreType: string;
4438
4320
  readonly Type: string;
4439
- readonly [name: string]: unknown | undefined;
4440
4321
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4441
4322
  AnnotationsToDebugString(indent?: int): string;
4442
4323
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4449,7 +4330,7 @@ export interface IStoreFunctionParameter$instance extends IAnnotatable, IReadOnl
4449
4330
  }
4450
4331
 
4451
4332
 
4452
- export type IStoreFunctionParameter = IStoreFunctionParameter$instance;
4333
+ export type IStoreFunctionParameter = IStoreFunctionParameter$instance & { readonly [name: string]: unknown | undefined; };
4453
4334
 
4454
4335
  export interface IStoreStoredProcedure$instance extends ITableBase, IAnnotatable, IReadOnlyAnnotatable {
4455
4336
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoreStoredProcedure: never;
@@ -4466,7 +4347,6 @@ export interface IStoreStoredProcedure$instance extends ITableBase, IAnnotatable
4466
4347
  readonly IsShared: boolean;
4467
4348
  readonly ComplexTypeMappings: IEnumerable_1<ITableMappingBase>;
4468
4349
  readonly Columns: IEnumerable_1<IColumnBase>;
4469
- readonly [name: string]: unknown | undefined;
4470
4350
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4471
4351
  AnnotationsToDebugString(indent?: int): string;
4472
4352
  FindColumn(property: IProperty): IColumnBase | undefined;
@@ -4487,7 +4367,7 @@ export interface IStoreStoredProcedure$instance extends ITableBase, IAnnotatable
4487
4367
  }
4488
4368
 
4489
4369
 
4490
- export type IStoreStoredProcedure = IStoreStoredProcedure$instance;
4370
+ export type IStoreStoredProcedure = IStoreStoredProcedure$instance & { readonly [name: string]: unknown | undefined; };
4491
4371
 
4492
4372
  export interface IStoreStoredProcedureParameter$instance extends IColumnBase, IAnnotatable, IReadOnlyAnnotatable {
4493
4373
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoreStoredProcedureParameter: never;
@@ -4503,7 +4383,6 @@ export interface IStoreStoredProcedureParameter$instance extends IColumnBase, IA
4503
4383
  readonly IsNullable: boolean;
4504
4384
  readonly Table: ITableBase;
4505
4385
  readonly ProviderValueComparer: ValueComparer;
4506
- readonly [name: string]: unknown | undefined;
4507
4386
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4508
4387
  AnnotationsToDebugString(indent?: int): string;
4509
4388
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -4518,7 +4397,7 @@ export interface IStoreStoredProcedureParameter$instance extends IColumnBase, IA
4518
4397
  }
4519
4398
 
4520
4399
 
4521
- export type IStoreStoredProcedureParameter = IStoreStoredProcedureParameter$instance;
4400
+ export type IStoreStoredProcedureParameter = IStoreStoredProcedureParameter$instance & { readonly [name: string]: unknown | undefined; };
4522
4401
 
4523
4402
  export interface IStoreStoredProcedureResultColumn$instance extends IColumnBase, IAnnotatable, IReadOnlyAnnotatable {
4524
4403
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoreStoredProcedureResultColumn: never;
@@ -4533,7 +4412,6 @@ export interface IStoreStoredProcedureResultColumn$instance extends IColumnBase,
4533
4412
  readonly IsNullable: boolean;
4534
4413
  readonly Table: ITableBase;
4535
4414
  readonly ProviderValueComparer: ValueComparer;
4536
- readonly [name: string]: unknown | undefined;
4537
4415
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4538
4416
  AnnotationsToDebugString(indent?: int): string;
4539
4417
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -4548,7 +4426,7 @@ export interface IStoreStoredProcedureResultColumn$instance extends IColumnBase,
4548
4426
  }
4549
4427
 
4550
4428
 
4551
- export type IStoreStoredProcedureResultColumn = IStoreStoredProcedureResultColumn$instance;
4429
+ export type IStoreStoredProcedureResultColumn = IStoreStoredProcedureResultColumn$instance & { readonly [name: string]: unknown | undefined; };
4552
4430
 
4553
4431
  export interface IStoreStoredProcedureReturnValue$instance extends IColumnBase, IAnnotatable, IReadOnlyAnnotatable {
4554
4432
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IStoreStoredProcedureReturnValue: never;
@@ -4562,7 +4440,6 @@ export interface IStoreStoredProcedureReturnValue$instance extends IColumnBase,
4562
4440
  readonly Table: ITableBase;
4563
4441
  readonly PropertyMappings: IReadOnlyList_1<IColumnMappingBase>;
4564
4442
  readonly ProviderValueComparer: ValueComparer;
4565
- readonly [name: string]: unknown | undefined;
4566
4443
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4567
4444
  AnnotationsToDebugString(indent?: int): string;
4568
4445
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -4576,7 +4453,7 @@ export interface IStoreStoredProcedureReturnValue$instance extends IColumnBase,
4576
4453
  }
4577
4454
 
4578
4455
 
4579
- export type IStoreStoredProcedureReturnValue = IStoreStoredProcedureReturnValue$instance;
4456
+ export type IStoreStoredProcedureReturnValue = IStoreStoredProcedureReturnValue$instance & { readonly [name: string]: unknown | undefined; };
4580
4457
 
4581
4458
  export interface ITable$instance extends ITableBase, IAnnotatable, IReadOnlyAnnotatable {
4582
4459
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITable: never;
@@ -4598,7 +4475,6 @@ export interface ITable$instance extends ITableBase, IAnnotatable, IReadOnlyAnno
4598
4475
  readonly Model: IRelationalModel;
4599
4476
  readonly IsShared: boolean;
4600
4477
  readonly ComplexTypeMappings: IEnumerable_1<ITableMappingBase>;
4601
- readonly [name: string]: unknown | undefined;
4602
4478
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4603
4479
  AnnotationsToDebugString(indent?: int): string;
4604
4480
  FindColumn(property: IProperty): IColumn | undefined;
@@ -4617,7 +4493,7 @@ export interface ITable$instance extends ITableBase, IAnnotatable, IReadOnlyAnno
4617
4493
  }
4618
4494
 
4619
4495
 
4620
- export type ITable = ITable$instance;
4496
+ export type ITable = ITable$instance & { readonly [name: string]: unknown | undefined; };
4621
4497
 
4622
4498
  export interface ITableBase$instance extends IAnnotatable, IReadOnlyAnnotatable {
4623
4499
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITableBase: never;
@@ -4630,7 +4506,6 @@ export interface ITableBase$instance extends IAnnotatable, IReadOnlyAnnotatable
4630
4506
  readonly EntityTypeMappings: IEnumerable_1<ITableMappingBase>;
4631
4507
  readonly ComplexTypeMappings: IEnumerable_1<ITableMappingBase>;
4632
4508
  readonly Columns: IEnumerable_1<IColumnBase>;
4633
- readonly [name: string]: unknown | undefined;
4634
4509
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4635
4510
  AnnotationsToDebugString(indent?: int): string;
4636
4511
  FindColumn(property: IProperty): IColumnBase | undefined;
@@ -4647,7 +4522,7 @@ export interface ITableBase$instance extends IAnnotatable, IReadOnlyAnnotatable
4647
4522
  }
4648
4523
 
4649
4524
 
4650
- export type ITableBase = ITableBase$instance;
4525
+ export type ITableBase = ITableBase$instance & { readonly [name: string]: unknown | undefined; };
4651
4526
 
4652
4527
  export interface ITableIndex$instance extends IAnnotatable, IReadOnlyAnnotatable {
4653
4528
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITableIndex: never;
@@ -4659,7 +4534,6 @@ export interface ITableIndex$instance extends IAnnotatable, IReadOnlyAnnotatable
4659
4534
  readonly IsUnique: boolean;
4660
4535
  readonly IsDescending: IReadOnlyList_1<System_Internal.Boolean> | undefined;
4661
4536
  readonly Filter: string | undefined;
4662
- readonly [name: string]: unknown | undefined;
4663
4537
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4664
4538
  AnnotationsToDebugString(indent?: int): string;
4665
4539
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4672,7 +4546,7 @@ export interface ITableIndex$instance extends IAnnotatable, IReadOnlyAnnotatable
4672
4546
  }
4673
4547
 
4674
4548
 
4675
- export type ITableIndex = ITableIndex$instance;
4549
+ export type ITableIndex = ITableIndex$instance & { readonly [name: string]: unknown | undefined; };
4676
4550
 
4677
4551
  export interface ITableMapping$instance extends ITableMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4678
4552
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITableMapping: never;
@@ -4686,7 +4560,6 @@ export interface ITableMapping$instance extends ITableMappingBase, IAnnotatable,
4686
4560
  readonly IsSharedTablePrincipal: Nullable_1<System_Internal.Boolean>;
4687
4561
  readonly IsSplitEntityTypePrincipal: Nullable_1<System_Internal.Boolean>;
4688
4562
  readonly IncludesDerivedTypes: Nullable_1<System_Internal.Boolean>;
4689
- readonly [name: string]: unknown | undefined;
4690
4563
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4691
4564
  AnnotationsToDebugString(indent?: int): string;
4692
4565
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4699,7 +4572,7 @@ export interface ITableMapping$instance extends ITableMappingBase, IAnnotatable,
4699
4572
  }
4700
4573
 
4701
4574
 
4702
- export type ITableMapping = ITableMapping$instance;
4575
+ export type ITableMapping = ITableMapping$instance & { readonly [name: string]: unknown | undefined; };
4703
4576
 
4704
4577
  export interface ITableMappingBase$instance extends IAnnotatable, IReadOnlyAnnotatable {
4705
4578
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITableMappingBase: never;
@@ -4710,7 +4583,6 @@ export interface ITableMappingBase$instance extends IAnnotatable, IReadOnlyAnnot
4710
4583
  readonly IsSharedTablePrincipal: Nullable_1<System_Internal.Boolean>;
4711
4584
  readonly IsSplitEntityTypePrincipal: Nullable_1<System_Internal.Boolean>;
4712
4585
  readonly IncludesDerivedTypes: Nullable_1<System_Internal.Boolean>;
4713
- readonly [name: string]: unknown | undefined;
4714
4586
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4715
4587
  AnnotationsToDebugString(indent?: int): string;
4716
4588
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4723,14 +4595,13 @@ export interface ITableMappingBase$instance extends IAnnotatable, IReadOnlyAnnot
4723
4595
  }
4724
4596
 
4725
4597
 
4726
- export type ITableMappingBase = ITableMappingBase$instance;
4598
+ export type ITableMappingBase = ITableMappingBase$instance & { readonly [name: string]: unknown | undefined; };
4727
4599
 
4728
4600
  export interface ITrigger$instance extends IReadOnlyTrigger, IReadOnlyAnnotatable, IAnnotatable {
4729
4601
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITrigger: never;
4730
4602
 
4731
4603
  readonly EntityType: IEntityType;
4732
4604
  readonly ModelName: string;
4733
- readonly [name: string]: unknown | undefined;
4734
4605
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4735
4606
  AnnotationsToDebugString(indent?: int): string;
4736
4607
  FindAnnotation(name: string): IAnnotation | undefined;
@@ -4743,7 +4614,7 @@ export interface ITrigger$instance extends IReadOnlyTrigger, IReadOnlyAnnotatabl
4743
4614
  }
4744
4615
 
4745
4616
 
4746
- export type ITrigger = ITrigger$instance;
4617
+ export type ITrigger = ITrigger$instance & { readonly [name: string]: unknown | undefined; };
4747
4618
 
4748
4619
  export interface ITypeBase$instance extends IReadOnlyTypeBase, IReadOnlyAnnotatable, IAnnotatable {
4749
4620
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITypeBase: never;
@@ -4756,7 +4627,6 @@ export interface ITypeBase$instance extends IReadOnlyTypeBase, IReadOnlyAnnotata
4756
4627
  readonly ClrType: Type;
4757
4628
  readonly HasSharedClrType: boolean;
4758
4629
  readonly IsPropertyBag: boolean;
4759
- readonly [name: string]: unknown | undefined;
4760
4630
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4761
4631
  AnnotationsToDebugString(indent?: int): string;
4762
4632
  DisplayName(): string;
@@ -4796,13 +4666,12 @@ export interface ITypeBase$instance extends IReadOnlyTypeBase, IReadOnlyAnnotata
4796
4666
  }
4797
4667
 
4798
4668
 
4799
- export type ITypeBase = ITypeBase$instance;
4669
+ export type ITypeBase = ITypeBase$instance & { readonly [name: string]: unknown | undefined; };
4800
4670
 
4801
4671
  export interface ITypeMappingConfiguration$instance extends IAnnotatable, IReadOnlyAnnotatable {
4802
4672
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_ITypeMappingConfiguration: never;
4803
4673
 
4804
4674
  readonly ClrType: Type;
4805
- readonly [name: string]: unknown | undefined;
4806
4675
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4807
4676
  AnnotationsToDebugString(indent?: int): string;
4808
4677
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4817,7 +4686,7 @@ export interface ITypeMappingConfiguration$instance extends IAnnotatable, IReadO
4817
4686
  }
4818
4687
 
4819
4688
 
4820
- export type ITypeMappingConfiguration = ITypeMappingConfiguration$instance;
4689
+ export type ITypeMappingConfiguration = ITypeMappingConfiguration$instance & { readonly [name: string]: unknown | undefined; };
4821
4690
 
4822
4691
  export interface IUniqueConstraint$instance extends IAnnotatable, IReadOnlyAnnotatable {
4823
4692
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IUniqueConstraint: never;
@@ -4826,7 +4695,6 @@ export interface IUniqueConstraint$instance extends IAnnotatable, IReadOnlyAnnot
4826
4695
  readonly MappedKeys: IEnumerable_1<IKey>;
4827
4696
  readonly Table: ITable;
4828
4697
  readonly Columns: IReadOnlyList_1<IColumn>;
4829
- readonly [name: string]: unknown | undefined;
4830
4698
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4831
4699
  AnnotationsToDebugString(indent?: int): string;
4832
4700
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4840,7 +4708,7 @@ export interface IUniqueConstraint$instance extends IAnnotatable, IReadOnlyAnnot
4840
4708
  }
4841
4709
 
4842
4710
 
4843
- export type IUniqueConstraint = IUniqueConstraint$instance;
4711
+ export type IUniqueConstraint = IUniqueConstraint$instance & { readonly [name: string]: unknown | undefined; };
4844
4712
 
4845
4713
  export interface IView$instance extends ITableBase, IAnnotatable, IReadOnlyAnnotatable {
4846
4714
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IView: never;
@@ -4854,7 +4722,6 @@ export interface IView$instance extends ITableBase, IAnnotatable, IReadOnlyAnnot
4854
4722
  readonly Model: IRelationalModel;
4855
4723
  readonly IsShared: boolean;
4856
4724
  readonly ComplexTypeMappings: IEnumerable_1<ITableMappingBase>;
4857
- readonly [name: string]: unknown | undefined;
4858
4725
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4859
4726
  AnnotationsToDebugString(indent?: int): string;
4860
4727
  FindColumn(property: IProperty): IColumnBase | undefined;
@@ -4873,7 +4740,7 @@ export interface IView$instance extends ITableBase, IAnnotatable, IReadOnlyAnnot
4873
4740
  }
4874
4741
 
4875
4742
 
4876
- export type IView = IView$instance;
4743
+ export type IView = IView$instance & { readonly [name: string]: unknown | undefined; };
4877
4744
 
4878
4745
  export interface IViewColumn$instance extends IColumnBase, IAnnotatable, IReadOnlyAnnotatable {
4879
4746
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IViewColumn: never;
@@ -4887,7 +4754,6 @@ export interface IViewColumn$instance extends IColumnBase, IAnnotatable, IReadOn
4887
4754
  readonly IsNullable: boolean;
4888
4755
  readonly Table: ITableBase;
4889
4756
  readonly ProviderValueComparer: ValueComparer;
4890
- readonly [name: string]: unknown | undefined;
4891
4757
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4892
4758
  AnnotationsToDebugString(indent?: int): string;
4893
4759
  FindColumnMapping(entityType: IReadOnlyEntityType): IColumnMappingBase | undefined;
@@ -4902,7 +4768,7 @@ export interface IViewColumn$instance extends IColumnBase, IAnnotatable, IReadOn
4902
4768
  }
4903
4769
 
4904
4770
 
4905
- export type IViewColumn = IViewColumn$instance;
4771
+ export type IViewColumn = IViewColumn$instance & { readonly [name: string]: unknown | undefined; };
4906
4772
 
4907
4773
  export interface IViewColumnMapping$instance extends IColumnMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4908
4774
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IViewColumnMapping: never;
@@ -4912,7 +4778,6 @@ export interface IViewColumnMapping$instance extends IColumnMappingBase, IAnnota
4912
4778
  readonly Property: IProperty;
4913
4779
  readonly TypeMapping: RelationalTypeMapping;
4914
4780
  readonly TableMapping: ITableMappingBase;
4915
- readonly [name: string]: unknown | undefined;
4916
4781
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4917
4782
  AnnotationsToDebugString(indent?: int): string;
4918
4783
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4925,7 +4790,7 @@ export interface IViewColumnMapping$instance extends IColumnMappingBase, IAnnota
4925
4790
  }
4926
4791
 
4927
4792
 
4928
- export type IViewColumnMapping = IViewColumnMapping$instance;
4793
+ export type IViewColumnMapping = IViewColumnMapping$instance & { readonly [name: string]: unknown | undefined; };
4929
4794
 
4930
4795
  export interface IViewMapping$instance extends ITableMappingBase, IAnnotatable, IReadOnlyAnnotatable {
4931
4796
  readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IViewMapping: never;
@@ -4937,7 +4802,6 @@ export interface IViewMapping$instance extends ITableMappingBase, IAnnotatable,
4937
4802
  readonly IsSharedTablePrincipal: Nullable_1<System_Internal.Boolean>;
4938
4803
  readonly IsSplitEntityTypePrincipal: Nullable_1<System_Internal.Boolean>;
4939
4804
  readonly IncludesDerivedTypes: Nullable_1<System_Internal.Boolean>;
4940
- readonly [name: string]: unknown | undefined;
4941
4805
  AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
4942
4806
  AnnotationsToDebugString(indent?: int): string;
4943
4807
  FindRuntimeAnnotation(name: string): IAnnotation | undefined;
@@ -4950,7 +4814,7 @@ export interface IViewMapping$instance extends ITableMappingBase, IAnnotatable,
4950
4814
  }
4951
4815
 
4952
4816
 
4953
- export type IViewMapping = IViewMapping$instance;
4817
+ export type IViewMapping = IViewMapping$instance & { readonly [name: string]: unknown | undefined; };
4954
4818
 
4955
4819
  export interface MemberIdentity$instance {
4956
4820
  readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_MemberIdentity: never;