effect-app 4.0.0-beta.304 → 4.0.0-beta.305

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