@astrale-domains/shell 0.1.0-beta.8 → 0.1.0-beta.9

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 (47) hide show
  1. package/dist/actions/user/resolve-home.js +1 -1
  2. package/dist/application.d.ts +9807 -3
  3. package/dist/mutations/group/membership.js +17 -19
  4. package/dist/mutations/space/access.js +21 -23
  5. package/dist/mutations/space/default.js +18 -20
  6. package/dist/mutations/user/repair.js +76 -78
  7. package/dist/queries/space/access.js +9 -11
  8. package/dist/queries/space/admin.js +18 -25
  9. package/dist/queries/space/member.js +15 -22
  10. package/dist/queries/user/groups.js +15 -22
  11. package/dist/queries/user/home.js +19 -26
  12. package/dist/queries/user/owned-spaces.js +15 -22
  13. package/dist/queries/user/profile.js +3 -6
  14. package/dist/queries/user/setup.js +11 -13
  15. package/dist/runtime.d.ts +7355 -2
  16. package/dist/schema/domain/index.d.ts +1162 -26408
  17. package/dist/schema/domain/index.js +4 -5
  18. package/dist/schema/group/class.d.ts +163 -3128
  19. package/dist/schema/group/core.d.ts +2 -6
  20. package/dist/schema/group/index.d.ts +1 -1
  21. package/dist/schema/group/index.js +1 -1
  22. package/dist/schema/group/methods.d.ts +13 -2059
  23. package/dist/schema/group/methods.js +2 -1
  24. package/dist/schema/group/relationships.d.ts +6 -4303
  25. package/dist/schema/group/view.d.ts +1 -3291
  26. package/dist/schema/home/view.d.ts +1 -3
  27. package/dist/schema/index.d.ts +5 -5
  28. package/dist/schema/index.js +1 -1
  29. package/dist/schema/setup/functions.d.ts +28 -47
  30. package/dist/schema/setup/index.d.ts +1 -1
  31. package/dist/schema/space/class.d.ts +56 -2289
  32. package/dist/schema/space/core.d.ts +3 -22515
  33. package/dist/schema/space/index.d.ts +1 -1
  34. package/dist/schema/space/index.js +1 -1
  35. package/dist/schema/space/methods.d.ts +18 -2089
  36. package/dist/schema/space/methods.js +5 -3
  37. package/dist/schema/space/relationships.d.ts +24 -23173
  38. package/dist/schema/space/view.d.ts +1 -2316
  39. package/dist/schema/user/class.d.ts +128 -865
  40. package/dist/schema/user/index.d.ts +1 -1
  41. package/dist/schema/user/methods.d.ts +7 -14
  42. package/dist/schema/user/view.d.ts +1 -1017
  43. package/dist/workflows/group/change.js +3 -3
  44. package/dist/workflows/setup/run.js +3 -3
  45. package/dist/workflows/space/access.js +3 -3
  46. package/dist/workflows/space/default.js +3 -3
  47. package/package.json +3 -3
package/dist/schema/group/relationships.d.ts CHANGED
@@ -1,4313 +1,16 @@
1
1
  export declare const member_of_group: import("@astrale-os/sdk/schema").DirectedEdgeClass<{
2
+ readonly depth: 0;
3
+ readonly abstract: false;
4
+ readonly extends: readonly [];
5
+ readonly properties: never;
2
6
  readonly source: {
3
7
  readonly as: "user";
4
- readonly accepts: readonly [import("@astrale-os/sdk/schema").NodeClass<{
5
- readonly description: "One externally identified person using Shell.";
6
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
7
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
8
- readonly name: "frozen";
9
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
10
- };
11
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
12
- readonly name: "iss";
13
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
14
- };
15
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
16
- claim: string;
17
- op: "contains";
18
- value: unknown;
19
- } | {
20
- claim: string;
21
- op: "eq";
22
- value: unknown;
23
- } | {
24
- claim: string;
25
- op: "exists";
26
- })[], false> & {
27
- readonly name: "requiredClaims";
28
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
29
- };
30
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
31
- readonly name: "sub";
32
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
33
- };
34
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
35
- readonly name: "frozen";
36
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
37
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
38
- readonly name: "iss";
39
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
40
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
41
- claim: string;
42
- op: "contains";
43
- value: unknown;
44
- } | {
45
- claim: string;
46
- op: "eq";
47
- value: unknown;
48
- } | {
49
- claim: string;
50
- op: "exists";
51
- })[], false> & {
52
- readonly name: "requiredClaims";
53
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
54
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
55
- readonly name: "sub";
56
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
57
- })> & {
58
- readonly byKey: Readonly<{
59
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
60
- readonly name: "frozen";
61
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
62
- };
63
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
64
- readonly name: "iss";
65
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
66
- };
67
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
68
- claim: string;
69
- op: "contains";
70
- value: unknown;
71
- } | {
72
- claim: string;
73
- op: "eq";
74
- value: unknown;
75
- } | {
76
- claim: string;
77
- op: "exists";
78
- })[], false> & {
79
- readonly name: "requiredClaims";
80
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
81
- };
82
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
83
- readonly name: "sub";
84
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
85
- };
86
- }>;
87
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
88
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
89
- readonly name: "frozen";
90
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
91
- };
92
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
93
- readonly name: "iss";
94
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
95
- };
96
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
97
- claim: string;
98
- op: "contains";
99
- value: unknown;
100
- } | {
101
- claim: string;
102
- op: "eq";
103
- value: unknown;
104
- } | {
105
- claim: string;
106
- op: "exists";
107
- })[], false> & {
108
- readonly name: "requiredClaims";
109
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
110
- };
111
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
112
- readonly name: "sub";
113
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
114
- };
115
- }>[Key];
116
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
117
- from(input: Readonly<{
118
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
119
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
120
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
121
- claim: string;
122
- op: "contains";
123
- value: unknown;
124
- } | {
125
- claim: string;
126
- op: "eq";
127
- value: unknown;
128
- } | {
129
- claim: string;
130
- op: "exists";
131
- })[] | undefined;
132
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
133
- } & {
134
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
135
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
136
- readonly requiredClaims?: ({
137
- claim: string;
138
- op: "contains";
139
- value: unknown;
140
- } | {
141
- claim: string;
142
- op: "eq";
143
- value: unknown;
144
- } | {
145
- claim: string;
146
- op: "exists";
147
- })[] | undefined;
148
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
149
- }>): import("@astrale-os/sdk/schema").PropertyValues;
150
- }, Readonly<Readonly<{
151
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
152
- audience: string;
153
- ttlSeconds: number;
154
- attenuation: unknown;
155
- }, {
156
- readonly mode: 'value';
157
- readonly value: string;
158
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
159
- readonly name: "delegate";
160
- };
161
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
162
- audience: string;
163
- ttlSeconds: number;
164
- attenuation: unknown;
165
- }, {
166
- readonly mode: 'value';
167
- readonly value: string;
168
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
169
- readonly name: "delegate";
170
- }> & {
171
- readonly byKey: Readonly<{
172
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
173
- audience: string;
174
- ttlSeconds: number;
175
- attenuation: unknown;
176
- }, {
177
- readonly mode: 'value';
178
- readonly value: string;
179
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
180
- readonly name: "delegate";
181
- };
182
- }>;
183
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
184
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
185
- audience: string;
186
- ttlSeconds: number;
187
- attenuation: unknown;
188
- }, {
189
- readonly mode: 'value';
190
- readonly value: string;
191
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
192
- readonly name: "delegate";
193
- };
194
- }>[Key];
195
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
196
- }, Readonly<Readonly<{
197
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
198
- policy: string;
199
- object: string;
200
- }, {
201
- readonly mode: 'value';
202
- readonly value: {
203
- allowed: boolean;
204
- };
205
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
206
- readonly name: "can";
207
- };
208
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
209
- audience?: string | undefined;
210
- ttlSeconds: number;
211
- grant?: unknown;
212
- }, {
213
- readonly mode: 'value';
214
- readonly value: string;
215
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
216
- readonly name: "mint";
217
- };
218
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
219
- readonly mode: 'value';
220
- readonly value: {
221
- id: string;
222
- issuer: string;
223
- subject: string;
224
- frozen: boolean;
225
- requiredClaims: ({
226
- claim: string;
227
- op: "contains";
228
- value: unknown;
229
- } | {
230
- claim: string;
231
- op: "eq";
232
- value: unknown;
233
- } | {
234
- claim: string;
235
- op: "exists";
236
- })[];
237
- };
238
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
239
- readonly name: "whoami";
240
- };
241
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
242
- issuer: string;
243
- subject: string;
244
- }, {
245
- readonly mode: 'value';
246
- readonly value: {
247
- id: string;
248
- issuer: string;
249
- subject: string;
250
- frozen: boolean;
251
- requiredClaims: ({
252
- claim: string;
253
- op: "contains";
254
- value: unknown;
255
- } | {
256
- claim: string;
257
- op: "eq";
258
- value: unknown;
259
- } | {
260
- claim: string;
261
- op: "exists";
262
- })[];
263
- } | null;
264
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
265
- readonly name: "whois";
266
- };
267
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
268
- policy: string;
269
- object: string;
270
- }, {
271
- readonly mode: 'value';
272
- readonly value: {
273
- allowed: boolean;
274
- };
275
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
276
- readonly name: "can";
277
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
278
- audience?: string | undefined;
279
- ttlSeconds: number;
280
- grant?: unknown;
281
- }, {
282
- readonly mode: 'value';
283
- readonly value: string;
284
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
285
- readonly name: "mint";
286
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
287
- readonly mode: 'value';
288
- readonly value: {
289
- id: string;
290
- issuer: string;
291
- subject: string;
292
- frozen: boolean;
293
- requiredClaims: ({
294
- claim: string;
295
- op: "contains";
296
- value: unknown;
297
- } | {
298
- claim: string;
299
- op: "eq";
300
- value: unknown;
301
- } | {
302
- claim: string;
303
- op: "exists";
304
- })[];
305
- };
306
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
307
- readonly name: "whoami";
308
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
309
- issuer: string;
310
- subject: string;
311
- }, {
312
- readonly mode: 'value';
313
- readonly value: {
314
- id: string;
315
- issuer: string;
316
- subject: string;
317
- frozen: boolean;
318
- requiredClaims: ({
319
- claim: string;
320
- op: "contains";
321
- value: unknown;
322
- } | {
323
- claim: string;
324
- op: "eq";
325
- value: unknown;
326
- } | {
327
- claim: string;
328
- op: "exists";
329
- })[];
330
- } | null;
331
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
332
- readonly name: "whois";
333
- })> & {
334
- readonly byKey: Readonly<{
335
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
336
- policy: string;
337
- object: string;
338
- }, {
339
- readonly mode: 'value';
340
- readonly value: {
341
- allowed: boolean;
342
- };
343
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
344
- readonly name: "can";
345
- };
346
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
347
- audience?: string | undefined;
348
- ttlSeconds: number;
349
- grant?: unknown;
350
- }, {
351
- readonly mode: 'value';
352
- readonly value: string;
353
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
354
- readonly name: "mint";
355
- };
356
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
357
- readonly mode: 'value';
358
- readonly value: {
359
- id: string;
360
- issuer: string;
361
- subject: string;
362
- frozen: boolean;
363
- requiredClaims: ({
364
- claim: string;
365
- op: "contains";
366
- value: unknown;
367
- } | {
368
- claim: string;
369
- op: "eq";
370
- value: unknown;
371
- } | {
372
- claim: string;
373
- op: "exists";
374
- })[];
375
- };
376
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
377
- readonly name: "whoami";
378
- };
379
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
380
- issuer: string;
381
- subject: string;
382
- }, {
383
- readonly mode: 'value';
384
- readonly value: {
385
- id: string;
386
- issuer: string;
387
- subject: string;
388
- frozen: boolean;
389
- requiredClaims: ({
390
- claim: string;
391
- op: "contains";
392
- value: unknown;
393
- } | {
394
- claim: string;
395
- op: "eq";
396
- value: unknown;
397
- } | {
398
- claim: string;
399
- op: "exists";
400
- })[];
401
- } | null;
402
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
403
- readonly name: "whois";
404
- };
405
- }>;
406
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
407
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
408
- policy: string;
409
- object: string;
410
- }, {
411
- readonly mode: 'value';
412
- readonly value: {
413
- allowed: boolean;
414
- };
415
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
416
- readonly name: "can";
417
- };
418
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
419
- audience?: string | undefined;
420
- ttlSeconds: number;
421
- grant?: unknown;
422
- }, {
423
- readonly mode: 'value';
424
- readonly value: string;
425
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
426
- readonly name: "mint";
427
- };
428
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
429
- readonly mode: 'value';
430
- readonly value: {
431
- id: string;
432
- issuer: string;
433
- subject: string;
434
- frozen: boolean;
435
- requiredClaims: ({
436
- claim: string;
437
- op: "contains";
438
- value: unknown;
439
- } | {
440
- claim: string;
441
- op: "eq";
442
- value: unknown;
443
- } | {
444
- claim: string;
445
- op: "exists";
446
- })[];
447
- };
448
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
449
- readonly name: "whoami";
450
- };
451
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
452
- issuer: string;
453
- subject: string;
454
- }, {
455
- readonly mode: 'value';
456
- readonly value: {
457
- id: string;
458
- issuer: string;
459
- subject: string;
460
- frozen: boolean;
461
- requiredClaims: ({
462
- claim: string;
463
- op: "contains";
464
- value: unknown;
465
- } | {
466
- claim: string;
467
- op: "eq";
468
- value: unknown;
469
- } | {
470
- claim: string;
471
- op: "exists";
472
- })[];
473
- } | null;
474
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
475
- readonly name: "whois";
476
- };
477
- }>[Key];
478
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
479
- }, Readonly<Readonly<{
480
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
481
- readonly name: "frozen";
482
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
483
- };
484
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
485
- readonly name: "iss";
486
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
487
- };
488
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
489
- claim: string;
490
- op: "contains";
491
- value: unknown;
492
- } | {
493
- claim: string;
494
- op: "eq";
495
- value: unknown;
496
- } | {
497
- claim: string;
498
- op: "exists";
499
- })[], false> & {
500
- readonly name: "requiredClaims";
501
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
502
- };
503
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
504
- readonly name: "sub";
505
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
506
- };
507
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
508
- readonly name: "frozen";
509
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
510
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
511
- readonly name: "iss";
512
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
513
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
514
- claim: string;
515
- op: "contains";
516
- value: unknown;
517
- } | {
518
- claim: string;
519
- op: "eq";
520
- value: unknown;
521
- } | {
522
- claim: string;
523
- op: "exists";
524
- })[], false> & {
525
- readonly name: "requiredClaims";
526
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
527
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
528
- readonly name: "sub";
529
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
530
- })> & {
531
- readonly byKey: Readonly<{
532
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
533
- readonly name: "frozen";
534
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
535
- };
536
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
537
- readonly name: "iss";
538
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
539
- };
540
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
541
- claim: string;
542
- op: "contains";
543
- value: unknown;
544
- } | {
545
- claim: string;
546
- op: "eq";
547
- value: unknown;
548
- } | {
549
- claim: string;
550
- op: "exists";
551
- })[], false> & {
552
- readonly name: "requiredClaims";
553
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
554
- };
555
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
556
- readonly name: "sub";
557
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
558
- };
559
- }>;
560
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
561
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
562
- readonly name: "frozen";
563
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
564
- };
565
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
566
- readonly name: "iss";
567
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
568
- };
569
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
570
- claim: string;
571
- op: "contains";
572
- value: unknown;
573
- } | {
574
- claim: string;
575
- op: "eq";
576
- value: unknown;
577
- } | {
578
- claim: string;
579
- op: "exists";
580
- })[], false> & {
581
- readonly name: "requiredClaims";
582
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
583
- };
584
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
585
- readonly name: "sub";
586
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
587
- };
588
- }>[Key];
589
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
590
- from(input: Readonly<{
591
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
592
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
593
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
594
- claim: string;
595
- op: "contains";
596
- value: unknown;
597
- } | {
598
- claim: string;
599
- op: "eq";
600
- value: unknown;
601
- } | {
602
- claim: string;
603
- op: "exists";
604
- })[] | undefined;
605
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
606
- } & {
607
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
608
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
609
- readonly requiredClaims?: ({
610
- claim: string;
611
- op: "contains";
612
- value: unknown;
613
- } | {
614
- claim: string;
615
- op: "eq";
616
- value: unknown;
617
- } | {
618
- claim: string;
619
- op: "exists";
620
- })[] | undefined;
621
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
622
- }>): import("@astrale-os/sdk/schema").PropertyValues;
623
- }, Readonly<Readonly<{
624
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
625
- audience: string;
626
- ttlSeconds: number;
627
- attenuation: unknown;
628
- }, {
629
- readonly mode: 'value';
630
- readonly value: string;
631
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
632
- readonly name: "delegate";
633
- };
634
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
635
- audience: string;
636
- ttlSeconds: number;
637
- attenuation: unknown;
638
- }, {
639
- readonly mode: 'value';
640
- readonly value: string;
641
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
642
- readonly name: "delegate";
643
- }> & {
644
- readonly byKey: Readonly<{
645
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
646
- audience: string;
647
- ttlSeconds: number;
648
- attenuation: unknown;
649
- }, {
650
- readonly mode: 'value';
651
- readonly value: string;
652
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
653
- readonly name: "delegate";
654
- };
655
- }>;
656
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
657
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
658
- audience: string;
659
- ttlSeconds: number;
660
- attenuation: unknown;
661
- }, {
662
- readonly mode: 'value';
663
- readonly value: string;
664
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
665
- readonly name: "delegate";
666
- };
667
- }>[Key];
668
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
669
- }, Readonly<Readonly<{
670
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
671
- policy: string;
672
- object: string;
673
- }, {
674
- readonly mode: 'value';
675
- readonly value: {
676
- allowed: boolean;
677
- };
678
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
679
- readonly name: "can";
680
- };
681
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
682
- audience?: string | undefined;
683
- ttlSeconds: number;
684
- grant?: unknown;
685
- }, {
686
- readonly mode: 'value';
687
- readonly value: string;
688
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
689
- readonly name: "mint";
690
- };
691
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
692
- readonly mode: 'value';
693
- readonly value: {
694
- id: string;
695
- issuer: string;
696
- subject: string;
697
- frozen: boolean;
698
- requiredClaims: ({
699
- claim: string;
700
- op: "contains";
701
- value: unknown;
702
- } | {
703
- claim: string;
704
- op: "eq";
705
- value: unknown;
706
- } | {
707
- claim: string;
708
- op: "exists";
709
- })[];
710
- };
711
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
712
- readonly name: "whoami";
713
- };
714
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
715
- issuer: string;
716
- subject: string;
717
- }, {
718
- readonly mode: 'value';
719
- readonly value: {
720
- id: string;
721
- issuer: string;
722
- subject: string;
723
- frozen: boolean;
724
- requiredClaims: ({
725
- claim: string;
726
- op: "contains";
727
- value: unknown;
728
- } | {
729
- claim: string;
730
- op: "eq";
731
- value: unknown;
732
- } | {
733
- claim: string;
734
- op: "exists";
735
- })[];
736
- } | null;
737
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
738
- readonly name: "whois";
739
- };
740
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
741
- policy: string;
742
- object: string;
743
- }, {
744
- readonly mode: 'value';
745
- readonly value: {
746
- allowed: boolean;
747
- };
748
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
749
- readonly name: "can";
750
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
751
- audience?: string | undefined;
752
- ttlSeconds: number;
753
- grant?: unknown;
754
- }, {
755
- readonly mode: 'value';
756
- readonly value: string;
757
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
758
- readonly name: "mint";
759
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
760
- readonly mode: 'value';
761
- readonly value: {
762
- id: string;
763
- issuer: string;
764
- subject: string;
765
- frozen: boolean;
766
- requiredClaims: ({
767
- claim: string;
768
- op: "contains";
769
- value: unknown;
770
- } | {
771
- claim: string;
772
- op: "eq";
773
- value: unknown;
774
- } | {
775
- claim: string;
776
- op: "exists";
777
- })[];
778
- };
779
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
780
- readonly name: "whoami";
781
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
782
- issuer: string;
783
- subject: string;
784
- }, {
785
- readonly mode: 'value';
786
- readonly value: {
787
- id: string;
788
- issuer: string;
789
- subject: string;
790
- frozen: boolean;
791
- requiredClaims: ({
792
- claim: string;
793
- op: "contains";
794
- value: unknown;
795
- } | {
796
- claim: string;
797
- op: "eq";
798
- value: unknown;
799
- } | {
800
- claim: string;
801
- op: "exists";
802
- })[];
803
- } | null;
804
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
805
- readonly name: "whois";
806
- })> & {
807
- readonly byKey: Readonly<{
808
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
809
- policy: string;
810
- object: string;
811
- }, {
812
- readonly mode: 'value';
813
- readonly value: {
814
- allowed: boolean;
815
- };
816
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
817
- readonly name: "can";
818
- };
819
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
820
- audience?: string | undefined;
821
- ttlSeconds: number;
822
- grant?: unknown;
823
- }, {
824
- readonly mode: 'value';
825
- readonly value: string;
826
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
827
- readonly name: "mint";
828
- };
829
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
830
- readonly mode: 'value';
831
- readonly value: {
832
- id: string;
833
- issuer: string;
834
- subject: string;
835
- frozen: boolean;
836
- requiredClaims: ({
837
- claim: string;
838
- op: "contains";
839
- value: unknown;
840
- } | {
841
- claim: string;
842
- op: "eq";
843
- value: unknown;
844
- } | {
845
- claim: string;
846
- op: "exists";
847
- })[];
848
- };
849
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
850
- readonly name: "whoami";
851
- };
852
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
853
- issuer: string;
854
- subject: string;
855
- }, {
856
- readonly mode: 'value';
857
- readonly value: {
858
- id: string;
859
- issuer: string;
860
- subject: string;
861
- frozen: boolean;
862
- requiredClaims: ({
863
- claim: string;
864
- op: "contains";
865
- value: unknown;
866
- } | {
867
- claim: string;
868
- op: "eq";
869
- value: unknown;
870
- } | {
871
- claim: string;
872
- op: "exists";
873
- })[];
874
- } | null;
875
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
876
- readonly name: "whois";
877
- };
878
- }>;
879
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
880
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
881
- policy: string;
882
- object: string;
883
- }, {
884
- readonly mode: 'value';
885
- readonly value: {
886
- allowed: boolean;
887
- };
888
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
889
- readonly name: "can";
890
- };
891
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
892
- audience?: string | undefined;
893
- ttlSeconds: number;
894
- grant?: unknown;
895
- }, {
896
- readonly mode: 'value';
897
- readonly value: string;
898
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
899
- readonly name: "mint";
900
- };
901
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
902
- readonly mode: 'value';
903
- readonly value: {
904
- id: string;
905
- issuer: string;
906
- subject: string;
907
- frozen: boolean;
908
- requiredClaims: ({
909
- claim: string;
910
- op: "contains";
911
- value: unknown;
912
- } | {
913
- claim: string;
914
- op: "eq";
915
- value: unknown;
916
- } | {
917
- claim: string;
918
- op: "exists";
919
- })[];
920
- };
921
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
922
- readonly name: "whoami";
923
- };
924
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
925
- issuer: string;
926
- subject: string;
927
- }, {
928
- readonly mode: 'value';
929
- readonly value: {
930
- id: string;
931
- issuer: string;
932
- subject: string;
933
- frozen: boolean;
934
- requiredClaims: ({
935
- claim: string;
936
- op: "contains";
937
- value: unknown;
938
- } | {
939
- claim: string;
940
- op: "eq";
941
- value: unknown;
942
- } | {
943
- claim: string;
944
- op: "exists";
945
- })[];
946
- } | null;
947
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
948
- readonly name: "whois";
949
- };
950
- }>[Key];
951
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
952
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
953
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
954
- readonly origin: "kernel.astrale.ai";
955
- };
956
- readonly kind: 'node';
957
- readonly abstract: true;
958
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
959
- readonly byKey: Readonly<{}>;
960
- get<Key extends never>(key: Key): Readonly<{}>[Key];
961
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
962
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
963
- }, Readonly<Readonly<{}>> & Iterable<never> & {
964
- readonly byKey: Readonly<{}>;
965
- get<Key extends never>(key: Key): Readonly<{}>[Key];
966
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
967
- }, Readonly<Readonly<{}>> & Iterable<never> & {
968
- readonly byKey: Readonly<{}>;
969
- get<Key extends never>(key: Key): Readonly<{}>[Key];
970
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
971
- }, Readonly<Readonly<{}>> & Iterable<never> & {
972
- readonly byKey: Readonly<{}>;
973
- get<Key extends never>(key: Key): Readonly<{}>[Key];
974
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
975
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
976
- }, Readonly<Readonly<{}>> & Iterable<never> & {
977
- readonly byKey: Readonly<{}>;
978
- get<Key extends never>(key: Key): Readonly<{}>[Key];
979
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
980
- }, Readonly<Readonly<{}>> & Iterable<never> & {
981
- readonly byKey: Readonly<{}>;
982
- get<Key extends never>(key: Key): Readonly<{}>[Key];
983
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
984
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
985
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
986
- readonly origin: "kernel.astrale.ai";
987
- };
988
- readonly kind: 'node';
989
- readonly abstract: true;
990
- }, readonly []> & {
991
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
992
- readonly origin: "kernel.astrale.ai";
993
- };
994
- readonly key: "kernel.astrale.ai:class.Node";
995
- }]> & {
996
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
997
- readonly origin: "kernel.astrale.ai";
998
- };
999
- readonly key: "kernel.astrale.ai:class.Identity";
1000
- }];
1001
- readonly properties: {
1002
- displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
1003
- readonly required: false;
1004
- }>;
1005
- };
1006
- readonly methods: {
1007
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
1008
- readonly description: "Resolve this User and its canonical personal Space.";
1009
- readonly auth: "authenticated";
1010
- readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
1011
- readonly output: import("zod").ZodObject<{
1012
- userId: import("zod").ZodString;
1013
- personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
1014
- }, import("zod/v4/core").$strict>;
1015
- }>;
1016
- };
1017
- }>];
1018
8
  readonly outgoing: "0..*";
1019
9
  };
1020
10
  readonly target: {
1021
11
  readonly as: "group";
1022
- readonly accepts: readonly [() => import("@astrale-os/sdk/schema").NodeClass<{
1023
- readonly description: "A named compositional Shell Identity.";
1024
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
1025
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1026
- readonly name: "frozen";
1027
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1028
- };
1029
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1030
- readonly name: "iss";
1031
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1032
- };
1033
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
1034
- claim: string;
1035
- op: "contains";
1036
- value: unknown;
1037
- } | {
1038
- claim: string;
1039
- op: "eq";
1040
- value: unknown;
1041
- } | {
1042
- claim: string;
1043
- op: "exists";
1044
- })[], false> & {
1045
- readonly name: "requiredClaims";
1046
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1047
- };
1048
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1049
- readonly name: "sub";
1050
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1051
- };
1052
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1053
- readonly name: "frozen";
1054
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1055
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1056
- readonly name: "iss";
1057
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1058
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
1059
- claim: string;
1060
- op: "contains";
1061
- value: unknown;
1062
- } | {
1063
- claim: string;
1064
- op: "eq";
1065
- value: unknown;
1066
- } | {
1067
- claim: string;
1068
- op: "exists";
1069
- })[], false> & {
1070
- readonly name: "requiredClaims";
1071
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1072
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1073
- readonly name: "sub";
1074
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1075
- })> & {
1076
- readonly byKey: Readonly<{
1077
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1078
- readonly name: "frozen";
1079
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1080
- };
1081
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1082
- readonly name: "iss";
1083
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1084
- };
1085
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1086
- claim: string;
1087
- op: "contains";
1088
- value: unknown;
1089
- } | {
1090
- claim: string;
1091
- op: "eq";
1092
- value: unknown;
1093
- } | {
1094
- claim: string;
1095
- op: "exists";
1096
- })[], false> & {
1097
- readonly name: "requiredClaims";
1098
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1099
- };
1100
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1101
- readonly name: "sub";
1102
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1103
- };
1104
- }>;
1105
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
1106
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1107
- readonly name: "frozen";
1108
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1109
- };
1110
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1111
- readonly name: "iss";
1112
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1113
- };
1114
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1115
- claim: string;
1116
- op: "contains";
1117
- value: unknown;
1118
- } | {
1119
- claim: string;
1120
- op: "eq";
1121
- value: unknown;
1122
- } | {
1123
- claim: string;
1124
- op: "exists";
1125
- })[], false> & {
1126
- readonly name: "requiredClaims";
1127
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1128
- };
1129
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1130
- readonly name: "sub";
1131
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1132
- };
1133
- }>[Key];
1134
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1135
- from(input: Readonly<{
1136
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1137
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1138
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
1139
- claim: string;
1140
- op: "contains";
1141
- value: unknown;
1142
- } | {
1143
- claim: string;
1144
- op: "eq";
1145
- value: unknown;
1146
- } | {
1147
- claim: string;
1148
- op: "exists";
1149
- })[] | undefined;
1150
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1151
- } & {
1152
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1153
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1154
- readonly requiredClaims?: ({
1155
- claim: string;
1156
- op: "contains";
1157
- value: unknown;
1158
- } | {
1159
- claim: string;
1160
- op: "eq";
1161
- value: unknown;
1162
- } | {
1163
- claim: string;
1164
- op: "exists";
1165
- })[] | undefined;
1166
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1167
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1168
- }, Readonly<Readonly<{
1169
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
1170
- audience: string;
1171
- ttlSeconds: number;
1172
- attenuation: unknown;
1173
- }, {
1174
- readonly mode: 'value';
1175
- readonly value: string;
1176
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1177
- readonly name: "delegate";
1178
- };
1179
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
1180
- audience: string;
1181
- ttlSeconds: number;
1182
- attenuation: unknown;
1183
- }, {
1184
- readonly mode: 'value';
1185
- readonly value: string;
1186
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1187
- readonly name: "delegate";
1188
- }> & {
1189
- readonly byKey: Readonly<{
1190
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1191
- audience: string;
1192
- ttlSeconds: number;
1193
- attenuation: unknown;
1194
- }, {
1195
- readonly mode: 'value';
1196
- readonly value: string;
1197
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1198
- readonly name: "delegate";
1199
- };
1200
- }>;
1201
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
1202
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1203
- audience: string;
1204
- ttlSeconds: number;
1205
- attenuation: unknown;
1206
- }, {
1207
- readonly mode: 'value';
1208
- readonly value: string;
1209
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1210
- readonly name: "delegate";
1211
- };
1212
- }>[Key];
1213
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1214
- }, Readonly<Readonly<{
1215
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
1216
- policy: string;
1217
- object: string;
1218
- }, {
1219
- readonly mode: 'value';
1220
- readonly value: {
1221
- allowed: boolean;
1222
- };
1223
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1224
- readonly name: "can";
1225
- };
1226
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
1227
- audience?: string | undefined;
1228
- ttlSeconds: number;
1229
- grant?: unknown;
1230
- }, {
1231
- readonly mode: 'value';
1232
- readonly value: string;
1233
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1234
- readonly name: "mint";
1235
- };
1236
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1237
- readonly mode: 'value';
1238
- readonly value: {
1239
- id: string;
1240
- issuer: string;
1241
- subject: string;
1242
- frozen: boolean;
1243
- requiredClaims: ({
1244
- claim: string;
1245
- op: "contains";
1246
- value: unknown;
1247
- } | {
1248
- claim: string;
1249
- op: "eq";
1250
- value: unknown;
1251
- } | {
1252
- claim: string;
1253
- op: "exists";
1254
- })[];
1255
- };
1256
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1257
- readonly name: "whoami";
1258
- };
1259
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
1260
- issuer: string;
1261
- subject: string;
1262
- }, {
1263
- readonly mode: 'value';
1264
- readonly value: {
1265
- id: string;
1266
- issuer: string;
1267
- subject: string;
1268
- frozen: boolean;
1269
- requiredClaims: ({
1270
- claim: string;
1271
- op: "contains";
1272
- value: unknown;
1273
- } | {
1274
- claim: string;
1275
- op: "eq";
1276
- value: unknown;
1277
- } | {
1278
- claim: string;
1279
- op: "exists";
1280
- })[];
1281
- } | null;
1282
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1283
- readonly name: "whois";
1284
- };
1285
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
1286
- policy: string;
1287
- object: string;
1288
- }, {
1289
- readonly mode: 'value';
1290
- readonly value: {
1291
- allowed: boolean;
1292
- };
1293
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1294
- readonly name: "can";
1295
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1296
- audience?: string | undefined;
1297
- ttlSeconds: number;
1298
- grant?: unknown;
1299
- }, {
1300
- readonly mode: 'value';
1301
- readonly value: string;
1302
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1303
- readonly name: "mint";
1304
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1305
- readonly mode: 'value';
1306
- readonly value: {
1307
- id: string;
1308
- issuer: string;
1309
- subject: string;
1310
- frozen: boolean;
1311
- requiredClaims: ({
1312
- claim: string;
1313
- op: "contains";
1314
- value: unknown;
1315
- } | {
1316
- claim: string;
1317
- op: "eq";
1318
- value: unknown;
1319
- } | {
1320
- claim: string;
1321
- op: "exists";
1322
- })[];
1323
- };
1324
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1325
- readonly name: "whoami";
1326
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1327
- issuer: string;
1328
- subject: string;
1329
- }, {
1330
- readonly mode: 'value';
1331
- readonly value: {
1332
- id: string;
1333
- issuer: string;
1334
- subject: string;
1335
- frozen: boolean;
1336
- requiredClaims: ({
1337
- claim: string;
1338
- op: "contains";
1339
- value: unknown;
1340
- } | {
1341
- claim: string;
1342
- op: "eq";
1343
- value: unknown;
1344
- } | {
1345
- claim: string;
1346
- op: "exists";
1347
- })[];
1348
- } | null;
1349
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1350
- readonly name: "whois";
1351
- })> & {
1352
- readonly byKey: Readonly<{
1353
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1354
- policy: string;
1355
- object: string;
1356
- }, {
1357
- readonly mode: 'value';
1358
- readonly value: {
1359
- allowed: boolean;
1360
- };
1361
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1362
- readonly name: "can";
1363
- };
1364
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1365
- audience?: string | undefined;
1366
- ttlSeconds: number;
1367
- grant?: unknown;
1368
- }, {
1369
- readonly mode: 'value';
1370
- readonly value: string;
1371
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1372
- readonly name: "mint";
1373
- };
1374
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1375
- readonly mode: 'value';
1376
- readonly value: {
1377
- id: string;
1378
- issuer: string;
1379
- subject: string;
1380
- frozen: boolean;
1381
- requiredClaims: ({
1382
- claim: string;
1383
- op: "contains";
1384
- value: unknown;
1385
- } | {
1386
- claim: string;
1387
- op: "eq";
1388
- value: unknown;
1389
- } | {
1390
- claim: string;
1391
- op: "exists";
1392
- })[];
1393
- };
1394
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1395
- readonly name: "whoami";
1396
- };
1397
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1398
- issuer: string;
1399
- subject: string;
1400
- }, {
1401
- readonly mode: 'value';
1402
- readonly value: {
1403
- id: string;
1404
- issuer: string;
1405
- subject: string;
1406
- frozen: boolean;
1407
- requiredClaims: ({
1408
- claim: string;
1409
- op: "contains";
1410
- value: unknown;
1411
- } | {
1412
- claim: string;
1413
- op: "eq";
1414
- value: unknown;
1415
- } | {
1416
- claim: string;
1417
- op: "exists";
1418
- })[];
1419
- } | null;
1420
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1421
- readonly name: "whois";
1422
- };
1423
- }>;
1424
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
1425
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1426
- policy: string;
1427
- object: string;
1428
- }, {
1429
- readonly mode: 'value';
1430
- readonly value: {
1431
- allowed: boolean;
1432
- };
1433
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1434
- readonly name: "can";
1435
- };
1436
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1437
- audience?: string | undefined;
1438
- ttlSeconds: number;
1439
- grant?: unknown;
1440
- }, {
1441
- readonly mode: 'value';
1442
- readonly value: string;
1443
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1444
- readonly name: "mint";
1445
- };
1446
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1447
- readonly mode: 'value';
1448
- readonly value: {
1449
- id: string;
1450
- issuer: string;
1451
- subject: string;
1452
- frozen: boolean;
1453
- requiredClaims: ({
1454
- claim: string;
1455
- op: "contains";
1456
- value: unknown;
1457
- } | {
1458
- claim: string;
1459
- op: "eq";
1460
- value: unknown;
1461
- } | {
1462
- claim: string;
1463
- op: "exists";
1464
- })[];
1465
- };
1466
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1467
- readonly name: "whoami";
1468
- };
1469
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1470
- issuer: string;
1471
- subject: string;
1472
- }, {
1473
- readonly mode: 'value';
1474
- readonly value: {
1475
- id: string;
1476
- issuer: string;
1477
- subject: string;
1478
- frozen: boolean;
1479
- requiredClaims: ({
1480
- claim: string;
1481
- op: "contains";
1482
- value: unknown;
1483
- } | {
1484
- claim: string;
1485
- op: "eq";
1486
- value: unknown;
1487
- } | {
1488
- claim: string;
1489
- op: "exists";
1490
- })[];
1491
- } | null;
1492
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1493
- readonly name: "whois";
1494
- };
1495
- }>[Key];
1496
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1497
- }, Readonly<Readonly<{
1498
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1499
- readonly name: "frozen";
1500
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1501
- };
1502
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1503
- readonly name: "iss";
1504
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1505
- };
1506
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
1507
- claim: string;
1508
- op: "contains";
1509
- value: unknown;
1510
- } | {
1511
- claim: string;
1512
- op: "eq";
1513
- value: unknown;
1514
- } | {
1515
- claim: string;
1516
- op: "exists";
1517
- })[], false> & {
1518
- readonly name: "requiredClaims";
1519
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1520
- };
1521
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1522
- readonly name: "sub";
1523
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1524
- };
1525
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1526
- readonly name: "frozen";
1527
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1528
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1529
- readonly name: "iss";
1530
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1531
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
1532
- claim: string;
1533
- op: "contains";
1534
- value: unknown;
1535
- } | {
1536
- claim: string;
1537
- op: "eq";
1538
- value: unknown;
1539
- } | {
1540
- claim: string;
1541
- op: "exists";
1542
- })[], false> & {
1543
- readonly name: "requiredClaims";
1544
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1545
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1546
- readonly name: "sub";
1547
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1548
- })> & {
1549
- readonly byKey: Readonly<{
1550
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1551
- readonly name: "frozen";
1552
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1553
- };
1554
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1555
- readonly name: "iss";
1556
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1557
- };
1558
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1559
- claim: string;
1560
- op: "contains";
1561
- value: unknown;
1562
- } | {
1563
- claim: string;
1564
- op: "eq";
1565
- value: unknown;
1566
- } | {
1567
- claim: string;
1568
- op: "exists";
1569
- })[], false> & {
1570
- readonly name: "requiredClaims";
1571
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1572
- };
1573
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1574
- readonly name: "sub";
1575
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1576
- };
1577
- }>;
1578
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
1579
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1580
- readonly name: "frozen";
1581
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1582
- };
1583
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1584
- readonly name: "iss";
1585
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1586
- };
1587
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1588
- claim: string;
1589
- op: "contains";
1590
- value: unknown;
1591
- } | {
1592
- claim: string;
1593
- op: "eq";
1594
- value: unknown;
1595
- } | {
1596
- claim: string;
1597
- op: "exists";
1598
- })[], false> & {
1599
- readonly name: "requiredClaims";
1600
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1601
- };
1602
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1603
- readonly name: "sub";
1604
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1605
- };
1606
- }>[Key];
1607
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1608
- from(input: Readonly<{
1609
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1610
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1611
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
1612
- claim: string;
1613
- op: "contains";
1614
- value: unknown;
1615
- } | {
1616
- claim: string;
1617
- op: "eq";
1618
- value: unknown;
1619
- } | {
1620
- claim: string;
1621
- op: "exists";
1622
- })[] | undefined;
1623
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1624
- } & {
1625
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1626
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1627
- readonly requiredClaims?: ({
1628
- claim: string;
1629
- op: "contains";
1630
- value: unknown;
1631
- } | {
1632
- claim: string;
1633
- op: "eq";
1634
- value: unknown;
1635
- } | {
1636
- claim: string;
1637
- op: "exists";
1638
- })[] | undefined;
1639
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1640
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1641
- }, Readonly<Readonly<{
1642
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
1643
- audience: string;
1644
- ttlSeconds: number;
1645
- attenuation: unknown;
1646
- }, {
1647
- readonly mode: 'value';
1648
- readonly value: string;
1649
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1650
- readonly name: "delegate";
1651
- };
1652
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
1653
- audience: string;
1654
- ttlSeconds: number;
1655
- attenuation: unknown;
1656
- }, {
1657
- readonly mode: 'value';
1658
- readonly value: string;
1659
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1660
- readonly name: "delegate";
1661
- }> & {
1662
- readonly byKey: Readonly<{
1663
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1664
- audience: string;
1665
- ttlSeconds: number;
1666
- attenuation: unknown;
1667
- }, {
1668
- readonly mode: 'value';
1669
- readonly value: string;
1670
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1671
- readonly name: "delegate";
1672
- };
1673
- }>;
1674
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
1675
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1676
- audience: string;
1677
- ttlSeconds: number;
1678
- attenuation: unknown;
1679
- }, {
1680
- readonly mode: 'value';
1681
- readonly value: string;
1682
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1683
- readonly name: "delegate";
1684
- };
1685
- }>[Key];
1686
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1687
- }, Readonly<Readonly<{
1688
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
1689
- policy: string;
1690
- object: string;
1691
- }, {
1692
- readonly mode: 'value';
1693
- readonly value: {
1694
- allowed: boolean;
1695
- };
1696
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1697
- readonly name: "can";
1698
- };
1699
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
1700
- audience?: string | undefined;
1701
- ttlSeconds: number;
1702
- grant?: unknown;
1703
- }, {
1704
- readonly mode: 'value';
1705
- readonly value: string;
1706
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1707
- readonly name: "mint";
1708
- };
1709
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1710
- readonly mode: 'value';
1711
- readonly value: {
1712
- id: string;
1713
- issuer: string;
1714
- subject: string;
1715
- frozen: boolean;
1716
- requiredClaims: ({
1717
- claim: string;
1718
- op: "contains";
1719
- value: unknown;
1720
- } | {
1721
- claim: string;
1722
- op: "eq";
1723
- value: unknown;
1724
- } | {
1725
- claim: string;
1726
- op: "exists";
1727
- })[];
1728
- };
1729
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1730
- readonly name: "whoami";
1731
- };
1732
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
1733
- issuer: string;
1734
- subject: string;
1735
- }, {
1736
- readonly mode: 'value';
1737
- readonly value: {
1738
- id: string;
1739
- issuer: string;
1740
- subject: string;
1741
- frozen: boolean;
1742
- requiredClaims: ({
1743
- claim: string;
1744
- op: "contains";
1745
- value: unknown;
1746
- } | {
1747
- claim: string;
1748
- op: "eq";
1749
- value: unknown;
1750
- } | {
1751
- claim: string;
1752
- op: "exists";
1753
- })[];
1754
- } | null;
1755
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1756
- readonly name: "whois";
1757
- };
1758
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
1759
- policy: string;
1760
- object: string;
1761
- }, {
1762
- readonly mode: 'value';
1763
- readonly value: {
1764
- allowed: boolean;
1765
- };
1766
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1767
- readonly name: "can";
1768
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1769
- audience?: string | undefined;
1770
- ttlSeconds: number;
1771
- grant?: unknown;
1772
- }, {
1773
- readonly mode: 'value';
1774
- readonly value: string;
1775
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1776
- readonly name: "mint";
1777
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1778
- readonly mode: 'value';
1779
- readonly value: {
1780
- id: string;
1781
- issuer: string;
1782
- subject: string;
1783
- frozen: boolean;
1784
- requiredClaims: ({
1785
- claim: string;
1786
- op: "contains";
1787
- value: unknown;
1788
- } | {
1789
- claim: string;
1790
- op: "eq";
1791
- value: unknown;
1792
- } | {
1793
- claim: string;
1794
- op: "exists";
1795
- })[];
1796
- };
1797
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1798
- readonly name: "whoami";
1799
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1800
- issuer: string;
1801
- subject: string;
1802
- }, {
1803
- readonly mode: 'value';
1804
- readonly value: {
1805
- id: string;
1806
- issuer: string;
1807
- subject: string;
1808
- frozen: boolean;
1809
- requiredClaims: ({
1810
- claim: string;
1811
- op: "contains";
1812
- value: unknown;
1813
- } | {
1814
- claim: string;
1815
- op: "eq";
1816
- value: unknown;
1817
- } | {
1818
- claim: string;
1819
- op: "exists";
1820
- })[];
1821
- } | null;
1822
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1823
- readonly name: "whois";
1824
- })> & {
1825
- readonly byKey: Readonly<{
1826
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1827
- policy: string;
1828
- object: string;
1829
- }, {
1830
- readonly mode: 'value';
1831
- readonly value: {
1832
- allowed: boolean;
1833
- };
1834
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1835
- readonly name: "can";
1836
- };
1837
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1838
- audience?: string | undefined;
1839
- ttlSeconds: number;
1840
- grant?: unknown;
1841
- }, {
1842
- readonly mode: 'value';
1843
- readonly value: string;
1844
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1845
- readonly name: "mint";
1846
- };
1847
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1848
- readonly mode: 'value';
1849
- readonly value: {
1850
- id: string;
1851
- issuer: string;
1852
- subject: string;
1853
- frozen: boolean;
1854
- requiredClaims: ({
1855
- claim: string;
1856
- op: "contains";
1857
- value: unknown;
1858
- } | {
1859
- claim: string;
1860
- op: "eq";
1861
- value: unknown;
1862
- } | {
1863
- claim: string;
1864
- op: "exists";
1865
- })[];
1866
- };
1867
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1868
- readonly name: "whoami";
1869
- };
1870
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1871
- issuer: string;
1872
- subject: string;
1873
- }, {
1874
- readonly mode: 'value';
1875
- readonly value: {
1876
- id: string;
1877
- issuer: string;
1878
- subject: string;
1879
- frozen: boolean;
1880
- requiredClaims: ({
1881
- claim: string;
1882
- op: "contains";
1883
- value: unknown;
1884
- } | {
1885
- claim: string;
1886
- op: "eq";
1887
- value: unknown;
1888
- } | {
1889
- claim: string;
1890
- op: "exists";
1891
- })[];
1892
- } | null;
1893
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1894
- readonly name: "whois";
1895
- };
1896
- }>;
1897
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
1898
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1899
- policy: string;
1900
- object: string;
1901
- }, {
1902
- readonly mode: 'value';
1903
- readonly value: {
1904
- allowed: boolean;
1905
- };
1906
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1907
- readonly name: "can";
1908
- };
1909
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1910
- audience?: string | undefined;
1911
- ttlSeconds: number;
1912
- grant?: unknown;
1913
- }, {
1914
- readonly mode: 'value';
1915
- readonly value: string;
1916
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
1917
- readonly name: "mint";
1918
- };
1919
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1920
- readonly mode: 'value';
1921
- readonly value: {
1922
- id: string;
1923
- issuer: string;
1924
- subject: string;
1925
- frozen: boolean;
1926
- requiredClaims: ({
1927
- claim: string;
1928
- op: "contains";
1929
- value: unknown;
1930
- } | {
1931
- claim: string;
1932
- op: "eq";
1933
- value: unknown;
1934
- } | {
1935
- claim: string;
1936
- op: "exists";
1937
- })[];
1938
- };
1939
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1940
- readonly name: "whoami";
1941
- };
1942
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1943
- issuer: string;
1944
- subject: string;
1945
- }, {
1946
- readonly mode: 'value';
1947
- readonly value: {
1948
- id: string;
1949
- issuer: string;
1950
- subject: string;
1951
- frozen: boolean;
1952
- requiredClaims: ({
1953
- claim: string;
1954
- op: "contains";
1955
- value: unknown;
1956
- } | {
1957
- claim: string;
1958
- op: "eq";
1959
- value: unknown;
1960
- } | {
1961
- claim: string;
1962
- op: "exists";
1963
- })[];
1964
- } | null;
1965
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
1966
- readonly name: "whois";
1967
- };
1968
- }>[Key];
1969
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1970
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
1971
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
1972
- readonly origin: "kernel.astrale.ai";
1973
- };
1974
- readonly kind: 'node';
1975
- readonly abstract: true;
1976
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
1977
- readonly byKey: Readonly<{}>;
1978
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1979
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1980
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
1981
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1982
- readonly byKey: Readonly<{}>;
1983
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1984
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1985
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1986
- readonly byKey: Readonly<{}>;
1987
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1988
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1989
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1990
- readonly byKey: Readonly<{}>;
1991
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1992
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1993
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
1994
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1995
- readonly byKey: Readonly<{}>;
1996
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1997
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1998
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1999
- readonly byKey: Readonly<{}>;
2000
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2001
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2002
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2003
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2004
- readonly origin: "kernel.astrale.ai";
2005
- };
2006
- readonly kind: 'node';
2007
- readonly abstract: true;
2008
- }, readonly []> & {
2009
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2010
- readonly origin: "kernel.astrale.ai";
2011
- };
2012
- readonly key: "kernel.astrale.ai:class.Node";
2013
- }]> & {
2014
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
2015
- readonly origin: "kernel.astrale.ai";
2016
- };
2017
- readonly key: "kernel.astrale.ai:class.Identity";
2018
- }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
2019
- name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2020
- readonly name: "name";
2021
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2022
- };
2023
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2024
- readonly name: "name";
2025
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2026
- }> & {
2027
- readonly byKey: Readonly<{
2028
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2029
- readonly name: "name";
2030
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2031
- };
2032
- }>;
2033
- get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
2034
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2035
- readonly name: "name";
2036
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2037
- };
2038
- }>[Key];
2039
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2040
- from(input: Readonly<{
2041
- readonly "kernel.astrale.ai:class.Named.property.name"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2042
- } & {
2043
- readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2044
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2045
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2046
- readonly byKey: Readonly<{}>;
2047
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2048
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2049
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2050
- readonly byKey: Readonly<{}>;
2051
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2052
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2053
- }, Readonly<Readonly<{
2054
- name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2055
- readonly name: "name";
2056
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2057
- };
2058
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2059
- readonly name: "name";
2060
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2061
- }> & {
2062
- readonly byKey: Readonly<{
2063
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2064
- readonly name: "name";
2065
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2066
- };
2067
- }>;
2068
- get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
2069
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2070
- readonly name: "name";
2071
- readonly key: "kernel.astrale.ai:class.Named.property.name";
2072
- };
2073
- }>[Key];
2074
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2075
- from(input: Readonly<{
2076
- readonly "kernel.astrale.ai:class.Named.property.name"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2077
- } & {
2078
- readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2079
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2080
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2081
- readonly byKey: Readonly<{}>;
2082
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2083
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2084
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2085
- readonly byKey: Readonly<{}>;
2086
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2087
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2088
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2089
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
2090
- readonly origin: "kernel.astrale.ai";
2091
- };
2092
- readonly kind: 'node';
2093
- readonly abstract: true;
2094
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
2095
- readonly byKey: Readonly<{}>;
2096
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2097
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2098
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2099
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2100
- readonly byKey: Readonly<{}>;
2101
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2102
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2103
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2104
- readonly byKey: Readonly<{}>;
2105
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2106
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2107
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2108
- readonly byKey: Readonly<{}>;
2109
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2110
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2111
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2112
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2113
- readonly byKey: Readonly<{}>;
2114
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2115
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2116
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2117
- readonly byKey: Readonly<{}>;
2118
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2119
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2120
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2121
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2122
- readonly origin: "kernel.astrale.ai";
2123
- };
2124
- readonly kind: 'node';
2125
- readonly abstract: true;
2126
- }, readonly []> & {
2127
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2128
- readonly origin: "kernel.astrale.ai";
2129
- };
2130
- readonly key: "kernel.astrale.ai:class.Node";
2131
- }]> & {
2132
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
2133
- readonly origin: "kernel.astrale.ai";
2134
- };
2135
- readonly key: "kernel.astrale.ai:class.Named";
2136
- }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
2137
- description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2138
- readonly name: "description";
2139
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2140
- };
2141
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2142
- readonly name: "description";
2143
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2144
- }> & {
2145
- readonly byKey: Readonly<{
2146
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2147
- readonly name: "description";
2148
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2149
- };
2150
- }>;
2151
- get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
2152
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2153
- readonly name: "description";
2154
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2155
- };
2156
- }>[Key];
2157
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2158
- from(input: Readonly<{
2159
- readonly "kernel.astrale.ai:class.Descriptable.property.description"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2160
- } & {
2161
- readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2162
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2163
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2164
- readonly byKey: Readonly<{}>;
2165
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2166
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2167
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2168
- readonly byKey: Readonly<{}>;
2169
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2170
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2171
- }, Readonly<Readonly<{
2172
- description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2173
- readonly name: "description";
2174
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2175
- };
2176
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2177
- readonly name: "description";
2178
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2179
- }> & {
2180
- readonly byKey: Readonly<{
2181
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2182
- readonly name: "description";
2183
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2184
- };
2185
- }>;
2186
- get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
2187
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2188
- readonly name: "description";
2189
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
2190
- };
2191
- }>[Key];
2192
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2193
- from(input: Readonly<{
2194
- readonly "kernel.astrale.ai:class.Descriptable.property.description"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2195
- } & {
2196
- readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2197
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2198
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2199
- readonly byKey: Readonly<{}>;
2200
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2201
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2202
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2203
- readonly byKey: Readonly<{}>;
2204
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2205
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2206
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2207
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
2208
- readonly origin: "kernel.astrale.ai";
2209
- };
2210
- readonly kind: 'node';
2211
- readonly abstract: true;
2212
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
2213
- readonly byKey: Readonly<{}>;
2214
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2215
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2216
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2217
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2218
- readonly byKey: Readonly<{}>;
2219
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2220
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2221
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2222
- readonly byKey: Readonly<{}>;
2223
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2224
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2225
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2226
- readonly byKey: Readonly<{}>;
2227
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2228
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2229
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2230
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2231
- readonly byKey: Readonly<{}>;
2232
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2233
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2234
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2235
- readonly byKey: Readonly<{}>;
2236
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2237
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2238
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2239
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2240
- readonly origin: "kernel.astrale.ai";
2241
- };
2242
- readonly kind: 'node';
2243
- readonly abstract: true;
2244
- }, readonly []> & {
2245
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2246
- readonly origin: "kernel.astrale.ai";
2247
- };
2248
- readonly key: "kernel.astrale.ai:class.Node";
2249
- }]> & {
2250
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
2251
- readonly origin: "kernel.astrale.ai";
2252
- };
2253
- readonly key: "kernel.astrale.ai:class.Descriptable";
2254
- }];
2255
- readonly methods: {
2256
- assignUser: import("@astrale-os/sdk/schema").Method<{
2257
- readonly description: string;
2258
- readonly input: import("zod").ZodObject<{
2259
- user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
2260
- readonly description: "One externally identified person using Shell.";
2261
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
2262
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2263
- readonly name: "frozen";
2264
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2265
- };
2266
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2267
- readonly name: "iss";
2268
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2269
- };
2270
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
2271
- claim: string;
2272
- op: "contains";
2273
- value: unknown;
2274
- } | {
2275
- claim: string;
2276
- op: "eq";
2277
- value: unknown;
2278
- } | {
2279
- claim: string;
2280
- op: "exists";
2281
- })[], false> & {
2282
- readonly name: "requiredClaims";
2283
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2284
- };
2285
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2286
- readonly name: "sub";
2287
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2288
- };
2289
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2290
- readonly name: "frozen";
2291
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2292
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2293
- readonly name: "iss";
2294
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2295
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
2296
- claim: string;
2297
- op: "contains";
2298
- value: unknown;
2299
- } | {
2300
- claim: string;
2301
- op: "eq";
2302
- value: unknown;
2303
- } | {
2304
- claim: string;
2305
- op: "exists";
2306
- })[], false> & {
2307
- readonly name: "requiredClaims";
2308
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2309
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2310
- readonly name: "sub";
2311
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2312
- })> & {
2313
- readonly byKey: Readonly<{
2314
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2315
- readonly name: "frozen";
2316
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2317
- };
2318
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2319
- readonly name: "iss";
2320
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2321
- };
2322
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2323
- claim: string;
2324
- op: "contains";
2325
- value: unknown;
2326
- } | {
2327
- claim: string;
2328
- op: "eq";
2329
- value: unknown;
2330
- } | {
2331
- claim: string;
2332
- op: "exists";
2333
- })[], false> & {
2334
- readonly name: "requiredClaims";
2335
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2336
- };
2337
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2338
- readonly name: "sub";
2339
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2340
- };
2341
- }>;
2342
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
2343
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2344
- readonly name: "frozen";
2345
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2346
- };
2347
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2348
- readonly name: "iss";
2349
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2350
- };
2351
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2352
- claim: string;
2353
- op: "contains";
2354
- value: unknown;
2355
- } | {
2356
- claim: string;
2357
- op: "eq";
2358
- value: unknown;
2359
- } | {
2360
- claim: string;
2361
- op: "exists";
2362
- })[], false> & {
2363
- readonly name: "requiredClaims";
2364
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2365
- };
2366
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2367
- readonly name: "sub";
2368
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2369
- };
2370
- }>[Key];
2371
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2372
- from(input: Readonly<{
2373
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2374
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2375
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
2376
- claim: string;
2377
- op: "contains";
2378
- value: unknown;
2379
- } | {
2380
- claim: string;
2381
- op: "eq";
2382
- value: unknown;
2383
- } | {
2384
- claim: string;
2385
- op: "exists";
2386
- })[] | undefined;
2387
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2388
- } & {
2389
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2390
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2391
- readonly requiredClaims?: ({
2392
- claim: string;
2393
- op: "contains";
2394
- value: unknown;
2395
- } | {
2396
- claim: string;
2397
- op: "eq";
2398
- value: unknown;
2399
- } | {
2400
- claim: string;
2401
- op: "exists";
2402
- })[] | undefined;
2403
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2404
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2405
- }, Readonly<Readonly<{
2406
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
2407
- audience: string;
2408
- ttlSeconds: number;
2409
- attenuation: unknown;
2410
- }, {
2411
- readonly mode: 'value';
2412
- readonly value: string;
2413
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2414
- readonly name: "delegate";
2415
- };
2416
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
2417
- audience: string;
2418
- ttlSeconds: number;
2419
- attenuation: unknown;
2420
- }, {
2421
- readonly mode: 'value';
2422
- readonly value: string;
2423
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2424
- readonly name: "delegate";
2425
- }> & {
2426
- readonly byKey: Readonly<{
2427
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2428
- audience: string;
2429
- ttlSeconds: number;
2430
- attenuation: unknown;
2431
- }, {
2432
- readonly mode: 'value';
2433
- readonly value: string;
2434
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2435
- readonly name: "delegate";
2436
- };
2437
- }>;
2438
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
2439
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2440
- audience: string;
2441
- ttlSeconds: number;
2442
- attenuation: unknown;
2443
- }, {
2444
- readonly mode: 'value';
2445
- readonly value: string;
2446
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2447
- readonly name: "delegate";
2448
- };
2449
- }>[Key];
2450
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2451
- }, Readonly<Readonly<{
2452
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
2453
- policy: string;
2454
- object: string;
2455
- }, {
2456
- readonly mode: 'value';
2457
- readonly value: {
2458
- allowed: boolean;
2459
- };
2460
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2461
- readonly name: "can";
2462
- };
2463
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
2464
- audience?: string | undefined;
2465
- ttlSeconds: number;
2466
- grant?: unknown;
2467
- }, {
2468
- readonly mode: 'value';
2469
- readonly value: string;
2470
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
2471
- readonly name: "mint";
2472
- };
2473
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2474
- readonly mode: 'value';
2475
- readonly value: {
2476
- id: string;
2477
- issuer: string;
2478
- subject: string;
2479
- frozen: boolean;
2480
- requiredClaims: ({
2481
- claim: string;
2482
- op: "contains";
2483
- value: unknown;
2484
- } | {
2485
- claim: string;
2486
- op: "eq";
2487
- value: unknown;
2488
- } | {
2489
- claim: string;
2490
- op: "exists";
2491
- })[];
2492
- };
2493
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2494
- readonly name: "whoami";
2495
- };
2496
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
2497
- issuer: string;
2498
- subject: string;
2499
- }, {
2500
- readonly mode: 'value';
2501
- readonly value: {
2502
- id: string;
2503
- issuer: string;
2504
- subject: string;
2505
- frozen: boolean;
2506
- requiredClaims: ({
2507
- claim: string;
2508
- op: "contains";
2509
- value: unknown;
2510
- } | {
2511
- claim: string;
2512
- op: "eq";
2513
- value: unknown;
2514
- } | {
2515
- claim: string;
2516
- op: "exists";
2517
- })[];
2518
- } | null;
2519
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
2520
- readonly name: "whois";
2521
- };
2522
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
2523
- policy: string;
2524
- object: string;
2525
- }, {
2526
- readonly mode: 'value';
2527
- readonly value: {
2528
- allowed: boolean;
2529
- };
2530
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2531
- readonly name: "can";
2532
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
2533
- audience?: string | undefined;
2534
- ttlSeconds: number;
2535
- grant?: unknown;
2536
- }, {
2537
- readonly mode: 'value';
2538
- readonly value: string;
2539
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
2540
- readonly name: "mint";
2541
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2542
- readonly mode: 'value';
2543
- readonly value: {
2544
- id: string;
2545
- issuer: string;
2546
- subject: string;
2547
- frozen: boolean;
2548
- requiredClaims: ({
2549
- claim: string;
2550
- op: "contains";
2551
- value: unknown;
2552
- } | {
2553
- claim: string;
2554
- op: "eq";
2555
- value: unknown;
2556
- } | {
2557
- claim: string;
2558
- op: "exists";
2559
- })[];
2560
- };
2561
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2562
- readonly name: "whoami";
2563
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
2564
- issuer: string;
2565
- subject: string;
2566
- }, {
2567
- readonly mode: 'value';
2568
- readonly value: {
2569
- id: string;
2570
- issuer: string;
2571
- subject: string;
2572
- frozen: boolean;
2573
- requiredClaims: ({
2574
- claim: string;
2575
- op: "contains";
2576
- value: unknown;
2577
- } | {
2578
- claim: string;
2579
- op: "eq";
2580
- value: unknown;
2581
- } | {
2582
- claim: string;
2583
- op: "exists";
2584
- })[];
2585
- } | null;
2586
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
2587
- readonly name: "whois";
2588
- })> & {
2589
- readonly byKey: Readonly<{
2590
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
2591
- policy: string;
2592
- object: string;
2593
- }, {
2594
- readonly mode: 'value';
2595
- readonly value: {
2596
- allowed: boolean;
2597
- };
2598
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2599
- readonly name: "can";
2600
- };
2601
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
2602
- audience?: string | undefined;
2603
- ttlSeconds: number;
2604
- grant?: unknown;
2605
- }, {
2606
- readonly mode: 'value';
2607
- readonly value: string;
2608
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
2609
- readonly name: "mint";
2610
- };
2611
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2612
- readonly mode: 'value';
2613
- readonly value: {
2614
- id: string;
2615
- issuer: string;
2616
- subject: string;
2617
- frozen: boolean;
2618
- requiredClaims: ({
2619
- claim: string;
2620
- op: "contains";
2621
- value: unknown;
2622
- } | {
2623
- claim: string;
2624
- op: "eq";
2625
- value: unknown;
2626
- } | {
2627
- claim: string;
2628
- op: "exists";
2629
- })[];
2630
- };
2631
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2632
- readonly name: "whoami";
2633
- };
2634
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
2635
- issuer: string;
2636
- subject: string;
2637
- }, {
2638
- readonly mode: 'value';
2639
- readonly value: {
2640
- id: string;
2641
- issuer: string;
2642
- subject: string;
2643
- frozen: boolean;
2644
- requiredClaims: ({
2645
- claim: string;
2646
- op: "contains";
2647
- value: unknown;
2648
- } | {
2649
- claim: string;
2650
- op: "eq";
2651
- value: unknown;
2652
- } | {
2653
- claim: string;
2654
- op: "exists";
2655
- })[];
2656
- } | null;
2657
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
2658
- readonly name: "whois";
2659
- };
2660
- }>;
2661
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
2662
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
2663
- policy: string;
2664
- object: string;
2665
- }, {
2666
- readonly mode: 'value';
2667
- readonly value: {
2668
- allowed: boolean;
2669
- };
2670
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2671
- readonly name: "can";
2672
- };
2673
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
2674
- audience?: string | undefined;
2675
- ttlSeconds: number;
2676
- grant?: unknown;
2677
- }, {
2678
- readonly mode: 'value';
2679
- readonly value: string;
2680
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
2681
- readonly name: "mint";
2682
- };
2683
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2684
- readonly mode: 'value';
2685
- readonly value: {
2686
- id: string;
2687
- issuer: string;
2688
- subject: string;
2689
- frozen: boolean;
2690
- requiredClaims: ({
2691
- claim: string;
2692
- op: "contains";
2693
- value: unknown;
2694
- } | {
2695
- claim: string;
2696
- op: "eq";
2697
- value: unknown;
2698
- } | {
2699
- claim: string;
2700
- op: "exists";
2701
- })[];
2702
- };
2703
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2704
- readonly name: "whoami";
2705
- };
2706
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
2707
- issuer: string;
2708
- subject: string;
2709
- }, {
2710
- readonly mode: 'value';
2711
- readonly value: {
2712
- id: string;
2713
- issuer: string;
2714
- subject: string;
2715
- frozen: boolean;
2716
- requiredClaims: ({
2717
- claim: string;
2718
- op: "contains";
2719
- value: unknown;
2720
- } | {
2721
- claim: string;
2722
- op: "eq";
2723
- value: unknown;
2724
- } | {
2725
- claim: string;
2726
- op: "exists";
2727
- })[];
2728
- } | null;
2729
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
2730
- readonly name: "whois";
2731
- };
2732
- }>[Key];
2733
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2734
- }, Readonly<Readonly<{
2735
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2736
- readonly name: "frozen";
2737
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2738
- };
2739
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2740
- readonly name: "iss";
2741
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2742
- };
2743
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
2744
- claim: string;
2745
- op: "contains";
2746
- value: unknown;
2747
- } | {
2748
- claim: string;
2749
- op: "eq";
2750
- value: unknown;
2751
- } | {
2752
- claim: string;
2753
- op: "exists";
2754
- })[], false> & {
2755
- readonly name: "requiredClaims";
2756
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2757
- };
2758
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2759
- readonly name: "sub";
2760
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2761
- };
2762
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2763
- readonly name: "frozen";
2764
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2765
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2766
- readonly name: "iss";
2767
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2768
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
2769
- claim: string;
2770
- op: "contains";
2771
- value: unknown;
2772
- } | {
2773
- claim: string;
2774
- op: "eq";
2775
- value: unknown;
2776
- } | {
2777
- claim: string;
2778
- op: "exists";
2779
- })[], false> & {
2780
- readonly name: "requiredClaims";
2781
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2782
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2783
- readonly name: "sub";
2784
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2785
- })> & {
2786
- readonly byKey: Readonly<{
2787
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2788
- readonly name: "frozen";
2789
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2790
- };
2791
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2792
- readonly name: "iss";
2793
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2794
- };
2795
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2796
- claim: string;
2797
- op: "contains";
2798
- value: unknown;
2799
- } | {
2800
- claim: string;
2801
- op: "eq";
2802
- value: unknown;
2803
- } | {
2804
- claim: string;
2805
- op: "exists";
2806
- })[], false> & {
2807
- readonly name: "requiredClaims";
2808
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2809
- };
2810
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2811
- readonly name: "sub";
2812
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2813
- };
2814
- }>;
2815
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
2816
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2817
- readonly name: "frozen";
2818
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2819
- };
2820
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2821
- readonly name: "iss";
2822
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2823
- };
2824
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2825
- claim: string;
2826
- op: "contains";
2827
- value: unknown;
2828
- } | {
2829
- claim: string;
2830
- op: "eq";
2831
- value: unknown;
2832
- } | {
2833
- claim: string;
2834
- op: "exists";
2835
- })[], false> & {
2836
- readonly name: "requiredClaims";
2837
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2838
- };
2839
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2840
- readonly name: "sub";
2841
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2842
- };
2843
- }>[Key];
2844
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2845
- from(input: Readonly<{
2846
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2847
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2848
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
2849
- claim: string;
2850
- op: "contains";
2851
- value: unknown;
2852
- } | {
2853
- claim: string;
2854
- op: "eq";
2855
- value: unknown;
2856
- } | {
2857
- claim: string;
2858
- op: "exists";
2859
- })[] | undefined;
2860
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2861
- } & {
2862
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2863
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2864
- readonly requiredClaims?: ({
2865
- claim: string;
2866
- op: "contains";
2867
- value: unknown;
2868
- } | {
2869
- claim: string;
2870
- op: "eq";
2871
- value: unknown;
2872
- } | {
2873
- claim: string;
2874
- op: "exists";
2875
- })[] | undefined;
2876
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2877
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2878
- }, Readonly<Readonly<{
2879
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
2880
- audience: string;
2881
- ttlSeconds: number;
2882
- attenuation: unknown;
2883
- }, {
2884
- readonly mode: 'value';
2885
- readonly value: string;
2886
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2887
- readonly name: "delegate";
2888
- };
2889
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
2890
- audience: string;
2891
- ttlSeconds: number;
2892
- attenuation: unknown;
2893
- }, {
2894
- readonly mode: 'value';
2895
- readonly value: string;
2896
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2897
- readonly name: "delegate";
2898
- }> & {
2899
- readonly byKey: Readonly<{
2900
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2901
- audience: string;
2902
- ttlSeconds: number;
2903
- attenuation: unknown;
2904
- }, {
2905
- readonly mode: 'value';
2906
- readonly value: string;
2907
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2908
- readonly name: "delegate";
2909
- };
2910
- }>;
2911
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
2912
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2913
- audience: string;
2914
- ttlSeconds: number;
2915
- attenuation: unknown;
2916
- }, {
2917
- readonly mode: 'value';
2918
- readonly value: string;
2919
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2920
- readonly name: "delegate";
2921
- };
2922
- }>[Key];
2923
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2924
- }, Readonly<Readonly<{
2925
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
2926
- policy: string;
2927
- object: string;
2928
- }, {
2929
- readonly mode: 'value';
2930
- readonly value: {
2931
- allowed: boolean;
2932
- };
2933
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2934
- readonly name: "can";
2935
- };
2936
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
2937
- audience?: string | undefined;
2938
- ttlSeconds: number;
2939
- grant?: unknown;
2940
- }, {
2941
- readonly mode: 'value';
2942
- readonly value: string;
2943
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
2944
- readonly name: "mint";
2945
- };
2946
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2947
- readonly mode: 'value';
2948
- readonly value: {
2949
- id: string;
2950
- issuer: string;
2951
- subject: string;
2952
- frozen: boolean;
2953
- requiredClaims: ({
2954
- claim: string;
2955
- op: "contains";
2956
- value: unknown;
2957
- } | {
2958
- claim: string;
2959
- op: "eq";
2960
- value: unknown;
2961
- } | {
2962
- claim: string;
2963
- op: "exists";
2964
- })[];
2965
- };
2966
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2967
- readonly name: "whoami";
2968
- };
2969
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
2970
- issuer: string;
2971
- subject: string;
2972
- }, {
2973
- readonly mode: 'value';
2974
- readonly value: {
2975
- id: string;
2976
- issuer: string;
2977
- subject: string;
2978
- frozen: boolean;
2979
- requiredClaims: ({
2980
- claim: string;
2981
- op: "contains";
2982
- value: unknown;
2983
- } | {
2984
- claim: string;
2985
- op: "eq";
2986
- value: unknown;
2987
- } | {
2988
- claim: string;
2989
- op: "exists";
2990
- })[];
2991
- } | null;
2992
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
2993
- readonly name: "whois";
2994
- };
2995
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
2996
- policy: string;
2997
- object: string;
2998
- }, {
2999
- readonly mode: 'value';
3000
- readonly value: {
3001
- allowed: boolean;
3002
- };
3003
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3004
- readonly name: "can";
3005
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
3006
- audience?: string | undefined;
3007
- ttlSeconds: number;
3008
- grant?: unknown;
3009
- }, {
3010
- readonly mode: 'value';
3011
- readonly value: string;
3012
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3013
- readonly name: "mint";
3014
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3015
- readonly mode: 'value';
3016
- readonly value: {
3017
- id: string;
3018
- issuer: string;
3019
- subject: string;
3020
- frozen: boolean;
3021
- requiredClaims: ({
3022
- claim: string;
3023
- op: "contains";
3024
- value: unknown;
3025
- } | {
3026
- claim: string;
3027
- op: "eq";
3028
- value: unknown;
3029
- } | {
3030
- claim: string;
3031
- op: "exists";
3032
- })[];
3033
- };
3034
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3035
- readonly name: "whoami";
3036
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
3037
- issuer: string;
3038
- subject: string;
3039
- }, {
3040
- readonly mode: 'value';
3041
- readonly value: {
3042
- id: string;
3043
- issuer: string;
3044
- subject: string;
3045
- frozen: boolean;
3046
- requiredClaims: ({
3047
- claim: string;
3048
- op: "contains";
3049
- value: unknown;
3050
- } | {
3051
- claim: string;
3052
- op: "eq";
3053
- value: unknown;
3054
- } | {
3055
- claim: string;
3056
- op: "exists";
3057
- })[];
3058
- } | null;
3059
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3060
- readonly name: "whois";
3061
- })> & {
3062
- readonly byKey: Readonly<{
3063
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
3064
- policy: string;
3065
- object: string;
3066
- }, {
3067
- readonly mode: 'value';
3068
- readonly value: {
3069
- allowed: boolean;
3070
- };
3071
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3072
- readonly name: "can";
3073
- };
3074
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
3075
- audience?: string | undefined;
3076
- ttlSeconds: number;
3077
- grant?: unknown;
3078
- }, {
3079
- readonly mode: 'value';
3080
- readonly value: string;
3081
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3082
- readonly name: "mint";
3083
- };
3084
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3085
- readonly mode: 'value';
3086
- readonly value: {
3087
- id: string;
3088
- issuer: string;
3089
- subject: string;
3090
- frozen: boolean;
3091
- requiredClaims: ({
3092
- claim: string;
3093
- op: "contains";
3094
- value: unknown;
3095
- } | {
3096
- claim: string;
3097
- op: "eq";
3098
- value: unknown;
3099
- } | {
3100
- claim: string;
3101
- op: "exists";
3102
- })[];
3103
- };
3104
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3105
- readonly name: "whoami";
3106
- };
3107
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
3108
- issuer: string;
3109
- subject: string;
3110
- }, {
3111
- readonly mode: 'value';
3112
- readonly value: {
3113
- id: string;
3114
- issuer: string;
3115
- subject: string;
3116
- frozen: boolean;
3117
- requiredClaims: ({
3118
- claim: string;
3119
- op: "contains";
3120
- value: unknown;
3121
- } | {
3122
- claim: string;
3123
- op: "eq";
3124
- value: unknown;
3125
- } | {
3126
- claim: string;
3127
- op: "exists";
3128
- })[];
3129
- } | null;
3130
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3131
- readonly name: "whois";
3132
- };
3133
- }>;
3134
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
3135
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
3136
- policy: string;
3137
- object: string;
3138
- }, {
3139
- readonly mode: 'value';
3140
- readonly value: {
3141
- allowed: boolean;
3142
- };
3143
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3144
- readonly name: "can";
3145
- };
3146
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
3147
- audience?: string | undefined;
3148
- ttlSeconds: number;
3149
- grant?: unknown;
3150
- }, {
3151
- readonly mode: 'value';
3152
- readonly value: string;
3153
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3154
- readonly name: "mint";
3155
- };
3156
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3157
- readonly mode: 'value';
3158
- readonly value: {
3159
- id: string;
3160
- issuer: string;
3161
- subject: string;
3162
- frozen: boolean;
3163
- requiredClaims: ({
3164
- claim: string;
3165
- op: "contains";
3166
- value: unknown;
3167
- } | {
3168
- claim: string;
3169
- op: "eq";
3170
- value: unknown;
3171
- } | {
3172
- claim: string;
3173
- op: "exists";
3174
- })[];
3175
- };
3176
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3177
- readonly name: "whoami";
3178
- };
3179
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
3180
- issuer: string;
3181
- subject: string;
3182
- }, {
3183
- readonly mode: 'value';
3184
- readonly value: {
3185
- id: string;
3186
- issuer: string;
3187
- subject: string;
3188
- frozen: boolean;
3189
- requiredClaims: ({
3190
- claim: string;
3191
- op: "contains";
3192
- value: unknown;
3193
- } | {
3194
- claim: string;
3195
- op: "eq";
3196
- value: unknown;
3197
- } | {
3198
- claim: string;
3199
- op: "exists";
3200
- })[];
3201
- } | null;
3202
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3203
- readonly name: "whois";
3204
- };
3205
- }>[Key];
3206
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3207
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
3208
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
3209
- readonly origin: "kernel.astrale.ai";
3210
- };
3211
- readonly kind: 'node';
3212
- readonly abstract: true;
3213
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
3214
- readonly byKey: Readonly<{}>;
3215
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3216
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
3217
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
3218
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3219
- readonly byKey: Readonly<{}>;
3220
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3221
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3222
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3223
- readonly byKey: Readonly<{}>;
3224
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3225
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3226
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3227
- readonly byKey: Readonly<{}>;
3228
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3229
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
3230
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
3231
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3232
- readonly byKey: Readonly<{}>;
3233
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3234
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3235
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3236
- readonly byKey: Readonly<{}>;
3237
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3238
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3239
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
3240
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
3241
- readonly origin: "kernel.astrale.ai";
3242
- };
3243
- readonly kind: 'node';
3244
- readonly abstract: true;
3245
- }, readonly []> & {
3246
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
3247
- readonly origin: "kernel.astrale.ai";
3248
- };
3249
- readonly key: "kernel.astrale.ai:class.Node";
3250
- }]> & {
3251
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
3252
- readonly origin: "kernel.astrale.ai";
3253
- };
3254
- readonly key: "kernel.astrale.ai:class.Identity";
3255
- }];
3256
- readonly properties: {
3257
- displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
3258
- readonly required: false;
3259
- }>;
3260
- };
3261
- readonly methods: {
3262
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
3263
- readonly description: "Resolve this User and its canonical personal Space.";
3264
- readonly auth: "authenticated";
3265
- readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
3266
- readonly output: import("zod").ZodObject<{
3267
- userId: import("zod").ZodString;
3268
- personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
3269
- }, import("zod/v4/core").$strict>;
3270
- }>;
3271
- };
3272
- }>]>;
3273
- }, import("zod/v4/core").$strict>;
3274
- readonly output: {
3275
- type: 'object';
3276
- properties: {};
3277
- additionalProperties: boolean;
3278
- };
3279
- readonly auth: "authorized";
3280
- readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
3281
- }>;
3282
- unassignUser: import("@astrale-os/sdk/schema").Method<{
3283
- readonly description: string;
3284
- readonly input: import("zod").ZodObject<{
3285
- user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
3286
- readonly description: "One externally identified person using Shell.";
3287
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
3288
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3289
- readonly name: "frozen";
3290
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3291
- };
3292
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3293
- readonly name: "iss";
3294
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3295
- };
3296
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
3297
- claim: string;
3298
- op: "contains";
3299
- value: unknown;
3300
- } | {
3301
- claim: string;
3302
- op: "eq";
3303
- value: unknown;
3304
- } | {
3305
- claim: string;
3306
- op: "exists";
3307
- })[], false> & {
3308
- readonly name: "requiredClaims";
3309
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3310
- };
3311
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3312
- readonly name: "sub";
3313
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3314
- };
3315
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3316
- readonly name: "frozen";
3317
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3318
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3319
- readonly name: "iss";
3320
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3321
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
3322
- claim: string;
3323
- op: "contains";
3324
- value: unknown;
3325
- } | {
3326
- claim: string;
3327
- op: "eq";
3328
- value: unknown;
3329
- } | {
3330
- claim: string;
3331
- op: "exists";
3332
- })[], false> & {
3333
- readonly name: "requiredClaims";
3334
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3335
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3336
- readonly name: "sub";
3337
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3338
- })> & {
3339
- readonly byKey: Readonly<{
3340
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3341
- readonly name: "frozen";
3342
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3343
- };
3344
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3345
- readonly name: "iss";
3346
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3347
- };
3348
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
3349
- claim: string;
3350
- op: "contains";
3351
- value: unknown;
3352
- } | {
3353
- claim: string;
3354
- op: "eq";
3355
- value: unknown;
3356
- } | {
3357
- claim: string;
3358
- op: "exists";
3359
- })[], false> & {
3360
- readonly name: "requiredClaims";
3361
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3362
- };
3363
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3364
- readonly name: "sub";
3365
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3366
- };
3367
- }>;
3368
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
3369
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3370
- readonly name: "frozen";
3371
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3372
- };
3373
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3374
- readonly name: "iss";
3375
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3376
- };
3377
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
3378
- claim: string;
3379
- op: "contains";
3380
- value: unknown;
3381
- } | {
3382
- claim: string;
3383
- op: "eq";
3384
- value: unknown;
3385
- } | {
3386
- claim: string;
3387
- op: "exists";
3388
- })[], false> & {
3389
- readonly name: "requiredClaims";
3390
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3391
- };
3392
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3393
- readonly name: "sub";
3394
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3395
- };
3396
- }>[Key];
3397
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
3398
- from(input: Readonly<{
3399
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3400
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3401
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
3402
- claim: string;
3403
- op: "contains";
3404
- value: unknown;
3405
- } | {
3406
- claim: string;
3407
- op: "eq";
3408
- value: unknown;
3409
- } | {
3410
- claim: string;
3411
- op: "exists";
3412
- })[] | undefined;
3413
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3414
- } & {
3415
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3416
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3417
- readonly requiredClaims?: ({
3418
- claim: string;
3419
- op: "contains";
3420
- value: unknown;
3421
- } | {
3422
- claim: string;
3423
- op: "eq";
3424
- value: unknown;
3425
- } | {
3426
- claim: string;
3427
- op: "exists";
3428
- })[] | undefined;
3429
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3430
- }>): import("@astrale-os/sdk/schema").PropertyValues;
3431
- }, Readonly<Readonly<{
3432
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
3433
- audience: string;
3434
- ttlSeconds: number;
3435
- attenuation: unknown;
3436
- }, {
3437
- readonly mode: 'value';
3438
- readonly value: string;
3439
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3440
- readonly name: "delegate";
3441
- };
3442
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
3443
- audience: string;
3444
- ttlSeconds: number;
3445
- attenuation: unknown;
3446
- }, {
3447
- readonly mode: 'value';
3448
- readonly value: string;
3449
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3450
- readonly name: "delegate";
3451
- }> & {
3452
- readonly byKey: Readonly<{
3453
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
3454
- audience: string;
3455
- ttlSeconds: number;
3456
- attenuation: unknown;
3457
- }, {
3458
- readonly mode: 'value';
3459
- readonly value: string;
3460
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3461
- readonly name: "delegate";
3462
- };
3463
- }>;
3464
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
3465
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
3466
- audience: string;
3467
- ttlSeconds: number;
3468
- attenuation: unknown;
3469
- }, {
3470
- readonly mode: 'value';
3471
- readonly value: string;
3472
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3473
- readonly name: "delegate";
3474
- };
3475
- }>[Key];
3476
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3477
- }, Readonly<Readonly<{
3478
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
3479
- policy: string;
3480
- object: string;
3481
- }, {
3482
- readonly mode: 'value';
3483
- readonly value: {
3484
- allowed: boolean;
3485
- };
3486
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3487
- readonly name: "can";
3488
- };
3489
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
3490
- audience?: string | undefined;
3491
- ttlSeconds: number;
3492
- grant?: unknown;
3493
- }, {
3494
- readonly mode: 'value';
3495
- readonly value: string;
3496
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3497
- readonly name: "mint";
3498
- };
3499
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3500
- readonly mode: 'value';
3501
- readonly value: {
3502
- id: string;
3503
- issuer: string;
3504
- subject: string;
3505
- frozen: boolean;
3506
- requiredClaims: ({
3507
- claim: string;
3508
- op: "contains";
3509
- value: unknown;
3510
- } | {
3511
- claim: string;
3512
- op: "eq";
3513
- value: unknown;
3514
- } | {
3515
- claim: string;
3516
- op: "exists";
3517
- })[];
3518
- };
3519
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3520
- readonly name: "whoami";
3521
- };
3522
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
3523
- issuer: string;
3524
- subject: string;
3525
- }, {
3526
- readonly mode: 'value';
3527
- readonly value: {
3528
- id: string;
3529
- issuer: string;
3530
- subject: string;
3531
- frozen: boolean;
3532
- requiredClaims: ({
3533
- claim: string;
3534
- op: "contains";
3535
- value: unknown;
3536
- } | {
3537
- claim: string;
3538
- op: "eq";
3539
- value: unknown;
3540
- } | {
3541
- claim: string;
3542
- op: "exists";
3543
- })[];
3544
- } | null;
3545
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3546
- readonly name: "whois";
3547
- };
3548
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
3549
- policy: string;
3550
- object: string;
3551
- }, {
3552
- readonly mode: 'value';
3553
- readonly value: {
3554
- allowed: boolean;
3555
- };
3556
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3557
- readonly name: "can";
3558
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
3559
- audience?: string | undefined;
3560
- ttlSeconds: number;
3561
- grant?: unknown;
3562
- }, {
3563
- readonly mode: 'value';
3564
- readonly value: string;
3565
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3566
- readonly name: "mint";
3567
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3568
- readonly mode: 'value';
3569
- readonly value: {
3570
- id: string;
3571
- issuer: string;
3572
- subject: string;
3573
- frozen: boolean;
3574
- requiredClaims: ({
3575
- claim: string;
3576
- op: "contains";
3577
- value: unknown;
3578
- } | {
3579
- claim: string;
3580
- op: "eq";
3581
- value: unknown;
3582
- } | {
3583
- claim: string;
3584
- op: "exists";
3585
- })[];
3586
- };
3587
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3588
- readonly name: "whoami";
3589
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
3590
- issuer: string;
3591
- subject: string;
3592
- }, {
3593
- readonly mode: 'value';
3594
- readonly value: {
3595
- id: string;
3596
- issuer: string;
3597
- subject: string;
3598
- frozen: boolean;
3599
- requiredClaims: ({
3600
- claim: string;
3601
- op: "contains";
3602
- value: unknown;
3603
- } | {
3604
- claim: string;
3605
- op: "eq";
3606
- value: unknown;
3607
- } | {
3608
- claim: string;
3609
- op: "exists";
3610
- })[];
3611
- } | null;
3612
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3613
- readonly name: "whois";
3614
- })> & {
3615
- readonly byKey: Readonly<{
3616
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
3617
- policy: string;
3618
- object: string;
3619
- }, {
3620
- readonly mode: 'value';
3621
- readonly value: {
3622
- allowed: boolean;
3623
- };
3624
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3625
- readonly name: "can";
3626
- };
3627
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
3628
- audience?: string | undefined;
3629
- ttlSeconds: number;
3630
- grant?: unknown;
3631
- }, {
3632
- readonly mode: 'value';
3633
- readonly value: string;
3634
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3635
- readonly name: "mint";
3636
- };
3637
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3638
- readonly mode: 'value';
3639
- readonly value: {
3640
- id: string;
3641
- issuer: string;
3642
- subject: string;
3643
- frozen: boolean;
3644
- requiredClaims: ({
3645
- claim: string;
3646
- op: "contains";
3647
- value: unknown;
3648
- } | {
3649
- claim: string;
3650
- op: "eq";
3651
- value: unknown;
3652
- } | {
3653
- claim: string;
3654
- op: "exists";
3655
- })[];
3656
- };
3657
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3658
- readonly name: "whoami";
3659
- };
3660
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
3661
- issuer: string;
3662
- subject: string;
3663
- }, {
3664
- readonly mode: 'value';
3665
- readonly value: {
3666
- id: string;
3667
- issuer: string;
3668
- subject: string;
3669
- frozen: boolean;
3670
- requiredClaims: ({
3671
- claim: string;
3672
- op: "contains";
3673
- value: unknown;
3674
- } | {
3675
- claim: string;
3676
- op: "eq";
3677
- value: unknown;
3678
- } | {
3679
- claim: string;
3680
- op: "exists";
3681
- })[];
3682
- } | null;
3683
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3684
- readonly name: "whois";
3685
- };
3686
- }>;
3687
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
3688
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
3689
- policy: string;
3690
- object: string;
3691
- }, {
3692
- readonly mode: 'value';
3693
- readonly value: {
3694
- allowed: boolean;
3695
- };
3696
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3697
- readonly name: "can";
3698
- };
3699
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
3700
- audience?: string | undefined;
3701
- ttlSeconds: number;
3702
- grant?: unknown;
3703
- }, {
3704
- readonly mode: 'value';
3705
- readonly value: string;
3706
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3707
- readonly name: "mint";
3708
- };
3709
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3710
- readonly mode: 'value';
3711
- readonly value: {
3712
- id: string;
3713
- issuer: string;
3714
- subject: string;
3715
- frozen: boolean;
3716
- requiredClaims: ({
3717
- claim: string;
3718
- op: "contains";
3719
- value: unknown;
3720
- } | {
3721
- claim: string;
3722
- op: "eq";
3723
- value: unknown;
3724
- } | {
3725
- claim: string;
3726
- op: "exists";
3727
- })[];
3728
- };
3729
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3730
- readonly name: "whoami";
3731
- };
3732
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
3733
- issuer: string;
3734
- subject: string;
3735
- }, {
3736
- readonly mode: 'value';
3737
- readonly value: {
3738
- id: string;
3739
- issuer: string;
3740
- subject: string;
3741
- frozen: boolean;
3742
- requiredClaims: ({
3743
- claim: string;
3744
- op: "contains";
3745
- value: unknown;
3746
- } | {
3747
- claim: string;
3748
- op: "eq";
3749
- value: unknown;
3750
- } | {
3751
- claim: string;
3752
- op: "exists";
3753
- })[];
3754
- } | null;
3755
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
3756
- readonly name: "whois";
3757
- };
3758
- }>[Key];
3759
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3760
- }, Readonly<Readonly<{
3761
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3762
- readonly name: "frozen";
3763
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3764
- };
3765
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3766
- readonly name: "iss";
3767
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3768
- };
3769
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
3770
- claim: string;
3771
- op: "contains";
3772
- value: unknown;
3773
- } | {
3774
- claim: string;
3775
- op: "eq";
3776
- value: unknown;
3777
- } | {
3778
- claim: string;
3779
- op: "exists";
3780
- })[], false> & {
3781
- readonly name: "requiredClaims";
3782
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3783
- };
3784
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3785
- readonly name: "sub";
3786
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3787
- };
3788
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3789
- readonly name: "frozen";
3790
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3791
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3792
- readonly name: "iss";
3793
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3794
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
3795
- claim: string;
3796
- op: "contains";
3797
- value: unknown;
3798
- } | {
3799
- claim: string;
3800
- op: "eq";
3801
- value: unknown;
3802
- } | {
3803
- claim: string;
3804
- op: "exists";
3805
- })[], false> & {
3806
- readonly name: "requiredClaims";
3807
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3808
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3809
- readonly name: "sub";
3810
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3811
- })> & {
3812
- readonly byKey: Readonly<{
3813
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3814
- readonly name: "frozen";
3815
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3816
- };
3817
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3818
- readonly name: "iss";
3819
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3820
- };
3821
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
3822
- claim: string;
3823
- op: "contains";
3824
- value: unknown;
3825
- } | {
3826
- claim: string;
3827
- op: "eq";
3828
- value: unknown;
3829
- } | {
3830
- claim: string;
3831
- op: "exists";
3832
- })[], false> & {
3833
- readonly name: "requiredClaims";
3834
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3835
- };
3836
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3837
- readonly name: "sub";
3838
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3839
- };
3840
- }>;
3841
- get<Key extends "kernel.astrale.ai:class.Identity.property.frozen" | "kernel.astrale.ai:class.Identity.property.iss" | "kernel.astrale.ai:class.Identity.property.requiredClaims" | "kernel.astrale.ai:class.Identity.property.sub">(key: Key): Readonly<{
3842
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
3843
- readonly name: "frozen";
3844
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
3845
- };
3846
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3847
- readonly name: "iss";
3848
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
3849
- };
3850
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
3851
- claim: string;
3852
- op: "contains";
3853
- value: unknown;
3854
- } | {
3855
- claim: string;
3856
- op: "eq";
3857
- value: unknown;
3858
- } | {
3859
- claim: string;
3860
- op: "exists";
3861
- })[], false> & {
3862
- readonly name: "requiredClaims";
3863
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
3864
- };
3865
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
3866
- readonly name: "sub";
3867
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
3868
- };
3869
- }>[Key];
3870
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
3871
- from(input: Readonly<{
3872
- readonly "kernel.astrale.ai:class.Identity.property.frozen"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3873
- readonly "kernel.astrale.ai:class.Identity.property.iss"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3874
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
3875
- claim: string;
3876
- op: "contains";
3877
- value: unknown;
3878
- } | {
3879
- claim: string;
3880
- op: "eq";
3881
- value: unknown;
3882
- } | {
3883
- claim: string;
3884
- op: "exists";
3885
- })[] | undefined;
3886
- readonly "kernel.astrale.ai:class.Identity.property.sub"?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3887
- } & {
3888
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3889
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3890
- readonly requiredClaims?: ({
3891
- claim: string;
3892
- op: "contains";
3893
- value: unknown;
3894
- } | {
3895
- claim: string;
3896
- op: "eq";
3897
- value: unknown;
3898
- } | {
3899
- claim: string;
3900
- op: "exists";
3901
- })[] | undefined;
3902
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
3903
- }>): import("@astrale-os/sdk/schema").PropertyValues;
3904
- }, Readonly<Readonly<{
3905
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
3906
- audience: string;
3907
- ttlSeconds: number;
3908
- attenuation: unknown;
3909
- }, {
3910
- readonly mode: 'value';
3911
- readonly value: string;
3912
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3913
- readonly name: "delegate";
3914
- };
3915
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
3916
- audience: string;
3917
- ttlSeconds: number;
3918
- attenuation: unknown;
3919
- }, {
3920
- readonly mode: 'value';
3921
- readonly value: string;
3922
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3923
- readonly name: "delegate";
3924
- }> & {
3925
- readonly byKey: Readonly<{
3926
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
3927
- audience: string;
3928
- ttlSeconds: number;
3929
- attenuation: unknown;
3930
- }, {
3931
- readonly mode: 'value';
3932
- readonly value: string;
3933
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3934
- readonly name: "delegate";
3935
- };
3936
- }>;
3937
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
3938
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
3939
- audience: string;
3940
- ttlSeconds: number;
3941
- attenuation: unknown;
3942
- }, {
3943
- readonly mode: 'value';
3944
- readonly value: string;
3945
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
3946
- readonly name: "delegate";
3947
- };
3948
- }>[Key];
3949
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3950
- }, Readonly<Readonly<{
3951
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
3952
- policy: string;
3953
- object: string;
3954
- }, {
3955
- readonly mode: 'value';
3956
- readonly value: {
3957
- allowed: boolean;
3958
- };
3959
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3960
- readonly name: "can";
3961
- };
3962
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
3963
- audience?: string | undefined;
3964
- ttlSeconds: number;
3965
- grant?: unknown;
3966
- }, {
3967
- readonly mode: 'value';
3968
- readonly value: string;
3969
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
3970
- readonly name: "mint";
3971
- };
3972
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3973
- readonly mode: 'value';
3974
- readonly value: {
3975
- id: string;
3976
- issuer: string;
3977
- subject: string;
3978
- frozen: boolean;
3979
- requiredClaims: ({
3980
- claim: string;
3981
- op: "contains";
3982
- value: unknown;
3983
- } | {
3984
- claim: string;
3985
- op: "eq";
3986
- value: unknown;
3987
- } | {
3988
- claim: string;
3989
- op: "exists";
3990
- })[];
3991
- };
3992
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3993
- readonly name: "whoami";
3994
- };
3995
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
3996
- issuer: string;
3997
- subject: string;
3998
- }, {
3999
- readonly mode: 'value';
4000
- readonly value: {
4001
- id: string;
4002
- issuer: string;
4003
- subject: string;
4004
- frozen: boolean;
4005
- requiredClaims: ({
4006
- claim: string;
4007
- op: "contains";
4008
- value: unknown;
4009
- } | {
4010
- claim: string;
4011
- op: "eq";
4012
- value: unknown;
4013
- } | {
4014
- claim: string;
4015
- op: "exists";
4016
- })[];
4017
- } | null;
4018
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
4019
- readonly name: "whois";
4020
- };
4021
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
4022
- policy: string;
4023
- object: string;
4024
- }, {
4025
- readonly mode: 'value';
4026
- readonly value: {
4027
- allowed: boolean;
4028
- };
4029
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
4030
- readonly name: "can";
4031
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
4032
- audience?: string | undefined;
4033
- ttlSeconds: number;
4034
- grant?: unknown;
4035
- }, {
4036
- readonly mode: 'value';
4037
- readonly value: string;
4038
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
4039
- readonly name: "mint";
4040
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
4041
- readonly mode: 'value';
4042
- readonly value: {
4043
- id: string;
4044
- issuer: string;
4045
- subject: string;
4046
- frozen: boolean;
4047
- requiredClaims: ({
4048
- claim: string;
4049
- op: "contains";
4050
- value: unknown;
4051
- } | {
4052
- claim: string;
4053
- op: "eq";
4054
- value: unknown;
4055
- } | {
4056
- claim: string;
4057
- op: "exists";
4058
- })[];
4059
- };
4060
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
4061
- readonly name: "whoami";
4062
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
4063
- issuer: string;
4064
- subject: string;
4065
- }, {
4066
- readonly mode: 'value';
4067
- readonly value: {
4068
- id: string;
4069
- issuer: string;
4070
- subject: string;
4071
- frozen: boolean;
4072
- requiredClaims: ({
4073
- claim: string;
4074
- op: "contains";
4075
- value: unknown;
4076
- } | {
4077
- claim: string;
4078
- op: "eq";
4079
- value: unknown;
4080
- } | {
4081
- claim: string;
4082
- op: "exists";
4083
- })[];
4084
- } | null;
4085
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
4086
- readonly name: "whois";
4087
- })> & {
4088
- readonly byKey: Readonly<{
4089
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
4090
- policy: string;
4091
- object: string;
4092
- }, {
4093
- readonly mode: 'value';
4094
- readonly value: {
4095
- allowed: boolean;
4096
- };
4097
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
4098
- readonly name: "can";
4099
- };
4100
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
4101
- audience?: string | undefined;
4102
- ttlSeconds: number;
4103
- grant?: unknown;
4104
- }, {
4105
- readonly mode: 'value';
4106
- readonly value: string;
4107
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
4108
- readonly name: "mint";
4109
- };
4110
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
4111
- readonly mode: 'value';
4112
- readonly value: {
4113
- id: string;
4114
- issuer: string;
4115
- subject: string;
4116
- frozen: boolean;
4117
- requiredClaims: ({
4118
- claim: string;
4119
- op: "contains";
4120
- value: unknown;
4121
- } | {
4122
- claim: string;
4123
- op: "eq";
4124
- value: unknown;
4125
- } | {
4126
- claim: string;
4127
- op: "exists";
4128
- })[];
4129
- };
4130
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
4131
- readonly name: "whoami";
4132
- };
4133
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
4134
- issuer: string;
4135
- subject: string;
4136
- }, {
4137
- readonly mode: 'value';
4138
- readonly value: {
4139
- id: string;
4140
- issuer: string;
4141
- subject: string;
4142
- frozen: boolean;
4143
- requiredClaims: ({
4144
- claim: string;
4145
- op: "contains";
4146
- value: unknown;
4147
- } | {
4148
- claim: string;
4149
- op: "eq";
4150
- value: unknown;
4151
- } | {
4152
- claim: string;
4153
- op: "exists";
4154
- })[];
4155
- } | null;
4156
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
4157
- readonly name: "whois";
4158
- };
4159
- }>;
4160
- get<Key extends "kernel.astrale.ai:class.Identity.method.can" | "kernel.astrale.ai:class.Identity.method.mint" | "kernel.astrale.ai:class.Identity.method.whoami" | "kernel.astrale.ai:class.Identity.method.whois">(key: Key): Readonly<{
4161
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
4162
- policy: string;
4163
- object: string;
4164
- }, {
4165
- readonly mode: 'value';
4166
- readonly value: {
4167
- allowed: boolean;
4168
- };
4169
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
4170
- readonly name: "can";
4171
- };
4172
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
4173
- audience?: string | undefined;
4174
- ttlSeconds: number;
4175
- grant?: unknown;
4176
- }, {
4177
- readonly mode: 'value';
4178
- readonly value: string;
4179
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.mint"> & {
4180
- readonly name: "mint";
4181
- };
4182
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
4183
- readonly mode: 'value';
4184
- readonly value: {
4185
- id: string;
4186
- issuer: string;
4187
- subject: string;
4188
- frozen: boolean;
4189
- requiredClaims: ({
4190
- claim: string;
4191
- op: "contains";
4192
- value: unknown;
4193
- } | {
4194
- claim: string;
4195
- op: "eq";
4196
- value: unknown;
4197
- } | {
4198
- claim: string;
4199
- op: "exists";
4200
- })[];
4201
- };
4202
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
4203
- readonly name: "whoami";
4204
- };
4205
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
4206
- issuer: string;
4207
- subject: string;
4208
- }, {
4209
- readonly mode: 'value';
4210
- readonly value: {
4211
- id: string;
4212
- issuer: string;
4213
- subject: string;
4214
- frozen: boolean;
4215
- requiredClaims: ({
4216
- claim: string;
4217
- op: "contains";
4218
- value: unknown;
4219
- } | {
4220
- claim: string;
4221
- op: "eq";
4222
- value: unknown;
4223
- } | {
4224
- claim: string;
4225
- op: "exists";
4226
- })[];
4227
- } | null;
4228
- }, true, "default", "authorized", import("@astrale-os/sdk/schema").PolicyCheckExpression<import("@astrale-os/sdk/schema").PolicyRef, import("@astrale-os/sdk/schema").PolicyCheckObject>, "kernel.astrale.ai:class.Identity.method.whois"> & {
4229
- readonly name: "whois";
4230
- };
4231
- }>[Key];
4232
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
4233
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
4234
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
4235
- readonly origin: "kernel.astrale.ai";
4236
- };
4237
- readonly kind: 'node';
4238
- readonly abstract: true;
4239
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
4240
- readonly byKey: Readonly<{}>;
4241
- get<Key extends never>(key: Key): Readonly<{}>[Key];
4242
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
4243
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
4244
- }, Readonly<Readonly<{}>> & Iterable<never> & {
4245
- readonly byKey: Readonly<{}>;
4246
- get<Key extends never>(key: Key): Readonly<{}>[Key];
4247
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
4248
- }, Readonly<Readonly<{}>> & Iterable<never> & {
4249
- readonly byKey: Readonly<{}>;
4250
- get<Key extends never>(key: Key): Readonly<{}>[Key];
4251
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
4252
- }, Readonly<Readonly<{}>> & Iterable<never> & {
4253
- readonly byKey: Readonly<{}>;
4254
- get<Key extends never>(key: Key): Readonly<{}>[Key];
4255
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
4256
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
4257
- }, Readonly<Readonly<{}>> & Iterable<never> & {
4258
- readonly byKey: Readonly<{}>;
4259
- get<Key extends never>(key: Key): Readonly<{}>[Key];
4260
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
4261
- }, Readonly<Readonly<{}>> & Iterable<never> & {
4262
- readonly byKey: Readonly<{}>;
4263
- get<Key extends never>(key: Key): Readonly<{}>[Key];
4264
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
4265
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
4266
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
4267
- readonly origin: "kernel.astrale.ai";
4268
- };
4269
- readonly kind: 'node';
4270
- readonly abstract: true;
4271
- }, readonly []> & {
4272
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
4273
- readonly origin: "kernel.astrale.ai";
4274
- };
4275
- readonly key: "kernel.astrale.ai:class.Node";
4276
- }]> & {
4277
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
4278
- readonly origin: "kernel.astrale.ai";
4279
- };
4280
- readonly key: "kernel.astrale.ai:class.Identity";
4281
- }];
4282
- readonly properties: {
4283
- displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
4284
- readonly required: false;
4285
- }>;
4286
- };
4287
- readonly methods: {
4288
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
4289
- readonly description: "Resolve this User and its canonical personal Space.";
4290
- readonly auth: "authenticated";
4291
- readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
4292
- readonly output: import("zod").ZodObject<{
4293
- userId: import("zod").ZodString;
4294
- personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
4295
- }, import("zod/v4/core").$strict>;
4296
- }>;
4297
- };
4298
- }>]>;
4299
- }, import("zod/v4/core").$strict>;
4300
- readonly output: {
4301
- type: 'object';
4302
- properties: {};
4303
- additionalProperties: boolean;
4304
- };
4305
- readonly auth: "authorized";
4306
- readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
4307
- }>;
4308
- };
4309
- }>];
4310
12
  readonly incoming: "0..*";
4311
13
  };
4312
- readonly description: "Shell product membership.";
14
+ readonly constraints: Record<never, never>;
15
+ readonly effectiveProperties: never;
4313
16
  }>;