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