@astrale-os/kernel-core 0.9.0-beta.51 → 0.9.0-beta.52

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 (19) hide show
  1. package/dist/graph/graph/model/codec.js +1 -1
  2. package/dist/graph/query/result/index.js +1 -1
  3. package/dist/schema/domain/domain.d.ts +424 -154
  4. package/dist/schema/identity/identity.d.ts +27 -9
  5. package/dist/schema/kernel/projection/index.d.ts +2 -2
  6. package/dist/schema/kernel/projection/index.js +1 -1
  7. package/dist/schema/kernel/projection/project.d.ts +3 -1
  8. package/dist/schema/kernel/projection/project.js +53 -32
  9. package/dist/schema/kernel/projection/types.d.ts +27 -1
  10. package/dist/schema/kernel/schema.d.ts +772 -484
  11. package/dist/schema/kernel/syscalls/contracts/can.d.ts +16 -4
  12. package/dist/schema/kernel/syscalls/contracts/can.js +11 -3
  13. package/dist/schema/kernel/syscalls/contracts/index.d.ts +1 -1
  14. package/dist/schema/kernel/syscalls/contracts/index.js +1 -1
  15. package/dist/schema/kernel/syscalls/declarations/can.d.ts +9 -0
  16. package/dist/schema/kernel/syscalls/declarations/can.js +1 -1
  17. package/dist/schema/kernel/syscalls/declarations/index.d.ts +9 -0
  18. package/dist/schema/kernel/syscalls/descriptors/identity.d.ts +9 -0
  19. package/package.json +2 -2
package/dist/schema/domain/domain.d.ts CHANGED
@@ -46,10 +46,19 @@ export declare const Domain: builder.NodeClass<{
46
46
  can: builder.Method<builder.CallableProjection<{
47
47
  policy: string;
48
48
  object: string;
49
+ } | {
50
+ checks: {
51
+ policy: string;
52
+ object: string;
53
+ }[];
49
54
  }, {
50
55
  readonly mode: 'value';
51
56
  readonly value: {
52
57
  allowed: boolean;
58
+ } | {
59
+ decisions: {
60
+ allowed: boolean;
61
+ }[];
53
62
  };
54
63
  }, "authenticated", true, false>>;
55
64
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -181,10 +190,19 @@ export declare const Domain: builder.NodeClass<{
181
190
  can: builder.Method<builder.CallableProjection<{
182
191
  policy: string;
183
192
  object: string;
193
+ } | {
194
+ checks: {
195
+ policy: string;
196
+ object: string;
197
+ }[];
184
198
  }, {
185
199
  readonly mode: 'value';
186
200
  readonly value: {
187
201
  allowed: boolean;
202
+ } | {
203
+ decisions: {
204
+ allowed: boolean;
205
+ }[];
188
206
  };
189
207
  }, "authenticated", true, false>>;
190
208
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -301,14 +319,6 @@ export declare const Domain: builder.NodeClass<{
301
319
  readonly mode: 'value';
302
320
  readonly value: string;
303
321
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
304
- policy: string;
305
- object: string;
306
- }, {
307
- readonly mode: 'value';
308
- readonly value: {
309
- allowed: boolean;
310
- };
311
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
312
322
  iss: string;
313
323
  sub: string;
314
324
  }, {
@@ -346,7 +356,24 @@ export declare const Domain: builder.NodeClass<{
346
356
  }, {
347
357
  readonly mode: 'value';
348
358
  readonly value: string;
349
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
359
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
360
+ policy: string;
361
+ object: string;
362
+ } | {
363
+ checks: {
364
+ policy: string;
365
+ object: string;
366
+ }[];
367
+ }, {
368
+ readonly mode: 'value';
369
+ readonly value: {
370
+ allowed: boolean;
371
+ } | {
372
+ decisions: {
373
+ allowed: boolean;
374
+ }[];
375
+ };
376
+ }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
350
377
  readonly abstract: true;
351
378
  readonly depth: 1;
352
379
  readonly properties: {
@@ -390,10 +417,19 @@ export declare const Domain: builder.NodeClass<{
390
417
  can: builder.Method<builder.CallableProjection<{
391
418
  policy: string;
392
419
  object: string;
420
+ } | {
421
+ checks: {
422
+ policy: string;
423
+ object: string;
424
+ }[];
393
425
  }, {
394
426
  readonly mode: 'value';
395
427
  readonly value: {
396
428
  allowed: boolean;
429
+ } | {
430
+ decisions: {
431
+ allowed: boolean;
432
+ }[];
397
433
  };
398
434
  }, "authenticated", true, false>>;
399
435
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -510,14 +546,6 @@ export declare const Domain: builder.NodeClass<{
510
546
  readonly mode: 'value';
511
547
  readonly value: string;
512
548
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
513
- policy: string;
514
- object: string;
515
- }, {
516
- readonly mode: 'value';
517
- readonly value: {
518
- allowed: boolean;
519
- };
520
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
521
549
  iss: string;
522
550
  sub: string;
523
551
  }, {
@@ -555,7 +583,24 @@ export declare const Domain: builder.NodeClass<{
555
583
  }, {
556
584
  readonly mode: 'value';
557
585
  readonly value: string;
558
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
586
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
587
+ policy: string;
588
+ object: string;
589
+ } | {
590
+ checks: {
591
+ policy: string;
592
+ object: string;
593
+ }[];
594
+ }, {
595
+ readonly mode: 'value';
596
+ readonly value: {
597
+ allowed: boolean;
598
+ } | {
599
+ decisions: {
600
+ allowed: boolean;
601
+ }[];
602
+ };
603
+ }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
559
604
  readonly abstract: true;
560
605
  readonly depth: 1;
561
606
  readonly properties: {
@@ -599,10 +644,19 @@ export declare const Domain: builder.NodeClass<{
599
644
  can: builder.Method<builder.CallableProjection<{
600
645
  policy: string;
601
646
  object: string;
647
+ } | {
648
+ checks: {
649
+ policy: string;
650
+ object: string;
651
+ }[];
602
652
  }, {
603
653
  readonly mode: 'value';
604
654
  readonly value: {
605
655
  allowed: boolean;
656
+ } | {
657
+ decisions: {
658
+ allowed: boolean;
659
+ }[];
606
660
  };
607
661
  }, "authenticated", true, false>>;
608
662
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -719,14 +773,6 @@ export declare const Domain: builder.NodeClass<{
719
773
  readonly mode: 'value';
720
774
  readonly value: string;
721
775
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
722
- policy: string;
723
- object: string;
724
- }, {
725
- readonly mode: 'value';
726
- readonly value: {
727
- allowed: boolean;
728
- };
729
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
730
776
  iss: string;
731
777
  sub: string;
732
778
  }, {
@@ -764,7 +810,24 @@ export declare const Domain: builder.NodeClass<{
764
810
  }, {
765
811
  readonly mode: 'value';
766
812
  readonly value: string;
767
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
813
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
814
+ policy: string;
815
+ object: string;
816
+ } | {
817
+ checks: {
818
+ policy: string;
819
+ object: string;
820
+ }[];
821
+ }, {
822
+ readonly mode: 'value';
823
+ readonly value: {
824
+ allowed: boolean;
825
+ } | {
826
+ decisions: {
827
+ allowed: boolean;
828
+ }[];
829
+ };
830
+ }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
768
831
  readonly abstract: true;
769
832
  readonly depth: 1;
770
833
  readonly properties: {
@@ -808,10 +871,19 @@ export declare const Domain: builder.NodeClass<{
808
871
  can: builder.Method<builder.CallableProjection<{
809
872
  policy: string;
810
873
  object: string;
874
+ } | {
875
+ checks: {
876
+ policy: string;
877
+ object: string;
878
+ }[];
811
879
  }, {
812
880
  readonly mode: 'value';
813
881
  readonly value: {
814
882
  allowed: boolean;
883
+ } | {
884
+ decisions: {
885
+ allowed: boolean;
886
+ }[];
815
887
  };
816
888
  }, "authenticated", true, false>>;
817
889
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -928,14 +1000,6 @@ export declare const Domain: builder.NodeClass<{
928
1000
  readonly mode: 'value';
929
1001
  readonly value: string;
930
1002
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
931
- policy: string;
932
- object: string;
933
- }, {
934
- readonly mode: 'value';
935
- readonly value: {
936
- allowed: boolean;
937
- };
938
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
939
1003
  iss: string;
940
1004
  sub: string;
941
1005
  }, {
@@ -973,7 +1037,24 @@ export declare const Domain: builder.NodeClass<{
973
1037
  }, {
974
1038
  readonly mode: 'value';
975
1039
  readonly value: string;
976
- }, "authorized", true, false>>, "impersonate", unknown>>, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
1040
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1041
+ policy: string;
1042
+ object: string;
1043
+ } | {
1044
+ checks: {
1045
+ policy: string;
1046
+ object: string;
1047
+ }[];
1048
+ }, {
1049
+ readonly mode: 'value';
1050
+ readonly value: {
1051
+ allowed: boolean;
1052
+ } | {
1053
+ decisions: {
1054
+ allowed: boolean;
1055
+ }[];
1056
+ };
1057
+ }, "authenticated", true, false>>, "can", unknown>>, never>, never, builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<Record<string, never>, {
977
1058
  readonly mode: 'value';
978
1059
  readonly value: {
979
1060
  id: string;
@@ -1037,10 +1118,19 @@ export declare const Domain: builder.NodeClass<{
1037
1118
  can: builder.Method<builder.CallableProjection<{
1038
1119
  policy: string;
1039
1120
  object: string;
1121
+ } | {
1122
+ checks: {
1123
+ policy: string;
1124
+ object: string;
1125
+ }[];
1040
1126
  }, {
1041
1127
  readonly mode: 'value';
1042
1128
  readonly value: {
1043
1129
  allowed: boolean;
1130
+ } | {
1131
+ decisions: {
1132
+ allowed: boolean;
1133
+ }[];
1044
1134
  };
1045
1135
  }, "authenticated", true, false>>;
1046
1136
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -1157,14 +1247,6 @@ export declare const Domain: builder.NodeClass<{
1157
1247
  readonly mode: 'value';
1158
1248
  readonly value: string;
1159
1249
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1160
- policy: string;
1161
- object: string;
1162
- }, {
1163
- readonly mode: 'value';
1164
- readonly value: {
1165
- allowed: boolean;
1166
- };
1167
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1168
1250
  iss: string;
1169
1251
  sub: string;
1170
1252
  }, {
@@ -1202,7 +1284,24 @@ export declare const Domain: builder.NodeClass<{
1202
1284
  }, {
1203
1285
  readonly mode: 'value';
1204
1286
  readonly value: string;
1205
- }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1287
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1288
+ policy: string;
1289
+ object: string;
1290
+ } | {
1291
+ checks: {
1292
+ policy: string;
1293
+ object: string;
1294
+ }[];
1295
+ }, {
1296
+ readonly mode: 'value';
1297
+ readonly value: {
1298
+ allowed: boolean;
1299
+ } | {
1300
+ decisions: {
1301
+ allowed: boolean;
1302
+ }[];
1303
+ };
1304
+ }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1206
1305
  principal: string;
1207
1306
  audience: string;
1208
1307
  ttlSeconds: number;
@@ -1254,10 +1353,19 @@ export declare const Domain: builder.NodeClass<{
1254
1353
  can: builder.Method<builder.CallableProjection<{
1255
1354
  policy: string;
1256
1355
  object: string;
1356
+ } | {
1357
+ checks: {
1358
+ policy: string;
1359
+ object: string;
1360
+ }[];
1257
1361
  }, {
1258
1362
  readonly mode: 'value';
1259
1363
  readonly value: {
1260
1364
  allowed: boolean;
1365
+ } | {
1366
+ decisions: {
1367
+ allowed: boolean;
1368
+ }[];
1261
1369
  };
1262
1370
  }, "authenticated", true, false>>;
1263
1371
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -1374,14 +1482,6 @@ export declare const Domain: builder.NodeClass<{
1374
1482
  readonly mode: 'value';
1375
1483
  readonly value: string;
1376
1484
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1377
- policy: string;
1378
- object: string;
1379
- }, {
1380
- readonly mode: 'value';
1381
- readonly value: {
1382
- allowed: boolean;
1383
- };
1384
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1385
1485
  iss: string;
1386
1486
  sub: string;
1387
1487
  }, {
@@ -1419,15 +1519,47 @@ export declare const Domain: builder.NodeClass<{
1419
1519
  }, {
1420
1520
  readonly mode: 'value';
1421
1521
  readonly value: string;
1422
- }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1522
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1423
1523
  policy: string;
1424
1524
  object: string;
1525
+ } | {
1526
+ checks: {
1527
+ policy: string;
1528
+ object: string;
1529
+ }[];
1425
1530
  }, {
1426
1531
  readonly mode: 'value';
1427
1532
  readonly value: {
1428
1533
  allowed: boolean;
1534
+ } | {
1535
+ decisions: {
1536
+ allowed: boolean;
1537
+ }[];
1429
1538
  };
1430
- }, "authenticated", true, false>>, "can", builder.ClassOwnerProjection<"node", {
1539
+ }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1540
+ iss: string;
1541
+ sub: string;
1542
+ }, {
1543
+ readonly mode: 'value';
1544
+ readonly value: {
1545
+ id: string;
1546
+ iss: string;
1547
+ sub: string;
1548
+ frozen: boolean;
1549
+ requiredClaims: ({
1550
+ claim: string;
1551
+ op: "contains";
1552
+ value: unknown;
1553
+ } | {
1554
+ claim: string;
1555
+ op: "eq";
1556
+ value: unknown;
1557
+ } | {
1558
+ claim: string;
1559
+ op: "exists";
1560
+ })[];
1561
+ } | null;
1562
+ }, "authorized", true, false>>, "whois", builder.ClassOwnerProjection<"node", {
1431
1563
  readonly abstract: true;
1432
1564
  readonly depth: 1;
1433
1565
  readonly properties: {
@@ -1471,10 +1603,19 @@ export declare const Domain: builder.NodeClass<{
1471
1603
  can: builder.Method<builder.CallableProjection<{
1472
1604
  policy: string;
1473
1605
  object: string;
1606
+ } | {
1607
+ checks: {
1608
+ policy: string;
1609
+ object: string;
1610
+ }[];
1474
1611
  }, {
1475
1612
  readonly mode: 'value';
1476
1613
  readonly value: {
1477
1614
  allowed: boolean;
1615
+ } | {
1616
+ decisions: {
1617
+ allowed: boolean;
1618
+ }[];
1478
1619
  };
1479
1620
  }, "authenticated", true, false>>;
1480
1621
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -1591,14 +1732,6 @@ export declare const Domain: builder.NodeClass<{
1591
1732
  readonly mode: 'value';
1592
1733
  readonly value: string;
1593
1734
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1594
- policy: string;
1595
- object: string;
1596
- }, {
1597
- readonly mode: 'value';
1598
- readonly value: {
1599
- allowed: boolean;
1600
- };
1601
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1602
1735
  iss: string;
1603
1736
  sub: string;
1604
1737
  }, {
@@ -1636,30 +1769,31 @@ export declare const Domain: builder.NodeClass<{
1636
1769
  }, {
1637
1770
  readonly mode: 'value';
1638
1771
  readonly value: string;
1639
- }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1640
- iss: string;
1641
- sub: string;
1772
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1773
+ policy: string;
1774
+ object: string;
1775
+ } | {
1776
+ checks: {
1777
+ policy: string;
1778
+ object: string;
1779
+ }[];
1642
1780
  }, {
1643
1781
  readonly mode: 'value';
1644
1782
  readonly value: {
1645
- id: string;
1646
- iss: string;
1647
- sub: string;
1648
- frozen: boolean;
1649
- requiredClaims: ({
1650
- claim: string;
1651
- op: "contains";
1652
- value: unknown;
1653
- } | {
1654
- claim: string;
1655
- op: "eq";
1656
- value: unknown;
1657
- } | {
1658
- claim: string;
1659
- op: "exists";
1660
- })[];
1661
- } | null;
1662
- }, "authorized", true, false>>, "whois", builder.ClassOwnerProjection<"node", {
1783
+ allowed: boolean;
1784
+ } | {
1785
+ decisions: {
1786
+ allowed: boolean;
1787
+ }[];
1788
+ };
1789
+ }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1790
+ audience?: string | undefined;
1791
+ ttlSeconds: number;
1792
+ grant?: unknown;
1793
+ }, {
1794
+ readonly mode: 'value';
1795
+ readonly value: string;
1796
+ }, "authenticated", true, false>>, "mint", builder.ClassOwnerProjection<"node", {
1663
1797
  readonly abstract: true;
1664
1798
  readonly depth: 1;
1665
1799
  readonly properties: {
@@ -1703,10 +1837,19 @@ export declare const Domain: builder.NodeClass<{
1703
1837
  can: builder.Method<builder.CallableProjection<{
1704
1838
  policy: string;
1705
1839
  object: string;
1840
+ } | {
1841
+ checks: {
1842
+ policy: string;
1843
+ object: string;
1844
+ }[];
1706
1845
  }, {
1707
1846
  readonly mode: 'value';
1708
1847
  readonly value: {
1709
1848
  allowed: boolean;
1849
+ } | {
1850
+ decisions: {
1851
+ allowed: boolean;
1852
+ }[];
1710
1853
  };
1711
1854
  }, "authenticated", true, false>>;
1712
1855
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -1823,14 +1966,6 @@ export declare const Domain: builder.NodeClass<{
1823
1966
  readonly mode: 'value';
1824
1967
  readonly value: string;
1825
1968
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1826
- policy: string;
1827
- object: string;
1828
- }, {
1829
- readonly mode: 'value';
1830
- readonly value: {
1831
- allowed: boolean;
1832
- };
1833
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1834
1969
  iss: string;
1835
1970
  sub: string;
1836
1971
  }, {
@@ -1868,14 +2003,32 @@ export declare const Domain: builder.NodeClass<{
1868
2003
  }, {
1869
2004
  readonly mode: 'value';
1870
2005
  readonly value: string;
1871
- }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2006
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2007
+ policy: string;
2008
+ object: string;
2009
+ } | {
2010
+ checks: {
2011
+ policy: string;
2012
+ object: string;
2013
+ }[];
2014
+ }, {
2015
+ readonly mode: 'value';
2016
+ readonly value: {
2017
+ allowed: boolean;
2018
+ } | {
2019
+ decisions: {
2020
+ allowed: boolean;
2021
+ }[];
2022
+ };
2023
+ }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
1872
2024
  audience?: string | undefined;
1873
2025
  ttlSeconds: number;
1874
2026
  grant?: unknown;
2027
+ identity: string;
1875
2028
  }, {
1876
2029
  readonly mode: 'value';
1877
2030
  readonly value: string;
1878
- }, "authenticated", true, false>>, "mint", builder.ClassOwnerProjection<"node", {
2031
+ }, "authorized", true, false>>, "impersonate", builder.ClassOwnerProjection<"node", {
1879
2032
  readonly abstract: true;
1880
2033
  readonly depth: 1;
1881
2034
  readonly properties: {
@@ -1919,10 +2072,19 @@ export declare const Domain: builder.NodeClass<{
1919
2072
  can: builder.Method<builder.CallableProjection<{
1920
2073
  policy: string;
1921
2074
  object: string;
2075
+ } | {
2076
+ checks: {
2077
+ policy: string;
2078
+ object: string;
2079
+ }[];
1922
2080
  }, {
1923
2081
  readonly mode: 'value';
1924
2082
  readonly value: {
1925
2083
  allowed: boolean;
2084
+ } | {
2085
+ decisions: {
2086
+ allowed: boolean;
2087
+ }[];
1926
2088
  };
1927
2089
  }, "authenticated", true, false>>;
1928
2090
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -2039,14 +2201,6 @@ export declare const Domain: builder.NodeClass<{
2039
2201
  readonly mode: 'value';
2040
2202
  readonly value: string;
2041
2203
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2042
- policy: string;
2043
- object: string;
2044
- }, {
2045
- readonly mode: 'value';
2046
- readonly value: {
2047
- allowed: boolean;
2048
- };
2049
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2050
2204
  iss: string;
2051
2205
  sub: string;
2052
2206
  }, {
@@ -2084,15 +2238,41 @@ export declare const Domain: builder.NodeClass<{
2084
2238
  }, {
2085
2239
  readonly mode: 'value';
2086
2240
  readonly value: string;
2087
- }, "authorized", true, false>>, "impersonate", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2088
- audience?: string | undefined;
2089
- ttlSeconds: number;
2090
- grant?: unknown;
2091
- identity: string;
2241
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2242
+ policy: string;
2243
+ object: string;
2244
+ } | {
2245
+ checks: {
2246
+ policy: string;
2247
+ object: string;
2248
+ }[];
2092
2249
  }, {
2093
2250
  readonly mode: 'value';
2094
- readonly value: string;
2095
- }, "authorized", true, false>>, "impersonate", builder.ClassOwnerProjection<"node", {
2251
+ readonly value: {
2252
+ allowed: boolean;
2253
+ } | {
2254
+ decisions: {
2255
+ allowed: boolean;
2256
+ }[];
2257
+ };
2258
+ }, "authenticated", true, false>>, "can", unknown>>> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2259
+ policy: string;
2260
+ object: string;
2261
+ } | {
2262
+ checks: {
2263
+ policy: string;
2264
+ object: string;
2265
+ }[];
2266
+ }, {
2267
+ readonly mode: 'value';
2268
+ readonly value: {
2269
+ allowed: boolean;
2270
+ } | {
2271
+ decisions: {
2272
+ allowed: boolean;
2273
+ }[];
2274
+ };
2275
+ }, "authenticated", true, false>>, "can", builder.ClassOwnerProjection<"node", {
2096
2276
  readonly abstract: true;
2097
2277
  readonly depth: 1;
2098
2278
  readonly properties: {
@@ -2136,10 +2316,19 @@ export declare const Domain: builder.NodeClass<{
2136
2316
  can: builder.Method<builder.CallableProjection<{
2137
2317
  policy: string;
2138
2318
  object: string;
2319
+ } | {
2320
+ checks: {
2321
+ policy: string;
2322
+ object: string;
2323
+ }[];
2139
2324
  }, {
2140
2325
  readonly mode: 'value';
2141
2326
  readonly value: {
2142
2327
  allowed: boolean;
2328
+ } | {
2329
+ decisions: {
2330
+ allowed: boolean;
2331
+ }[];
2143
2332
  };
2144
2333
  }, "authenticated", true, false>>;
2145
2334
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -2256,14 +2445,6 @@ export declare const Domain: builder.NodeClass<{
2256
2445
  readonly mode: 'value';
2257
2446
  readonly value: string;
2258
2447
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2259
- policy: string;
2260
- object: string;
2261
- }, {
2262
- readonly mode: 'value';
2263
- readonly value: {
2264
- allowed: boolean;
2265
- };
2266
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2267
2448
  iss: string;
2268
2449
  sub: string;
2269
2450
  }, {
@@ -2301,7 +2482,24 @@ export declare const Domain: builder.NodeClass<{
2301
2482
  }, {
2302
2483
  readonly mode: 'value';
2303
2484
  readonly value: string;
2304
- }, "authorized", true, false>>, "impersonate", unknown>>>>];
2485
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2486
+ policy: string;
2487
+ object: string;
2488
+ } | {
2489
+ checks: {
2490
+ policy: string;
2491
+ object: string;
2492
+ }[];
2493
+ }, {
2494
+ readonly mode: 'value';
2495
+ readonly value: {
2496
+ allowed: boolean;
2497
+ } | {
2498
+ decisions: {
2499
+ allowed: boolean;
2500
+ }[];
2501
+ };
2502
+ }, "authenticated", true, false>>, "can", unknown>>>>];
2305
2503
  readonly properties: {
2306
2504
  readonly origin: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined>;
2307
2505
  readonly dependencyContext: builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never>;
@@ -2375,10 +2573,19 @@ export declare const Domain: builder.NodeClass<{
2375
2573
  can: builder.Method<builder.CallableProjection<{
2376
2574
  policy: string;
2377
2575
  object: string;
2576
+ } | {
2577
+ checks: {
2578
+ policy: string;
2579
+ object: string;
2580
+ }[];
2378
2581
  }, {
2379
2582
  readonly mode: 'value';
2380
2583
  readonly value: {
2381
2584
  allowed: boolean;
2585
+ } | {
2586
+ decisions: {
2587
+ allowed: boolean;
2588
+ }[];
2382
2589
  };
2383
2590
  }, "authenticated", true, false>>;
2384
2591
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -2495,14 +2702,6 @@ export declare const Domain: builder.NodeClass<{
2495
2702
  readonly mode: 'value';
2496
2703
  readonly value: string;
2497
2704
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2498
- policy: string;
2499
- object: string;
2500
- }, {
2501
- readonly mode: 'value';
2502
- readonly value: {
2503
- allowed: boolean;
2504
- };
2505
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2506
2705
  iss: string;
2507
2706
  sub: string;
2508
2707
  }, {
@@ -2540,7 +2739,24 @@ export declare const Domain: builder.NodeClass<{
2540
2739
  }, {
2541
2740
  readonly mode: 'value';
2542
2741
  readonly value: string;
2543
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
2742
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2743
+ policy: string;
2744
+ object: string;
2745
+ } | {
2746
+ checks: {
2747
+ policy: string;
2748
+ object: string;
2749
+ }[];
2750
+ }, {
2751
+ readonly mode: 'value';
2752
+ readonly value: {
2753
+ allowed: boolean;
2754
+ } | {
2755
+ decisions: {
2756
+ allowed: boolean;
2757
+ }[];
2758
+ };
2759
+ }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "frozen", builder.ClassOwnerProjection<"node", {
2544
2760
  readonly abstract: true;
2545
2761
  readonly depth: 1;
2546
2762
  readonly properties: {
@@ -2584,10 +2800,19 @@ export declare const Domain: builder.NodeClass<{
2584
2800
  can: builder.Method<builder.CallableProjection<{
2585
2801
  policy: string;
2586
2802
  object: string;
2803
+ } | {
2804
+ checks: {
2805
+ policy: string;
2806
+ object: string;
2807
+ }[];
2587
2808
  }, {
2588
2809
  readonly mode: 'value';
2589
2810
  readonly value: {
2590
2811
  allowed: boolean;
2812
+ } | {
2813
+ decisions: {
2814
+ allowed: boolean;
2815
+ }[];
2591
2816
  };
2592
2817
  }, "authenticated", true, false>>;
2593
2818
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -2704,14 +2929,6 @@ export declare const Domain: builder.NodeClass<{
2704
2929
  readonly mode: 'value';
2705
2930
  readonly value: string;
2706
2931
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2707
- policy: string;
2708
- object: string;
2709
- }, {
2710
- readonly mode: 'value';
2711
- readonly value: {
2712
- allowed: boolean;
2713
- };
2714
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2715
2932
  iss: string;
2716
2933
  sub: string;
2717
2934
  }, {
@@ -2749,7 +2966,24 @@ export declare const Domain: builder.NodeClass<{
2749
2966
  }, {
2750
2967
  readonly mode: 'value';
2751
2968
  readonly value: string;
2752
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
2969
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2970
+ policy: string;
2971
+ object: string;
2972
+ } | {
2973
+ checks: {
2974
+ policy: string;
2975
+ object: string;
2976
+ }[];
2977
+ }, {
2978
+ readonly mode: 'value';
2979
+ readonly value: {
2980
+ allowed: boolean;
2981
+ } | {
2982
+ decisions: {
2983
+ allowed: boolean;
2984
+ }[];
2985
+ };
2986
+ }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "iss", builder.ClassOwnerProjection<"node", {
2753
2987
  readonly abstract: true;
2754
2988
  readonly depth: 1;
2755
2989
  readonly properties: {
@@ -2793,10 +3027,19 @@ export declare const Domain: builder.NodeClass<{
2793
3027
  can: builder.Method<builder.CallableProjection<{
2794
3028
  policy: string;
2795
3029
  object: string;
3030
+ } | {
3031
+ checks: {
3032
+ policy: string;
3033
+ object: string;
3034
+ }[];
2796
3035
  }, {
2797
3036
  readonly mode: 'value';
2798
3037
  readonly value: {
2799
3038
  allowed: boolean;
3039
+ } | {
3040
+ decisions: {
3041
+ allowed: boolean;
3042
+ }[];
2800
3043
  };
2801
3044
  }, "authenticated", true, false>>;
2802
3045
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -2913,14 +3156,6 @@ export declare const Domain: builder.NodeClass<{
2913
3156
  readonly mode: 'value';
2914
3157
  readonly value: string;
2915
3158
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2916
- policy: string;
2917
- object: string;
2918
- }, {
2919
- readonly mode: 'value';
2920
- readonly value: {
2921
- allowed: boolean;
2922
- };
2923
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
2924
3159
  iss: string;
2925
3160
  sub: string;
2926
3161
  }, {
@@ -2958,7 +3193,24 @@ export declare const Domain: builder.NodeClass<{
2958
3193
  }, {
2959
3194
  readonly mode: 'value';
2960
3195
  readonly value: string;
2961
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
3196
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
3197
+ policy: string;
3198
+ object: string;
3199
+ } | {
3200
+ checks: {
3201
+ policy: string;
3202
+ object: string;
3203
+ }[];
3204
+ }, {
3205
+ readonly mode: 'value';
3206
+ readonly value: {
3207
+ allowed: boolean;
3208
+ } | {
3209
+ decisions: {
3210
+ allowed: boolean;
3211
+ }[];
3212
+ };
3213
+ }, "authenticated", true, false>>, "can", unknown>>, never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "sub", builder.ClassOwnerProjection<"node", {
2962
3214
  readonly abstract: true;
2963
3215
  readonly depth: 1;
2964
3216
  readonly properties: {
@@ -3002,10 +3254,19 @@ export declare const Domain: builder.NodeClass<{
3002
3254
  can: builder.Method<builder.CallableProjection<{
3003
3255
  policy: string;
3004
3256
  object: string;
3257
+ } | {
3258
+ checks: {
3259
+ policy: string;
3260
+ object: string;
3261
+ }[];
3005
3262
  }, {
3006
3263
  readonly mode: 'value';
3007
3264
  readonly value: {
3008
3265
  allowed: boolean;
3266
+ } | {
3267
+ decisions: {
3268
+ allowed: boolean;
3269
+ }[];
3009
3270
  };
3010
3271
  }, "authenticated", true, false>>;
3011
3272
  whoami: builder.Method<builder.CallableProjection<Record<string, never>, {
@@ -3122,14 +3383,6 @@ export declare const Domain: builder.NodeClass<{
3122
3383
  readonly mode: 'value';
3123
3384
  readonly value: string;
3124
3385
  }, "authenticated", true, false>>, "delegate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
3125
- policy: string;
3126
- object: string;
3127
- }, {
3128
- readonly mode: 'value';
3129
- readonly value: {
3130
- allowed: boolean;
3131
- };
3132
- }, "authenticated", true, false>>, "can", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
3133
3386
  iss: string;
3134
3387
  sub: string;
3135
3388
  }, {
@@ -3167,7 +3420,24 @@ export declare const Domain: builder.NodeClass<{
3167
3420
  }, {
3168
3421
  readonly mode: 'value';
3169
3422
  readonly value: string;
3170
- }, "authorized", true, false>>, "impersonate", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
3423
+ }, "authorized", true, false>>, "impersonate", unknown> | builder.AuthoredMethodProjection<builder.Method<builder.CallableProjection<{
3424
+ policy: string;
3425
+ object: string;
3426
+ } | {
3427
+ checks: {
3428
+ policy: string;
3429
+ object: string;
3430
+ }[];
3431
+ }, {
3432
+ readonly mode: 'value';
3433
+ readonly value: {
3434
+ allowed: boolean;
3435
+ } | {
3436
+ decisions: {
3437
+ allowed: boolean;
3438
+ }[];
3439
+ };
3440
+ }, "authenticated", true, false>>, "can", unknown>>, never> | (builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, false, "dependencyContext", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "origin", "self", undefined> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schema", "self", never> | builder.AuthoredPropertyProjection<import("@astrale-os/kernel-dsl/value").Value, import("@astrale-os/kernel-dsl/value").Value, true, "schemaRevision", "self", never>);
3171
3441
  readonly abstractInstanceMethods: never;
3172
3442
  readonly abstractStaticMethods: never;
3173
3443
  readonly effectiveInstanceMethods: never;