@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/view.d.ts CHANGED
@@ -1,3291 +1 @@
1
- export declare const groupView: import("@astrale-os/sdk/schema").View<{
2
- readonly description: "Shell Group membership and administration.";
3
- readonly target: import("@astrale-os/sdk/schema").NodeClass<{
4
- readonly description: "A named compositional Shell Identity.";
5
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
6
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
7
- readonly name: "frozen";
8
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
9
- };
10
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
11
- readonly name: "iss";
12
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
13
- };
14
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
15
- claim: string;
16
- op: "contains";
17
- value: unknown;
18
- } | {
19
- claim: string;
20
- op: "eq";
21
- value: unknown;
22
- } | {
23
- claim: string;
24
- op: "exists";
25
- })[], false> & {
26
- readonly name: "requiredClaims";
27
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
28
- };
29
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
30
- readonly name: "sub";
31
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
32
- };
33
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
34
- readonly name: "frozen";
35
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
36
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
37
- readonly name: "iss";
38
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
39
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
40
- claim: string;
41
- op: "contains";
42
- value: unknown;
43
- } | {
44
- claim: string;
45
- op: "eq";
46
- value: unknown;
47
- } | {
48
- claim: string;
49
- op: "exists";
50
- })[], false> & {
51
- readonly name: "requiredClaims";
52
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
53
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
54
- readonly name: "sub";
55
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
56
- })> & {
57
- readonly byKey: Readonly<{
58
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
59
- readonly name: "frozen";
60
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
61
- };
62
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
63
- readonly name: "iss";
64
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
65
- };
66
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
67
- claim: string;
68
- op: "contains";
69
- value: unknown;
70
- } | {
71
- claim: string;
72
- op: "eq";
73
- value: unknown;
74
- } | {
75
- claim: string;
76
- op: "exists";
77
- })[], false> & {
78
- readonly name: "requiredClaims";
79
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
80
- };
81
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
82
- readonly name: "sub";
83
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
84
- };
85
- }>;
86
- 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<{
87
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
88
- readonly name: "frozen";
89
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
90
- };
91
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
92
- readonly name: "iss";
93
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
94
- };
95
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
96
- claim: string;
97
- op: "contains";
98
- value: unknown;
99
- } | {
100
- claim: string;
101
- op: "eq";
102
- value: unknown;
103
- } | {
104
- claim: string;
105
- op: "exists";
106
- })[], false> & {
107
- readonly name: "requiredClaims";
108
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
109
- };
110
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
111
- readonly name: "sub";
112
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
113
- };
114
- }>[Key];
115
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
116
- from(input: Readonly<{
117
- 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;
118
- 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;
119
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
120
- claim: string;
121
- op: "contains";
122
- value: unknown;
123
- } | {
124
- claim: string;
125
- op: "eq";
126
- value: unknown;
127
- } | {
128
- claim: string;
129
- op: "exists";
130
- })[] | undefined;
131
- 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;
132
- } & {
133
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
134
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
135
- readonly requiredClaims?: ({
136
- claim: string;
137
- op: "contains";
138
- value: unknown;
139
- } | {
140
- claim: string;
141
- op: "eq";
142
- value: unknown;
143
- } | {
144
- claim: string;
145
- op: "exists";
146
- })[] | undefined;
147
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
148
- }>): import("@astrale-os/sdk/schema").PropertyValues;
149
- }, Readonly<Readonly<{
150
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
151
- audience: string;
152
- ttlSeconds: number;
153
- attenuation: unknown;
154
- }, {
155
- readonly mode: 'value';
156
- readonly value: string;
157
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
158
- readonly name: "delegate";
159
- };
160
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
161
- audience: string;
162
- ttlSeconds: number;
163
- attenuation: unknown;
164
- }, {
165
- readonly mode: 'value';
166
- readonly value: string;
167
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
168
- readonly name: "delegate";
169
- }> & {
170
- readonly byKey: Readonly<{
171
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
172
- audience: string;
173
- ttlSeconds: number;
174
- attenuation: unknown;
175
- }, {
176
- readonly mode: 'value';
177
- readonly value: string;
178
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
179
- readonly name: "delegate";
180
- };
181
- }>;
182
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
183
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
184
- audience: string;
185
- ttlSeconds: number;
186
- attenuation: unknown;
187
- }, {
188
- readonly mode: 'value';
189
- readonly value: string;
190
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
191
- readonly name: "delegate";
192
- };
193
- }>[Key];
194
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
195
- }, Readonly<Readonly<{
196
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
197
- policy: string;
198
- object: string;
199
- }, {
200
- readonly mode: 'value';
201
- readonly value: {
202
- allowed: boolean;
203
- };
204
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
205
- readonly name: "can";
206
- };
207
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
208
- audience?: string | undefined;
209
- ttlSeconds: number;
210
- grant?: unknown;
211
- }, {
212
- readonly mode: 'value';
213
- readonly value: string;
214
- }, 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"> & {
215
- readonly name: "mint";
216
- };
217
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
218
- readonly mode: 'value';
219
- readonly value: {
220
- id: string;
221
- issuer: string;
222
- subject: string;
223
- frozen: boolean;
224
- requiredClaims: ({
225
- claim: string;
226
- op: "contains";
227
- value: unknown;
228
- } | {
229
- claim: string;
230
- op: "eq";
231
- value: unknown;
232
- } | {
233
- claim: string;
234
- op: "exists";
235
- })[];
236
- };
237
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
238
- readonly name: "whoami";
239
- };
240
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
241
- issuer: string;
242
- subject: string;
243
- }, {
244
- readonly mode: 'value';
245
- readonly value: {
246
- id: string;
247
- issuer: string;
248
- subject: string;
249
- frozen: boolean;
250
- requiredClaims: ({
251
- claim: string;
252
- op: "contains";
253
- value: unknown;
254
- } | {
255
- claim: string;
256
- op: "eq";
257
- value: unknown;
258
- } | {
259
- claim: string;
260
- op: "exists";
261
- })[];
262
- } | null;
263
- }, 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"> & {
264
- readonly name: "whois";
265
- };
266
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
267
- policy: string;
268
- object: string;
269
- }, {
270
- readonly mode: 'value';
271
- readonly value: {
272
- allowed: boolean;
273
- };
274
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
275
- readonly name: "can";
276
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
277
- audience?: string | undefined;
278
- ttlSeconds: number;
279
- grant?: unknown;
280
- }, {
281
- readonly mode: 'value';
282
- readonly value: string;
283
- }, 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"> & {
284
- readonly name: "mint";
285
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
286
- readonly mode: 'value';
287
- readonly value: {
288
- id: string;
289
- issuer: string;
290
- subject: string;
291
- frozen: boolean;
292
- requiredClaims: ({
293
- claim: string;
294
- op: "contains";
295
- value: unknown;
296
- } | {
297
- claim: string;
298
- op: "eq";
299
- value: unknown;
300
- } | {
301
- claim: string;
302
- op: "exists";
303
- })[];
304
- };
305
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
306
- readonly name: "whoami";
307
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
308
- issuer: string;
309
- subject: string;
310
- }, {
311
- readonly mode: 'value';
312
- readonly value: {
313
- id: string;
314
- issuer: string;
315
- subject: string;
316
- frozen: boolean;
317
- requiredClaims: ({
318
- claim: string;
319
- op: "contains";
320
- value: unknown;
321
- } | {
322
- claim: string;
323
- op: "eq";
324
- value: unknown;
325
- } | {
326
- claim: string;
327
- op: "exists";
328
- })[];
329
- } | null;
330
- }, 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"> & {
331
- readonly name: "whois";
332
- })> & {
333
- readonly byKey: Readonly<{
334
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
335
- policy: string;
336
- object: string;
337
- }, {
338
- readonly mode: 'value';
339
- readonly value: {
340
- allowed: boolean;
341
- };
342
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
343
- readonly name: "can";
344
- };
345
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
346
- audience?: string | undefined;
347
- ttlSeconds: number;
348
- grant?: unknown;
349
- }, {
350
- readonly mode: 'value';
351
- readonly value: string;
352
- }, 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"> & {
353
- readonly name: "mint";
354
- };
355
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
356
- readonly mode: 'value';
357
- readonly value: {
358
- id: string;
359
- issuer: string;
360
- subject: string;
361
- frozen: boolean;
362
- requiredClaims: ({
363
- claim: string;
364
- op: "contains";
365
- value: unknown;
366
- } | {
367
- claim: string;
368
- op: "eq";
369
- value: unknown;
370
- } | {
371
- claim: string;
372
- op: "exists";
373
- })[];
374
- };
375
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
376
- readonly name: "whoami";
377
- };
378
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
379
- issuer: string;
380
- subject: string;
381
- }, {
382
- readonly mode: 'value';
383
- readonly value: {
384
- id: string;
385
- issuer: string;
386
- subject: string;
387
- frozen: boolean;
388
- requiredClaims: ({
389
- claim: string;
390
- op: "contains";
391
- value: unknown;
392
- } | {
393
- claim: string;
394
- op: "eq";
395
- value: unknown;
396
- } | {
397
- claim: string;
398
- op: "exists";
399
- })[];
400
- } | null;
401
- }, 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"> & {
402
- readonly name: "whois";
403
- };
404
- }>;
405
- 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<{
406
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
407
- policy: string;
408
- object: string;
409
- }, {
410
- readonly mode: 'value';
411
- readonly value: {
412
- allowed: boolean;
413
- };
414
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
415
- readonly name: "can";
416
- };
417
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
418
- audience?: string | undefined;
419
- ttlSeconds: number;
420
- grant?: unknown;
421
- }, {
422
- readonly mode: 'value';
423
- readonly value: string;
424
- }, 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"> & {
425
- readonly name: "mint";
426
- };
427
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
428
- readonly mode: 'value';
429
- readonly value: {
430
- id: string;
431
- issuer: string;
432
- subject: string;
433
- frozen: boolean;
434
- requiredClaims: ({
435
- claim: string;
436
- op: "contains";
437
- value: unknown;
438
- } | {
439
- claim: string;
440
- op: "eq";
441
- value: unknown;
442
- } | {
443
- claim: string;
444
- op: "exists";
445
- })[];
446
- };
447
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
448
- readonly name: "whoami";
449
- };
450
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
451
- issuer: string;
452
- subject: string;
453
- }, {
454
- readonly mode: 'value';
455
- readonly value: {
456
- id: string;
457
- issuer: string;
458
- subject: string;
459
- frozen: boolean;
460
- requiredClaims: ({
461
- claim: string;
462
- op: "contains";
463
- value: unknown;
464
- } | {
465
- claim: string;
466
- op: "eq";
467
- value: unknown;
468
- } | {
469
- claim: string;
470
- op: "exists";
471
- })[];
472
- } | null;
473
- }, 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"> & {
474
- readonly name: "whois";
475
- };
476
- }>[Key];
477
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
478
- }, Readonly<Readonly<{
479
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
480
- readonly name: "frozen";
481
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
482
- };
483
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
484
- readonly name: "iss";
485
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
486
- };
487
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
488
- claim: string;
489
- op: "contains";
490
- value: unknown;
491
- } | {
492
- claim: string;
493
- op: "eq";
494
- value: unknown;
495
- } | {
496
- claim: string;
497
- op: "exists";
498
- })[], false> & {
499
- readonly name: "requiredClaims";
500
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
501
- };
502
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
503
- readonly name: "sub";
504
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
505
- };
506
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
507
- readonly name: "frozen";
508
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
509
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
510
- readonly name: "iss";
511
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
512
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
513
- claim: string;
514
- op: "contains";
515
- value: unknown;
516
- } | {
517
- claim: string;
518
- op: "eq";
519
- value: unknown;
520
- } | {
521
- claim: string;
522
- op: "exists";
523
- })[], false> & {
524
- readonly name: "requiredClaims";
525
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
526
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
527
- readonly name: "sub";
528
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
529
- })> & {
530
- readonly byKey: Readonly<{
531
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
532
- readonly name: "frozen";
533
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
534
- };
535
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
536
- readonly name: "iss";
537
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
538
- };
539
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
540
- claim: string;
541
- op: "contains";
542
- value: unknown;
543
- } | {
544
- claim: string;
545
- op: "eq";
546
- value: unknown;
547
- } | {
548
- claim: string;
549
- op: "exists";
550
- })[], false> & {
551
- readonly name: "requiredClaims";
552
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
553
- };
554
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
555
- readonly name: "sub";
556
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
557
- };
558
- }>;
559
- 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<{
560
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
561
- readonly name: "frozen";
562
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
563
- };
564
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
565
- readonly name: "iss";
566
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
567
- };
568
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
569
- claim: string;
570
- op: "contains";
571
- value: unknown;
572
- } | {
573
- claim: string;
574
- op: "eq";
575
- value: unknown;
576
- } | {
577
- claim: string;
578
- op: "exists";
579
- })[], false> & {
580
- readonly name: "requiredClaims";
581
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
582
- };
583
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
584
- readonly name: "sub";
585
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
586
- };
587
- }>[Key];
588
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
589
- from(input: Readonly<{
590
- 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;
591
- 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;
592
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
593
- claim: string;
594
- op: "contains";
595
- value: unknown;
596
- } | {
597
- claim: string;
598
- op: "eq";
599
- value: unknown;
600
- } | {
601
- claim: string;
602
- op: "exists";
603
- })[] | undefined;
604
- 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;
605
- } & {
606
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
607
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
608
- readonly requiredClaims?: ({
609
- claim: string;
610
- op: "contains";
611
- value: unknown;
612
- } | {
613
- claim: string;
614
- op: "eq";
615
- value: unknown;
616
- } | {
617
- claim: string;
618
- op: "exists";
619
- })[] | undefined;
620
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
621
- }>): import("@astrale-os/sdk/schema").PropertyValues;
622
- }, Readonly<Readonly<{
623
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
624
- audience: string;
625
- ttlSeconds: number;
626
- attenuation: unknown;
627
- }, {
628
- readonly mode: 'value';
629
- readonly value: string;
630
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
631
- readonly name: "delegate";
632
- };
633
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
634
- audience: string;
635
- ttlSeconds: number;
636
- attenuation: unknown;
637
- }, {
638
- readonly mode: 'value';
639
- readonly value: string;
640
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
641
- readonly name: "delegate";
642
- }> & {
643
- readonly byKey: Readonly<{
644
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
645
- audience: string;
646
- ttlSeconds: number;
647
- attenuation: unknown;
648
- }, {
649
- readonly mode: 'value';
650
- readonly value: string;
651
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
652
- readonly name: "delegate";
653
- };
654
- }>;
655
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
656
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
657
- audience: string;
658
- ttlSeconds: number;
659
- attenuation: unknown;
660
- }, {
661
- readonly mode: 'value';
662
- readonly value: string;
663
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
664
- readonly name: "delegate";
665
- };
666
- }>[Key];
667
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
668
- }, Readonly<Readonly<{
669
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
670
- policy: string;
671
- object: string;
672
- }, {
673
- readonly mode: 'value';
674
- readonly value: {
675
- allowed: boolean;
676
- };
677
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
678
- readonly name: "can";
679
- };
680
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
681
- audience?: string | undefined;
682
- ttlSeconds: number;
683
- grant?: unknown;
684
- }, {
685
- readonly mode: 'value';
686
- readonly value: string;
687
- }, 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"> & {
688
- readonly name: "mint";
689
- };
690
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
691
- readonly mode: 'value';
692
- readonly value: {
693
- id: string;
694
- issuer: string;
695
- subject: string;
696
- frozen: boolean;
697
- requiredClaims: ({
698
- claim: string;
699
- op: "contains";
700
- value: unknown;
701
- } | {
702
- claim: string;
703
- op: "eq";
704
- value: unknown;
705
- } | {
706
- claim: string;
707
- op: "exists";
708
- })[];
709
- };
710
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
711
- readonly name: "whoami";
712
- };
713
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
714
- issuer: string;
715
- subject: string;
716
- }, {
717
- readonly mode: 'value';
718
- readonly value: {
719
- id: string;
720
- issuer: string;
721
- subject: string;
722
- frozen: boolean;
723
- requiredClaims: ({
724
- claim: string;
725
- op: "contains";
726
- value: unknown;
727
- } | {
728
- claim: string;
729
- op: "eq";
730
- value: unknown;
731
- } | {
732
- claim: string;
733
- op: "exists";
734
- })[];
735
- } | null;
736
- }, 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"> & {
737
- readonly name: "whois";
738
- };
739
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
740
- policy: string;
741
- object: string;
742
- }, {
743
- readonly mode: 'value';
744
- readonly value: {
745
- allowed: boolean;
746
- };
747
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
748
- readonly name: "can";
749
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
750
- audience?: string | undefined;
751
- ttlSeconds: number;
752
- grant?: unknown;
753
- }, {
754
- readonly mode: 'value';
755
- readonly value: string;
756
- }, 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"> & {
757
- readonly name: "mint";
758
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
759
- readonly mode: 'value';
760
- readonly value: {
761
- id: string;
762
- issuer: string;
763
- subject: string;
764
- frozen: boolean;
765
- requiredClaims: ({
766
- claim: string;
767
- op: "contains";
768
- value: unknown;
769
- } | {
770
- claim: string;
771
- op: "eq";
772
- value: unknown;
773
- } | {
774
- claim: string;
775
- op: "exists";
776
- })[];
777
- };
778
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
779
- readonly name: "whoami";
780
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
781
- issuer: string;
782
- subject: string;
783
- }, {
784
- readonly mode: 'value';
785
- readonly value: {
786
- id: string;
787
- issuer: string;
788
- subject: string;
789
- frozen: boolean;
790
- requiredClaims: ({
791
- claim: string;
792
- op: "contains";
793
- value: unknown;
794
- } | {
795
- claim: string;
796
- op: "eq";
797
- value: unknown;
798
- } | {
799
- claim: string;
800
- op: "exists";
801
- })[];
802
- } | null;
803
- }, 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"> & {
804
- readonly name: "whois";
805
- })> & {
806
- readonly byKey: Readonly<{
807
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
808
- policy: string;
809
- object: string;
810
- }, {
811
- readonly mode: 'value';
812
- readonly value: {
813
- allowed: boolean;
814
- };
815
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
816
- readonly name: "can";
817
- };
818
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
819
- audience?: string | undefined;
820
- ttlSeconds: number;
821
- grant?: unknown;
822
- }, {
823
- readonly mode: 'value';
824
- readonly value: string;
825
- }, 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"> & {
826
- readonly name: "mint";
827
- };
828
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
829
- readonly mode: 'value';
830
- readonly value: {
831
- id: string;
832
- issuer: string;
833
- subject: string;
834
- frozen: boolean;
835
- requiredClaims: ({
836
- claim: string;
837
- op: "contains";
838
- value: unknown;
839
- } | {
840
- claim: string;
841
- op: "eq";
842
- value: unknown;
843
- } | {
844
- claim: string;
845
- op: "exists";
846
- })[];
847
- };
848
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
849
- readonly name: "whoami";
850
- };
851
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
852
- issuer: string;
853
- subject: string;
854
- }, {
855
- readonly mode: 'value';
856
- readonly value: {
857
- id: string;
858
- issuer: string;
859
- subject: string;
860
- frozen: boolean;
861
- requiredClaims: ({
862
- claim: string;
863
- op: "contains";
864
- value: unknown;
865
- } | {
866
- claim: string;
867
- op: "eq";
868
- value: unknown;
869
- } | {
870
- claim: string;
871
- op: "exists";
872
- })[];
873
- } | null;
874
- }, 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"> & {
875
- readonly name: "whois";
876
- };
877
- }>;
878
- 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<{
879
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
880
- policy: string;
881
- object: string;
882
- }, {
883
- readonly mode: 'value';
884
- readonly value: {
885
- allowed: boolean;
886
- };
887
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
888
- readonly name: "can";
889
- };
890
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
891
- audience?: string | undefined;
892
- ttlSeconds: number;
893
- grant?: unknown;
894
- }, {
895
- readonly mode: 'value';
896
- readonly value: string;
897
- }, 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"> & {
898
- readonly name: "mint";
899
- };
900
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
901
- readonly mode: 'value';
902
- readonly value: {
903
- id: string;
904
- issuer: string;
905
- subject: string;
906
- frozen: boolean;
907
- requiredClaims: ({
908
- claim: string;
909
- op: "contains";
910
- value: unknown;
911
- } | {
912
- claim: string;
913
- op: "eq";
914
- value: unknown;
915
- } | {
916
- claim: string;
917
- op: "exists";
918
- })[];
919
- };
920
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
921
- readonly name: "whoami";
922
- };
923
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
924
- issuer: string;
925
- subject: string;
926
- }, {
927
- readonly mode: 'value';
928
- readonly value: {
929
- id: string;
930
- issuer: string;
931
- subject: string;
932
- frozen: boolean;
933
- requiredClaims: ({
934
- claim: string;
935
- op: "contains";
936
- value: unknown;
937
- } | {
938
- claim: string;
939
- op: "eq";
940
- value: unknown;
941
- } | {
942
- claim: string;
943
- op: "exists";
944
- })[];
945
- } | null;
946
- }, 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"> & {
947
- readonly name: "whois";
948
- };
949
- }>[Key];
950
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
951
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
952
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
953
- readonly origin: "kernel.astrale.ai";
954
- };
955
- readonly kind: 'node';
956
- readonly abstract: true;
957
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
958
- readonly byKey: Readonly<{}>;
959
- get<Key extends never>(key: Key): Readonly<{}>[Key];
960
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
961
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
962
- }, Readonly<Readonly<{}>> & Iterable<never> & {
963
- readonly byKey: Readonly<{}>;
964
- get<Key extends never>(key: Key): Readonly<{}>[Key];
965
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
966
- }, Readonly<Readonly<{}>> & Iterable<never> & {
967
- readonly byKey: Readonly<{}>;
968
- get<Key extends never>(key: Key): Readonly<{}>[Key];
969
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
970
- }, Readonly<Readonly<{}>> & Iterable<never> & {
971
- readonly byKey: Readonly<{}>;
972
- get<Key extends never>(key: Key): Readonly<{}>[Key];
973
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
974
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
975
- }, Readonly<Readonly<{}>> & Iterable<never> & {
976
- readonly byKey: Readonly<{}>;
977
- get<Key extends never>(key: Key): Readonly<{}>[Key];
978
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
979
- }, Readonly<Readonly<{}>> & Iterable<never> & {
980
- readonly byKey: Readonly<{}>;
981
- get<Key extends never>(key: Key): Readonly<{}>[Key];
982
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
983
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
984
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
985
- readonly origin: "kernel.astrale.ai";
986
- };
987
- readonly kind: 'node';
988
- readonly abstract: true;
989
- }, readonly []> & {
990
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
991
- readonly origin: "kernel.astrale.ai";
992
- };
993
- readonly key: "kernel.astrale.ai:class.Node";
994
- }]> & {
995
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
996
- readonly origin: "kernel.astrale.ai";
997
- };
998
- readonly key: "kernel.astrale.ai:class.Identity";
999
- }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
1000
- name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1001
- readonly name: "name";
1002
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1003
- };
1004
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1005
- readonly name: "name";
1006
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1007
- }> & {
1008
- readonly byKey: Readonly<{
1009
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1010
- readonly name: "name";
1011
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1012
- };
1013
- }>;
1014
- get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
1015
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1016
- readonly name: "name";
1017
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1018
- };
1019
- }>[Key];
1020
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1021
- from(input: Readonly<{
1022
- 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;
1023
- } & {
1024
- readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1025
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1026
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1027
- readonly byKey: Readonly<{}>;
1028
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1029
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1030
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1031
- readonly byKey: Readonly<{}>;
1032
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1033
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1034
- }, Readonly<Readonly<{
1035
- name: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1036
- readonly name: "name";
1037
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1038
- };
1039
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1040
- readonly name: "name";
1041
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1042
- }> & {
1043
- readonly byKey: Readonly<{
1044
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1045
- readonly name: "name";
1046
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1047
- };
1048
- }>;
1049
- get<Key extends "kernel.astrale.ai:class.Named.property.name">(key: Key): Readonly<{
1050
- "kernel.astrale.ai:class.Named.property.name": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1051
- readonly name: "name";
1052
- readonly key: "kernel.astrale.ai:class.Named.property.name";
1053
- };
1054
- }>[Key];
1055
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1056
- from(input: Readonly<{
1057
- 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;
1058
- } & {
1059
- readonly name?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1060
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1061
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1062
- readonly byKey: Readonly<{}>;
1063
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1064
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1065
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1066
- readonly byKey: Readonly<{}>;
1067
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1068
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1069
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
1070
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
1071
- readonly origin: "kernel.astrale.ai";
1072
- };
1073
- readonly kind: 'node';
1074
- readonly abstract: true;
1075
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
1076
- readonly byKey: Readonly<{}>;
1077
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1078
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1079
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
1080
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1081
- readonly byKey: Readonly<{}>;
1082
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1083
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1084
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1085
- readonly byKey: Readonly<{}>;
1086
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1087
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1088
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1089
- readonly byKey: Readonly<{}>;
1090
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1091
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1092
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
1093
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1094
- readonly byKey: Readonly<{}>;
1095
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1096
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1097
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1098
- readonly byKey: Readonly<{}>;
1099
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1100
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1101
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
1102
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
1103
- readonly origin: "kernel.astrale.ai";
1104
- };
1105
- readonly kind: 'node';
1106
- readonly abstract: true;
1107
- }, readonly []> & {
1108
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
1109
- readonly origin: "kernel.astrale.ai";
1110
- };
1111
- readonly key: "kernel.astrale.ai:class.Node";
1112
- }]> & {
1113
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Named"> & {
1114
- readonly origin: "kernel.astrale.ai";
1115
- };
1116
- readonly key: "kernel.astrale.ai:class.Named";
1117
- }, import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
1118
- description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1119
- readonly name: "description";
1120
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1121
- };
1122
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1123
- readonly name: "description";
1124
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1125
- }> & {
1126
- readonly byKey: Readonly<{
1127
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1128
- readonly name: "description";
1129
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1130
- };
1131
- }>;
1132
- get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
1133
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1134
- readonly name: "description";
1135
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1136
- };
1137
- }>[Key];
1138
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1139
- from(input: Readonly<{
1140
- 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;
1141
- } & {
1142
- readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1143
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1144
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1145
- readonly byKey: Readonly<{}>;
1146
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1147
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1148
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1149
- readonly byKey: Readonly<{}>;
1150
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1151
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1152
- }, Readonly<Readonly<{
1153
- description: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1154
- readonly name: "description";
1155
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1156
- };
1157
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1158
- readonly name: "description";
1159
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1160
- }> & {
1161
- readonly byKey: Readonly<{
1162
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1163
- readonly name: "description";
1164
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1165
- };
1166
- }>;
1167
- get<Key extends "kernel.astrale.ai:class.Descriptable.property.description">(key: Key): Readonly<{
1168
- "kernel.astrale.ai:class.Descriptable.property.description": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1169
- readonly name: "description";
1170
- readonly key: "kernel.astrale.ai:class.Descriptable.property.description";
1171
- };
1172
- }>[Key];
1173
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1174
- from(input: Readonly<{
1175
- 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;
1176
- } & {
1177
- readonly description?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1178
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1179
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1180
- readonly byKey: Readonly<{}>;
1181
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1182
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1183
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1184
- readonly byKey: Readonly<{}>;
1185
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1186
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1187
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
1188
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
1189
- readonly origin: "kernel.astrale.ai";
1190
- };
1191
- readonly kind: 'node';
1192
- readonly abstract: true;
1193
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
1194
- readonly byKey: Readonly<{}>;
1195
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1196
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1197
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
1198
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1199
- readonly byKey: Readonly<{}>;
1200
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1201
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1202
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1203
- readonly byKey: Readonly<{}>;
1204
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1205
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1206
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1207
- readonly byKey: Readonly<{}>;
1208
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1209
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1210
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
1211
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1212
- readonly byKey: Readonly<{}>;
1213
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1214
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1215
- }, Readonly<Readonly<{}>> & Iterable<never> & {
1216
- readonly byKey: Readonly<{}>;
1217
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1218
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1219
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
1220
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
1221
- readonly origin: "kernel.astrale.ai";
1222
- };
1223
- readonly kind: 'node';
1224
- readonly abstract: true;
1225
- }, readonly []> & {
1226
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
1227
- readonly origin: "kernel.astrale.ai";
1228
- };
1229
- readonly key: "kernel.astrale.ai:class.Node";
1230
- }]> & {
1231
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Descriptable"> & {
1232
- readonly origin: "kernel.astrale.ai";
1233
- };
1234
- readonly key: "kernel.astrale.ai:class.Descriptable";
1235
- }];
1236
- readonly methods: {
1237
- assignUser: import("@astrale-os/sdk/schema").Method<{
1238
- readonly description: string;
1239
- readonly input: import("zod").ZodObject<{
1240
- user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
1241
- readonly description: "One externally identified person using Shell.";
1242
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
1243
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1244
- readonly name: "frozen";
1245
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1246
- };
1247
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1248
- readonly name: "iss";
1249
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1250
- };
1251
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
1252
- claim: string;
1253
- op: "contains";
1254
- value: unknown;
1255
- } | {
1256
- claim: string;
1257
- op: "eq";
1258
- value: unknown;
1259
- } | {
1260
- claim: string;
1261
- op: "exists";
1262
- })[], false> & {
1263
- readonly name: "requiredClaims";
1264
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1265
- };
1266
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1267
- readonly name: "sub";
1268
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1269
- };
1270
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1271
- readonly name: "frozen";
1272
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1273
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1274
- readonly name: "iss";
1275
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1276
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
1277
- claim: string;
1278
- op: "contains";
1279
- value: unknown;
1280
- } | {
1281
- claim: string;
1282
- op: "eq";
1283
- value: unknown;
1284
- } | {
1285
- claim: string;
1286
- op: "exists";
1287
- })[], false> & {
1288
- readonly name: "requiredClaims";
1289
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1290
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1291
- readonly name: "sub";
1292
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1293
- })> & {
1294
- readonly byKey: Readonly<{
1295
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1296
- readonly name: "frozen";
1297
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1298
- };
1299
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1300
- readonly name: "iss";
1301
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1302
- };
1303
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1304
- claim: string;
1305
- op: "contains";
1306
- value: unknown;
1307
- } | {
1308
- claim: string;
1309
- op: "eq";
1310
- value: unknown;
1311
- } | {
1312
- claim: string;
1313
- op: "exists";
1314
- })[], false> & {
1315
- readonly name: "requiredClaims";
1316
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1317
- };
1318
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1319
- readonly name: "sub";
1320
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1321
- };
1322
- }>;
1323
- 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<{
1324
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1325
- readonly name: "frozen";
1326
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1327
- };
1328
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1329
- readonly name: "iss";
1330
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1331
- };
1332
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1333
- claim: string;
1334
- op: "contains";
1335
- value: unknown;
1336
- } | {
1337
- claim: string;
1338
- op: "eq";
1339
- value: unknown;
1340
- } | {
1341
- claim: string;
1342
- op: "exists";
1343
- })[], false> & {
1344
- readonly name: "requiredClaims";
1345
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1346
- };
1347
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1348
- readonly name: "sub";
1349
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1350
- };
1351
- }>[Key];
1352
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1353
- from(input: Readonly<{
1354
- 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;
1355
- 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;
1356
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
1357
- claim: string;
1358
- op: "contains";
1359
- value: unknown;
1360
- } | {
1361
- claim: string;
1362
- op: "eq";
1363
- value: unknown;
1364
- } | {
1365
- claim: string;
1366
- op: "exists";
1367
- })[] | undefined;
1368
- 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;
1369
- } & {
1370
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1371
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1372
- readonly requiredClaims?: ({
1373
- claim: string;
1374
- op: "contains";
1375
- value: unknown;
1376
- } | {
1377
- claim: string;
1378
- op: "eq";
1379
- value: unknown;
1380
- } | {
1381
- claim: string;
1382
- op: "exists";
1383
- })[] | undefined;
1384
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1385
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1386
- }, Readonly<Readonly<{
1387
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
1388
- audience: string;
1389
- ttlSeconds: number;
1390
- attenuation: unknown;
1391
- }, {
1392
- readonly mode: 'value';
1393
- readonly value: string;
1394
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1395
- readonly name: "delegate";
1396
- };
1397
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
1398
- audience: string;
1399
- ttlSeconds: number;
1400
- attenuation: unknown;
1401
- }, {
1402
- readonly mode: 'value';
1403
- readonly value: string;
1404
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1405
- readonly name: "delegate";
1406
- }> & {
1407
- readonly byKey: Readonly<{
1408
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1409
- audience: string;
1410
- ttlSeconds: number;
1411
- attenuation: unknown;
1412
- }, {
1413
- readonly mode: 'value';
1414
- readonly value: string;
1415
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1416
- readonly name: "delegate";
1417
- };
1418
- }>;
1419
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
1420
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1421
- audience: string;
1422
- ttlSeconds: number;
1423
- attenuation: unknown;
1424
- }, {
1425
- readonly mode: 'value';
1426
- readonly value: string;
1427
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1428
- readonly name: "delegate";
1429
- };
1430
- }>[Key];
1431
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1432
- }, Readonly<Readonly<{
1433
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
1434
- policy: string;
1435
- object: string;
1436
- }, {
1437
- readonly mode: 'value';
1438
- readonly value: {
1439
- allowed: boolean;
1440
- };
1441
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1442
- readonly name: "can";
1443
- };
1444
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
1445
- audience?: string | undefined;
1446
- ttlSeconds: number;
1447
- grant?: unknown;
1448
- }, {
1449
- readonly mode: 'value';
1450
- readonly value: string;
1451
- }, 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"> & {
1452
- readonly name: "mint";
1453
- };
1454
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1455
- readonly mode: 'value';
1456
- readonly value: {
1457
- id: string;
1458
- issuer: string;
1459
- subject: string;
1460
- frozen: boolean;
1461
- requiredClaims: ({
1462
- claim: string;
1463
- op: "contains";
1464
- value: unknown;
1465
- } | {
1466
- claim: string;
1467
- op: "eq";
1468
- value: unknown;
1469
- } | {
1470
- claim: string;
1471
- op: "exists";
1472
- })[];
1473
- };
1474
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1475
- readonly name: "whoami";
1476
- };
1477
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
1478
- issuer: string;
1479
- subject: string;
1480
- }, {
1481
- readonly mode: 'value';
1482
- readonly value: {
1483
- id: string;
1484
- issuer: string;
1485
- subject: string;
1486
- frozen: boolean;
1487
- requiredClaims: ({
1488
- claim: string;
1489
- op: "contains";
1490
- value: unknown;
1491
- } | {
1492
- claim: string;
1493
- op: "eq";
1494
- value: unknown;
1495
- } | {
1496
- claim: string;
1497
- op: "exists";
1498
- })[];
1499
- } | null;
1500
- }, 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"> & {
1501
- readonly name: "whois";
1502
- };
1503
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
1504
- policy: string;
1505
- object: string;
1506
- }, {
1507
- readonly mode: 'value';
1508
- readonly value: {
1509
- allowed: boolean;
1510
- };
1511
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1512
- readonly name: "can";
1513
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1514
- audience?: string | undefined;
1515
- ttlSeconds: number;
1516
- grant?: unknown;
1517
- }, {
1518
- readonly mode: 'value';
1519
- readonly value: string;
1520
- }, 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"> & {
1521
- readonly name: "mint";
1522
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1523
- readonly mode: 'value';
1524
- readonly value: {
1525
- id: string;
1526
- issuer: string;
1527
- subject: string;
1528
- frozen: boolean;
1529
- requiredClaims: ({
1530
- claim: string;
1531
- op: "contains";
1532
- value: unknown;
1533
- } | {
1534
- claim: string;
1535
- op: "eq";
1536
- value: unknown;
1537
- } | {
1538
- claim: string;
1539
- op: "exists";
1540
- })[];
1541
- };
1542
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1543
- readonly name: "whoami";
1544
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1545
- issuer: string;
1546
- subject: string;
1547
- }, {
1548
- readonly mode: 'value';
1549
- readonly value: {
1550
- id: string;
1551
- issuer: string;
1552
- subject: string;
1553
- frozen: boolean;
1554
- requiredClaims: ({
1555
- claim: string;
1556
- op: "contains";
1557
- value: unknown;
1558
- } | {
1559
- claim: string;
1560
- op: "eq";
1561
- value: unknown;
1562
- } | {
1563
- claim: string;
1564
- op: "exists";
1565
- })[];
1566
- } | null;
1567
- }, 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"> & {
1568
- readonly name: "whois";
1569
- })> & {
1570
- readonly byKey: Readonly<{
1571
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1572
- policy: string;
1573
- object: string;
1574
- }, {
1575
- readonly mode: 'value';
1576
- readonly value: {
1577
- allowed: boolean;
1578
- };
1579
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1580
- readonly name: "can";
1581
- };
1582
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1583
- audience?: string | undefined;
1584
- ttlSeconds: number;
1585
- grant?: unknown;
1586
- }, {
1587
- readonly mode: 'value';
1588
- readonly value: string;
1589
- }, 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"> & {
1590
- readonly name: "mint";
1591
- };
1592
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1593
- readonly mode: 'value';
1594
- readonly value: {
1595
- id: string;
1596
- issuer: string;
1597
- subject: string;
1598
- frozen: boolean;
1599
- requiredClaims: ({
1600
- claim: string;
1601
- op: "contains";
1602
- value: unknown;
1603
- } | {
1604
- claim: string;
1605
- op: "eq";
1606
- value: unknown;
1607
- } | {
1608
- claim: string;
1609
- op: "exists";
1610
- })[];
1611
- };
1612
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1613
- readonly name: "whoami";
1614
- };
1615
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1616
- issuer: string;
1617
- subject: string;
1618
- }, {
1619
- readonly mode: 'value';
1620
- readonly value: {
1621
- id: string;
1622
- issuer: string;
1623
- subject: string;
1624
- frozen: boolean;
1625
- requiredClaims: ({
1626
- claim: string;
1627
- op: "contains";
1628
- value: unknown;
1629
- } | {
1630
- claim: string;
1631
- op: "eq";
1632
- value: unknown;
1633
- } | {
1634
- claim: string;
1635
- op: "exists";
1636
- })[];
1637
- } | null;
1638
- }, 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"> & {
1639
- readonly name: "whois";
1640
- };
1641
- }>;
1642
- 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<{
1643
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1644
- policy: string;
1645
- object: string;
1646
- }, {
1647
- readonly mode: 'value';
1648
- readonly value: {
1649
- allowed: boolean;
1650
- };
1651
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1652
- readonly name: "can";
1653
- };
1654
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1655
- audience?: string | undefined;
1656
- ttlSeconds: number;
1657
- grant?: unknown;
1658
- }, {
1659
- readonly mode: 'value';
1660
- readonly value: string;
1661
- }, 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"> & {
1662
- readonly name: "mint";
1663
- };
1664
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1665
- readonly mode: 'value';
1666
- readonly value: {
1667
- id: string;
1668
- issuer: string;
1669
- subject: string;
1670
- frozen: boolean;
1671
- requiredClaims: ({
1672
- claim: string;
1673
- op: "contains";
1674
- value: unknown;
1675
- } | {
1676
- claim: string;
1677
- op: "eq";
1678
- value: unknown;
1679
- } | {
1680
- claim: string;
1681
- op: "exists";
1682
- })[];
1683
- };
1684
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1685
- readonly name: "whoami";
1686
- };
1687
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1688
- issuer: string;
1689
- subject: string;
1690
- }, {
1691
- readonly mode: 'value';
1692
- readonly value: {
1693
- id: string;
1694
- issuer: string;
1695
- subject: string;
1696
- frozen: boolean;
1697
- requiredClaims: ({
1698
- claim: string;
1699
- op: "contains";
1700
- value: unknown;
1701
- } | {
1702
- claim: string;
1703
- op: "eq";
1704
- value: unknown;
1705
- } | {
1706
- claim: string;
1707
- op: "exists";
1708
- })[];
1709
- } | null;
1710
- }, 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"> & {
1711
- readonly name: "whois";
1712
- };
1713
- }>[Key];
1714
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1715
- }, Readonly<Readonly<{
1716
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1717
- readonly name: "frozen";
1718
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1719
- };
1720
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1721
- readonly name: "iss";
1722
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1723
- };
1724
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
1725
- claim: string;
1726
- op: "contains";
1727
- value: unknown;
1728
- } | {
1729
- claim: string;
1730
- op: "eq";
1731
- value: unknown;
1732
- } | {
1733
- claim: string;
1734
- op: "exists";
1735
- })[], false> & {
1736
- readonly name: "requiredClaims";
1737
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1738
- };
1739
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1740
- readonly name: "sub";
1741
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1742
- };
1743
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1744
- readonly name: "frozen";
1745
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1746
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1747
- readonly name: "iss";
1748
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1749
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
1750
- claim: string;
1751
- op: "contains";
1752
- value: unknown;
1753
- } | {
1754
- claim: string;
1755
- op: "eq";
1756
- value: unknown;
1757
- } | {
1758
- claim: string;
1759
- op: "exists";
1760
- })[], false> & {
1761
- readonly name: "requiredClaims";
1762
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1763
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1764
- readonly name: "sub";
1765
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1766
- })> & {
1767
- readonly byKey: Readonly<{
1768
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1769
- readonly name: "frozen";
1770
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1771
- };
1772
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1773
- readonly name: "iss";
1774
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1775
- };
1776
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1777
- claim: string;
1778
- op: "contains";
1779
- value: unknown;
1780
- } | {
1781
- claim: string;
1782
- op: "eq";
1783
- value: unknown;
1784
- } | {
1785
- claim: string;
1786
- op: "exists";
1787
- })[], false> & {
1788
- readonly name: "requiredClaims";
1789
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1790
- };
1791
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1792
- readonly name: "sub";
1793
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1794
- };
1795
- }>;
1796
- 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<{
1797
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1798
- readonly name: "frozen";
1799
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1800
- };
1801
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1802
- readonly name: "iss";
1803
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1804
- };
1805
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1806
- claim: string;
1807
- op: "contains";
1808
- value: unknown;
1809
- } | {
1810
- claim: string;
1811
- op: "eq";
1812
- value: unknown;
1813
- } | {
1814
- claim: string;
1815
- op: "exists";
1816
- })[], false> & {
1817
- readonly name: "requiredClaims";
1818
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1819
- };
1820
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1821
- readonly name: "sub";
1822
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1823
- };
1824
- }>[Key];
1825
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1826
- from(input: Readonly<{
1827
- 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;
1828
- 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;
1829
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
1830
- claim: string;
1831
- op: "contains";
1832
- value: unknown;
1833
- } | {
1834
- claim: string;
1835
- op: "eq";
1836
- value: unknown;
1837
- } | {
1838
- claim: string;
1839
- op: "exists";
1840
- })[] | undefined;
1841
- 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;
1842
- } & {
1843
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1844
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1845
- readonly requiredClaims?: ({
1846
- claim: string;
1847
- op: "contains";
1848
- value: unknown;
1849
- } | {
1850
- claim: string;
1851
- op: "eq";
1852
- value: unknown;
1853
- } | {
1854
- claim: string;
1855
- op: "exists";
1856
- })[] | undefined;
1857
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1858
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1859
- }, Readonly<Readonly<{
1860
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
1861
- audience: string;
1862
- ttlSeconds: number;
1863
- attenuation: unknown;
1864
- }, {
1865
- readonly mode: 'value';
1866
- readonly value: string;
1867
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1868
- readonly name: "delegate";
1869
- };
1870
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
1871
- audience: string;
1872
- ttlSeconds: number;
1873
- attenuation: unknown;
1874
- }, {
1875
- readonly mode: 'value';
1876
- readonly value: string;
1877
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1878
- readonly name: "delegate";
1879
- }> & {
1880
- readonly byKey: Readonly<{
1881
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1882
- audience: string;
1883
- ttlSeconds: number;
1884
- attenuation: unknown;
1885
- }, {
1886
- readonly mode: 'value';
1887
- readonly value: string;
1888
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1889
- readonly name: "delegate";
1890
- };
1891
- }>;
1892
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
1893
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1894
- audience: string;
1895
- ttlSeconds: number;
1896
- attenuation: unknown;
1897
- }, {
1898
- readonly mode: 'value';
1899
- readonly value: string;
1900
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1901
- readonly name: "delegate";
1902
- };
1903
- }>[Key];
1904
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1905
- }, Readonly<Readonly<{
1906
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
1907
- policy: string;
1908
- object: string;
1909
- }, {
1910
- readonly mode: 'value';
1911
- readonly value: {
1912
- allowed: boolean;
1913
- };
1914
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1915
- readonly name: "can";
1916
- };
1917
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
1918
- audience?: string | undefined;
1919
- ttlSeconds: number;
1920
- grant?: unknown;
1921
- }, {
1922
- readonly mode: 'value';
1923
- readonly value: string;
1924
- }, 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"> & {
1925
- readonly name: "mint";
1926
- };
1927
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1928
- readonly mode: 'value';
1929
- readonly value: {
1930
- id: string;
1931
- issuer: string;
1932
- subject: string;
1933
- frozen: boolean;
1934
- requiredClaims: ({
1935
- claim: string;
1936
- op: "contains";
1937
- value: unknown;
1938
- } | {
1939
- claim: string;
1940
- op: "eq";
1941
- value: unknown;
1942
- } | {
1943
- claim: string;
1944
- op: "exists";
1945
- })[];
1946
- };
1947
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1948
- readonly name: "whoami";
1949
- };
1950
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
1951
- issuer: string;
1952
- subject: string;
1953
- }, {
1954
- readonly mode: 'value';
1955
- readonly value: {
1956
- id: string;
1957
- issuer: string;
1958
- subject: string;
1959
- frozen: boolean;
1960
- requiredClaims: ({
1961
- claim: string;
1962
- op: "contains";
1963
- value: unknown;
1964
- } | {
1965
- claim: string;
1966
- op: "eq";
1967
- value: unknown;
1968
- } | {
1969
- claim: string;
1970
- op: "exists";
1971
- })[];
1972
- } | null;
1973
- }, 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"> & {
1974
- readonly name: "whois";
1975
- };
1976
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
1977
- policy: string;
1978
- object: string;
1979
- }, {
1980
- readonly mode: 'value';
1981
- readonly value: {
1982
- allowed: boolean;
1983
- };
1984
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1985
- readonly name: "can";
1986
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1987
- audience?: string | undefined;
1988
- ttlSeconds: number;
1989
- grant?: unknown;
1990
- }, {
1991
- readonly mode: 'value';
1992
- readonly value: string;
1993
- }, 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"> & {
1994
- readonly name: "mint";
1995
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1996
- readonly mode: 'value';
1997
- readonly value: {
1998
- id: string;
1999
- issuer: string;
2000
- subject: string;
2001
- frozen: boolean;
2002
- requiredClaims: ({
2003
- claim: string;
2004
- op: "contains";
2005
- value: unknown;
2006
- } | {
2007
- claim: string;
2008
- op: "eq";
2009
- value: unknown;
2010
- } | {
2011
- claim: string;
2012
- op: "exists";
2013
- })[];
2014
- };
2015
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2016
- readonly name: "whoami";
2017
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
2018
- issuer: string;
2019
- subject: string;
2020
- }, {
2021
- readonly mode: 'value';
2022
- readonly value: {
2023
- id: string;
2024
- issuer: string;
2025
- subject: string;
2026
- frozen: boolean;
2027
- requiredClaims: ({
2028
- claim: string;
2029
- op: "contains";
2030
- value: unknown;
2031
- } | {
2032
- claim: string;
2033
- op: "eq";
2034
- value: unknown;
2035
- } | {
2036
- claim: string;
2037
- op: "exists";
2038
- })[];
2039
- } | null;
2040
- }, 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"> & {
2041
- readonly name: "whois";
2042
- })> & {
2043
- readonly byKey: Readonly<{
2044
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
2045
- policy: string;
2046
- object: string;
2047
- }, {
2048
- readonly mode: 'value';
2049
- readonly value: {
2050
- allowed: boolean;
2051
- };
2052
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2053
- readonly name: "can";
2054
- };
2055
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
2056
- audience?: string | undefined;
2057
- ttlSeconds: number;
2058
- grant?: unknown;
2059
- }, {
2060
- readonly mode: 'value';
2061
- readonly value: string;
2062
- }, 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"> & {
2063
- readonly name: "mint";
2064
- };
2065
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2066
- readonly mode: 'value';
2067
- readonly value: {
2068
- id: string;
2069
- issuer: string;
2070
- subject: string;
2071
- frozen: boolean;
2072
- requiredClaims: ({
2073
- claim: string;
2074
- op: "contains";
2075
- value: unknown;
2076
- } | {
2077
- claim: string;
2078
- op: "eq";
2079
- value: unknown;
2080
- } | {
2081
- claim: string;
2082
- op: "exists";
2083
- })[];
2084
- };
2085
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2086
- readonly name: "whoami";
2087
- };
2088
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
2089
- issuer: string;
2090
- subject: string;
2091
- }, {
2092
- readonly mode: 'value';
2093
- readonly value: {
2094
- id: string;
2095
- issuer: string;
2096
- subject: string;
2097
- frozen: boolean;
2098
- requiredClaims: ({
2099
- claim: string;
2100
- op: "contains";
2101
- value: unknown;
2102
- } | {
2103
- claim: string;
2104
- op: "eq";
2105
- value: unknown;
2106
- } | {
2107
- claim: string;
2108
- op: "exists";
2109
- })[];
2110
- } | null;
2111
- }, 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"> & {
2112
- readonly name: "whois";
2113
- };
2114
- }>;
2115
- 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<{
2116
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
2117
- policy: string;
2118
- object: string;
2119
- }, {
2120
- readonly mode: 'value';
2121
- readonly value: {
2122
- allowed: boolean;
2123
- };
2124
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2125
- readonly name: "can";
2126
- };
2127
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
2128
- audience?: string | undefined;
2129
- ttlSeconds: number;
2130
- grant?: unknown;
2131
- }, {
2132
- readonly mode: 'value';
2133
- readonly value: string;
2134
- }, 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"> & {
2135
- readonly name: "mint";
2136
- };
2137
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2138
- readonly mode: 'value';
2139
- readonly value: {
2140
- id: string;
2141
- issuer: string;
2142
- subject: string;
2143
- frozen: boolean;
2144
- requiredClaims: ({
2145
- claim: string;
2146
- op: "contains";
2147
- value: unknown;
2148
- } | {
2149
- claim: string;
2150
- op: "eq";
2151
- value: unknown;
2152
- } | {
2153
- claim: string;
2154
- op: "exists";
2155
- })[];
2156
- };
2157
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2158
- readonly name: "whoami";
2159
- };
2160
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
2161
- issuer: string;
2162
- subject: string;
2163
- }, {
2164
- readonly mode: 'value';
2165
- readonly value: {
2166
- id: string;
2167
- issuer: string;
2168
- subject: string;
2169
- frozen: boolean;
2170
- requiredClaims: ({
2171
- claim: string;
2172
- op: "contains";
2173
- value: unknown;
2174
- } | {
2175
- claim: string;
2176
- op: "eq";
2177
- value: unknown;
2178
- } | {
2179
- claim: string;
2180
- op: "exists";
2181
- })[];
2182
- } | null;
2183
- }, 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"> & {
2184
- readonly name: "whois";
2185
- };
2186
- }>[Key];
2187
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2188
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2189
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
2190
- readonly origin: "kernel.astrale.ai";
2191
- };
2192
- readonly kind: 'node';
2193
- readonly abstract: true;
2194
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
2195
- readonly byKey: Readonly<{}>;
2196
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2197
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2198
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2199
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2200
- readonly byKey: Readonly<{}>;
2201
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2202
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2203
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2204
- readonly byKey: Readonly<{}>;
2205
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2206
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2207
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2208
- readonly byKey: Readonly<{}>;
2209
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2210
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2211
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2212
- }, 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").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2216
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2217
- readonly byKey: Readonly<{}>;
2218
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2219
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2220
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2221
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2222
- readonly origin: "kernel.astrale.ai";
2223
- };
2224
- readonly kind: 'node';
2225
- readonly abstract: true;
2226
- }, readonly []> & {
2227
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2228
- readonly origin: "kernel.astrale.ai";
2229
- };
2230
- readonly key: "kernel.astrale.ai:class.Node";
2231
- }]> & {
2232
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
2233
- readonly origin: "kernel.astrale.ai";
2234
- };
2235
- readonly key: "kernel.astrale.ai:class.Identity";
2236
- }];
2237
- readonly properties: {
2238
- displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
2239
- readonly required: false;
2240
- }>;
2241
- };
2242
- readonly methods: {
2243
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
2244
- readonly description: "Resolve this User and its canonical personal Space.";
2245
- readonly auth: "authenticated";
2246
- readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
2247
- readonly output: import("zod").ZodObject<{
2248
- userId: import("zod").ZodString;
2249
- personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
2250
- }, import("zod/v4/core").$strict>;
2251
- }>;
2252
- };
2253
- }>]>;
2254
- }, import("zod/v4/core").$strict>;
2255
- readonly output: {
2256
- type: 'object';
2257
- properties: {};
2258
- additionalProperties: boolean;
2259
- };
2260
- readonly auth: "authorized";
2261
- readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
2262
- }>;
2263
- unassignUser: import("@astrale-os/sdk/schema").Method<{
2264
- readonly description: string;
2265
- readonly input: import("zod").ZodObject<{
2266
- user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
2267
- readonly description: "One externally identified person using Shell.";
2268
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
2269
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2270
- readonly name: "frozen";
2271
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2272
- };
2273
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2274
- readonly name: "iss";
2275
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2276
- };
2277
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
2278
- claim: string;
2279
- op: "contains";
2280
- value: unknown;
2281
- } | {
2282
- claim: string;
2283
- op: "eq";
2284
- value: unknown;
2285
- } | {
2286
- claim: string;
2287
- op: "exists";
2288
- })[], false> & {
2289
- readonly name: "requiredClaims";
2290
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2291
- };
2292
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2293
- readonly name: "sub";
2294
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2295
- };
2296
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2297
- readonly name: "frozen";
2298
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2299
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2300
- readonly name: "iss";
2301
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2302
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
2303
- claim: string;
2304
- op: "contains";
2305
- value: unknown;
2306
- } | {
2307
- claim: string;
2308
- op: "eq";
2309
- value: unknown;
2310
- } | {
2311
- claim: string;
2312
- op: "exists";
2313
- })[], false> & {
2314
- readonly name: "requiredClaims";
2315
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2316
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2317
- readonly name: "sub";
2318
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2319
- })> & {
2320
- readonly byKey: Readonly<{
2321
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2322
- readonly name: "frozen";
2323
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2324
- };
2325
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2326
- readonly name: "iss";
2327
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2328
- };
2329
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2330
- claim: string;
2331
- op: "contains";
2332
- value: unknown;
2333
- } | {
2334
- claim: string;
2335
- op: "eq";
2336
- value: unknown;
2337
- } | {
2338
- claim: string;
2339
- op: "exists";
2340
- })[], false> & {
2341
- readonly name: "requiredClaims";
2342
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2343
- };
2344
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2345
- readonly name: "sub";
2346
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2347
- };
2348
- }>;
2349
- 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<{
2350
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2351
- readonly name: "frozen";
2352
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2353
- };
2354
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2355
- readonly name: "iss";
2356
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2357
- };
2358
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2359
- claim: string;
2360
- op: "contains";
2361
- value: unknown;
2362
- } | {
2363
- claim: string;
2364
- op: "eq";
2365
- value: unknown;
2366
- } | {
2367
- claim: string;
2368
- op: "exists";
2369
- })[], false> & {
2370
- readonly name: "requiredClaims";
2371
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2372
- };
2373
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2374
- readonly name: "sub";
2375
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2376
- };
2377
- }>[Key];
2378
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2379
- from(input: Readonly<{
2380
- 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;
2381
- 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;
2382
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
2383
- claim: string;
2384
- op: "contains";
2385
- value: unknown;
2386
- } | {
2387
- claim: string;
2388
- op: "eq";
2389
- value: unknown;
2390
- } | {
2391
- claim: string;
2392
- op: "exists";
2393
- })[] | undefined;
2394
- 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;
2395
- } & {
2396
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2397
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2398
- readonly requiredClaims?: ({
2399
- claim: string;
2400
- op: "contains";
2401
- value: unknown;
2402
- } | {
2403
- claim: string;
2404
- op: "eq";
2405
- value: unknown;
2406
- } | {
2407
- claim: string;
2408
- op: "exists";
2409
- })[] | undefined;
2410
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2411
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2412
- }, Readonly<Readonly<{
2413
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
2414
- audience: string;
2415
- ttlSeconds: number;
2416
- attenuation: unknown;
2417
- }, {
2418
- readonly mode: 'value';
2419
- readonly value: string;
2420
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2421
- readonly name: "delegate";
2422
- };
2423
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
2424
- audience: string;
2425
- ttlSeconds: number;
2426
- attenuation: unknown;
2427
- }, {
2428
- readonly mode: 'value';
2429
- readonly value: string;
2430
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2431
- readonly name: "delegate";
2432
- }> & {
2433
- readonly byKey: Readonly<{
2434
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2435
- audience: string;
2436
- ttlSeconds: number;
2437
- attenuation: unknown;
2438
- }, {
2439
- readonly mode: 'value';
2440
- readonly value: string;
2441
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2442
- readonly name: "delegate";
2443
- };
2444
- }>;
2445
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
2446
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2447
- audience: string;
2448
- ttlSeconds: number;
2449
- attenuation: unknown;
2450
- }, {
2451
- readonly mode: 'value';
2452
- readonly value: string;
2453
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2454
- readonly name: "delegate";
2455
- };
2456
- }>[Key];
2457
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2458
- }, Readonly<Readonly<{
2459
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
2460
- policy: string;
2461
- object: string;
2462
- }, {
2463
- readonly mode: 'value';
2464
- readonly value: {
2465
- allowed: boolean;
2466
- };
2467
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2468
- readonly name: "can";
2469
- };
2470
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
2471
- audience?: string | undefined;
2472
- ttlSeconds: number;
2473
- grant?: unknown;
2474
- }, {
2475
- readonly mode: 'value';
2476
- readonly value: string;
2477
- }, 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"> & {
2478
- readonly name: "mint";
2479
- };
2480
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2481
- readonly mode: 'value';
2482
- readonly value: {
2483
- id: string;
2484
- issuer: string;
2485
- subject: string;
2486
- frozen: boolean;
2487
- requiredClaims: ({
2488
- claim: string;
2489
- op: "contains";
2490
- value: unknown;
2491
- } | {
2492
- claim: string;
2493
- op: "eq";
2494
- value: unknown;
2495
- } | {
2496
- claim: string;
2497
- op: "exists";
2498
- })[];
2499
- };
2500
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2501
- readonly name: "whoami";
2502
- };
2503
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
2504
- issuer: string;
2505
- subject: string;
2506
- }, {
2507
- readonly mode: 'value';
2508
- readonly value: {
2509
- id: string;
2510
- issuer: string;
2511
- subject: string;
2512
- frozen: boolean;
2513
- requiredClaims: ({
2514
- claim: string;
2515
- op: "contains";
2516
- value: unknown;
2517
- } | {
2518
- claim: string;
2519
- op: "eq";
2520
- value: unknown;
2521
- } | {
2522
- claim: string;
2523
- op: "exists";
2524
- })[];
2525
- } | null;
2526
- }, 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"> & {
2527
- readonly name: "whois";
2528
- };
2529
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
2530
- policy: string;
2531
- object: string;
2532
- }, {
2533
- readonly mode: 'value';
2534
- readonly value: {
2535
- allowed: boolean;
2536
- };
2537
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2538
- readonly name: "can";
2539
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
2540
- audience?: string | undefined;
2541
- ttlSeconds: number;
2542
- grant?: unknown;
2543
- }, {
2544
- readonly mode: 'value';
2545
- readonly value: string;
2546
- }, 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"> & {
2547
- readonly name: "mint";
2548
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2549
- readonly mode: 'value';
2550
- readonly value: {
2551
- id: string;
2552
- issuer: string;
2553
- subject: string;
2554
- frozen: boolean;
2555
- requiredClaims: ({
2556
- claim: string;
2557
- op: "contains";
2558
- value: unknown;
2559
- } | {
2560
- claim: string;
2561
- op: "eq";
2562
- value: unknown;
2563
- } | {
2564
- claim: string;
2565
- op: "exists";
2566
- })[];
2567
- };
2568
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2569
- readonly name: "whoami";
2570
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
2571
- issuer: string;
2572
- subject: string;
2573
- }, {
2574
- readonly mode: 'value';
2575
- readonly value: {
2576
- id: string;
2577
- issuer: string;
2578
- subject: string;
2579
- frozen: boolean;
2580
- requiredClaims: ({
2581
- claim: string;
2582
- op: "contains";
2583
- value: unknown;
2584
- } | {
2585
- claim: string;
2586
- op: "eq";
2587
- value: unknown;
2588
- } | {
2589
- claim: string;
2590
- op: "exists";
2591
- })[];
2592
- } | null;
2593
- }, 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"> & {
2594
- readonly name: "whois";
2595
- })> & {
2596
- readonly byKey: Readonly<{
2597
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
2598
- policy: string;
2599
- object: string;
2600
- }, {
2601
- readonly mode: 'value';
2602
- readonly value: {
2603
- allowed: boolean;
2604
- };
2605
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2606
- readonly name: "can";
2607
- };
2608
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
2609
- audience?: string | undefined;
2610
- ttlSeconds: number;
2611
- grant?: unknown;
2612
- }, {
2613
- readonly mode: 'value';
2614
- readonly value: string;
2615
- }, 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"> & {
2616
- readonly name: "mint";
2617
- };
2618
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2619
- readonly mode: 'value';
2620
- readonly value: {
2621
- id: string;
2622
- issuer: string;
2623
- subject: string;
2624
- frozen: boolean;
2625
- requiredClaims: ({
2626
- claim: string;
2627
- op: "contains";
2628
- value: unknown;
2629
- } | {
2630
- claim: string;
2631
- op: "eq";
2632
- value: unknown;
2633
- } | {
2634
- claim: string;
2635
- op: "exists";
2636
- })[];
2637
- };
2638
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2639
- readonly name: "whoami";
2640
- };
2641
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
2642
- issuer: string;
2643
- subject: string;
2644
- }, {
2645
- readonly mode: 'value';
2646
- readonly value: {
2647
- id: string;
2648
- issuer: string;
2649
- subject: string;
2650
- frozen: boolean;
2651
- requiredClaims: ({
2652
- claim: string;
2653
- op: "contains";
2654
- value: unknown;
2655
- } | {
2656
- claim: string;
2657
- op: "eq";
2658
- value: unknown;
2659
- } | {
2660
- claim: string;
2661
- op: "exists";
2662
- })[];
2663
- } | null;
2664
- }, 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"> & {
2665
- readonly name: "whois";
2666
- };
2667
- }>;
2668
- 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<{
2669
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
2670
- policy: string;
2671
- object: string;
2672
- }, {
2673
- readonly mode: 'value';
2674
- readonly value: {
2675
- allowed: boolean;
2676
- };
2677
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2678
- readonly name: "can";
2679
- };
2680
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
2681
- audience?: string | undefined;
2682
- ttlSeconds: number;
2683
- grant?: unknown;
2684
- }, {
2685
- readonly mode: 'value';
2686
- readonly value: string;
2687
- }, 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"> & {
2688
- readonly name: "mint";
2689
- };
2690
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2691
- readonly mode: 'value';
2692
- readonly value: {
2693
- id: string;
2694
- issuer: string;
2695
- subject: string;
2696
- frozen: boolean;
2697
- requiredClaims: ({
2698
- claim: string;
2699
- op: "contains";
2700
- value: unknown;
2701
- } | {
2702
- claim: string;
2703
- op: "eq";
2704
- value: unknown;
2705
- } | {
2706
- claim: string;
2707
- op: "exists";
2708
- })[];
2709
- };
2710
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2711
- readonly name: "whoami";
2712
- };
2713
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
2714
- issuer: string;
2715
- subject: string;
2716
- }, {
2717
- readonly mode: 'value';
2718
- readonly value: {
2719
- id: string;
2720
- issuer: string;
2721
- subject: string;
2722
- frozen: boolean;
2723
- requiredClaims: ({
2724
- claim: string;
2725
- op: "contains";
2726
- value: unknown;
2727
- } | {
2728
- claim: string;
2729
- op: "eq";
2730
- value: unknown;
2731
- } | {
2732
- claim: string;
2733
- op: "exists";
2734
- })[];
2735
- } | null;
2736
- }, 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"> & {
2737
- readonly name: "whois";
2738
- };
2739
- }>[Key];
2740
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2741
- }, Readonly<Readonly<{
2742
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2743
- readonly name: "frozen";
2744
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2745
- };
2746
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2747
- readonly name: "iss";
2748
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2749
- };
2750
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
2751
- claim: string;
2752
- op: "contains";
2753
- value: unknown;
2754
- } | {
2755
- claim: string;
2756
- op: "eq";
2757
- value: unknown;
2758
- } | {
2759
- claim: string;
2760
- op: "exists";
2761
- })[], false> & {
2762
- readonly name: "requiredClaims";
2763
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2764
- };
2765
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2766
- readonly name: "sub";
2767
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2768
- };
2769
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2770
- readonly name: "frozen";
2771
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2772
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2773
- readonly name: "iss";
2774
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2775
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
2776
- claim: string;
2777
- op: "contains";
2778
- value: unknown;
2779
- } | {
2780
- claim: string;
2781
- op: "eq";
2782
- value: unknown;
2783
- } | {
2784
- claim: string;
2785
- op: "exists";
2786
- })[], false> & {
2787
- readonly name: "requiredClaims";
2788
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2789
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2790
- readonly name: "sub";
2791
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2792
- })> & {
2793
- readonly byKey: Readonly<{
2794
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2795
- readonly name: "frozen";
2796
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2797
- };
2798
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2799
- readonly name: "iss";
2800
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2801
- };
2802
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2803
- claim: string;
2804
- op: "contains";
2805
- value: unknown;
2806
- } | {
2807
- claim: string;
2808
- op: "eq";
2809
- value: unknown;
2810
- } | {
2811
- claim: string;
2812
- op: "exists";
2813
- })[], false> & {
2814
- readonly name: "requiredClaims";
2815
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2816
- };
2817
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2818
- readonly name: "sub";
2819
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2820
- };
2821
- }>;
2822
- 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<{
2823
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
2824
- readonly name: "frozen";
2825
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
2826
- };
2827
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2828
- readonly name: "iss";
2829
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
2830
- };
2831
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
2832
- claim: string;
2833
- op: "contains";
2834
- value: unknown;
2835
- } | {
2836
- claim: string;
2837
- op: "eq";
2838
- value: unknown;
2839
- } | {
2840
- claim: string;
2841
- op: "exists";
2842
- })[], false> & {
2843
- readonly name: "requiredClaims";
2844
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
2845
- };
2846
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
2847
- readonly name: "sub";
2848
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
2849
- };
2850
- }>[Key];
2851
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2852
- from(input: Readonly<{
2853
- 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;
2854
- 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;
2855
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
2856
- claim: string;
2857
- op: "contains";
2858
- value: unknown;
2859
- } | {
2860
- claim: string;
2861
- op: "eq";
2862
- value: unknown;
2863
- } | {
2864
- claim: string;
2865
- op: "exists";
2866
- })[] | undefined;
2867
- 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;
2868
- } & {
2869
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2870
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2871
- readonly requiredClaims?: ({
2872
- claim: string;
2873
- op: "contains";
2874
- value: unknown;
2875
- } | {
2876
- claim: string;
2877
- op: "eq";
2878
- value: unknown;
2879
- } | {
2880
- claim: string;
2881
- op: "exists";
2882
- })[] | undefined;
2883
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
2884
- }>): import("@astrale-os/sdk/schema").PropertyValues;
2885
- }, Readonly<Readonly<{
2886
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
2887
- audience: string;
2888
- ttlSeconds: number;
2889
- attenuation: unknown;
2890
- }, {
2891
- readonly mode: 'value';
2892
- readonly value: string;
2893
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2894
- readonly name: "delegate";
2895
- };
2896
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
2897
- audience: string;
2898
- ttlSeconds: number;
2899
- attenuation: unknown;
2900
- }, {
2901
- readonly mode: 'value';
2902
- readonly value: string;
2903
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2904
- readonly name: "delegate";
2905
- }> & {
2906
- readonly byKey: Readonly<{
2907
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2908
- audience: string;
2909
- ttlSeconds: number;
2910
- attenuation: unknown;
2911
- }, {
2912
- readonly mode: 'value';
2913
- readonly value: string;
2914
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2915
- readonly name: "delegate";
2916
- };
2917
- }>;
2918
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
2919
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
2920
- audience: string;
2921
- ttlSeconds: number;
2922
- attenuation: unknown;
2923
- }, {
2924
- readonly mode: 'value';
2925
- readonly value: string;
2926
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
2927
- readonly name: "delegate";
2928
- };
2929
- }>[Key];
2930
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2931
- }, Readonly<Readonly<{
2932
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
2933
- policy: string;
2934
- object: string;
2935
- }, {
2936
- readonly mode: 'value';
2937
- readonly value: {
2938
- allowed: boolean;
2939
- };
2940
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
2941
- readonly name: "can";
2942
- };
2943
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
2944
- audience?: string | undefined;
2945
- ttlSeconds: number;
2946
- grant?: unknown;
2947
- }, {
2948
- readonly mode: 'value';
2949
- readonly value: string;
2950
- }, 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"> & {
2951
- readonly name: "mint";
2952
- };
2953
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
2954
- readonly mode: 'value';
2955
- readonly value: {
2956
- id: string;
2957
- issuer: string;
2958
- subject: string;
2959
- frozen: boolean;
2960
- requiredClaims: ({
2961
- claim: string;
2962
- op: "contains";
2963
- value: unknown;
2964
- } | {
2965
- claim: string;
2966
- op: "eq";
2967
- value: unknown;
2968
- } | {
2969
- claim: string;
2970
- op: "exists";
2971
- })[];
2972
- };
2973
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
2974
- readonly name: "whoami";
2975
- };
2976
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
2977
- issuer: string;
2978
- subject: string;
2979
- }, {
2980
- readonly mode: 'value';
2981
- readonly value: {
2982
- id: string;
2983
- issuer: string;
2984
- subject: string;
2985
- frozen: boolean;
2986
- requiredClaims: ({
2987
- claim: string;
2988
- op: "contains";
2989
- value: unknown;
2990
- } | {
2991
- claim: string;
2992
- op: "eq";
2993
- value: unknown;
2994
- } | {
2995
- claim: string;
2996
- op: "exists";
2997
- })[];
2998
- } | null;
2999
- }, 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"> & {
3000
- readonly name: "whois";
3001
- };
3002
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
3003
- policy: string;
3004
- object: string;
3005
- }, {
3006
- readonly mode: 'value';
3007
- readonly value: {
3008
- allowed: boolean;
3009
- };
3010
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3011
- readonly name: "can";
3012
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
3013
- audience?: string | undefined;
3014
- ttlSeconds: number;
3015
- grant?: unknown;
3016
- }, {
3017
- readonly mode: 'value';
3018
- readonly value: string;
3019
- }, 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"> & {
3020
- readonly name: "mint";
3021
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3022
- readonly mode: 'value';
3023
- readonly value: {
3024
- id: string;
3025
- issuer: string;
3026
- subject: string;
3027
- frozen: boolean;
3028
- requiredClaims: ({
3029
- claim: string;
3030
- op: "contains";
3031
- value: unknown;
3032
- } | {
3033
- claim: string;
3034
- op: "eq";
3035
- value: unknown;
3036
- } | {
3037
- claim: string;
3038
- op: "exists";
3039
- })[];
3040
- };
3041
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3042
- readonly name: "whoami";
3043
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
3044
- issuer: string;
3045
- subject: string;
3046
- }, {
3047
- readonly mode: 'value';
3048
- readonly value: {
3049
- id: string;
3050
- issuer: string;
3051
- subject: string;
3052
- frozen: boolean;
3053
- requiredClaims: ({
3054
- claim: string;
3055
- op: "contains";
3056
- value: unknown;
3057
- } | {
3058
- claim: string;
3059
- op: "eq";
3060
- value: unknown;
3061
- } | {
3062
- claim: string;
3063
- op: "exists";
3064
- })[];
3065
- } | null;
3066
- }, 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"> & {
3067
- readonly name: "whois";
3068
- })> & {
3069
- readonly byKey: Readonly<{
3070
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
3071
- policy: string;
3072
- object: string;
3073
- }, {
3074
- readonly mode: 'value';
3075
- readonly value: {
3076
- allowed: boolean;
3077
- };
3078
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3079
- readonly name: "can";
3080
- };
3081
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
3082
- audience?: string | undefined;
3083
- ttlSeconds: number;
3084
- grant?: unknown;
3085
- }, {
3086
- readonly mode: 'value';
3087
- readonly value: string;
3088
- }, 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"> & {
3089
- readonly name: "mint";
3090
- };
3091
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3092
- readonly mode: 'value';
3093
- readonly value: {
3094
- id: string;
3095
- issuer: string;
3096
- subject: string;
3097
- frozen: boolean;
3098
- requiredClaims: ({
3099
- claim: string;
3100
- op: "contains";
3101
- value: unknown;
3102
- } | {
3103
- claim: string;
3104
- op: "eq";
3105
- value: unknown;
3106
- } | {
3107
- claim: string;
3108
- op: "exists";
3109
- })[];
3110
- };
3111
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3112
- readonly name: "whoami";
3113
- };
3114
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
3115
- issuer: string;
3116
- subject: string;
3117
- }, {
3118
- readonly mode: 'value';
3119
- readonly value: {
3120
- id: string;
3121
- issuer: string;
3122
- subject: string;
3123
- frozen: boolean;
3124
- requiredClaims: ({
3125
- claim: string;
3126
- op: "contains";
3127
- value: unknown;
3128
- } | {
3129
- claim: string;
3130
- op: "eq";
3131
- value: unknown;
3132
- } | {
3133
- claim: string;
3134
- op: "exists";
3135
- })[];
3136
- } | null;
3137
- }, 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"> & {
3138
- readonly name: "whois";
3139
- };
3140
- }>;
3141
- 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<{
3142
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
3143
- policy: string;
3144
- object: string;
3145
- }, {
3146
- readonly mode: 'value';
3147
- readonly value: {
3148
- allowed: boolean;
3149
- };
3150
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
3151
- readonly name: "can";
3152
- };
3153
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
3154
- audience?: string | undefined;
3155
- ttlSeconds: number;
3156
- grant?: unknown;
3157
- }, {
3158
- readonly mode: 'value';
3159
- readonly value: string;
3160
- }, 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"> & {
3161
- readonly name: "mint";
3162
- };
3163
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
3164
- readonly mode: 'value';
3165
- readonly value: {
3166
- id: string;
3167
- issuer: string;
3168
- subject: string;
3169
- frozen: boolean;
3170
- requiredClaims: ({
3171
- claim: string;
3172
- op: "contains";
3173
- value: unknown;
3174
- } | {
3175
- claim: string;
3176
- op: "eq";
3177
- value: unknown;
3178
- } | {
3179
- claim: string;
3180
- op: "exists";
3181
- })[];
3182
- };
3183
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
3184
- readonly name: "whoami";
3185
- };
3186
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
3187
- issuer: string;
3188
- subject: string;
3189
- }, {
3190
- readonly mode: 'value';
3191
- readonly value: {
3192
- id: string;
3193
- issuer: string;
3194
- subject: string;
3195
- frozen: boolean;
3196
- requiredClaims: ({
3197
- claim: string;
3198
- op: "contains";
3199
- value: unknown;
3200
- } | {
3201
- claim: string;
3202
- op: "eq";
3203
- value: unknown;
3204
- } | {
3205
- claim: string;
3206
- op: "exists";
3207
- })[];
3208
- } | null;
3209
- }, 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"> & {
3210
- readonly name: "whois";
3211
- };
3212
- }>[Key];
3213
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3214
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
3215
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
3216
- readonly origin: "kernel.astrale.ai";
3217
- };
3218
- readonly kind: 'node';
3219
- readonly abstract: true;
3220
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
3221
- readonly byKey: Readonly<{}>;
3222
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3223
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
3224
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
3225
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3226
- readonly byKey: Readonly<{}>;
3227
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3228
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3229
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3230
- readonly byKey: Readonly<{}>;
3231
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3232
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3233
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3234
- readonly byKey: Readonly<{}>;
3235
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3236
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
3237
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
3238
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3239
- readonly byKey: Readonly<{}>;
3240
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3241
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3242
- }, Readonly<Readonly<{}>> & Iterable<never> & {
3243
- readonly byKey: Readonly<{}>;
3244
- get<Key extends never>(key: Key): Readonly<{}>[Key];
3245
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
3246
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
3247
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
3248
- readonly origin: "kernel.astrale.ai";
3249
- };
3250
- readonly kind: 'node';
3251
- readonly abstract: true;
3252
- }, readonly []> & {
3253
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
3254
- readonly origin: "kernel.astrale.ai";
3255
- };
3256
- readonly key: "kernel.astrale.ai:class.Node";
3257
- }]> & {
3258
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
3259
- readonly origin: "kernel.astrale.ai";
3260
- };
3261
- readonly key: "kernel.astrale.ai:class.Identity";
3262
- }];
3263
- readonly properties: {
3264
- displayName: import("@astrale-os/sdk/schema").Property<import("zod").ZodString, {
3265
- readonly required: false;
3266
- }>;
3267
- };
3268
- readonly methods: {
3269
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
3270
- readonly description: "Resolve this User and its canonical personal Space.";
3271
- readonly auth: "authenticated";
3272
- readonly input: import("zod").ZodObject<{}, import("zod/v4/core").$strict>;
3273
- readonly output: import("zod").ZodObject<{
3274
- userId: import("zod").ZodString;
3275
- personalSpaceId: import("zod").ZodNullable<import("zod").ZodString>;
3276
- }, import("zod/v4/core").$strict>;
3277
- }>;
3278
- };
3279
- }>]>;
3280
- }, import("zod/v4/core").$strict>;
3281
- readonly output: {
3282
- type: 'object';
3283
- properties: {};
3284
- additionalProperties: boolean;
3285
- };
3286
- readonly auth: "authorized";
3287
- readonly policy: ({ check, ref }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
3288
- }>;
3289
- };
3290
- }>;
3291
- }>;
1
+ export declare const groupView: import("@astrale-os/sdk/schema").View;