@bsb/registry 1.0.4 → 1.1.1

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 (38) hide show
  1. package/README.md +1 -1
  2. package/lib/.bsb/clients/service-bsb-registry.d.ts +348 -982
  3. package/lib/.bsb/clients/service-bsb-registry.d.ts.map +1 -1
  4. package/lib/.bsb/clients/service-bsb-registry.js +287 -291
  5. package/lib/.bsb/clients/service-bsb-registry.js.map +1 -1
  6. package/lib/plugins/service-bsb-registry/auth.d.ts +2 -2
  7. package/lib/plugins/service-bsb-registry/auth.d.ts.map +1 -1
  8. package/lib/plugins/service-bsb-registry/auth.js +5 -9
  9. package/lib/plugins/service-bsb-registry/auth.js.map +1 -1
  10. package/lib/plugins/service-bsb-registry/db/file.d.ts +2 -2
  11. package/lib/plugins/service-bsb-registry/db/file.d.ts.map +1 -1
  12. package/lib/plugins/service-bsb-registry/db/file.js +3 -40
  13. package/lib/plugins/service-bsb-registry/db/file.js.map +1 -1
  14. package/lib/plugins/service-bsb-registry/db/index.d.ts +1 -1
  15. package/lib/plugins/service-bsb-registry/db/index.d.ts.map +1 -1
  16. package/lib/plugins/service-bsb-registry/db/index.js +3 -6
  17. package/lib/plugins/service-bsb-registry/db/index.js.map +1 -1
  18. package/lib/plugins/service-bsb-registry/index.d.ts +377 -1020
  19. package/lib/plugins/service-bsb-registry/index.d.ts.map +1 -1
  20. package/lib/plugins/service-bsb-registry/index.js +58 -95
  21. package/lib/plugins/service-bsb-registry/index.js.map +1 -1
  22. package/lib/plugins/service-bsb-registry/types.d.ts +197 -517
  23. package/lib/plugins/service-bsb-registry/types.d.ts.map +1 -1
  24. package/lib/plugins/service-bsb-registry/types.js +164 -167
  25. package/lib/plugins/service-bsb-registry/types.js.map +1 -1
  26. package/lib/plugins/service-bsb-registry-ui/http-server.d.ts +2 -2
  27. package/lib/plugins/service-bsb-registry-ui/http-server.d.ts.map +1 -1
  28. package/lib/plugins/service-bsb-registry-ui/http-server.js +229 -181
  29. package/lib/plugins/service-bsb-registry-ui/http-server.js.map +1 -1
  30. package/lib/plugins/service-bsb-registry-ui/index.d.ts +27 -27
  31. package/lib/plugins/service-bsb-registry-ui/index.d.ts.map +1 -1
  32. package/lib/plugins/service-bsb-registry-ui/index.js +22 -26
  33. package/lib/plugins/service-bsb-registry-ui/index.js.map +1 -1
  34. package/lib/schemas/service-bsb-registry-ui.json +1 -46
  35. package/lib/schemas/service-bsb-registry-ui.plugin.json +2 -47
  36. package/lib/schemas/service-bsb-registry.json +1903 -1693
  37. package/lib/schemas/service-bsb-registry.plugin.json +1 -47
  38. package/package.json +4 -7
package/lib/plugins/service-bsb-registry/index.d.ts CHANGED
@@ -1,21 +1,18 @@
1
- import { z } from 'zod';
1
+ import * as av from '@anyvali/js';
2
2
  import { BSBService, BSBServiceConstructor, Observable } from '@bsb/base';
3
3
  /**
4
4
  * Configuration schema for BSB Registry (Core - Event-Driven).
5
5
  */
6
- export declare const RegistryConfigSchema: z.ZodObject<{
7
- database: z.ZodObject<{
8
- type: z.ZodDefault<z.ZodEnum<{
9
- file: "file";
10
- postgres: "postgres";
11
- }>>;
12
- path: z.ZodDefault<z.ZodString>;
13
- }, z.core.$strip>;
14
- auth: z.ZodObject<{
15
- requireAuth: z.ZodDefault<z.ZodBoolean>;
16
- }, z.core.$strip>;
17
- }, z.core.$strip>;
18
- export type RegistryConfig = z.infer<typeof RegistryConfigSchema>;
6
+ export declare const RegistryConfigSchema: av.ObjectSchema<{
7
+ database: av.ObjectSchema<{
8
+ type: av.OptionalSchema<av.EnumSchema<string[]>>;
9
+ path: av.OptionalSchema<av.StringSchema>;
10
+ }>;
11
+ auth: av.ObjectSchema<{
12
+ requireAuth: av.OptionalSchema<av.BoolSchema>;
13
+ }>;
14
+ }>;
15
+ export type RegistryConfig = av.Infer<typeof RegistryConfigSchema>;
19
16
  /**
20
17
  * Event schemas for BSB Registry Core.
21
18
  * All operations are event-driven for maximum flexibility.
@@ -23,537 +20,220 @@ export type RegistryConfig = z.infer<typeof RegistryConfigSchema>;
23
20
  export declare const EventSchemas: {
24
21
  readonly onReturnableEvents: {
25
22
  readonly 'registry.plugin.publish': {
26
- input: {
27
- _bsb: "object";
28
- properties: {
29
- readonly org: import("@bsb/base").BSBStringType;
30
- readonly name: import("@bsb/base").BSBStringType;
31
- readonly version: import("@bsb/base").BSBStringType;
32
- readonly language: import("@bsb/base").BSBEnumType;
33
- readonly metadata: {
34
- _bsb: "object";
35
- properties: {
36
- readonly displayName: import("@bsb/base").BSBStringType;
37
- readonly description: import("@bsb/base").BSBStringType;
38
- readonly category: import("@bsb/base").BSBEnumType;
39
- readonly tags: import("@bsb/base").BSBArrayType;
40
- readonly author: import("@bsb/base").BSBUnionType & {
41
- optional: true;
42
- };
43
- readonly license: import("@bsb/base").BSBStringType & {
44
- optional: true;
45
- };
46
- readonly homepage: import("@bsb/base").BSBStringType & {
47
- optional: true;
48
- };
49
- readonly repository: import("@bsb/base").BSBStringType & {
50
- optional: true;
51
- };
52
- };
53
- required: string[];
54
- description?: string;
55
- optional?: boolean;
56
- nullable?: boolean;
57
- };
58
- readonly eventSchema: import("@bsb/base").BSBType;
59
- readonly capabilities: import("@bsb/base").BSBType & {
60
- optional: true;
61
- };
62
- readonly configSchema: import("@bsb/base").BSBType & {
63
- optional: true;
64
- };
65
- readonly typeDefinitions: {
66
- _bsb: "object";
67
- properties: {
68
- readonly nodejs: import("@bsb/base").BSBStringType & {
69
- optional: true;
70
- };
71
- readonly csharp: import("@bsb/base").BSBStringType & {
72
- optional: true;
73
- };
74
- readonly go: import("@bsb/base").BSBStringType & {
75
- optional: true;
76
- };
77
- readonly java: import("@bsb/base").BSBStringType & {
78
- optional: true;
79
- };
80
- };
81
- required: string[];
82
- description?: string;
83
- optional?: boolean;
84
- nullable?: boolean;
85
- } & {
86
- optional: true;
87
- };
88
- readonly documentation: import("@bsb/base").BSBArrayType;
89
- readonly dependencies: import("@bsb/base").BSBArrayType & {
90
- optional: true;
91
- };
92
- readonly package: {
93
- _bsb: "object";
94
- properties: {
95
- readonly nodejs: import("@bsb/base").BSBStringType & {
96
- optional: true;
97
- };
98
- readonly csharp: import("@bsb/base").BSBStringType & {
99
- optional: true;
100
- };
101
- readonly go: import("@bsb/base").BSBStringType & {
102
- optional: true;
103
- };
104
- readonly java: import("@bsb/base").BSBStringType & {
105
- optional: true;
106
- };
107
- readonly python: import("@bsb/base").BSBStringType & {
108
- optional: true;
109
- };
110
- };
111
- required: string[];
112
- description?: string;
113
- optional?: boolean;
114
- nullable?: boolean;
115
- } & {
116
- optional: true;
117
- };
118
- readonly runtime: {
119
- _bsb: "object";
120
- properties: {
121
- readonly nodejs: import("@bsb/base").BSBStringType & {
122
- optional: true;
123
- };
124
- readonly dotnet: import("@bsb/base").BSBStringType & {
125
- optional: true;
126
- };
127
- readonly go: import("@bsb/base").BSBStringType & {
128
- optional: true;
129
- };
130
- readonly java: import("@bsb/base").BSBStringType & {
131
- optional: true;
132
- };
133
- readonly python: import("@bsb/base").BSBStringType & {
134
- optional: true;
135
- };
136
- };
137
- required: string[];
138
- description?: string;
139
- optional?: boolean;
140
- nullable?: boolean;
141
- } & {
142
- optional: true;
143
- };
144
- readonly visibility: import("@bsb/base").BSBEnumType & {
145
- optional: true;
146
- };
147
- readonly publishedBy: import("@bsb/base").BSBStringType & {
148
- optional: true;
149
- };
150
- };
151
- required: string[];
152
- description?: string;
153
- optional?: boolean;
154
- nullable?: boolean;
155
- };
156
- output: {
157
- _bsb: "object";
158
- properties: {
159
- readonly success: import("@bsb/base").BSBBooleanType;
160
- readonly pluginId: import("@bsb/base").BSBStringType;
161
- readonly version: import("@bsb/base").BSBStringType;
162
- readonly message: import("@bsb/base").BSBStringType & {
163
- optional: true;
164
- };
165
- };
166
- required: string[];
167
- description?: string;
168
- optional?: boolean;
169
- nullable?: boolean;
170
- };
23
+ input: av.ObjectSchema<{
24
+ org: av.StringSchema;
25
+ name: av.StringSchema;
26
+ version: av.StringSchema;
27
+ language: av.EnumSchema<readonly (string | number)[]>;
28
+ metadata: av.ObjectSchema<{
29
+ displayName: av.StringSchema;
30
+ description: av.StringSchema;
31
+ category: av.EnumSchema<readonly (string | number)[]>;
32
+ tags: av.ArraySchema<import("@bsb/base").BSBType>;
33
+ author: av.OptionalSchema<av.UnknownSchema | av.UnionSchema<[import("@bsb/base").BSBType, ...import("@bsb/base").BSBType[]]>>;
34
+ license: av.OptionalSchema<av.StringSchema>;
35
+ homepage: av.OptionalSchema<av.StringSchema>;
36
+ repository: av.OptionalSchema<av.StringSchema>;
37
+ }>;
38
+ eventSchema: av.UnknownSchema;
39
+ capabilities: av.OptionalSchema<av.UnknownSchema>;
40
+ configSchema: av.OptionalSchema<av.UnknownSchema>;
41
+ typeDefinitions: av.OptionalSchema<av.ObjectSchema<{
42
+ nodejs: av.OptionalSchema<av.StringSchema>;
43
+ csharp: av.OptionalSchema<av.StringSchema>;
44
+ go: av.OptionalSchema<av.StringSchema>;
45
+ java: av.OptionalSchema<av.StringSchema>;
46
+ }>>;
47
+ documentation: av.ArraySchema<import("@bsb/base").BSBType>;
48
+ dependencies: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
49
+ package: av.OptionalSchema<av.ObjectSchema<{
50
+ nodejs: av.OptionalSchema<av.StringSchema>;
51
+ csharp: av.OptionalSchema<av.StringSchema>;
52
+ go: av.OptionalSchema<av.StringSchema>;
53
+ java: av.OptionalSchema<av.StringSchema>;
54
+ python: av.OptionalSchema<av.StringSchema>;
55
+ }>>;
56
+ runtime: av.OptionalSchema<av.ObjectSchema<{
57
+ nodejs: av.OptionalSchema<av.StringSchema>;
58
+ dotnet: av.OptionalSchema<av.StringSchema>;
59
+ go: av.OptionalSchema<av.StringSchema>;
60
+ java: av.OptionalSchema<av.StringSchema>;
61
+ python: av.OptionalSchema<av.StringSchema>;
62
+ }>>;
63
+ visibility: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
64
+ publishedBy: av.OptionalSchema<av.StringSchema>;
65
+ }>;
66
+ output: av.ObjectSchema<{
67
+ success: av.BoolSchema;
68
+ pluginId: av.StringSchema;
69
+ version: av.StringSchema;
70
+ message: av.OptionalSchema<av.StringSchema>;
71
+ }>;
171
72
  description?: string;
172
73
  defaultTimeout?: number;
173
74
  readonly __brand: "returnable";
174
75
  };
175
76
  readonly 'registry.plugin.get': {
176
- input: {
177
- _bsb: "object";
178
- properties: {
179
- readonly org: import("@bsb/base").BSBStringType;
180
- readonly name: import("@bsb/base").BSBStringType;
181
- readonly version: import("@bsb/base").BSBStringType & {
182
- optional: true;
183
- };
184
- };
185
- required: string[];
186
- description?: string;
187
- optional?: boolean;
188
- nullable?: boolean;
189
- };
190
- output: {
191
- _bsb: "object";
192
- properties: {
193
- readonly id: import("@bsb/base").BSBStringType;
194
- readonly org: import("@bsb/base").BSBStringType;
195
- readonly name: import("@bsb/base").BSBStringType;
196
- readonly displayName: import("@bsb/base").BSBStringType;
197
- readonly description: import("@bsb/base").BSBStringType;
198
- readonly version: import("@bsb/base").BSBStringType;
199
- readonly majorMinor: import("@bsb/base").BSBStringType;
200
- readonly language: import("@bsb/base").BSBEnumType;
201
- readonly package: {
202
- _bsb: "object";
203
- properties: {
204
- readonly nodejs: import("@bsb/base").BSBStringType & {
205
- optional: true;
206
- };
207
- readonly csharp: import("@bsb/base").BSBStringType & {
208
- optional: true;
209
- };
210
- readonly go: import("@bsb/base").BSBStringType & {
211
- optional: true;
212
- };
213
- readonly java: import("@bsb/base").BSBStringType & {
214
- optional: true;
215
- };
216
- readonly python: import("@bsb/base").BSBStringType & {
217
- optional: true;
218
- };
219
- };
220
- required: string[];
221
- description?: string;
222
- optional?: boolean;
223
- nullable?: boolean;
224
- } & {
225
- optional: true;
226
- };
227
- readonly category: import("@bsb/base").BSBEnumType;
228
- readonly tags: import("@bsb/base").BSBArrayType;
229
- readonly author: import("@bsb/base").BSBUnionType & {
230
- optional: true;
231
- };
232
- readonly license: import("@bsb/base").BSBStringType & {
233
- optional: true;
234
- };
235
- readonly homepage: import("@bsb/base").BSBStringType & {
236
- optional: true;
237
- };
238
- readonly repository: import("@bsb/base").BSBStringType & {
239
- optional: true;
240
- };
241
- readonly visibility: import("@bsb/base").BSBEnumType;
242
- readonly eventSchema: import("@bsb/base").BSBType;
243
- readonly capabilities: import("@bsb/base").BSBType & {
244
- optional: true;
245
- };
246
- readonly configSchema: import("@bsb/base").BSBType & {
247
- optional: true;
248
- };
249
- readonly typeDefinitions: {
250
- _bsb: "object";
251
- properties: {
252
- readonly nodejs: import("@bsb/base").BSBStringType & {
253
- optional: true;
254
- };
255
- readonly csharp: import("@bsb/base").BSBStringType & {
256
- optional: true;
257
- };
258
- readonly go: import("@bsb/base").BSBStringType & {
259
- optional: true;
260
- };
261
- readonly java: import("@bsb/base").BSBStringType & {
262
- optional: true;
263
- };
264
- };
265
- required: string[];
266
- description?: string;
267
- optional?: boolean;
268
- nullable?: boolean;
269
- } & {
270
- optional: true;
271
- };
272
- readonly documentation: import("@bsb/base").BSBArrayType & {
273
- optional: true;
274
- };
275
- readonly dependencies: import("@bsb/base").BSBArrayType & {
276
- optional: true;
277
- };
278
- readonly permissions: import("@bsb/base").BSBArrayType & {
279
- optional: true;
280
- };
281
- readonly eventCount: import("@bsb/base").BSBNumberType;
282
- readonly emitEventCount: import("@bsb/base").BSBNumberType;
283
- readonly onEventCount: import("@bsb/base").BSBNumberType;
284
- readonly returnableEventCount: import("@bsb/base").BSBNumberType;
285
- readonly broadcastEventCount: import("@bsb/base").BSBNumberType;
286
- readonly publishedBy: import("@bsb/base").BSBStringType;
287
- readonly publishedAt: import("@bsb/base").BSBStringType;
288
- readonly updatedAt: import("@bsb/base").BSBStringType;
289
- readonly downloads: import("@bsb/base").BSBNumberType & {
290
- optional: true;
291
- };
292
- readonly runtime: {
293
- _bsb: "object";
294
- properties: {
295
- readonly nodejs: import("@bsb/base").BSBStringType & {
296
- optional: true;
297
- };
298
- readonly dotnet: import("@bsb/base").BSBStringType & {
299
- optional: true;
300
- };
301
- readonly go: import("@bsb/base").BSBStringType & {
302
- optional: true;
303
- };
304
- readonly java: import("@bsb/base").BSBStringType & {
305
- optional: true;
306
- };
307
- readonly python: import("@bsb/base").BSBStringType & {
308
- optional: true;
309
- };
310
- };
311
- required: string[];
312
- description?: string;
313
- optional?: boolean;
314
- nullable?: boolean;
315
- } & {
316
- optional: true;
317
- };
318
- };
319
- required: string[];
320
- description?: string;
321
- optional?: boolean;
322
- nullable?: boolean;
323
- };
77
+ input: av.ObjectSchema<{
78
+ org: av.StringSchema;
79
+ name: av.StringSchema;
80
+ version: av.OptionalSchema<av.StringSchema>;
81
+ }>;
82
+ output: av.ObjectSchema<{
83
+ id: av.StringSchema;
84
+ org: av.StringSchema;
85
+ name: av.StringSchema;
86
+ displayName: av.StringSchema;
87
+ description: av.StringSchema;
88
+ version: av.StringSchema;
89
+ majorMinor: av.StringSchema;
90
+ language: av.EnumSchema<readonly (string | number)[]>;
91
+ package: av.OptionalSchema<av.ObjectSchema<{
92
+ nodejs: av.OptionalSchema<av.StringSchema>;
93
+ csharp: av.OptionalSchema<av.StringSchema>;
94
+ go: av.OptionalSchema<av.StringSchema>;
95
+ java: av.OptionalSchema<av.StringSchema>;
96
+ python: av.OptionalSchema<av.StringSchema>;
97
+ }>>;
98
+ category: av.EnumSchema<readonly (string | number)[]>;
99
+ tags: av.ArraySchema<import("@bsb/base").BSBType>;
100
+ author: av.OptionalSchema<av.UnknownSchema | av.UnionSchema<[import("@bsb/base").BSBType, ...import("@bsb/base").BSBType[]]>>;
101
+ license: av.OptionalSchema<av.StringSchema>;
102
+ homepage: av.OptionalSchema<av.StringSchema>;
103
+ repository: av.OptionalSchema<av.StringSchema>;
104
+ visibility: av.EnumSchema<readonly (string | number)[]>;
105
+ eventSchema: av.UnknownSchema;
106
+ capabilities: av.OptionalSchema<av.UnknownSchema>;
107
+ configSchema: av.OptionalSchema<av.UnknownSchema>;
108
+ typeDefinitions: av.OptionalSchema<av.ObjectSchema<{
109
+ nodejs: av.OptionalSchema<av.StringSchema>;
110
+ csharp: av.OptionalSchema<av.StringSchema>;
111
+ go: av.OptionalSchema<av.StringSchema>;
112
+ java: av.OptionalSchema<av.StringSchema>;
113
+ }>>;
114
+ documentation: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
115
+ dependencies: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
116
+ permissions: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
117
+ eventCount: import("@bsb/base").BSBType;
118
+ emitEventCount: import("@bsb/base").BSBType;
119
+ onEventCount: import("@bsb/base").BSBType;
120
+ returnableEventCount: import("@bsb/base").BSBType;
121
+ broadcastEventCount: import("@bsb/base").BSBType;
122
+ publishedBy: av.StringSchema;
123
+ publishedAt: av.StringSchema;
124
+ updatedAt: av.StringSchema;
125
+ downloads: av.OptionalSchema<import("@bsb/base").BSBType>;
126
+ runtime: av.OptionalSchema<av.ObjectSchema<{
127
+ nodejs: av.OptionalSchema<av.StringSchema>;
128
+ dotnet: av.OptionalSchema<av.StringSchema>;
129
+ go: av.OptionalSchema<av.StringSchema>;
130
+ java: av.OptionalSchema<av.StringSchema>;
131
+ python: av.OptionalSchema<av.StringSchema>;
132
+ }>>;
133
+ }>;
324
134
  description?: string;
325
135
  defaultTimeout?: number;
326
136
  readonly __brand: "returnable";
327
137
  };
328
138
  readonly 'registry.plugin.list': {
329
- input: {
330
- _bsb: "object";
331
- properties: {
332
- readonly org: import("@bsb/base").BSBStringType & {
333
- optional: true;
334
- };
335
- readonly language: import("@bsb/base").BSBEnumType & {
336
- optional: true;
337
- };
338
- readonly category: import("@bsb/base").BSBEnumType & {
339
- optional: true;
340
- };
341
- readonly limit: import("@bsb/base").BSBNumberType & {
342
- optional: true;
343
- };
344
- readonly offset: import("@bsb/base").BSBNumberType & {
345
- optional: true;
346
- };
347
- };
348
- required: string[];
349
- description?: string;
350
- optional?: boolean;
351
- nullable?: boolean;
352
- };
353
- output: {
354
- _bsb: "object";
355
- properties: {
356
- readonly results: import("@bsb/base").BSBArrayType;
357
- readonly total: import("@bsb/base").BSBNumberType;
358
- readonly page: import("@bsb/base").BSBNumberType;
359
- };
360
- required: string[];
361
- description?: string;
362
- optional?: boolean;
363
- nullable?: boolean;
364
- };
139
+ input: av.ObjectSchema<{
140
+ org: av.OptionalSchema<av.StringSchema>;
141
+ language: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
142
+ category: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
143
+ limit: av.OptionalSchema<import("@bsb/base").BSBType>;
144
+ offset: av.OptionalSchema<import("@bsb/base").BSBType>;
145
+ }>;
146
+ output: av.ObjectSchema<{
147
+ results: av.ArraySchema<import("@bsb/base").BSBType>;
148
+ total: import("@bsb/base").BSBType;
149
+ page: import("@bsb/base").BSBType;
150
+ }>;
365
151
  description?: string;
366
152
  defaultTimeout?: number;
367
153
  readonly __brand: "returnable";
368
154
  };
369
155
  readonly 'registry.plugin.search': {
370
- input: {
371
- _bsb: "object";
372
- properties: {
373
- readonly query: import("@bsb/base").BSBStringType;
374
- readonly language: import("@bsb/base").BSBEnumType & {
375
- optional: true;
376
- };
377
- readonly category: import("@bsb/base").BSBEnumType & {
378
- optional: true;
379
- };
380
- readonly limit: import("@bsb/base").BSBNumberType & {
381
- optional: true;
382
- };
383
- readonly offset: import("@bsb/base").BSBNumberType & {
384
- optional: true;
385
- };
386
- };
387
- required: string[];
388
- description?: string;
389
- optional?: boolean;
390
- nullable?: boolean;
391
- };
392
- output: {
393
- _bsb: "object";
394
- properties: {
395
- readonly results: import("@bsb/base").BSBArrayType;
396
- readonly total: import("@bsb/base").BSBNumberType;
397
- readonly query: import("@bsb/base").BSBStringType;
398
- };
399
- required: string[];
400
- description?: string;
401
- optional?: boolean;
402
- nullable?: boolean;
403
- };
156
+ input: av.ObjectSchema<{
157
+ query: av.StringSchema;
158
+ language: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
159
+ category: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
160
+ limit: av.OptionalSchema<import("@bsb/base").BSBType>;
161
+ offset: av.OptionalSchema<import("@bsb/base").BSBType>;
162
+ }>;
163
+ output: av.ObjectSchema<{
164
+ results: av.ArraySchema<import("@bsb/base").BSBType>;
165
+ total: import("@bsb/base").BSBType;
166
+ query: av.StringSchema;
167
+ }>;
404
168
  description?: string;
405
169
  defaultTimeout?: number;
406
170
  readonly __brand: "returnable";
407
171
  };
408
172
  readonly 'registry.plugin.delete': {
409
- input: {
410
- _bsb: "object";
411
- properties: {
412
- readonly org: import("@bsb/base").BSBStringType;
413
- readonly name: import("@bsb/base").BSBStringType;
414
- readonly version: import("@bsb/base").BSBStringType & {
415
- optional: true;
416
- };
417
- };
418
- required: string[];
419
- description?: string;
420
- optional?: boolean;
421
- nullable?: boolean;
422
- };
423
- output: {
424
- _bsb: "object";
425
- properties: {
426
- readonly success: import("@bsb/base").BSBBooleanType;
427
- readonly deleted: import("@bsb/base").BSBNumberType;
428
- };
429
- required: string[];
430
- description?: string;
431
- optional?: boolean;
432
- nullable?: boolean;
433
- };
173
+ input: av.ObjectSchema<{
174
+ org: av.StringSchema;
175
+ name: av.StringSchema;
176
+ version: av.OptionalSchema<av.StringSchema>;
177
+ }>;
178
+ output: av.ObjectSchema<{
179
+ success: av.BoolSchema;
180
+ deleted: import("@bsb/base").BSBType;
181
+ }>;
434
182
  description?: string;
435
183
  defaultTimeout?: number;
436
184
  readonly __brand: "returnable";
437
185
  };
438
186
  readonly 'registry.plugin.versions': {
439
- input: {
440
- _bsb: "object";
441
- properties: {
442
- readonly org: import("@bsb/base").BSBStringType;
443
- readonly name: import("@bsb/base").BSBStringType;
444
- readonly majorMinor: import("@bsb/base").BSBStringType & {
445
- optional: true;
446
- };
447
- };
448
- required: string[];
449
- description?: string;
450
- optional?: boolean;
451
- nullable?: boolean;
452
- };
453
- output: {
454
- _bsb: "object";
455
- properties: {
456
- readonly versions: import("@bsb/base").BSBArrayType;
457
- readonly latest: import("@bsb/base").BSBStringType;
458
- readonly latestForMajorMinor: import("@bsb/base").BSBStringType;
459
- };
460
- required: string[];
461
- description?: string;
462
- optional?: boolean;
463
- nullable?: boolean;
464
- };
187
+ input: av.ObjectSchema<{
188
+ org: av.StringSchema;
189
+ name: av.StringSchema;
190
+ majorMinor: av.OptionalSchema<av.StringSchema>;
191
+ }>;
192
+ output: av.ObjectSchema<{
193
+ versions: av.ArraySchema<import("@bsb/base").BSBType>;
194
+ latest: av.StringSchema;
195
+ latestForMajorMinor: av.StringSchema;
196
+ }>;
465
197
  description?: string;
466
198
  defaultTimeout?: number;
467
199
  readonly __brand: "returnable";
468
200
  };
469
201
  readonly 'registry.stats.get': {
470
- input: {
471
- _bsb: "object";
472
- properties: {};
473
- required: string[];
474
- description?: string;
475
- optional?: boolean;
476
- nullable?: boolean;
477
- };
478
- output: {
479
- _bsb: "object";
480
- properties: {
481
- readonly totalPlugins: import("@bsb/base").BSBNumberType;
482
- readonly byLanguage: import("@bsb/base").BSBStringType;
483
- readonly byCategory: import("@bsb/base").BSBStringType;
484
- readonly totalDownloads: import("@bsb/base").BSBNumberType;
485
- };
486
- required: string[];
487
- description?: string;
488
- optional?: boolean;
489
- nullable?: boolean;
490
- };
202
+ input: av.ObjectSchema<{}>;
203
+ output: av.ObjectSchema<{
204
+ totalPlugins: import("@bsb/base").BSBType;
205
+ byLanguage: av.StringSchema;
206
+ byCategory: av.StringSchema;
207
+ totalDownloads: import("@bsb/base").BSBType;
208
+ }>;
491
209
  description?: string;
492
210
  defaultTimeout?: number;
493
211
  readonly __brand: "returnable";
494
212
  };
495
213
  readonly 'registry.auth.login': {
496
- input: {
497
- _bsb: "object";
498
- properties: {
499
- readonly username: import("@bsb/base").BSBStringType;
500
- readonly password: import("@bsb/base").BSBStringType;
501
- };
502
- required: string[];
503
- description?: string;
504
- optional?: boolean;
505
- nullable?: boolean;
506
- };
507
- output: {
508
- _bsb: "object";
509
- properties: {
510
- readonly success: import("@bsb/base").BSBBooleanType;
511
- readonly token: import("@bsb/base").BSBStringType & {
512
- optional: true;
513
- };
514
- readonly expiresAt: import("@bsb/base").BSBStringType & {
515
- optional: true;
516
- };
517
- readonly message: import("@bsb/base").BSBStringType & {
518
- optional: true;
519
- };
520
- };
521
- required: string[];
522
- description?: string;
523
- optional?: boolean;
524
- nullable?: boolean;
525
- };
214
+ input: av.ObjectSchema<{
215
+ username: av.StringSchema;
216
+ password: av.StringSchema;
217
+ }>;
218
+ output: av.ObjectSchema<{
219
+ success: av.BoolSchema;
220
+ token: av.OptionalSchema<av.StringSchema>;
221
+ expiresAt: av.OptionalSchema<av.StringSchema>;
222
+ message: av.OptionalSchema<av.StringSchema>;
223
+ }>;
526
224
  description?: string;
527
225
  defaultTimeout?: number;
528
226
  readonly __brand: "returnable";
529
227
  };
530
228
  readonly 'registry.auth.verify': {
531
- input: {
532
- _bsb: "object";
533
- properties: {
534
- readonly token: import("@bsb/base").BSBStringType;
535
- };
536
- required: string[];
537
- description?: string;
538
- optional?: boolean;
539
- nullable?: boolean;
540
- };
541
- output: {
542
- _bsb: "object";
543
- properties: {
544
- readonly valid: import("@bsb/base").BSBBooleanType;
545
- readonly userId: import("@bsb/base").BSBStringType & {
546
- optional: true;
547
- };
548
- readonly permissions: import("@bsb/base").BSBArrayType & {
549
- optional: true;
550
- };
551
- };
552
- required: string[];
553
- description?: string;
554
- optional?: boolean;
555
- nullable?: boolean;
556
- };
229
+ input: av.ObjectSchema<{
230
+ token: av.StringSchema;
231
+ }>;
232
+ output: av.ObjectSchema<{
233
+ valid: av.BoolSchema;
234
+ userId: av.OptionalSchema<av.StringSchema>;
235
+ permissions: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
236
+ }>;
557
237
  description?: string;
558
238
  defaultTimeout?: number;
559
239
  readonly __brand: "returnable";
@@ -563,18 +243,15 @@ export declare const EventSchemas: {
563
243
  /**
564
244
  * Config for BSB Registry Core.
565
245
  */
566
- export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
567
- database: z.ZodObject<{
568
- type: z.ZodDefault<z.ZodEnum<{
569
- file: "file";
570
- postgres: "postgres";
571
- }>>;
572
- path: z.ZodDefault<z.ZodString>;
573
- }, z.core.$strip>;
574
- auth: z.ZodObject<{
575
- requireAuth: z.ZodDefault<z.ZodBoolean>;
576
- }, z.core.$strip>;
577
- }, z.core.$strip>>;
246
+ export declare const Config: import("@bsb/base").BSBPluginConfigClass<av.ObjectSchema<{
247
+ database: av.ObjectSchema<{
248
+ type: av.OptionalSchema<av.EnumSchema<string[]>>;
249
+ path: av.OptionalSchema<av.StringSchema>;
250
+ }>;
251
+ auth: av.ObjectSchema<{
252
+ requireAuth: av.OptionalSchema<av.BoolSchema>;
253
+ }>;
254
+ }>>;
578
255
  /**
579
256
  * BSB Registry Core Plugin (Event-Driven)
580
257
  *
@@ -606,552 +283,232 @@ export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObjec
606
283
  * - registry.auth.verify - Verify token
607
284
  */
608
285
  export declare class Plugin extends BSBService<InstanceType<typeof Config>, typeof EventSchemas> {
609
- static Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
610
- database: z.ZodObject<{
611
- type: z.ZodDefault<z.ZodEnum<{
612
- file: "file";
613
- postgres: "postgres";
614
- }>>;
615
- path: z.ZodDefault<z.ZodString>;
616
- }, z.core.$strip>;
617
- auth: z.ZodObject<{
618
- requireAuth: z.ZodDefault<z.ZodBoolean>;
619
- }, z.core.$strip>;
620
- }, z.core.$strip>>;
286
+ static Config: import("@bsb/base").BSBPluginConfigClass<av.ObjectSchema<{
287
+ database: av.ObjectSchema<{
288
+ type: av.OptionalSchema<av.EnumSchema<string[]>>;
289
+ path: av.OptionalSchema<av.StringSchema>;
290
+ }>;
291
+ auth: av.ObjectSchema<{
292
+ requireAuth: av.OptionalSchema<av.BoolSchema>;
293
+ }>;
294
+ }>>;
621
295
  static EventSchemas: {
622
296
  readonly onReturnableEvents: {
623
297
  readonly 'registry.plugin.publish': {
624
- input: {
625
- _bsb: "object";
626
- properties: {
627
- readonly org: import("@bsb/base").BSBStringType;
628
- readonly name: import("@bsb/base").BSBStringType;
629
- readonly version: import("@bsb/base").BSBStringType;
630
- readonly language: import("@bsb/base").BSBEnumType;
631
- readonly metadata: {
632
- _bsb: "object";
633
- properties: {
634
- readonly displayName: import("@bsb/base").BSBStringType;
635
- readonly description: import("@bsb/base").BSBStringType;
636
- readonly category: import("@bsb/base").BSBEnumType;
637
- readonly tags: import("@bsb/base").BSBArrayType;
638
- readonly author: import("@bsb/base").BSBUnionType & {
639
- optional: true;
640
- };
641
- readonly license: import("@bsb/base").BSBStringType & {
642
- optional: true;
643
- };
644
- readonly homepage: import("@bsb/base").BSBStringType & {
645
- optional: true;
646
- };
647
- readonly repository: import("@bsb/base").BSBStringType & {
648
- optional: true;
649
- };
650
- };
651
- required: string[];
652
- description?: string;
653
- optional?: boolean;
654
- nullable?: boolean;
655
- };
656
- readonly eventSchema: import("@bsb/base").BSBType;
657
- readonly capabilities: import("@bsb/base").BSBType & {
658
- optional: true;
659
- };
660
- readonly configSchema: import("@bsb/base").BSBType & {
661
- optional: true;
662
- };
663
- readonly typeDefinitions: {
664
- _bsb: "object";
665
- properties: {
666
- readonly nodejs: import("@bsb/base").BSBStringType & {
667
- optional: true;
668
- };
669
- readonly csharp: import("@bsb/base").BSBStringType & {
670
- optional: true;
671
- };
672
- readonly go: import("@bsb/base").BSBStringType & {
673
- optional: true;
674
- };
675
- readonly java: import("@bsb/base").BSBStringType & {
676
- optional: true;
677
- };
678
- };
679
- required: string[];
680
- description?: string;
681
- optional?: boolean;
682
- nullable?: boolean;
683
- } & {
684
- optional: true;
685
- };
686
- readonly documentation: import("@bsb/base").BSBArrayType;
687
- readonly dependencies: import("@bsb/base").BSBArrayType & {
688
- optional: true;
689
- };
690
- readonly package: {
691
- _bsb: "object";
692
- properties: {
693
- readonly nodejs: import("@bsb/base").BSBStringType & {
694
- optional: true;
695
- };
696
- readonly csharp: import("@bsb/base").BSBStringType & {
697
- optional: true;
698
- };
699
- readonly go: import("@bsb/base").BSBStringType & {
700
- optional: true;
701
- };
702
- readonly java: import("@bsb/base").BSBStringType & {
703
- optional: true;
704
- };
705
- readonly python: import("@bsb/base").BSBStringType & {
706
- optional: true;
707
- };
708
- };
709
- required: string[];
710
- description?: string;
711
- optional?: boolean;
712
- nullable?: boolean;
713
- } & {
714
- optional: true;
715
- };
716
- readonly runtime: {
717
- _bsb: "object";
718
- properties: {
719
- readonly nodejs: import("@bsb/base").BSBStringType & {
720
- optional: true;
721
- };
722
- readonly dotnet: import("@bsb/base").BSBStringType & {
723
- optional: true;
724
- };
725
- readonly go: import("@bsb/base").BSBStringType & {
726
- optional: true;
727
- };
728
- readonly java: import("@bsb/base").BSBStringType & {
729
- optional: true;
730
- };
731
- readonly python: import("@bsb/base").BSBStringType & {
732
- optional: true;
733
- };
734
- };
735
- required: string[];
736
- description?: string;
737
- optional?: boolean;
738
- nullable?: boolean;
739
- } & {
740
- optional: true;
741
- };
742
- readonly visibility: import("@bsb/base").BSBEnumType & {
743
- optional: true;
744
- };
745
- readonly publishedBy: import("@bsb/base").BSBStringType & {
746
- optional: true;
747
- };
748
- };
749
- required: string[];
750
- description?: string;
751
- optional?: boolean;
752
- nullable?: boolean;
753
- };
754
- output: {
755
- _bsb: "object";
756
- properties: {
757
- readonly success: import("@bsb/base").BSBBooleanType;
758
- readonly pluginId: import("@bsb/base").BSBStringType;
759
- readonly version: import("@bsb/base").BSBStringType;
760
- readonly message: import("@bsb/base").BSBStringType & {
761
- optional: true;
762
- };
763
- };
764
- required: string[];
765
- description?: string;
766
- optional?: boolean;
767
- nullable?: boolean;
768
- };
298
+ input: av.ObjectSchema<{
299
+ org: av.StringSchema;
300
+ name: av.StringSchema;
301
+ version: av.StringSchema;
302
+ language: av.EnumSchema<readonly (string | number)[]>;
303
+ metadata: av.ObjectSchema<{
304
+ displayName: av.StringSchema;
305
+ description: av.StringSchema;
306
+ category: av.EnumSchema<readonly (string | number)[]>;
307
+ tags: av.ArraySchema<import("@bsb/base").BSBType>;
308
+ author: av.OptionalSchema<av.UnknownSchema | av.UnionSchema<[import("@bsb/base").BSBType, ...import("@bsb/base").BSBType[]]>>;
309
+ license: av.OptionalSchema<av.StringSchema>;
310
+ homepage: av.OptionalSchema<av.StringSchema>;
311
+ repository: av.OptionalSchema<av.StringSchema>;
312
+ }>;
313
+ eventSchema: av.UnknownSchema;
314
+ capabilities: av.OptionalSchema<av.UnknownSchema>;
315
+ configSchema: av.OptionalSchema<av.UnknownSchema>;
316
+ typeDefinitions: av.OptionalSchema<av.ObjectSchema<{
317
+ nodejs: av.OptionalSchema<av.StringSchema>;
318
+ csharp: av.OptionalSchema<av.StringSchema>;
319
+ go: av.OptionalSchema<av.StringSchema>;
320
+ java: av.OptionalSchema<av.StringSchema>;
321
+ }>>;
322
+ documentation: av.ArraySchema<import("@bsb/base").BSBType>;
323
+ dependencies: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
324
+ package: av.OptionalSchema<av.ObjectSchema<{
325
+ nodejs: av.OptionalSchema<av.StringSchema>;
326
+ csharp: av.OptionalSchema<av.StringSchema>;
327
+ go: av.OptionalSchema<av.StringSchema>;
328
+ java: av.OptionalSchema<av.StringSchema>;
329
+ python: av.OptionalSchema<av.StringSchema>;
330
+ }>>;
331
+ runtime: av.OptionalSchema<av.ObjectSchema<{
332
+ nodejs: av.OptionalSchema<av.StringSchema>;
333
+ dotnet: av.OptionalSchema<av.StringSchema>;
334
+ go: av.OptionalSchema<av.StringSchema>;
335
+ java: av.OptionalSchema<av.StringSchema>;
336
+ python: av.OptionalSchema<av.StringSchema>;
337
+ }>>;
338
+ visibility: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
339
+ publishedBy: av.OptionalSchema<av.StringSchema>;
340
+ }>;
341
+ output: av.ObjectSchema<{
342
+ success: av.BoolSchema;
343
+ pluginId: av.StringSchema;
344
+ version: av.StringSchema;
345
+ message: av.OptionalSchema<av.StringSchema>;
346
+ }>;
769
347
  description?: string;
770
348
  defaultTimeout?: number;
771
349
  readonly __brand: "returnable";
772
350
  };
773
351
  readonly 'registry.plugin.get': {
774
- input: {
775
- _bsb: "object";
776
- properties: {
777
- readonly org: import("@bsb/base").BSBStringType;
778
- readonly name: import("@bsb/base").BSBStringType;
779
- readonly version: import("@bsb/base").BSBStringType & {
780
- optional: true;
781
- };
782
- };
783
- required: string[];
784
- description?: string;
785
- optional?: boolean;
786
- nullable?: boolean;
787
- };
788
- output: {
789
- _bsb: "object";
790
- properties: {
791
- readonly id: import("@bsb/base").BSBStringType;
792
- readonly org: import("@bsb/base").BSBStringType;
793
- readonly name: import("@bsb/base").BSBStringType;
794
- readonly displayName: import("@bsb/base").BSBStringType;
795
- readonly description: import("@bsb/base").BSBStringType;
796
- readonly version: import("@bsb/base").BSBStringType;
797
- readonly majorMinor: import("@bsb/base").BSBStringType;
798
- readonly language: import("@bsb/base").BSBEnumType;
799
- readonly package: {
800
- _bsb: "object";
801
- properties: {
802
- readonly nodejs: import("@bsb/base").BSBStringType & {
803
- optional: true;
804
- };
805
- readonly csharp: import("@bsb/base").BSBStringType & {
806
- optional: true;
807
- };
808
- readonly go: import("@bsb/base").BSBStringType & {
809
- optional: true;
810
- };
811
- readonly java: import("@bsb/base").BSBStringType & {
812
- optional: true;
813
- };
814
- readonly python: import("@bsb/base").BSBStringType & {
815
- optional: true;
816
- };
817
- };
818
- required: string[];
819
- description?: string;
820
- optional?: boolean;
821
- nullable?: boolean;
822
- } & {
823
- optional: true;
824
- };
825
- readonly category: import("@bsb/base").BSBEnumType;
826
- readonly tags: import("@bsb/base").BSBArrayType;
827
- readonly author: import("@bsb/base").BSBUnionType & {
828
- optional: true;
829
- };
830
- readonly license: import("@bsb/base").BSBStringType & {
831
- optional: true;
832
- };
833
- readonly homepage: import("@bsb/base").BSBStringType & {
834
- optional: true;
835
- };
836
- readonly repository: import("@bsb/base").BSBStringType & {
837
- optional: true;
838
- };
839
- readonly visibility: import("@bsb/base").BSBEnumType;
840
- readonly eventSchema: import("@bsb/base").BSBType;
841
- readonly capabilities: import("@bsb/base").BSBType & {
842
- optional: true;
843
- };
844
- readonly configSchema: import("@bsb/base").BSBType & {
845
- optional: true;
846
- };
847
- readonly typeDefinitions: {
848
- _bsb: "object";
849
- properties: {
850
- readonly nodejs: import("@bsb/base").BSBStringType & {
851
- optional: true;
852
- };
853
- readonly csharp: import("@bsb/base").BSBStringType & {
854
- optional: true;
855
- };
856
- readonly go: import("@bsb/base").BSBStringType & {
857
- optional: true;
858
- };
859
- readonly java: import("@bsb/base").BSBStringType & {
860
- optional: true;
861
- };
862
- };
863
- required: string[];
864
- description?: string;
865
- optional?: boolean;
866
- nullable?: boolean;
867
- } & {
868
- optional: true;
869
- };
870
- readonly documentation: import("@bsb/base").BSBArrayType & {
871
- optional: true;
872
- };
873
- readonly dependencies: import("@bsb/base").BSBArrayType & {
874
- optional: true;
875
- };
876
- readonly permissions: import("@bsb/base").BSBArrayType & {
877
- optional: true;
878
- };
879
- readonly eventCount: import("@bsb/base").BSBNumberType;
880
- readonly emitEventCount: import("@bsb/base").BSBNumberType;
881
- readonly onEventCount: import("@bsb/base").BSBNumberType;
882
- readonly returnableEventCount: import("@bsb/base").BSBNumberType;
883
- readonly broadcastEventCount: import("@bsb/base").BSBNumberType;
884
- readonly publishedBy: import("@bsb/base").BSBStringType;
885
- readonly publishedAt: import("@bsb/base").BSBStringType;
886
- readonly updatedAt: import("@bsb/base").BSBStringType;
887
- readonly downloads: import("@bsb/base").BSBNumberType & {
888
- optional: true;
889
- };
890
- readonly runtime: {
891
- _bsb: "object";
892
- properties: {
893
- readonly nodejs: import("@bsb/base").BSBStringType & {
894
- optional: true;
895
- };
896
- readonly dotnet: import("@bsb/base").BSBStringType & {
897
- optional: true;
898
- };
899
- readonly go: import("@bsb/base").BSBStringType & {
900
- optional: true;
901
- };
902
- readonly java: import("@bsb/base").BSBStringType & {
903
- optional: true;
904
- };
905
- readonly python: import("@bsb/base").BSBStringType & {
906
- optional: true;
907
- };
908
- };
909
- required: string[];
910
- description?: string;
911
- optional?: boolean;
912
- nullable?: boolean;
913
- } & {
914
- optional: true;
915
- };
916
- };
917
- required: string[];
918
- description?: string;
919
- optional?: boolean;
920
- nullable?: boolean;
921
- };
352
+ input: av.ObjectSchema<{
353
+ org: av.StringSchema;
354
+ name: av.StringSchema;
355
+ version: av.OptionalSchema<av.StringSchema>;
356
+ }>;
357
+ output: av.ObjectSchema<{
358
+ id: av.StringSchema;
359
+ org: av.StringSchema;
360
+ name: av.StringSchema;
361
+ displayName: av.StringSchema;
362
+ description: av.StringSchema;
363
+ version: av.StringSchema;
364
+ majorMinor: av.StringSchema;
365
+ language: av.EnumSchema<readonly (string | number)[]>;
366
+ package: av.OptionalSchema<av.ObjectSchema<{
367
+ nodejs: av.OptionalSchema<av.StringSchema>;
368
+ csharp: av.OptionalSchema<av.StringSchema>;
369
+ go: av.OptionalSchema<av.StringSchema>;
370
+ java: av.OptionalSchema<av.StringSchema>;
371
+ python: av.OptionalSchema<av.StringSchema>;
372
+ }>>;
373
+ category: av.EnumSchema<readonly (string | number)[]>;
374
+ tags: av.ArraySchema<import("@bsb/base").BSBType>;
375
+ author: av.OptionalSchema<av.UnknownSchema | av.UnionSchema<[import("@bsb/base").BSBType, ...import("@bsb/base").BSBType[]]>>;
376
+ license: av.OptionalSchema<av.StringSchema>;
377
+ homepage: av.OptionalSchema<av.StringSchema>;
378
+ repository: av.OptionalSchema<av.StringSchema>;
379
+ visibility: av.EnumSchema<readonly (string | number)[]>;
380
+ eventSchema: av.UnknownSchema;
381
+ capabilities: av.OptionalSchema<av.UnknownSchema>;
382
+ configSchema: av.OptionalSchema<av.UnknownSchema>;
383
+ typeDefinitions: av.OptionalSchema<av.ObjectSchema<{
384
+ nodejs: av.OptionalSchema<av.StringSchema>;
385
+ csharp: av.OptionalSchema<av.StringSchema>;
386
+ go: av.OptionalSchema<av.StringSchema>;
387
+ java: av.OptionalSchema<av.StringSchema>;
388
+ }>>;
389
+ documentation: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
390
+ dependencies: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
391
+ permissions: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
392
+ eventCount: import("@bsb/base").BSBType;
393
+ emitEventCount: import("@bsb/base").BSBType;
394
+ onEventCount: import("@bsb/base").BSBType;
395
+ returnableEventCount: import("@bsb/base").BSBType;
396
+ broadcastEventCount: import("@bsb/base").BSBType;
397
+ publishedBy: av.StringSchema;
398
+ publishedAt: av.StringSchema;
399
+ updatedAt: av.StringSchema;
400
+ downloads: av.OptionalSchema<import("@bsb/base").BSBType>;
401
+ runtime: av.OptionalSchema<av.ObjectSchema<{
402
+ nodejs: av.OptionalSchema<av.StringSchema>;
403
+ dotnet: av.OptionalSchema<av.StringSchema>;
404
+ go: av.OptionalSchema<av.StringSchema>;
405
+ java: av.OptionalSchema<av.StringSchema>;
406
+ python: av.OptionalSchema<av.StringSchema>;
407
+ }>>;
408
+ }>;
922
409
  description?: string;
923
410
  defaultTimeout?: number;
924
411
  readonly __brand: "returnable";
925
412
  };
926
413
  readonly 'registry.plugin.list': {
927
- input: {
928
- _bsb: "object";
929
- properties: {
930
- readonly org: import("@bsb/base").BSBStringType & {
931
- optional: true;
932
- };
933
- readonly language: import("@bsb/base").BSBEnumType & {
934
- optional: true;
935
- };
936
- readonly category: import("@bsb/base").BSBEnumType & {
937
- optional: true;
938
- };
939
- readonly limit: import("@bsb/base").BSBNumberType & {
940
- optional: true;
941
- };
942
- readonly offset: import("@bsb/base").BSBNumberType & {
943
- optional: true;
944
- };
945
- };
946
- required: string[];
947
- description?: string;
948
- optional?: boolean;
949
- nullable?: boolean;
950
- };
951
- output: {
952
- _bsb: "object";
953
- properties: {
954
- readonly results: import("@bsb/base").BSBArrayType;
955
- readonly total: import("@bsb/base").BSBNumberType;
956
- readonly page: import("@bsb/base").BSBNumberType;
957
- };
958
- required: string[];
959
- description?: string;
960
- optional?: boolean;
961
- nullable?: boolean;
962
- };
414
+ input: av.ObjectSchema<{
415
+ org: av.OptionalSchema<av.StringSchema>;
416
+ language: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
417
+ category: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
418
+ limit: av.OptionalSchema<import("@bsb/base").BSBType>;
419
+ offset: av.OptionalSchema<import("@bsb/base").BSBType>;
420
+ }>;
421
+ output: av.ObjectSchema<{
422
+ results: av.ArraySchema<import("@bsb/base").BSBType>;
423
+ total: import("@bsb/base").BSBType;
424
+ page: import("@bsb/base").BSBType;
425
+ }>;
963
426
  description?: string;
964
427
  defaultTimeout?: number;
965
428
  readonly __brand: "returnable";
966
429
  };
967
430
  readonly 'registry.plugin.search': {
968
- input: {
969
- _bsb: "object";
970
- properties: {
971
- readonly query: import("@bsb/base").BSBStringType;
972
- readonly language: import("@bsb/base").BSBEnumType & {
973
- optional: true;
974
- };
975
- readonly category: import("@bsb/base").BSBEnumType & {
976
- optional: true;
977
- };
978
- readonly limit: import("@bsb/base").BSBNumberType & {
979
- optional: true;
980
- };
981
- readonly offset: import("@bsb/base").BSBNumberType & {
982
- optional: true;
983
- };
984
- };
985
- required: string[];
986
- description?: string;
987
- optional?: boolean;
988
- nullable?: boolean;
989
- };
990
- output: {
991
- _bsb: "object";
992
- properties: {
993
- readonly results: import("@bsb/base").BSBArrayType;
994
- readonly total: import("@bsb/base").BSBNumberType;
995
- readonly query: import("@bsb/base").BSBStringType;
996
- };
997
- required: string[];
998
- description?: string;
999
- optional?: boolean;
1000
- nullable?: boolean;
1001
- };
431
+ input: av.ObjectSchema<{
432
+ query: av.StringSchema;
433
+ language: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
434
+ category: av.OptionalSchema<av.EnumSchema<readonly (string | number)[]>>;
435
+ limit: av.OptionalSchema<import("@bsb/base").BSBType>;
436
+ offset: av.OptionalSchema<import("@bsb/base").BSBType>;
437
+ }>;
438
+ output: av.ObjectSchema<{
439
+ results: av.ArraySchema<import("@bsb/base").BSBType>;
440
+ total: import("@bsb/base").BSBType;
441
+ query: av.StringSchema;
442
+ }>;
1002
443
  description?: string;
1003
444
  defaultTimeout?: number;
1004
445
  readonly __brand: "returnable";
1005
446
  };
1006
447
  readonly 'registry.plugin.delete': {
1007
- input: {
1008
- _bsb: "object";
1009
- properties: {
1010
- readonly org: import("@bsb/base").BSBStringType;
1011
- readonly name: import("@bsb/base").BSBStringType;
1012
- readonly version: import("@bsb/base").BSBStringType & {
1013
- optional: true;
1014
- };
1015
- };
1016
- required: string[];
1017
- description?: string;
1018
- optional?: boolean;
1019
- nullable?: boolean;
1020
- };
1021
- output: {
1022
- _bsb: "object";
1023
- properties: {
1024
- readonly success: import("@bsb/base").BSBBooleanType;
1025
- readonly deleted: import("@bsb/base").BSBNumberType;
1026
- };
1027
- required: string[];
1028
- description?: string;
1029
- optional?: boolean;
1030
- nullable?: boolean;
1031
- };
448
+ input: av.ObjectSchema<{
449
+ org: av.StringSchema;
450
+ name: av.StringSchema;
451
+ version: av.OptionalSchema<av.StringSchema>;
452
+ }>;
453
+ output: av.ObjectSchema<{
454
+ success: av.BoolSchema;
455
+ deleted: import("@bsb/base").BSBType;
456
+ }>;
1032
457
  description?: string;
1033
458
  defaultTimeout?: number;
1034
459
  readonly __brand: "returnable";
1035
460
  };
1036
461
  readonly 'registry.plugin.versions': {
1037
- input: {
1038
- _bsb: "object";
1039
- properties: {
1040
- readonly org: import("@bsb/base").BSBStringType;
1041
- readonly name: import("@bsb/base").BSBStringType;
1042
- readonly majorMinor: import("@bsb/base").BSBStringType & {
1043
- optional: true;
1044
- };
1045
- };
1046
- required: string[];
1047
- description?: string;
1048
- optional?: boolean;
1049
- nullable?: boolean;
1050
- };
1051
- output: {
1052
- _bsb: "object";
1053
- properties: {
1054
- readonly versions: import("@bsb/base").BSBArrayType;
1055
- readonly latest: import("@bsb/base").BSBStringType;
1056
- readonly latestForMajorMinor: import("@bsb/base").BSBStringType;
1057
- };
1058
- required: string[];
1059
- description?: string;
1060
- optional?: boolean;
1061
- nullable?: boolean;
1062
- };
462
+ input: av.ObjectSchema<{
463
+ org: av.StringSchema;
464
+ name: av.StringSchema;
465
+ majorMinor: av.OptionalSchema<av.StringSchema>;
466
+ }>;
467
+ output: av.ObjectSchema<{
468
+ versions: av.ArraySchema<import("@bsb/base").BSBType>;
469
+ latest: av.StringSchema;
470
+ latestForMajorMinor: av.StringSchema;
471
+ }>;
1063
472
  description?: string;
1064
473
  defaultTimeout?: number;
1065
474
  readonly __brand: "returnable";
1066
475
  };
1067
476
  readonly 'registry.stats.get': {
1068
- input: {
1069
- _bsb: "object";
1070
- properties: {};
1071
- required: string[];
1072
- description?: string;
1073
- optional?: boolean;
1074
- nullable?: boolean;
1075
- };
1076
- output: {
1077
- _bsb: "object";
1078
- properties: {
1079
- readonly totalPlugins: import("@bsb/base").BSBNumberType;
1080
- readonly byLanguage: import("@bsb/base").BSBStringType;
1081
- readonly byCategory: import("@bsb/base").BSBStringType;
1082
- readonly totalDownloads: import("@bsb/base").BSBNumberType;
1083
- };
1084
- required: string[];
1085
- description?: string;
1086
- optional?: boolean;
1087
- nullable?: boolean;
1088
- };
477
+ input: av.ObjectSchema<{}>;
478
+ output: av.ObjectSchema<{
479
+ totalPlugins: import("@bsb/base").BSBType;
480
+ byLanguage: av.StringSchema;
481
+ byCategory: av.StringSchema;
482
+ totalDownloads: import("@bsb/base").BSBType;
483
+ }>;
1089
484
  description?: string;
1090
485
  defaultTimeout?: number;
1091
486
  readonly __brand: "returnable";
1092
487
  };
1093
488
  readonly 'registry.auth.login': {
1094
- input: {
1095
- _bsb: "object";
1096
- properties: {
1097
- readonly username: import("@bsb/base").BSBStringType;
1098
- readonly password: import("@bsb/base").BSBStringType;
1099
- };
1100
- required: string[];
1101
- description?: string;
1102
- optional?: boolean;
1103
- nullable?: boolean;
1104
- };
1105
- output: {
1106
- _bsb: "object";
1107
- properties: {
1108
- readonly success: import("@bsb/base").BSBBooleanType;
1109
- readonly token: import("@bsb/base").BSBStringType & {
1110
- optional: true;
1111
- };
1112
- readonly expiresAt: import("@bsb/base").BSBStringType & {
1113
- optional: true;
1114
- };
1115
- readonly message: import("@bsb/base").BSBStringType & {
1116
- optional: true;
1117
- };
1118
- };
1119
- required: string[];
1120
- description?: string;
1121
- optional?: boolean;
1122
- nullable?: boolean;
1123
- };
489
+ input: av.ObjectSchema<{
490
+ username: av.StringSchema;
491
+ password: av.StringSchema;
492
+ }>;
493
+ output: av.ObjectSchema<{
494
+ success: av.BoolSchema;
495
+ token: av.OptionalSchema<av.StringSchema>;
496
+ expiresAt: av.OptionalSchema<av.StringSchema>;
497
+ message: av.OptionalSchema<av.StringSchema>;
498
+ }>;
1124
499
  description?: string;
1125
500
  defaultTimeout?: number;
1126
501
  readonly __brand: "returnable";
1127
502
  };
1128
503
  readonly 'registry.auth.verify': {
1129
- input: {
1130
- _bsb: "object";
1131
- properties: {
1132
- readonly token: import("@bsb/base").BSBStringType;
1133
- };
1134
- required: string[];
1135
- description?: string;
1136
- optional?: boolean;
1137
- nullable?: boolean;
1138
- };
1139
- output: {
1140
- _bsb: "object";
1141
- properties: {
1142
- readonly valid: import("@bsb/base").BSBBooleanType;
1143
- readonly userId: import("@bsb/base").BSBStringType & {
1144
- optional: true;
1145
- };
1146
- readonly permissions: import("@bsb/base").BSBArrayType & {
1147
- optional: true;
1148
- };
1149
- };
1150
- required: string[];
1151
- description?: string;
1152
- optional?: boolean;
1153
- nullable?: boolean;
1154
- };
504
+ input: av.ObjectSchema<{
505
+ token: av.StringSchema;
506
+ }>;
507
+ output: av.ObjectSchema<{
508
+ valid: av.BoolSchema;
509
+ userId: av.OptionalSchema<av.StringSchema>;
510
+ permissions: av.OptionalSchema<av.ArraySchema<import("@bsb/base").BSBType>>;
511
+ }>;
1155
512
  description?: string;
1156
513
  defaultTimeout?: number;
1157
514
  readonly __brand: "returnable";