@girs/gcalc-1 4.9.0 → 5.1.0

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.
Files changed (3) hide show
  1. package/README.md +1 -1
  2. package/gcalc-1.d.ts +37 -148
  3. package/package.json +7 -7
package/README.md CHANGED
@@ -4,7 +4,7 @@
4
4
  ![version](https://img.shields.io/npm/v/@girs/gcalc-1)
5
5
  ![downloads/week](https://img.shields.io/npm/dw/@girs/gcalc-1)
6
6
 
7
- GJS TypeScript type definitions for GCalc-1 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.9.0.
7
+ GJS TypeScript type definitions for GCalc-1 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v5.1.0.
8
8
 
9
9
  This package contains type declarations only. It ships no runtime code, so it adds
10
10
  nothing to your program and works with any bundler or none at all.
package/gcalc-1.d.ts CHANGED
@@ -253,15 +253,12 @@ export namespace GCalc {
253
253
  // Signals
254
254
  /** @signal */
255
255
  connect<K extends keyof ExpressionContainer.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, ExpressionContainer.SignalSignatures[K]>): number;
256
- connect(signal: string, callback: (...args: any[]) => any): number;
257
256
 
258
257
  /** @signal */
259
258
  connect_after<K extends keyof ExpressionContainer.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, ExpressionContainer.SignalSignatures[K]>): number;
260
- connect_after(signal: string, callback: (...args: any[]) => any): number;
261
259
 
262
260
  /** @signal */
263
- emit<K extends keyof ExpressionContainer.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<ExpressionContainer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
264
- emit(signal: string, ...args: any[]): void;
261
+ emit<K extends keyof ExpressionContainer.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<ExpressionContainer.SignalSignatures[K]>): void;
265
262
 
266
263
  // Methods
267
264
  /**
@@ -497,15 +494,12 @@ export namespace GCalc {
497
494
  // Signals
498
495
  /** @signal */
499
496
  connect<K extends keyof ExpressionHashMap.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, ExpressionHashMap.SignalSignatures[K]>): number;
500
- connect(signal: string, callback: (...args: any[]) => any): number;
501
497
 
502
498
  /** @signal */
503
499
  connect_after<K extends keyof ExpressionHashMap.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, ExpressionHashMap.SignalSignatures[K]>): number;
504
- connect_after(signal: string, callback: (...args: any[]) => any): number;
505
500
 
506
501
  /** @signal */
507
- emit<K extends keyof ExpressionHashMap.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<ExpressionHashMap.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
508
- emit(signal: string, ...args: any[]): void;
502
+ emit<K extends keyof ExpressionHashMap.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<ExpressionHashMap.SignalSignatures[K]>): void;
509
503
 
510
504
  // Methods
511
505
  /**
@@ -571,15 +565,12 @@ export namespace GCalc {
571
565
  // Signals
572
566
  /** @signal */
573
567
  connect<K extends keyof GFunctionAcos.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAcos.SignalSignatures[K]>): number;
574
- connect(signal: string, callback: (...args: any[]) => any): number;
575
568
 
576
569
  /** @signal */
577
570
  connect_after<K extends keyof GFunctionAcos.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAcos.SignalSignatures[K]>): number;
578
- connect_after(signal: string, callback: (...args: any[]) => any): number;
579
571
 
580
572
  /** @signal */
581
- emit<K extends keyof GFunctionAcos.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAcos.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
582
- emit(signal: string, ...args: any[]): void;
573
+ emit<K extends keyof GFunctionAcos.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAcos.SignalSignatures[K]>): void;
583
574
  }
584
575
 
585
576
 
@@ -616,15 +607,12 @@ export namespace GCalc {
616
607
  // Signals
617
608
  /** @signal */
618
609
  connect<K extends keyof GFunctionAcosh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAcosh.SignalSignatures[K]>): number;
619
- connect(signal: string, callback: (...args: any[]) => any): number;
620
610
 
621
611
  /** @signal */
622
612
  connect_after<K extends keyof GFunctionAcosh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAcosh.SignalSignatures[K]>): number;
623
- connect_after(signal: string, callback: (...args: any[]) => any): number;
624
613
 
625
614
  /** @signal */
626
- emit<K extends keyof GFunctionAcosh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAcosh.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
627
- emit(signal: string, ...args: any[]): void;
615
+ emit<K extends keyof GFunctionAcosh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAcosh.SignalSignatures[K]>): void;
628
616
  }
629
617
 
630
618
 
@@ -661,15 +649,12 @@ export namespace GCalc {
661
649
  // Signals
662
650
  /** @signal */
663
651
  connect<K extends keyof GFunctionAsin.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAsin.SignalSignatures[K]>): number;
664
- connect(signal: string, callback: (...args: any[]) => any): number;
665
652
 
666
653
  /** @signal */
667
654
  connect_after<K extends keyof GFunctionAsin.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAsin.SignalSignatures[K]>): number;
668
- connect_after(signal: string, callback: (...args: any[]) => any): number;
669
655
 
670
656
  /** @signal */
671
- emit<K extends keyof GFunctionAsin.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAsin.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
672
- emit(signal: string, ...args: any[]): void;
657
+ emit<K extends keyof GFunctionAsin.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAsin.SignalSignatures[K]>): void;
673
658
  }
674
659
 
675
660
 
@@ -706,15 +691,12 @@ export namespace GCalc {
706
691
  // Signals
707
692
  /** @signal */
708
693
  connect<K extends keyof GFunctionAsinh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAsinh.SignalSignatures[K]>): number;
709
- connect(signal: string, callback: (...args: any[]) => any): number;
710
694
 
711
695
  /** @signal */
712
696
  connect_after<K extends keyof GFunctionAsinh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAsinh.SignalSignatures[K]>): number;
713
- connect_after(signal: string, callback: (...args: any[]) => any): number;
714
697
 
715
698
  /** @signal */
716
- emit<K extends keyof GFunctionAsinh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAsinh.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
717
- emit(signal: string, ...args: any[]): void;
699
+ emit<K extends keyof GFunctionAsinh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAsinh.SignalSignatures[K]>): void;
718
700
  }
719
701
 
720
702
 
@@ -751,15 +733,12 @@ export namespace GCalc {
751
733
  // Signals
752
734
  /** @signal */
753
735
  connect<K extends keyof GFunctionAtan.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAtan.SignalSignatures[K]>): number;
754
- connect(signal: string, callback: (...args: any[]) => any): number;
755
736
 
756
737
  /** @signal */
757
738
  connect_after<K extends keyof GFunctionAtan.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAtan.SignalSignatures[K]>): number;
758
- connect_after(signal: string, callback: (...args: any[]) => any): number;
759
739
 
760
740
  /** @signal */
761
- emit<K extends keyof GFunctionAtan.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAtan.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
762
- emit(signal: string, ...args: any[]): void;
741
+ emit<K extends keyof GFunctionAtan.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAtan.SignalSignatures[K]>): void;
763
742
  }
764
743
 
765
744
 
@@ -796,15 +775,12 @@ export namespace GCalc {
796
775
  // Signals
797
776
  /** @signal */
798
777
  connect<K extends keyof GFunctionAtanh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAtanh.SignalSignatures[K]>): number;
799
- connect(signal: string, callback: (...args: any[]) => any): number;
800
778
 
801
779
  /** @signal */
802
780
  connect_after<K extends keyof GFunctionAtanh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionAtanh.SignalSignatures[K]>): number;
803
- connect_after(signal: string, callback: (...args: any[]) => any): number;
804
781
 
805
782
  /** @signal */
806
- emit<K extends keyof GFunctionAtanh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAtanh.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
807
- emit(signal: string, ...args: any[]): void;
783
+ emit<K extends keyof GFunctionAtanh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionAtanh.SignalSignatures[K]>): void;
808
784
  }
809
785
 
810
786
 
@@ -841,15 +817,12 @@ export namespace GCalc {
841
817
  // Signals
842
818
  /** @signal */
843
819
  connect<K extends keyof GFunctionCos.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionCos.SignalSignatures[K]>): number;
844
- connect(signal: string, callback: (...args: any[]) => any): number;
845
820
 
846
821
  /** @signal */
847
822
  connect_after<K extends keyof GFunctionCos.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionCos.SignalSignatures[K]>): number;
848
- connect_after(signal: string, callback: (...args: any[]) => any): number;
849
823
 
850
824
  /** @signal */
851
- emit<K extends keyof GFunctionCos.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionCos.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
852
- emit(signal: string, ...args: any[]): void;
825
+ emit<K extends keyof GFunctionCos.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionCos.SignalSignatures[K]>): void;
853
826
  }
854
827
 
855
828
 
@@ -886,15 +859,12 @@ export namespace GCalc {
886
859
  // Signals
887
860
  /** @signal */
888
861
  connect<K extends keyof GFunctionCosh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionCosh.SignalSignatures[K]>): number;
889
- connect(signal: string, callback: (...args: any[]) => any): number;
890
862
 
891
863
  /** @signal */
892
864
  connect_after<K extends keyof GFunctionCosh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionCosh.SignalSignatures[K]>): number;
893
- connect_after(signal: string, callback: (...args: any[]) => any): number;
894
865
 
895
866
  /** @signal */
896
- emit<K extends keyof GFunctionCosh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionCosh.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
897
- emit(signal: string, ...args: any[]): void;
867
+ emit<K extends keyof GFunctionCosh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionCosh.SignalSignatures[K]>): void;
898
868
  }
899
869
 
900
870
 
@@ -931,15 +901,12 @@ export namespace GCalc {
931
901
  // Signals
932
902
  /** @signal */
933
903
  connect<K extends keyof GFunctionExp.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionExp.SignalSignatures[K]>): number;
934
- connect(signal: string, callback: (...args: any[]) => any): number;
935
904
 
936
905
  /** @signal */
937
906
  connect_after<K extends keyof GFunctionExp.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionExp.SignalSignatures[K]>): number;
938
- connect_after(signal: string, callback: (...args: any[]) => any): number;
939
907
 
940
908
  /** @signal */
941
- emit<K extends keyof GFunctionExp.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionExp.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
942
- emit(signal: string, ...args: any[]): void;
909
+ emit<K extends keyof GFunctionExp.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionExp.SignalSignatures[K]>): void;
943
910
  }
944
911
 
945
912
 
@@ -976,15 +943,12 @@ export namespace GCalc {
976
943
  // Signals
977
944
  /** @signal */
978
945
  connect<K extends keyof GFunctionLog.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionLog.SignalSignatures[K]>): number;
979
- connect(signal: string, callback: (...args: any[]) => any): number;
980
946
 
981
947
  /** @signal */
982
948
  connect_after<K extends keyof GFunctionLog.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionLog.SignalSignatures[K]>): number;
983
- connect_after(signal: string, callback: (...args: any[]) => any): number;
984
949
 
985
950
  /** @signal */
986
- emit<K extends keyof GFunctionLog.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionLog.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
987
- emit(signal: string, ...args: any[]): void;
951
+ emit<K extends keyof GFunctionLog.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionLog.SignalSignatures[K]>): void;
988
952
  }
989
953
 
990
954
 
@@ -1021,15 +985,12 @@ export namespace GCalc {
1021
985
  // Signals
1022
986
  /** @signal */
1023
987
  connect<K extends keyof GFunctionSin.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionSin.SignalSignatures[K]>): number;
1024
- connect(signal: string, callback: (...args: any[]) => any): number;
1025
988
 
1026
989
  /** @signal */
1027
990
  connect_after<K extends keyof GFunctionSin.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionSin.SignalSignatures[K]>): number;
1028
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1029
991
 
1030
992
  /** @signal */
1031
- emit<K extends keyof GFunctionSin.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionSin.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1032
- emit(signal: string, ...args: any[]): void;
993
+ emit<K extends keyof GFunctionSin.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionSin.SignalSignatures[K]>): void;
1033
994
  }
1034
995
 
1035
996
 
@@ -1066,15 +1027,12 @@ export namespace GCalc {
1066
1027
  // Signals
1067
1028
  /** @signal */
1068
1029
  connect<K extends keyof GFunctionSinh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionSinh.SignalSignatures[K]>): number;
1069
- connect(signal: string, callback: (...args: any[]) => any): number;
1070
1030
 
1071
1031
  /** @signal */
1072
1032
  connect_after<K extends keyof GFunctionSinh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionSinh.SignalSignatures[K]>): number;
1073
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1074
1033
 
1075
1034
  /** @signal */
1076
- emit<K extends keyof GFunctionSinh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionSinh.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1077
- emit(signal: string, ...args: any[]): void;
1035
+ emit<K extends keyof GFunctionSinh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionSinh.SignalSignatures[K]>): void;
1078
1036
  }
1079
1037
 
1080
1038
 
@@ -1111,15 +1069,12 @@ export namespace GCalc {
1111
1069
  // Signals
1112
1070
  /** @signal */
1113
1071
  connect<K extends keyof GFunctionSqrt.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionSqrt.SignalSignatures[K]>): number;
1114
- connect(signal: string, callback: (...args: any[]) => any): number;
1115
1072
 
1116
1073
  /** @signal */
1117
1074
  connect_after<K extends keyof GFunctionSqrt.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionSqrt.SignalSignatures[K]>): number;
1118
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1119
1075
 
1120
1076
  /** @signal */
1121
- emit<K extends keyof GFunctionSqrt.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionSqrt.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1122
- emit(signal: string, ...args: any[]): void;
1077
+ emit<K extends keyof GFunctionSqrt.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionSqrt.SignalSignatures[K]>): void;
1123
1078
  }
1124
1079
 
1125
1080
 
@@ -1156,15 +1111,12 @@ export namespace GCalc {
1156
1111
  // Signals
1157
1112
  /** @signal */
1158
1113
  connect<K extends keyof GFunctionTan.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionTan.SignalSignatures[K]>): number;
1159
- connect(signal: string, callback: (...args: any[]) => any): number;
1160
1114
 
1161
1115
  /** @signal */
1162
1116
  connect_after<K extends keyof GFunctionTan.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionTan.SignalSignatures[K]>): number;
1163
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1164
1117
 
1165
1118
  /** @signal */
1166
- emit<K extends keyof GFunctionTan.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionTan.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1167
- emit(signal: string, ...args: any[]): void;
1119
+ emit<K extends keyof GFunctionTan.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionTan.SignalSignatures[K]>): void;
1168
1120
  }
1169
1121
 
1170
1122
 
@@ -1201,15 +1153,12 @@ export namespace GCalc {
1201
1153
  // Signals
1202
1154
  /** @signal */
1203
1155
  connect<K extends keyof GFunctionTanh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionTanh.SignalSignatures[K]>): number;
1204
- connect(signal: string, callback: (...args: any[]) => any): number;
1205
1156
 
1206
1157
  /** @signal */
1207
1158
  connect_after<K extends keyof GFunctionTanh.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunctionTanh.SignalSignatures[K]>): number;
1208
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1209
1159
 
1210
1160
  /** @signal */
1211
- emit<K extends keyof GFunctionTanh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionTanh.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1212
- emit(signal: string, ...args: any[]): void;
1161
+ emit<K extends keyof GFunctionTanh.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunctionTanh.SignalSignatures[K]>): void;
1213
1162
  }
1214
1163
 
1215
1164
 
@@ -1249,15 +1198,12 @@ export namespace GCalc {
1249
1198
  // Signals
1250
1199
  /** @signal */
1251
1200
  connect<K extends keyof GExpression.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GExpression.SignalSignatures[K]>): number;
1252
- connect(signal: string, callback: (...args: any[]) => any): number;
1253
1201
 
1254
1202
  /** @signal */
1255
1203
  connect_after<K extends keyof GExpression.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GExpression.SignalSignatures[K]>): number;
1256
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1257
1204
 
1258
1205
  /** @signal */
1259
- emit<K extends keyof GExpression.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GExpression.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1260
- emit(signal: string, ...args: any[]): void;
1206
+ emit<K extends keyof GExpression.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GExpression.SignalSignatures[K]>): void;
1261
1207
 
1262
1208
  // Virtual methods
1263
1209
  /**
@@ -1345,15 +1291,12 @@ export namespace GCalc {
1345
1291
  // Signals
1346
1292
  /** @signal */
1347
1293
  connect<K extends keyof GErrorExpression.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GErrorExpression.SignalSignatures[K]>): number;
1348
- connect(signal: string, callback: (...args: any[]) => any): number;
1349
1294
 
1350
1295
  /** @signal */
1351
1296
  connect_after<K extends keyof GErrorExpression.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GErrorExpression.SignalSignatures[K]>): number;
1352
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1353
1297
 
1354
1298
  /** @signal */
1355
- emit<K extends keyof GErrorExpression.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GErrorExpression.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1356
- emit(signal: string, ...args: any[]): void;
1299
+ emit<K extends keyof GErrorExpression.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GErrorExpression.SignalSignatures[K]>): void;
1357
1300
  }
1358
1301
 
1359
1302
 
@@ -1390,15 +1333,12 @@ export namespace GCalc {
1390
1333
  // Signals
1391
1334
  /** @signal */
1392
1335
  connect<K extends keyof GAssign.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GAssign.SignalSignatures[K]>): number;
1393
- connect(signal: string, callback: (...args: any[]) => any): number;
1394
1336
 
1395
1337
  /** @signal */
1396
1338
  connect_after<K extends keyof GAssign.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GAssign.SignalSignatures[K]>): number;
1397
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1398
1339
 
1399
1340
  /** @signal */
1400
- emit<K extends keyof GAssign.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GAssign.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1401
- emit(signal: string, ...args: any[]): void;
1341
+ emit<K extends keyof GAssign.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GAssign.SignalSignatures[K]>): void;
1402
1342
 
1403
1343
  /**
1404
1344
  * @throws GLib.Error
@@ -1448,15 +1388,12 @@ export namespace GCalc {
1448
1388
  // Signals
1449
1389
  /** @signal */
1450
1390
  connect<K extends keyof GConstant.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GConstant.SignalSignatures[K]>): number;
1451
- connect(signal: string, callback: (...args: any[]) => any): number;
1452
1391
 
1453
1392
  /** @signal */
1454
1393
  connect_after<K extends keyof GConstant.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GConstant.SignalSignatures[K]>): number;
1455
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1456
1394
 
1457
1395
  /** @signal */
1458
- emit<K extends keyof GConstant.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GConstant.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1459
- emit(signal: string, ...args: any[]): void;
1396
+ emit<K extends keyof GConstant.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GConstant.SignalSignatures[K]>): void;
1460
1397
 
1461
1398
  // Methods
1462
1399
  /**
@@ -1571,15 +1508,12 @@ export namespace GCalc {
1571
1508
  // Signals
1572
1509
  /** @signal */
1573
1510
  connect<K extends keyof GDivision.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GDivision.SignalSignatures[K]>): number;
1574
- connect(signal: string, callback: (...args: any[]) => any): number;
1575
1511
 
1576
1512
  /** @signal */
1577
1513
  connect_after<K extends keyof GDivision.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GDivision.SignalSignatures[K]>): number;
1578
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1579
1514
 
1580
1515
  /** @signal */
1581
- emit<K extends keyof GDivision.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GDivision.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1582
- emit(signal: string, ...args: any[]): void;
1516
+ emit<K extends keyof GDivision.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GDivision.SignalSignatures[K]>): void;
1583
1517
  }
1584
1518
 
1585
1519
 
@@ -1619,15 +1553,12 @@ export namespace GCalc {
1619
1553
  // Signals
1620
1554
  /** @signal */
1621
1555
  connect<K extends keyof GErrorResult.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GErrorResult.SignalSignatures[K]>): number;
1622
- connect(signal: string, callback: (...args: any[]) => any): number;
1623
1556
 
1624
1557
  /** @signal */
1625
1558
  connect_after<K extends keyof GErrorResult.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GErrorResult.SignalSignatures[K]>): number;
1626
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1627
1559
 
1628
1560
  /** @signal */
1629
- emit<K extends keyof GErrorResult.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GErrorResult.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1630
- emit(signal: string, ...args: any[]): void;
1561
+ emit<K extends keyof GErrorResult.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GErrorResult.SignalSignatures[K]>): void;
1631
1562
 
1632
1563
  /**
1633
1564
  * @read-only
@@ -1704,15 +1635,12 @@ export namespace GCalc {
1704
1635
  // Signals
1705
1636
  /** @signal */
1706
1637
  connect<K extends keyof GFunction.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunction.SignalSignatures[K]>): number;
1707
- connect(signal: string, callback: (...args: any[]) => any): number;
1708
1638
 
1709
1639
  /** @signal */
1710
1640
  connect_after<K extends keyof GFunction.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GFunction.SignalSignatures[K]>): number;
1711
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1712
1641
 
1713
1642
  /** @signal */
1714
- emit<K extends keyof GFunction.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunction.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1715
- emit(signal: string, ...args: any[]): void;
1643
+ emit<K extends keyof GFunction.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GFunction.SignalSignatures[K]>): void;
1716
1644
 
1717
1645
  // Virtual methods
1718
1646
  /**
@@ -1869,15 +1797,12 @@ export namespace GCalc {
1869
1797
  // Signals
1870
1798
  /** @signal */
1871
1799
  connect<K extends keyof GMathEquation.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMathEquation.SignalSignatures[K]>): number;
1872
- connect(signal: string, callback: (...args: any[]) => any): number;
1873
1800
 
1874
1801
  /** @signal */
1875
1802
  connect_after<K extends keyof GMathEquation.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMathEquation.SignalSignatures[K]>): number;
1876
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1877
1803
 
1878
1804
  /** @signal */
1879
- emit<K extends keyof GMathEquation.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMathEquation.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1880
- emit(signal: string, ...args: any[]): void;
1805
+ emit<K extends keyof GMathEquation.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMathEquation.SignalSignatures[K]>): void;
1881
1806
 
1882
1807
  /**
1883
1808
  * @read-only
@@ -1930,15 +1855,12 @@ export namespace GCalc {
1930
1855
  // Signals
1931
1856
  /** @signal */
1932
1857
  connect<K extends keyof GMathEquationManager.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMathEquationManager.SignalSignatures[K]>): number;
1933
- connect(signal: string, callback: (...args: any[]) => any): number;
1934
1858
 
1935
1859
  /** @signal */
1936
1860
  connect_after<K extends keyof GMathEquationManager.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMathEquationManager.SignalSignatures[K]>): number;
1937
- connect_after(signal: string, callback: (...args: any[]) => any): number;
1938
1861
 
1939
1862
  /** @signal */
1940
- emit<K extends keyof GMathEquationManager.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMathEquationManager.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
1941
- emit(signal: string, ...args: any[]): void;
1863
+ emit<K extends keyof GMathEquationManager.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMathEquationManager.SignalSignatures[K]>): void;
1942
1864
 
1943
1865
  /**
1944
1866
  * @read-only
@@ -2012,15 +1934,12 @@ export namespace GCalc {
2012
1934
  // Signals
2013
1935
  /** @signal */
2014
1936
  connect<K extends keyof GMinus.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMinus.SignalSignatures[K]>): number;
2015
- connect(signal: string, callback: (...args: any[]) => any): number;
2016
1937
 
2017
1938
  /** @signal */
2018
1939
  connect_after<K extends keyof GMinus.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMinus.SignalSignatures[K]>): number;
2019
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2020
1940
 
2021
1941
  /** @signal */
2022
- emit<K extends keyof GMinus.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMinus.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2023
- emit(signal: string, ...args: any[]): void;
1942
+ emit<K extends keyof GMinus.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMinus.SignalSignatures[K]>): void;
2024
1943
  }
2025
1944
 
2026
1945
 
@@ -2057,15 +1976,12 @@ export namespace GCalc {
2057
1976
  // Signals
2058
1977
  /** @signal */
2059
1978
  connect<K extends keyof GMultiply.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMultiply.SignalSignatures[K]>): number;
2060
- connect(signal: string, callback: (...args: any[]) => any): number;
2061
1979
 
2062
1980
  /** @signal */
2063
1981
  connect_after<K extends keyof GMultiply.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GMultiply.SignalSignatures[K]>): number;
2064
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2065
1982
 
2066
1983
  /** @signal */
2067
- emit<K extends keyof GMultiply.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMultiply.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2068
- emit(signal: string, ...args: any[]): void;
1984
+ emit<K extends keyof GMultiply.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GMultiply.SignalSignatures[K]>): void;
2069
1985
  }
2070
1986
 
2071
1987
 
@@ -2102,15 +2018,12 @@ export namespace GCalc {
2102
2018
  // Signals
2103
2019
  /** @signal */
2104
2020
  connect<K extends keyof GParser.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GParser.SignalSignatures[K]>): number;
2105
- connect(signal: string, callback: (...args: any[]) => any): number;
2106
2021
 
2107
2022
  /** @signal */
2108
2023
  connect_after<K extends keyof GParser.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GParser.SignalSignatures[K]>): number;
2109
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2110
2024
 
2111
2025
  /** @signal */
2112
- emit<K extends keyof GParser.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GParser.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2113
- emit(signal: string, ...args: any[]): void;
2026
+ emit<K extends keyof GParser.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GParser.SignalSignatures[K]>): void;
2114
2027
 
2115
2028
  // Methods
2116
2029
  /**
@@ -2159,15 +2072,12 @@ export namespace GCalc {
2159
2072
  // Signals
2160
2073
  /** @signal */
2161
2074
  connect<K extends keyof GPlus.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GPlus.SignalSignatures[K]>): number;
2162
- connect(signal: string, callback: (...args: any[]) => any): number;
2163
2075
 
2164
2076
  /** @signal */
2165
2077
  connect_after<K extends keyof GPlus.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GPlus.SignalSignatures[K]>): number;
2166
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2167
2078
 
2168
2079
  /** @signal */
2169
- emit<K extends keyof GPlus.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GPlus.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2170
- emit(signal: string, ...args: any[]): void;
2080
+ emit<K extends keyof GPlus.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GPlus.SignalSignatures[K]>): void;
2171
2081
  }
2172
2082
 
2173
2083
 
@@ -2204,15 +2114,12 @@ export namespace GCalc {
2204
2114
  // Signals
2205
2115
  /** @signal */
2206
2116
  connect<K extends keyof GPolynomial.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GPolynomial.SignalSignatures[K]>): number;
2207
- connect(signal: string, callback: (...args: any[]) => any): number;
2208
2117
 
2209
2118
  /** @signal */
2210
2119
  connect_after<K extends keyof GPolynomial.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GPolynomial.SignalSignatures[K]>): number;
2211
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2212
2120
 
2213
2121
  /** @signal */
2214
- emit<K extends keyof GPolynomial.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GPolynomial.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2215
- emit(signal: string, ...args: any[]): void;
2122
+ emit<K extends keyof GPolynomial.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GPolynomial.SignalSignatures[K]>): void;
2216
2123
 
2217
2124
  /**
2218
2125
  * @throws GLib.Error
@@ -2259,15 +2166,12 @@ export namespace GCalc {
2259
2166
  // Signals
2260
2167
  /** @signal */
2261
2168
  connect<K extends keyof GPow.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GPow.SignalSignatures[K]>): number;
2262
- connect(signal: string, callback: (...args: any[]) => any): number;
2263
2169
 
2264
2170
  /** @signal */
2265
2171
  connect_after<K extends keyof GPow.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GPow.SignalSignatures[K]>): number;
2266
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2267
2172
 
2268
2173
  /** @signal */
2269
- emit<K extends keyof GPow.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GPow.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2270
- emit(signal: string, ...args: any[]): void;
2174
+ emit<K extends keyof GPow.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GPow.SignalSignatures[K]>): void;
2271
2175
  }
2272
2176
 
2273
2177
 
@@ -2306,15 +2210,12 @@ export namespace GCalc {
2306
2210
  // Signals
2307
2211
  /** @signal */
2308
2212
  connect<K extends keyof GResult.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GResult.SignalSignatures[K]>): number;
2309
- connect(signal: string, callback: (...args: any[]) => any): number;
2310
2213
 
2311
2214
  /** @signal */
2312
2215
  connect_after<K extends keyof GResult.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GResult.SignalSignatures[K]>): number;
2313
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2314
2216
 
2315
2217
  /** @signal */
2316
- emit<K extends keyof GResult.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GResult.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2317
- emit(signal: string, ...args: any[]): void;
2218
+ emit<K extends keyof GResult.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GResult.SignalSignatures[K]>): void;
2318
2219
 
2319
2220
  /**
2320
2221
  * @read-only
@@ -2374,15 +2275,12 @@ export namespace GCalc {
2374
2275
  // Signals
2375
2276
  /** @signal */
2376
2277
  connect<K extends keyof GGroup.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GGroup.SignalSignatures[K]>): number;
2377
- connect(signal: string, callback: (...args: any[]) => any): number;
2378
2278
 
2379
2279
  /** @signal */
2380
2280
  connect_after<K extends keyof GGroup.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GGroup.SignalSignatures[K]>): number;
2381
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2382
2281
 
2383
2282
  /** @signal */
2384
- emit<K extends keyof GGroup.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GGroup.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2385
- emit(signal: string, ...args: any[]): void;
2283
+ emit<K extends keyof GGroup.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GGroup.SignalSignatures[K]>): void;
2386
2284
 
2387
2285
  /** @category Inherited from GCalc.Group */
2388
2286
  get level(): GroupLevel;
@@ -2475,15 +2373,12 @@ export namespace GCalc {
2475
2373
  // Signals
2476
2374
  /** @signal */
2477
2375
  connect<K extends keyof GSolver.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GSolver.SignalSignatures[K]>): number;
2478
- connect(signal: string, callback: (...args: any[]) => any): number;
2479
2376
 
2480
2377
  /** @signal */
2481
2378
  connect_after<K extends keyof GSolver.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GSolver.SignalSignatures[K]>): number;
2482
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2483
2379
 
2484
2380
  /** @signal */
2485
- emit<K extends keyof GSolver.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GSolver.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2486
- emit(signal: string, ...args: any[]): void;
2381
+ emit<K extends keyof GSolver.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GSolver.SignalSignatures[K]>): void;
2487
2382
 
2488
2383
  /** @category Inherited from GCalc.Solver */
2489
2384
  get equation_manager(): MathEquationManager;
@@ -2558,15 +2453,12 @@ export namespace GCalc {
2558
2453
  // Signals
2559
2454
  /** @signal */
2560
2455
  connect<K extends keyof GTerm.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GTerm.SignalSignatures[K]>): number;
2561
- connect(signal: string, callback: (...args: any[]) => any): number;
2562
2456
 
2563
2457
  /** @signal */
2564
2458
  connect_after<K extends keyof GTerm.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GTerm.SignalSignatures[K]>): number;
2565
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2566
2459
 
2567
2460
  /** @signal */
2568
- emit<K extends keyof GTerm.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GTerm.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2569
- emit(signal: string, ...args: any[]): void;
2461
+ emit<K extends keyof GTerm.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GTerm.SignalSignatures[K]>): void;
2570
2462
 
2571
2463
  /**
2572
2464
  * @param t
@@ -2632,15 +2524,12 @@ export namespace GCalc {
2632
2524
  // Signals
2633
2525
  /** @signal */
2634
2526
  connect<K extends keyof GVariable.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GVariable.SignalSignatures[K]>): number;
2635
- connect(signal: string, callback: (...args: any[]) => any): number;
2636
2527
 
2637
2528
  /** @signal */
2638
2529
  connect_after<K extends keyof GVariable.SignalSignatures>(signal: K, callback: GObject.SignalCallback<this, GVariable.SignalSignatures[K]>): number;
2639
- connect_after(signal: string, callback: (...args: any[]) => any): number;
2640
2530
 
2641
2531
  /** @signal */
2642
- emit<K extends keyof GVariable.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GVariable.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never): void;
2643
- emit(signal: string, ...args: any[]): void;
2532
+ emit<K extends keyof GVariable.SignalSignatures>(signal: K, ...args: GObject.GjsParameters<GVariable.SignalSignatures[K]>): void;
2644
2533
 
2645
2534
  /** @category Inherited from GCalc.Variable */
2646
2535
  get name(): string;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@girs/gcalc-1",
3
- "version": "4.9.0",
3
+ "version": "5.1.0",
4
4
  "description": "GJS TypeScript type definitions for GCalc-1",
5
5
  "type": "module",
6
6
  "module": "gcalc-1.js",
@@ -31,12 +31,12 @@
31
31
  "test": "tsc --project tsconfig.json"
32
32
  },
33
33
  "dependencies": {
34
- "@girs/gjs": "^4.9.0",
35
- "@girs/gobject-2.0": "^4.9.0",
36
- "@girs/glib-2.0": "^4.9.0",
37
- "@girs/gio-2.0": "^4.9.0",
38
- "@girs/gmodule-2.0": "^4.9.0",
39
- "@girs/gee-0.8": "^4.9.0" },
34
+ "@girs/gjs": "^5.1.0",
35
+ "@girs/gobject-2.0": "^5.1.0",
36
+ "@girs/glib-2.0": "^5.1.0",
37
+ "@girs/gio-2.0": "^5.1.0",
38
+ "@girs/gmodule-2.0": "^5.1.0",
39
+ "@girs/gee-0.8": "^5.1.0" },
40
40
  "devDependencies": {
41
41
  "typescript": "*"
42
42
  },