@astrale-domains/shell 0.1.0-beta.7 → 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 +1161 -26407
  17. package/dist/schema/domain/index.js +4 -5
  18. package/dist/schema/group/class.d.ts +167 -3132
  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/space/methods.d.ts CHANGED
@@ -1,2089 +1,18 @@
1
- import type { PathLike } from '@astrale-os/sdk/graph/path';
2
- import { z } from 'zod';
3
- export type SpaceUserAccess = 'member' | 'admin';
4
- export interface SpaceUserAccessInput {
5
- readonly user: PathLike;
6
- readonly access: SpaceUserAccess;
7
- }
8
- export interface SpaceUserAccessResult extends Readonly<Record<never, never>> {
9
- }
10
- export interface SpaceUserInput {
11
- readonly user: PathLike;
12
- }
13
- export interface SpaceUserResult extends Readonly<Record<never, never>> {
14
- }
15
- export interface SetDefaultSpaceInput extends Readonly<Record<never, never>> {
16
- }
17
- export interface SetDefaultSpaceResult extends Readonly<Record<never, never>> {
18
- }
19
- export declare const spaceAddUser: import("@astrale-os/sdk/schema").Method<{
20
- readonly description: "Set one User direct member or admin access.";
21
- readonly input: z.ZodObject<{
22
- user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
23
- readonly description: "One externally identified person using Shell.";
24
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
25
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
26
- readonly name: "frozen";
27
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
28
- };
29
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
30
- readonly name: "iss";
31
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
32
- };
33
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
34
- claim: string;
35
- op: "contains";
36
- value: unknown;
37
- } | {
38
- claim: string;
39
- op: "eq";
40
- value: unknown;
41
- } | {
42
- claim: string;
43
- op: "exists";
44
- })[], false> & {
45
- readonly name: "requiredClaims";
46
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
47
- };
48
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
49
- readonly name: "sub";
50
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
51
- };
52
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
53
- readonly name: "frozen";
54
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
55
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
56
- readonly name: "iss";
57
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
58
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
59
- claim: string;
60
- op: "contains";
61
- value: unknown;
62
- } | {
63
- claim: string;
64
- op: "eq";
65
- value: unknown;
66
- } | {
67
- claim: string;
68
- op: "exists";
69
- })[], false> & {
70
- readonly name: "requiredClaims";
71
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
72
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
73
- readonly name: "sub";
74
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
75
- })> & {
76
- readonly byKey: Readonly<{
77
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
78
- readonly name: "frozen";
79
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
80
- };
81
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
82
- readonly name: "iss";
83
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
84
- };
85
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
86
- claim: string;
87
- op: "contains";
88
- value: unknown;
89
- } | {
90
- claim: string;
91
- op: "eq";
92
- value: unknown;
93
- } | {
94
- claim: string;
95
- op: "exists";
96
- })[], false> & {
97
- readonly name: "requiredClaims";
98
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
99
- };
100
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
101
- readonly name: "sub";
102
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
103
- };
104
- }>;
105
- 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<{
106
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
107
- readonly name: "frozen";
108
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
109
- };
110
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
111
- readonly name: "iss";
112
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
113
- };
114
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
115
- claim: string;
116
- op: "contains";
117
- value: unknown;
118
- } | {
119
- claim: string;
120
- op: "eq";
121
- value: unknown;
122
- } | {
123
- claim: string;
124
- op: "exists";
125
- })[], false> & {
126
- readonly name: "requiredClaims";
127
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
128
- };
129
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
130
- readonly name: "sub";
131
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
132
- };
133
- }>[Key];
134
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
135
- from(input: Readonly<{
136
- 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;
137
- 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;
138
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
139
- claim: string;
140
- op: "contains";
141
- value: unknown;
142
- } | {
143
- claim: string;
144
- op: "eq";
145
- value: unknown;
146
- } | {
147
- claim: string;
148
- op: "exists";
149
- })[] | undefined;
150
- 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;
151
- } & {
152
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
153
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
154
- readonly requiredClaims?: ({
155
- claim: string;
156
- op: "contains";
157
- value: unknown;
158
- } | {
159
- claim: string;
160
- op: "eq";
161
- value: unknown;
162
- } | {
163
- claim: string;
164
- op: "exists";
165
- })[] | undefined;
166
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
167
- }>): import("@astrale-os/sdk/schema").PropertyValues;
168
- }, Readonly<Readonly<{
169
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
170
- audience: string;
171
- ttlSeconds: number;
172
- attenuation: unknown;
173
- }, {
174
- readonly mode: 'value';
175
- readonly value: string;
176
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
177
- readonly name: "delegate";
178
- };
179
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
180
- audience: string;
181
- ttlSeconds: number;
182
- attenuation: unknown;
183
- }, {
184
- readonly mode: 'value';
185
- readonly value: string;
186
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
187
- readonly name: "delegate";
188
- }> & {
189
- readonly byKey: Readonly<{
190
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
191
- audience: string;
192
- ttlSeconds: number;
193
- attenuation: unknown;
194
- }, {
195
- readonly mode: 'value';
196
- readonly value: string;
197
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
198
- readonly name: "delegate";
199
- };
200
- }>;
201
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
202
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
203
- audience: string;
204
- ttlSeconds: number;
205
- attenuation: unknown;
206
- }, {
207
- readonly mode: 'value';
208
- readonly value: string;
209
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
210
- readonly name: "delegate";
211
- };
212
- }>[Key];
213
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
214
- }, Readonly<Readonly<{
215
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
216
- policy: string;
217
- object: string;
218
- }, {
219
- readonly mode: 'value';
220
- readonly value: {
221
- allowed: boolean;
222
- };
223
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
224
- readonly name: "can";
225
- };
226
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
227
- audience?: string | undefined;
228
- ttlSeconds: number;
229
- grant?: unknown;
230
- }, {
231
- readonly mode: 'value';
232
- readonly value: string;
233
- }, 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"> & {
234
- readonly name: "mint";
235
- };
236
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
237
- readonly mode: 'value';
238
- readonly value: {
239
- id: string;
240
- issuer: string;
241
- subject: string;
242
- frozen: boolean;
243
- requiredClaims: ({
244
- claim: string;
245
- op: "contains";
246
- value: unknown;
247
- } | {
248
- claim: string;
249
- op: "eq";
250
- value: unknown;
251
- } | {
252
- claim: string;
253
- op: "exists";
254
- })[];
255
- };
256
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
257
- readonly name: "whoami";
258
- };
259
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
260
- issuer: string;
261
- subject: string;
262
- }, {
263
- readonly mode: 'value';
264
- readonly value: {
265
- id: string;
266
- issuer: string;
267
- subject: string;
268
- frozen: boolean;
269
- requiredClaims: ({
270
- claim: string;
271
- op: "contains";
272
- value: unknown;
273
- } | {
274
- claim: string;
275
- op: "eq";
276
- value: unknown;
277
- } | {
278
- claim: string;
279
- op: "exists";
280
- })[];
281
- } | null;
282
- }, 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"> & {
283
- readonly name: "whois";
284
- };
285
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
286
- policy: string;
287
- object: string;
288
- }, {
289
- readonly mode: 'value';
290
- readonly value: {
291
- allowed: boolean;
292
- };
293
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
294
- readonly name: "can";
295
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
296
- audience?: string | undefined;
297
- ttlSeconds: number;
298
- grant?: unknown;
299
- }, {
300
- readonly mode: 'value';
301
- readonly value: string;
302
- }, 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"> & {
303
- readonly name: "mint";
304
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
305
- readonly mode: 'value';
306
- readonly value: {
307
- id: string;
308
- issuer: string;
309
- subject: string;
310
- frozen: boolean;
311
- requiredClaims: ({
312
- claim: string;
313
- op: "contains";
314
- value: unknown;
315
- } | {
316
- claim: string;
317
- op: "eq";
318
- value: unknown;
319
- } | {
320
- claim: string;
321
- op: "exists";
322
- })[];
323
- };
324
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
325
- readonly name: "whoami";
326
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
327
- issuer: string;
328
- subject: string;
329
- }, {
330
- readonly mode: 'value';
331
- readonly value: {
332
- id: string;
333
- issuer: string;
334
- subject: string;
335
- frozen: boolean;
336
- requiredClaims: ({
337
- claim: string;
338
- op: "contains";
339
- value: unknown;
340
- } | {
341
- claim: string;
342
- op: "eq";
343
- value: unknown;
344
- } | {
345
- claim: string;
346
- op: "exists";
347
- })[];
348
- } | null;
349
- }, 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"> & {
350
- readonly name: "whois";
351
- })> & {
352
- readonly byKey: Readonly<{
353
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
354
- policy: string;
355
- object: string;
356
- }, {
357
- readonly mode: 'value';
358
- readonly value: {
359
- allowed: boolean;
360
- };
361
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
362
- readonly name: "can";
363
- };
364
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
365
- audience?: string | undefined;
366
- ttlSeconds: number;
367
- grant?: unknown;
368
- }, {
369
- readonly mode: 'value';
370
- readonly value: string;
371
- }, 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"> & {
372
- readonly name: "mint";
373
- };
374
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
375
- readonly mode: 'value';
376
- readonly value: {
377
- id: string;
378
- issuer: string;
379
- subject: string;
380
- frozen: boolean;
381
- requiredClaims: ({
382
- claim: string;
383
- op: "contains";
384
- value: unknown;
385
- } | {
386
- claim: string;
387
- op: "eq";
388
- value: unknown;
389
- } | {
390
- claim: string;
391
- op: "exists";
392
- })[];
393
- };
394
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
395
- readonly name: "whoami";
396
- };
397
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
398
- issuer: string;
399
- subject: string;
400
- }, {
401
- readonly mode: 'value';
402
- readonly value: {
403
- id: string;
404
- issuer: string;
405
- subject: string;
406
- frozen: boolean;
407
- requiredClaims: ({
408
- claim: string;
409
- op: "contains";
410
- value: unknown;
411
- } | {
412
- claim: string;
413
- op: "eq";
414
- value: unknown;
415
- } | {
416
- claim: string;
417
- op: "exists";
418
- })[];
419
- } | null;
420
- }, 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"> & {
421
- readonly name: "whois";
422
- };
423
- }>;
424
- 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<{
425
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
426
- policy: string;
427
- object: string;
428
- }, {
429
- readonly mode: 'value';
430
- readonly value: {
431
- allowed: boolean;
432
- };
433
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
434
- readonly name: "can";
435
- };
436
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
437
- audience?: string | undefined;
438
- ttlSeconds: number;
439
- grant?: unknown;
440
- }, {
441
- readonly mode: 'value';
442
- readonly value: string;
443
- }, 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"> & {
444
- readonly name: "mint";
445
- };
446
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
447
- readonly mode: 'value';
448
- readonly value: {
449
- id: string;
450
- issuer: string;
451
- subject: string;
452
- frozen: boolean;
453
- requiredClaims: ({
454
- claim: string;
455
- op: "contains";
456
- value: unknown;
457
- } | {
458
- claim: string;
459
- op: "eq";
460
- value: unknown;
461
- } | {
462
- claim: string;
463
- op: "exists";
464
- })[];
465
- };
466
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
467
- readonly name: "whoami";
468
- };
469
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
470
- issuer: string;
471
- subject: string;
472
- }, {
473
- readonly mode: 'value';
474
- readonly value: {
475
- id: string;
476
- issuer: string;
477
- subject: string;
478
- frozen: boolean;
479
- requiredClaims: ({
480
- claim: string;
481
- op: "contains";
482
- value: unknown;
483
- } | {
484
- claim: string;
485
- op: "eq";
486
- value: unknown;
487
- } | {
488
- claim: string;
489
- op: "exists";
490
- })[];
491
- } | null;
492
- }, 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"> & {
493
- readonly name: "whois";
494
- };
495
- }>[Key];
496
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
497
- }, Readonly<Readonly<{
498
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
499
- readonly name: "frozen";
500
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
501
- };
502
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
503
- readonly name: "iss";
504
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
505
- };
506
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
507
- claim: string;
508
- op: "contains";
509
- value: unknown;
510
- } | {
511
- claim: string;
512
- op: "eq";
513
- value: unknown;
514
- } | {
515
- claim: string;
516
- op: "exists";
517
- })[], false> & {
518
- readonly name: "requiredClaims";
519
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
520
- };
521
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
522
- readonly name: "sub";
523
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
524
- };
525
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
526
- readonly name: "frozen";
527
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
528
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
529
- readonly name: "iss";
530
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
531
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
532
- claim: string;
533
- op: "contains";
534
- value: unknown;
535
- } | {
536
- claim: string;
537
- op: "eq";
538
- value: unknown;
539
- } | {
540
- claim: string;
541
- op: "exists";
542
- })[], false> & {
543
- readonly name: "requiredClaims";
544
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
545
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
546
- readonly name: "sub";
547
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
548
- })> & {
549
- readonly byKey: Readonly<{
550
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
551
- readonly name: "frozen";
552
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
553
- };
554
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
555
- readonly name: "iss";
556
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
557
- };
558
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
559
- claim: string;
560
- op: "contains";
561
- value: unknown;
562
- } | {
563
- claim: string;
564
- op: "eq";
565
- value: unknown;
566
- } | {
567
- claim: string;
568
- op: "exists";
569
- })[], false> & {
570
- readonly name: "requiredClaims";
571
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
572
- };
573
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
574
- readonly name: "sub";
575
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
576
- };
577
- }>;
578
- 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<{
579
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
580
- readonly name: "frozen";
581
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
582
- };
583
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
584
- readonly name: "iss";
585
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
586
- };
587
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
588
- claim: string;
589
- op: "contains";
590
- value: unknown;
591
- } | {
592
- claim: string;
593
- op: "eq";
594
- value: unknown;
595
- } | {
596
- claim: string;
597
- op: "exists";
598
- })[], false> & {
599
- readonly name: "requiredClaims";
600
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
601
- };
602
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
603
- readonly name: "sub";
604
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
605
- };
606
- }>[Key];
607
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
608
- from(input: Readonly<{
609
- 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;
610
- 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;
611
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
612
- claim: string;
613
- op: "contains";
614
- value: unknown;
615
- } | {
616
- claim: string;
617
- op: "eq";
618
- value: unknown;
619
- } | {
620
- claim: string;
621
- op: "exists";
622
- })[] | undefined;
623
- 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;
624
- } & {
625
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
626
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
627
- readonly requiredClaims?: ({
628
- claim: string;
629
- op: "contains";
630
- value: unknown;
631
- } | {
632
- claim: string;
633
- op: "eq";
634
- value: unknown;
635
- } | {
636
- claim: string;
637
- op: "exists";
638
- })[] | undefined;
639
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
640
- }>): import("@astrale-os/sdk/schema").PropertyValues;
641
- }, Readonly<Readonly<{
642
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
643
- audience: string;
644
- ttlSeconds: number;
645
- attenuation: unknown;
646
- }, {
647
- readonly mode: 'value';
648
- readonly value: string;
649
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
650
- readonly name: "delegate";
651
- };
652
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
653
- audience: string;
654
- ttlSeconds: number;
655
- attenuation: unknown;
656
- }, {
657
- readonly mode: 'value';
658
- readonly value: string;
659
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
660
- readonly name: "delegate";
661
- }> & {
662
- readonly byKey: Readonly<{
663
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
664
- audience: string;
665
- ttlSeconds: number;
666
- attenuation: unknown;
667
- }, {
668
- readonly mode: 'value';
669
- readonly value: string;
670
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
671
- readonly name: "delegate";
672
- };
673
- }>;
674
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
675
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
676
- audience: string;
677
- ttlSeconds: number;
678
- attenuation: unknown;
679
- }, {
680
- readonly mode: 'value';
681
- readonly value: string;
682
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
683
- readonly name: "delegate";
684
- };
685
- }>[Key];
686
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
687
- }, Readonly<Readonly<{
688
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
689
- policy: string;
690
- object: string;
691
- }, {
692
- readonly mode: 'value';
693
- readonly value: {
694
- allowed: boolean;
695
- };
696
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
697
- readonly name: "can";
698
- };
699
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
700
- audience?: string | undefined;
701
- ttlSeconds: number;
702
- grant?: unknown;
703
- }, {
704
- readonly mode: 'value';
705
- readonly value: string;
706
- }, 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"> & {
707
- readonly name: "mint";
708
- };
709
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
710
- readonly mode: 'value';
711
- readonly value: {
712
- id: string;
713
- issuer: string;
714
- subject: string;
715
- frozen: boolean;
716
- requiredClaims: ({
717
- claim: string;
718
- op: "contains";
719
- value: unknown;
720
- } | {
721
- claim: string;
722
- op: "eq";
723
- value: unknown;
724
- } | {
725
- claim: string;
726
- op: "exists";
727
- })[];
728
- };
729
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
730
- readonly name: "whoami";
731
- };
732
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
733
- issuer: string;
734
- subject: string;
735
- }, {
736
- readonly mode: 'value';
737
- readonly value: {
738
- id: string;
739
- issuer: string;
740
- subject: string;
741
- frozen: boolean;
742
- requiredClaims: ({
743
- claim: string;
744
- op: "contains";
745
- value: unknown;
746
- } | {
747
- claim: string;
748
- op: "eq";
749
- value: unknown;
750
- } | {
751
- claim: string;
752
- op: "exists";
753
- })[];
754
- } | null;
755
- }, 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"> & {
756
- readonly name: "whois";
757
- };
758
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
759
- policy: string;
760
- object: string;
761
- }, {
762
- readonly mode: 'value';
763
- readonly value: {
764
- allowed: boolean;
765
- };
766
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
767
- readonly name: "can";
768
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
769
- audience?: string | undefined;
770
- ttlSeconds: number;
771
- grant?: unknown;
772
- }, {
773
- readonly mode: 'value';
774
- readonly value: string;
775
- }, 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"> & {
776
- readonly name: "mint";
777
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
778
- readonly mode: 'value';
779
- readonly value: {
780
- id: string;
781
- issuer: string;
782
- subject: string;
783
- frozen: boolean;
784
- requiredClaims: ({
785
- claim: string;
786
- op: "contains";
787
- value: unknown;
788
- } | {
789
- claim: string;
790
- op: "eq";
791
- value: unknown;
792
- } | {
793
- claim: string;
794
- op: "exists";
795
- })[];
796
- };
797
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
798
- readonly name: "whoami";
799
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
800
- issuer: string;
801
- subject: string;
802
- }, {
803
- readonly mode: 'value';
804
- readonly value: {
805
- id: string;
806
- issuer: string;
807
- subject: string;
808
- frozen: boolean;
809
- requiredClaims: ({
810
- claim: string;
811
- op: "contains";
812
- value: unknown;
813
- } | {
814
- claim: string;
815
- op: "eq";
816
- value: unknown;
817
- } | {
818
- claim: string;
819
- op: "exists";
820
- })[];
821
- } | null;
822
- }, 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"> & {
823
- readonly name: "whois";
824
- })> & {
825
- readonly byKey: Readonly<{
826
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
827
- policy: string;
828
- object: string;
829
- }, {
830
- readonly mode: 'value';
831
- readonly value: {
832
- allowed: boolean;
833
- };
834
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
835
- readonly name: "can";
836
- };
837
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
838
- audience?: string | undefined;
839
- ttlSeconds: number;
840
- grant?: unknown;
841
- }, {
842
- readonly mode: 'value';
843
- readonly value: string;
844
- }, 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"> & {
845
- readonly name: "mint";
846
- };
847
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
848
- readonly mode: 'value';
849
- readonly value: {
850
- id: string;
851
- issuer: string;
852
- subject: string;
853
- frozen: boolean;
854
- requiredClaims: ({
855
- claim: string;
856
- op: "contains";
857
- value: unknown;
858
- } | {
859
- claim: string;
860
- op: "eq";
861
- value: unknown;
862
- } | {
863
- claim: string;
864
- op: "exists";
865
- })[];
866
- };
867
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
868
- readonly name: "whoami";
869
- };
870
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
871
- issuer: string;
872
- subject: string;
873
- }, {
874
- readonly mode: 'value';
875
- readonly value: {
876
- id: string;
877
- issuer: string;
878
- subject: string;
879
- frozen: boolean;
880
- requiredClaims: ({
881
- claim: string;
882
- op: "contains";
883
- value: unknown;
884
- } | {
885
- claim: string;
886
- op: "eq";
887
- value: unknown;
888
- } | {
889
- claim: string;
890
- op: "exists";
891
- })[];
892
- } | null;
893
- }, 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"> & {
894
- readonly name: "whois";
895
- };
896
- }>;
897
- 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<{
898
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
899
- policy: string;
900
- object: string;
901
- }, {
902
- readonly mode: 'value';
903
- readonly value: {
904
- allowed: boolean;
905
- };
906
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
907
- readonly name: "can";
908
- };
909
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
910
- audience?: string | undefined;
911
- ttlSeconds: number;
912
- grant?: unknown;
913
- }, {
914
- readonly mode: 'value';
915
- readonly value: string;
916
- }, 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"> & {
917
- readonly name: "mint";
918
- };
919
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
920
- readonly mode: 'value';
921
- readonly value: {
922
- id: string;
923
- issuer: string;
924
- subject: string;
925
- frozen: boolean;
926
- requiredClaims: ({
927
- claim: string;
928
- op: "contains";
929
- value: unknown;
930
- } | {
931
- claim: string;
932
- op: "eq";
933
- value: unknown;
934
- } | {
935
- claim: string;
936
- op: "exists";
937
- })[];
938
- };
939
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
940
- readonly name: "whoami";
941
- };
942
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
943
- issuer: string;
944
- subject: string;
945
- }, {
946
- readonly mode: 'value';
947
- readonly value: {
948
- id: string;
949
- issuer: string;
950
- subject: string;
951
- frozen: boolean;
952
- requiredClaims: ({
953
- claim: string;
954
- op: "contains";
955
- value: unknown;
956
- } | {
957
- claim: string;
958
- op: "eq";
959
- value: unknown;
960
- } | {
961
- claim: string;
962
- op: "exists";
963
- })[];
964
- } | null;
965
- }, 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"> & {
966
- readonly name: "whois";
967
- };
968
- }>[Key];
969
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
970
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
971
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
972
- readonly origin: "kernel.astrale.ai";
973
- };
974
- readonly kind: 'node';
975
- readonly abstract: true;
976
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
977
- readonly byKey: Readonly<{}>;
978
- get<Key extends never>(key: Key): Readonly<{}>[Key];
979
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
980
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
981
- }, Readonly<Readonly<{}>> & Iterable<never> & {
982
- readonly byKey: Readonly<{}>;
983
- get<Key extends never>(key: Key): Readonly<{}>[Key];
984
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
985
- }, Readonly<Readonly<{}>> & Iterable<never> & {
986
- readonly byKey: Readonly<{}>;
987
- get<Key extends never>(key: Key): Readonly<{}>[Key];
988
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
989
- }, Readonly<Readonly<{}>> & Iterable<never> & {
990
- readonly byKey: Readonly<{}>;
991
- get<Key extends never>(key: Key): Readonly<{}>[Key];
992
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
993
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
994
- }, Readonly<Readonly<{}>> & Iterable<never> & {
995
- readonly byKey: Readonly<{}>;
996
- get<Key extends never>(key: Key): Readonly<{}>[Key];
997
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
998
- }, Readonly<Readonly<{}>> & Iterable<never> & {
999
- readonly byKey: Readonly<{}>;
1000
- get<Key extends never>(key: Key): Readonly<{}>[Key];
1001
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1002
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
1003
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
1004
- readonly origin: "kernel.astrale.ai";
1005
- };
1006
- readonly kind: 'node';
1007
- readonly abstract: true;
1008
- }, readonly []> & {
1009
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
1010
- readonly origin: "kernel.astrale.ai";
1011
- };
1012
- readonly key: "kernel.astrale.ai:class.Node";
1013
- }]> & {
1014
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
1015
- readonly origin: "kernel.astrale.ai";
1016
- };
1017
- readonly key: "kernel.astrale.ai:class.Identity";
1018
- }];
1019
- readonly properties: {
1020
- displayName: import("@astrale-os/sdk/schema").Property<z.ZodString, {
1021
- readonly required: false;
1022
- }>;
1023
- };
1024
- readonly methods: {
1025
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
1026
- readonly description: "Resolve this User and its canonical personal Space.";
1027
- readonly auth: "authenticated";
1028
- readonly input: z.ZodObject<{}, z.core.$strict>;
1029
- readonly output: z.ZodObject<{
1030
- userId: z.ZodString;
1031
- personalSpaceId: z.ZodNullable<z.ZodString>;
1032
- }, z.core.$strict>;
1033
- }>;
1034
- };
1035
- }>]>;
1036
- access: z.ZodEnum<{
1037
- admin: "admin";
1038
- member: "member";
1039
- }>;
1040
- }, z.core.$strict>;
1041
- readonly output: {
1042
- type: 'object';
1043
- properties: {};
1044
- additionalProperties: boolean;
1045
- };
1046
- readonly auth: "authorized";
1047
- readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
1048
- }>;
1049
- export declare const spaceRemoveUser: import("@astrale-os/sdk/schema").Method<{
1050
- readonly description: "Remove one User direct access.";
1051
- readonly input: z.ZodObject<{
1052
- user: import("@astrale-os/sdk/schema").PathAuthoring<readonly [import("@astrale-os/sdk/schema").NodeClass<{
1053
- readonly description: "One externally identified person using Shell.";
1054
- readonly extends: readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{
1055
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1056
- readonly name: "frozen";
1057
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1058
- };
1059
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1060
- readonly name: "iss";
1061
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1062
- };
1063
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
1064
- claim: string;
1065
- op: "contains";
1066
- value: unknown;
1067
- } | {
1068
- claim: string;
1069
- op: "eq";
1070
- value: unknown;
1071
- } | {
1072
- claim: string;
1073
- op: "exists";
1074
- })[], false> & {
1075
- readonly name: "requiredClaims";
1076
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1077
- };
1078
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1079
- readonly name: "sub";
1080
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1081
- };
1082
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1083
- readonly name: "frozen";
1084
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1085
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1086
- readonly name: "iss";
1087
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1088
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
1089
- claim: string;
1090
- op: "contains";
1091
- value: unknown;
1092
- } | {
1093
- claim: string;
1094
- op: "eq";
1095
- value: unknown;
1096
- } | {
1097
- claim: string;
1098
- op: "exists";
1099
- })[], false> & {
1100
- readonly name: "requiredClaims";
1101
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1102
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1103
- readonly name: "sub";
1104
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1105
- })> & {
1106
- readonly byKey: Readonly<{
1107
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1108
- readonly name: "frozen";
1109
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1110
- };
1111
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1112
- readonly name: "iss";
1113
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1114
- };
1115
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1116
- claim: string;
1117
- op: "contains";
1118
- value: unknown;
1119
- } | {
1120
- claim: string;
1121
- op: "eq";
1122
- value: unknown;
1123
- } | {
1124
- claim: string;
1125
- op: "exists";
1126
- })[], false> & {
1127
- readonly name: "requiredClaims";
1128
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1129
- };
1130
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1131
- readonly name: "sub";
1132
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1133
- };
1134
- }>;
1135
- 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<{
1136
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1137
- readonly name: "frozen";
1138
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1139
- };
1140
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1141
- readonly name: "iss";
1142
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1143
- };
1144
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1145
- claim: string;
1146
- op: "contains";
1147
- value: unknown;
1148
- } | {
1149
- claim: string;
1150
- op: "eq";
1151
- value: unknown;
1152
- } | {
1153
- claim: string;
1154
- op: "exists";
1155
- })[], false> & {
1156
- readonly name: "requiredClaims";
1157
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1158
- };
1159
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1160
- readonly name: "sub";
1161
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1162
- };
1163
- }>[Key];
1164
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1165
- from(input: Readonly<{
1166
- 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;
1167
- 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;
1168
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
1169
- claim: string;
1170
- op: "contains";
1171
- value: unknown;
1172
- } | {
1173
- claim: string;
1174
- op: "eq";
1175
- value: unknown;
1176
- } | {
1177
- claim: string;
1178
- op: "exists";
1179
- })[] | undefined;
1180
- 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;
1181
- } & {
1182
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1183
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1184
- readonly requiredClaims?: ({
1185
- claim: string;
1186
- op: "contains";
1187
- value: unknown;
1188
- } | {
1189
- claim: string;
1190
- op: "eq";
1191
- value: unknown;
1192
- } | {
1193
- claim: string;
1194
- op: "exists";
1195
- })[] | undefined;
1196
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1197
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1198
- }, Readonly<Readonly<{
1199
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
1200
- audience: string;
1201
- ttlSeconds: number;
1202
- attenuation: unknown;
1203
- }, {
1204
- readonly mode: 'value';
1205
- readonly value: string;
1206
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1207
- readonly name: "delegate";
1208
- };
1209
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
1210
- audience: string;
1211
- ttlSeconds: number;
1212
- attenuation: unknown;
1213
- }, {
1214
- readonly mode: 'value';
1215
- readonly value: string;
1216
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1217
- readonly name: "delegate";
1218
- }> & {
1219
- readonly byKey: Readonly<{
1220
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1221
- audience: string;
1222
- ttlSeconds: number;
1223
- attenuation: unknown;
1224
- }, {
1225
- readonly mode: 'value';
1226
- readonly value: string;
1227
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1228
- readonly name: "delegate";
1229
- };
1230
- }>;
1231
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
1232
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1233
- audience: string;
1234
- ttlSeconds: number;
1235
- attenuation: unknown;
1236
- }, {
1237
- readonly mode: 'value';
1238
- readonly value: string;
1239
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1240
- readonly name: "delegate";
1241
- };
1242
- }>[Key];
1243
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1244
- }, Readonly<Readonly<{
1245
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
1246
- policy: string;
1247
- object: string;
1248
- }, {
1249
- readonly mode: 'value';
1250
- readonly value: {
1251
- allowed: boolean;
1252
- };
1253
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1254
- readonly name: "can";
1255
- };
1256
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
1257
- audience?: string | undefined;
1258
- ttlSeconds: number;
1259
- grant?: unknown;
1260
- }, {
1261
- readonly mode: 'value';
1262
- readonly value: string;
1263
- }, 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"> & {
1264
- readonly name: "mint";
1265
- };
1266
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1267
- readonly mode: 'value';
1268
- readonly value: {
1269
- id: string;
1270
- issuer: string;
1271
- subject: string;
1272
- frozen: boolean;
1273
- requiredClaims: ({
1274
- claim: string;
1275
- op: "contains";
1276
- value: unknown;
1277
- } | {
1278
- claim: string;
1279
- op: "eq";
1280
- value: unknown;
1281
- } | {
1282
- claim: string;
1283
- op: "exists";
1284
- })[];
1285
- };
1286
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1287
- readonly name: "whoami";
1288
- };
1289
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
1290
- issuer: string;
1291
- subject: string;
1292
- }, {
1293
- readonly mode: 'value';
1294
- readonly value: {
1295
- id: string;
1296
- issuer: string;
1297
- subject: string;
1298
- frozen: boolean;
1299
- requiredClaims: ({
1300
- claim: string;
1301
- op: "contains";
1302
- value: unknown;
1303
- } | {
1304
- claim: string;
1305
- op: "eq";
1306
- value: unknown;
1307
- } | {
1308
- claim: string;
1309
- op: "exists";
1310
- })[];
1311
- } | null;
1312
- }, 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"> & {
1313
- readonly name: "whois";
1314
- };
1315
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
1316
- policy: string;
1317
- object: string;
1318
- }, {
1319
- readonly mode: 'value';
1320
- readonly value: {
1321
- allowed: boolean;
1322
- };
1323
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1324
- readonly name: "can";
1325
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1326
- audience?: string | undefined;
1327
- ttlSeconds: number;
1328
- grant?: unknown;
1329
- }, {
1330
- readonly mode: 'value';
1331
- readonly value: string;
1332
- }, 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"> & {
1333
- readonly name: "mint";
1334
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1335
- readonly mode: 'value';
1336
- readonly value: {
1337
- id: string;
1338
- issuer: string;
1339
- subject: string;
1340
- frozen: boolean;
1341
- requiredClaims: ({
1342
- claim: string;
1343
- op: "contains";
1344
- value: unknown;
1345
- } | {
1346
- claim: string;
1347
- op: "eq";
1348
- value: unknown;
1349
- } | {
1350
- claim: string;
1351
- op: "exists";
1352
- })[];
1353
- };
1354
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1355
- readonly name: "whoami";
1356
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1357
- issuer: string;
1358
- subject: string;
1359
- }, {
1360
- readonly mode: 'value';
1361
- readonly value: {
1362
- id: string;
1363
- issuer: string;
1364
- subject: string;
1365
- frozen: boolean;
1366
- requiredClaims: ({
1367
- claim: string;
1368
- op: "contains";
1369
- value: unknown;
1370
- } | {
1371
- claim: string;
1372
- op: "eq";
1373
- value: unknown;
1374
- } | {
1375
- claim: string;
1376
- op: "exists";
1377
- })[];
1378
- } | null;
1379
- }, 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"> & {
1380
- readonly name: "whois";
1381
- })> & {
1382
- readonly byKey: Readonly<{
1383
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1384
- policy: string;
1385
- object: string;
1386
- }, {
1387
- readonly mode: 'value';
1388
- readonly value: {
1389
- allowed: boolean;
1390
- };
1391
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1392
- readonly name: "can";
1393
- };
1394
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1395
- audience?: string | undefined;
1396
- ttlSeconds: number;
1397
- grant?: unknown;
1398
- }, {
1399
- readonly mode: 'value';
1400
- readonly value: string;
1401
- }, 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"> & {
1402
- readonly name: "mint";
1403
- };
1404
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1405
- readonly mode: 'value';
1406
- readonly value: {
1407
- id: string;
1408
- issuer: string;
1409
- subject: string;
1410
- frozen: boolean;
1411
- requiredClaims: ({
1412
- claim: string;
1413
- op: "contains";
1414
- value: unknown;
1415
- } | {
1416
- claim: string;
1417
- op: "eq";
1418
- value: unknown;
1419
- } | {
1420
- claim: string;
1421
- op: "exists";
1422
- })[];
1423
- };
1424
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1425
- readonly name: "whoami";
1426
- };
1427
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1428
- issuer: string;
1429
- subject: string;
1430
- }, {
1431
- readonly mode: 'value';
1432
- readonly value: {
1433
- id: string;
1434
- issuer: string;
1435
- subject: string;
1436
- frozen: boolean;
1437
- requiredClaims: ({
1438
- claim: string;
1439
- op: "contains";
1440
- value: unknown;
1441
- } | {
1442
- claim: string;
1443
- op: "eq";
1444
- value: unknown;
1445
- } | {
1446
- claim: string;
1447
- op: "exists";
1448
- })[];
1449
- } | null;
1450
- }, 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"> & {
1451
- readonly name: "whois";
1452
- };
1453
- }>;
1454
- 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<{
1455
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1456
- policy: string;
1457
- object: string;
1458
- }, {
1459
- readonly mode: 'value';
1460
- readonly value: {
1461
- allowed: boolean;
1462
- };
1463
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1464
- readonly name: "can";
1465
- };
1466
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1467
- audience?: string | undefined;
1468
- ttlSeconds: number;
1469
- grant?: unknown;
1470
- }, {
1471
- readonly mode: 'value';
1472
- readonly value: string;
1473
- }, 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"> & {
1474
- readonly name: "mint";
1475
- };
1476
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1477
- readonly mode: 'value';
1478
- readonly value: {
1479
- id: string;
1480
- issuer: string;
1481
- subject: string;
1482
- frozen: boolean;
1483
- requiredClaims: ({
1484
- claim: string;
1485
- op: "contains";
1486
- value: unknown;
1487
- } | {
1488
- claim: string;
1489
- op: "eq";
1490
- value: unknown;
1491
- } | {
1492
- claim: string;
1493
- op: "exists";
1494
- })[];
1495
- };
1496
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1497
- readonly name: "whoami";
1498
- };
1499
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1500
- issuer: string;
1501
- subject: string;
1502
- }, {
1503
- readonly mode: 'value';
1504
- readonly value: {
1505
- id: string;
1506
- issuer: string;
1507
- subject: string;
1508
- frozen: boolean;
1509
- requiredClaims: ({
1510
- claim: string;
1511
- op: "contains";
1512
- value: unknown;
1513
- } | {
1514
- claim: string;
1515
- op: "eq";
1516
- value: unknown;
1517
- } | {
1518
- claim: string;
1519
- op: "exists";
1520
- })[];
1521
- } | null;
1522
- }, 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"> & {
1523
- readonly name: "whois";
1524
- };
1525
- }>[Key];
1526
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1527
- }, Readonly<Readonly<{
1528
- frozen: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1529
- readonly name: "frozen";
1530
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1531
- };
1532
- iss: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1533
- readonly name: "iss";
1534
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1535
- };
1536
- requiredClaims: import("@astrale-os/sdk/schema").ResolvedProperty<({
1537
- claim: string;
1538
- op: "contains";
1539
- value: unknown;
1540
- } | {
1541
- claim: string;
1542
- op: "eq";
1543
- value: unknown;
1544
- } | {
1545
- claim: string;
1546
- op: "exists";
1547
- })[], false> & {
1548
- readonly name: "requiredClaims";
1549
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1550
- };
1551
- sub: import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1552
- readonly name: "sub";
1553
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1554
- };
1555
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1556
- readonly name: "frozen";
1557
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1558
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1559
- readonly name: "iss";
1560
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1561
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<({
1562
- claim: string;
1563
- op: "contains";
1564
- value: unknown;
1565
- } | {
1566
- claim: string;
1567
- op: "eq";
1568
- value: unknown;
1569
- } | {
1570
- claim: string;
1571
- op: "exists";
1572
- })[], false> & {
1573
- readonly name: "requiredClaims";
1574
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1575
- }) | (import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1576
- readonly name: "sub";
1577
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1578
- })> & {
1579
- readonly byKey: Readonly<{
1580
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1581
- readonly name: "frozen";
1582
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1583
- };
1584
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1585
- readonly name: "iss";
1586
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1587
- };
1588
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1589
- claim: string;
1590
- op: "contains";
1591
- value: unknown;
1592
- } | {
1593
- claim: string;
1594
- op: "eq";
1595
- value: unknown;
1596
- } | {
1597
- claim: string;
1598
- op: "exists";
1599
- })[], false> & {
1600
- readonly name: "requiredClaims";
1601
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1602
- };
1603
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1604
- readonly name: "sub";
1605
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1606
- };
1607
- }>;
1608
- 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<{
1609
- "kernel.astrale.ai:class.Identity.property.frozen": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, false> & {
1610
- readonly name: "frozen";
1611
- readonly key: "kernel.astrale.ai:class.Identity.property.frozen";
1612
- };
1613
- "kernel.astrale.ai:class.Identity.property.iss": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1614
- readonly name: "iss";
1615
- readonly key: "kernel.astrale.ai:class.Identity.property.iss";
1616
- };
1617
- "kernel.astrale.ai:class.Identity.property.requiredClaims": import("@astrale-os/sdk/schema").ResolvedProperty<({
1618
- claim: string;
1619
- op: "contains";
1620
- value: unknown;
1621
- } | {
1622
- claim: string;
1623
- op: "eq";
1624
- value: unknown;
1625
- } | {
1626
- claim: string;
1627
- op: "exists";
1628
- })[], false> & {
1629
- readonly name: "requiredClaims";
1630
- readonly key: "kernel.astrale.ai:class.Identity.property.requiredClaims";
1631
- };
1632
- "kernel.astrale.ai:class.Identity.property.sub": import("@astrale-os/sdk/schema").ResolvedProperty<import("@astrale-os/sdk/schema").Value, true> & {
1633
- readonly name: "sub";
1634
- readonly key: "kernel.astrale.ai:class.Identity.property.sub";
1635
- };
1636
- }>[Key];
1637
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
1638
- from(input: Readonly<{
1639
- 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;
1640
- 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;
1641
- readonly "kernel.astrale.ai:class.Identity.property.requiredClaims"?: ({
1642
- claim: string;
1643
- op: "contains";
1644
- value: unknown;
1645
- } | {
1646
- claim: string;
1647
- op: "eq";
1648
- value: unknown;
1649
- } | {
1650
- claim: string;
1651
- op: "exists";
1652
- })[] | undefined;
1653
- 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;
1654
- } & {
1655
- readonly frozen?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1656
- readonly iss?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1657
- readonly requiredClaims?: ({
1658
- claim: string;
1659
- op: "contains";
1660
- value: unknown;
1661
- } | {
1662
- claim: string;
1663
- op: "eq";
1664
- value: unknown;
1665
- } | {
1666
- claim: string;
1667
- op: "exists";
1668
- })[] | undefined;
1669
- readonly sub?: string | number | boolean | import("@astrale-os/sdk/schema").Array | import("@astrale-os/sdk/schema").Object | null | undefined;
1670
- }>): import("@astrale-os/sdk/schema").PropertyValues;
1671
- }, Readonly<Readonly<{
1672
- delegate: import("@astrale-os/sdk/schema").ResolvedMethod<{
1673
- audience: string;
1674
- ttlSeconds: number;
1675
- attenuation: unknown;
1676
- }, {
1677
- readonly mode: 'value';
1678
- readonly value: string;
1679
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1680
- readonly name: "delegate";
1681
- };
1682
- }>> & Iterable<import("@astrale-os/sdk/schema").ResolvedMethod<{
1683
- audience: string;
1684
- ttlSeconds: number;
1685
- attenuation: unknown;
1686
- }, {
1687
- readonly mode: 'value';
1688
- readonly value: string;
1689
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1690
- readonly name: "delegate";
1691
- }> & {
1692
- readonly byKey: Readonly<{
1693
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1694
- audience: string;
1695
- ttlSeconds: number;
1696
- attenuation: unknown;
1697
- }, {
1698
- readonly mode: 'value';
1699
- readonly value: string;
1700
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1701
- readonly name: "delegate";
1702
- };
1703
- }>;
1704
- get<Key extends "kernel.astrale.ai:class.Identity.method.delegate">(key: Key): Readonly<{
1705
- "kernel.astrale.ai:class.Identity.method.delegate": import("@astrale-os/sdk/schema").ResolvedMethod<{
1706
- audience: string;
1707
- ttlSeconds: number;
1708
- attenuation: unknown;
1709
- }, {
1710
- readonly mode: 'value';
1711
- readonly value: string;
1712
- }, false, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.delegate"> & {
1713
- readonly name: "delegate";
1714
- };
1715
- }>[Key];
1716
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
1717
- }, Readonly<Readonly<{
1718
- can: import("@astrale-os/sdk/schema").ResolvedMethod<{
1719
- policy: string;
1720
- object: string;
1721
- }, {
1722
- readonly mode: 'value';
1723
- readonly value: {
1724
- allowed: boolean;
1725
- };
1726
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1727
- readonly name: "can";
1728
- };
1729
- mint: import("@astrale-os/sdk/schema").ResolvedMethod<{
1730
- audience?: string | undefined;
1731
- ttlSeconds: number;
1732
- grant?: unknown;
1733
- }, {
1734
- readonly mode: 'value';
1735
- readonly value: string;
1736
- }, 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"> & {
1737
- readonly name: "mint";
1738
- };
1739
- whoami: import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1740
- readonly mode: 'value';
1741
- readonly value: {
1742
- id: string;
1743
- issuer: string;
1744
- subject: string;
1745
- frozen: boolean;
1746
- requiredClaims: ({
1747
- claim: string;
1748
- op: "contains";
1749
- value: unknown;
1750
- } | {
1751
- claim: string;
1752
- op: "eq";
1753
- value: unknown;
1754
- } | {
1755
- claim: string;
1756
- op: "exists";
1757
- })[];
1758
- };
1759
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1760
- readonly name: "whoami";
1761
- };
1762
- whois: import("@astrale-os/sdk/schema").ResolvedMethod<{
1763
- issuer: string;
1764
- subject: string;
1765
- }, {
1766
- readonly mode: 'value';
1767
- readonly value: {
1768
- id: string;
1769
- issuer: string;
1770
- subject: string;
1771
- frozen: boolean;
1772
- requiredClaims: ({
1773
- claim: string;
1774
- op: "contains";
1775
- value: unknown;
1776
- } | {
1777
- claim: string;
1778
- op: "eq";
1779
- value: unknown;
1780
- } | {
1781
- claim: string;
1782
- op: "exists";
1783
- })[];
1784
- } | null;
1785
- }, 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"> & {
1786
- readonly name: "whois";
1787
- };
1788
- }>> & Iterable<(import("@astrale-os/sdk/schema").ResolvedMethod<{
1789
- policy: string;
1790
- object: string;
1791
- }, {
1792
- readonly mode: 'value';
1793
- readonly value: {
1794
- allowed: boolean;
1795
- };
1796
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1797
- readonly name: "can";
1798
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1799
- audience?: string | undefined;
1800
- ttlSeconds: number;
1801
- grant?: unknown;
1802
- }, {
1803
- readonly mode: 'value';
1804
- readonly value: string;
1805
- }, 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"> & {
1806
- readonly name: "mint";
1807
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1808
- readonly mode: 'value';
1809
- readonly value: {
1810
- id: string;
1811
- issuer: string;
1812
- subject: string;
1813
- frozen: boolean;
1814
- requiredClaims: ({
1815
- claim: string;
1816
- op: "contains";
1817
- value: unknown;
1818
- } | {
1819
- claim: string;
1820
- op: "eq";
1821
- value: unknown;
1822
- } | {
1823
- claim: string;
1824
- op: "exists";
1825
- })[];
1826
- };
1827
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1828
- readonly name: "whoami";
1829
- }) | (import("@astrale-os/sdk/schema").ResolvedMethod<{
1830
- issuer: string;
1831
- subject: string;
1832
- }, {
1833
- readonly mode: 'value';
1834
- readonly value: {
1835
- id: string;
1836
- issuer: string;
1837
- subject: string;
1838
- frozen: boolean;
1839
- requiredClaims: ({
1840
- claim: string;
1841
- op: "contains";
1842
- value: unknown;
1843
- } | {
1844
- claim: string;
1845
- op: "eq";
1846
- value: unknown;
1847
- } | {
1848
- claim: string;
1849
- op: "exists";
1850
- })[];
1851
- } | null;
1852
- }, 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"> & {
1853
- readonly name: "whois";
1854
- })> & {
1855
- readonly byKey: Readonly<{
1856
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1857
- policy: string;
1858
- object: string;
1859
- }, {
1860
- readonly mode: 'value';
1861
- readonly value: {
1862
- allowed: boolean;
1863
- };
1864
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1865
- readonly name: "can";
1866
- };
1867
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1868
- audience?: string | undefined;
1869
- ttlSeconds: number;
1870
- grant?: unknown;
1871
- }, {
1872
- readonly mode: 'value';
1873
- readonly value: string;
1874
- }, 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"> & {
1875
- readonly name: "mint";
1876
- };
1877
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1878
- readonly mode: 'value';
1879
- readonly value: {
1880
- id: string;
1881
- issuer: string;
1882
- subject: string;
1883
- frozen: boolean;
1884
- requiredClaims: ({
1885
- claim: string;
1886
- op: "contains";
1887
- value: unknown;
1888
- } | {
1889
- claim: string;
1890
- op: "eq";
1891
- value: unknown;
1892
- } | {
1893
- claim: string;
1894
- op: "exists";
1895
- })[];
1896
- };
1897
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1898
- readonly name: "whoami";
1899
- };
1900
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1901
- issuer: string;
1902
- subject: string;
1903
- }, {
1904
- readonly mode: 'value';
1905
- readonly value: {
1906
- id: string;
1907
- issuer: string;
1908
- subject: string;
1909
- frozen: boolean;
1910
- requiredClaims: ({
1911
- claim: string;
1912
- op: "contains";
1913
- value: unknown;
1914
- } | {
1915
- claim: string;
1916
- op: "eq";
1917
- value: unknown;
1918
- } | {
1919
- claim: string;
1920
- op: "exists";
1921
- })[];
1922
- } | null;
1923
- }, 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"> & {
1924
- readonly name: "whois";
1925
- };
1926
- }>;
1927
- 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<{
1928
- "kernel.astrale.ai:class.Identity.method.can": import("@astrale-os/sdk/schema").ResolvedMethod<{
1929
- policy: string;
1930
- object: string;
1931
- }, {
1932
- readonly mode: 'value';
1933
- readonly value: {
1934
- allowed: boolean;
1935
- };
1936
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.can"> & {
1937
- readonly name: "can";
1938
- };
1939
- "kernel.astrale.ai:class.Identity.method.mint": import("@astrale-os/sdk/schema").ResolvedMethod<{
1940
- audience?: string | undefined;
1941
- ttlSeconds: number;
1942
- grant?: unknown;
1943
- }, {
1944
- readonly mode: 'value';
1945
- readonly value: string;
1946
- }, 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"> & {
1947
- readonly name: "mint";
1948
- };
1949
- "kernel.astrale.ai:class.Identity.method.whoami": import("@astrale-os/sdk/schema").ResolvedMethod<Record<string, never>, {
1950
- readonly mode: 'value';
1951
- readonly value: {
1952
- id: string;
1953
- issuer: string;
1954
- subject: string;
1955
- frozen: boolean;
1956
- requiredClaims: ({
1957
- claim: string;
1958
- op: "contains";
1959
- value: unknown;
1960
- } | {
1961
- claim: string;
1962
- op: "eq";
1963
- value: unknown;
1964
- } | {
1965
- claim: string;
1966
- op: "exists";
1967
- })[];
1968
- };
1969
- }, true, "default", "authenticated", never, "kernel.astrale.ai:class.Identity.method.whoami"> & {
1970
- readonly name: "whoami";
1971
- };
1972
- "kernel.astrale.ai:class.Identity.method.whois": import("@astrale-os/sdk/schema").ResolvedMethod<{
1973
- issuer: string;
1974
- subject: string;
1975
- }, {
1976
- readonly mode: 'value';
1977
- readonly value: {
1978
- id: string;
1979
- issuer: string;
1980
- subject: string;
1981
- frozen: boolean;
1982
- requiredClaims: ({
1983
- claim: string;
1984
- op: "contains";
1985
- value: unknown;
1986
- } | {
1987
- claim: string;
1988
- op: "eq";
1989
- value: unknown;
1990
- } | {
1991
- claim: string;
1992
- op: "exists";
1993
- })[];
1994
- } | null;
1995
- }, 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"> & {
1996
- readonly name: "whois";
1997
- };
1998
- }>[Key];
1999
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2000
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2001
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
2002
- readonly origin: "kernel.astrale.ai";
2003
- };
2004
- readonly kind: 'node';
2005
- readonly abstract: true;
2006
- }, readonly [import("@astrale-os/sdk/schema").ResolvedClass<"node", Readonly<Readonly<{}>> & Iterable<never> & {
2007
- readonly byKey: Readonly<{}>;
2008
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2009
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2010
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2011
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2012
- readonly byKey: Readonly<{}>;
2013
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2014
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2015
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2016
- readonly byKey: Readonly<{}>;
2017
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2018
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2019
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2020
- readonly byKey: Readonly<{}>;
2021
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2022
- get(key: import("@astrale-os/sdk/schema").PropertyKey): import("@astrale-os/sdk/schema").ResolvedProperty | undefined;
2023
- from(input: Readonly<{} & {}>): import("@astrale-os/sdk/schema").PropertyValues;
2024
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2025
- readonly byKey: Readonly<{}>;
2026
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2027
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2028
- }, Readonly<Readonly<{}>> & Iterable<never> & {
2029
- readonly byKey: Readonly<{}>;
2030
- get<Key extends never>(key: Key): Readonly<{}>[Key];
2031
- get(key: import("@astrale-os/sdk/schema").MethodKey): import("@astrale-os/sdk/schema").ResolvedMethod | undefined;
2032
- }, import("@astrale-os/sdk/schema").NodeClassDefinition & {
2033
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2034
- readonly origin: "kernel.astrale.ai";
2035
- };
2036
- readonly kind: 'node';
2037
- readonly abstract: true;
2038
- }, readonly []> & {
2039
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Node"> & {
2040
- readonly origin: "kernel.astrale.ai";
2041
- };
2042
- readonly key: "kernel.astrale.ai:class.Node";
2043
- }]> & {
2044
- readonly ref: import("@astrale-os/sdk/schema").ClassRef<"Identity"> & {
2045
- readonly origin: "kernel.astrale.ai";
2046
- };
2047
- readonly key: "kernel.astrale.ai:class.Identity";
2048
- }];
2049
- readonly properties: {
2050
- displayName: import("@astrale-os/sdk/schema").Property<z.ZodString, {
2051
- readonly required: false;
2052
- }>;
2053
- };
2054
- readonly methods: {
2055
- readonly resolveHome: import("@astrale-os/sdk/schema").Method<{
2056
- readonly description: "Resolve this User and its canonical personal Space.";
2057
- readonly auth: "authenticated";
2058
- readonly input: z.ZodObject<{}, z.core.$strict>;
2059
- readonly output: z.ZodObject<{
2060
- userId: z.ZodString;
2061
- personalSpaceId: z.ZodNullable<z.ZodString>;
2062
- }, z.core.$strict>;
2063
- }>;
2064
- };
2065
- }>]>;
2066
- }, z.core.$strict>;
2067
- readonly output: {
2068
- type: 'object';
2069
- properties: {};
2070
- additionalProperties: boolean;
2071
- };
2072
- readonly auth: "authorized";
2073
- readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
2074
- }>;
2075
- export declare const spaceSetDefault: import("@astrale-os/sdk/schema").Method<{
2076
- readonly description: "Set this accessible Space as the granted User fallback.";
2077
- readonly input: {
2078
- type: 'object';
2079
- properties: {};
2080
- additionalProperties: boolean;
2081
- };
2082
- readonly output: {
2083
- type: 'object';
2084
- properties: {};
2085
- additionalProperties: boolean;
2086
- };
2087
- readonly auth: "authorized";
2088
- readonly policy: ({ check, self }: import("@astrale-os/sdk/schema").CallablePolicyContext) => import("@astrale-os/sdk/schema").PolicyCheckExpression;
2089
- }>;
1
+ import { type builder } from '@astrale-os/sdk/schema';
2
+ export declare const spaceAddUser: builder.Method<builder.CallableProjection<{
3
+ user: string;
4
+ access: "admin" | "member";
5
+ }, {
6
+ readonly mode: 'value';
7
+ readonly value: import("@astrale-os/sdk/schema").Value;
8
+ }, "authorized", false, "default">>;
9
+ export declare const spaceRemoveUser: builder.Method<builder.CallableProjection<{
10
+ user: string;
11
+ }, {
12
+ readonly mode: 'value';
13
+ readonly value: import("@astrale-os/sdk/schema").Value;
14
+ }, "authorized", false, "default">>;
15
+ export declare const spaceSetDefault: builder.Method<builder.CallableProjection<import("@astrale-os/sdk/schema").Value, {
16
+ readonly mode: 'value';
17
+ readonly value: import("@astrale-os/sdk/schema").Value;
18
+ }, "authorized", false, "default">>;