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

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