effect-app 4.0.0-beta.190 → 4.0.0-beta.192

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 (28) hide show
  1. package/CHANGELOG.md +8 -0
  2. package/dist/Layer.d.ts +2 -2
  3. package/dist/Layer.d.ts.map +1 -1
  4. package/dist/Schema/Class.d.ts +2 -2
  5. package/dist/Schema/Class.d.ts.map +1 -1
  6. package/dist/client/apiClientFactory.d.ts +3 -3
  7. package/dist/client/apiClientFactory.d.ts.map +1 -1
  8. package/dist/client/apiClientFactory.js +1 -1
  9. package/dist/client/clientFor.d.ts +3 -2
  10. package/dist/client/clientFor.d.ts.map +1 -1
  11. package/dist/client/makeClient.js +1 -1
  12. package/dist/rpc/MiddlewareMaker.d.ts +1 -1
  13. package/dist/rpc/MiddlewareMaker.d.ts.map +1 -1
  14. package/dist/rpc/MiddlewareMaker.js +6 -2
  15. package/dist/utils.d.ts +2 -2
  16. package/dist/utils.d.ts.map +1 -1
  17. package/dist/utils.js +2 -2
  18. package/package.json +6 -8
  19. package/src/Layer.ts +1 -1
  20. package/src/client/apiClientFactory.ts +3 -5
  21. package/src/client/clientFor.ts +2 -2
  22. package/src/client/makeClient.ts +1 -1
  23. package/src/rpc/MiddlewareMaker.ts +4 -3
  24. package/src/utils.ts +2 -2
  25. package/dist/Operations.d.ts +0 -409
  26. package/dist/Operations.d.ts.map +0 -1
  27. package/dist/Operations.js +0 -29
  28. package/eslint.config.mjs +0 -26
package/dist/Operations.d.ts DELETED
@@ -1,409 +0,0 @@
1
- import * as S from "./Schema.js";
2
- export type OperationId = S.StringId;
3
- export declare const OperationId: S.WithDefaults<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
4
- readonly Type: S.StringId;
5
- readonly Iso: S.StringId;
6
- readonly "~type.make": S.StringId;
7
- } & {
8
- make: () => S.StringId;
9
- withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
10
- readonly Type: S.StringId;
11
- readonly Iso: S.StringId;
12
- readonly "~type.make": S.StringId;
13
- }>;
14
- }> & Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
15
- readonly Type: S.StringId;
16
- readonly Iso: S.StringId;
17
- readonly "~type.make": S.StringId;
18
- } & {
19
- make: () => S.StringId;
20
- withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
21
- readonly Type: S.StringId;
22
- readonly Iso: S.StringId;
23
- readonly "~type.make": S.StringId;
24
- }>;
25
- };
26
- declare const OperationProgress_base: import("effect/Schema").Opaque<OperationProgress, Omit<S.Struct<{
27
- readonly completed: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
28
- readonly Type: S.NonNegativeInt;
29
- readonly Iso: S.NonNegativeInt;
30
- readonly "~type.make": S.NonNegativeInt;
31
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
32
- readonly Type: S.NonNegativeInt;
33
- readonly Iso: S.NonNegativeInt;
34
- readonly "~type.make": S.NonNegativeInt;
35
- } & {
36
- withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
37
- readonly Type: S.NonNegativeInt;
38
- readonly Iso: S.NonNegativeInt;
39
- readonly "~type.make": S.NonNegativeInt;
40
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
41
- readonly Type: S.NonNegativeInt;
42
- readonly Iso: S.NonNegativeInt;
43
- readonly "~type.make": S.NonNegativeInt;
44
- }>;
45
- };
46
- readonly total: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
47
- readonly Type: S.NonNegativeInt;
48
- readonly Iso: S.NonNegativeInt;
49
- readonly "~type.make": S.NonNegativeInt;
50
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
51
- readonly Type: S.NonNegativeInt;
52
- readonly Iso: S.NonNegativeInt;
53
- readonly "~type.make": S.NonNegativeInt;
54
- } & {
55
- withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
56
- readonly Type: S.NonNegativeInt;
57
- readonly Iso: S.NonNegativeInt;
58
- readonly "~type.make": S.NonNegativeInt;
59
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
60
- readonly Type: S.NonNegativeInt;
61
- readonly Iso: S.NonNegativeInt;
62
- readonly "~type.make": S.NonNegativeInt;
63
- }>;
64
- };
65
- }>, "Encoded"> & {
66
- readonly Encoded: OperationProgress.Encoded;
67
- }, {}> & Omit<S.Struct<{
68
- readonly completed: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
69
- readonly Type: S.NonNegativeInt;
70
- readonly Iso: S.NonNegativeInt;
71
- readonly "~type.make": S.NonNegativeInt;
72
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
73
- readonly Type: S.NonNegativeInt;
74
- readonly Iso: S.NonNegativeInt;
75
- readonly "~type.make": S.NonNegativeInt;
76
- } & {
77
- withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
78
- readonly Type: S.NonNegativeInt;
79
- readonly Iso: S.NonNegativeInt;
80
- readonly "~type.make": S.NonNegativeInt;
81
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
82
- readonly Type: S.NonNegativeInt;
83
- readonly Iso: S.NonNegativeInt;
84
- readonly "~type.make": S.NonNegativeInt;
85
- }>;
86
- };
87
- readonly total: S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
88
- readonly Type: S.NonNegativeInt;
89
- readonly Iso: S.NonNegativeInt;
90
- readonly "~type.make": S.NonNegativeInt;
91
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
92
- readonly Type: S.NonNegativeInt;
93
- readonly Iso: S.NonNegativeInt;
94
- readonly "~type.make": S.NonNegativeInt;
95
- } & {
96
- withDefault: S.withConstructorDefault<S.WithDefaults<Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
97
- readonly Type: S.NonNegativeInt;
98
- readonly Iso: S.NonNegativeInt;
99
- readonly "~type.make": S.NonNegativeInt;
100
- }> & Omit<S.brand<import("effect/Schema").Int, "Int" | "NonNegativeInt" | "NonNegativeNumber">, "Iso" | "Type" | "~type.make"> & {
101
- readonly Type: S.NonNegativeInt;
102
- readonly Iso: S.NonNegativeInt;
103
- readonly "~type.make": S.NonNegativeInt;
104
- }>;
105
- };
106
- }>, keyof S.Top>;
107
- export declare class OperationProgress extends OperationProgress_base {
108
- }
109
- declare const OperationSuccess_base: import("effect/Schema").Opaque<OperationSuccess, Omit<S.TaggedStruct<"OperationSuccess", {
110
- readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
111
- readonly Type: S.NonEmptyString2k;
112
- readonly Iso: S.NonEmptyString2k;
113
- readonly "~type.make": S.NonEmptyString2k;
114
- }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
115
- readonly Type: S.NonEmptyString2k;
116
- readonly Iso: S.NonEmptyString2k;
117
- readonly "~type.make": S.NonEmptyString2k;
118
- }>>;
119
- }>, "Encoded"> & {
120
- readonly Encoded: OperationSuccess.Encoded;
121
- }, {}> & Omit<S.TaggedStruct<"OperationSuccess", {
122
- readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
123
- readonly Type: S.NonEmptyString2k;
124
- readonly Iso: S.NonEmptyString2k;
125
- readonly "~type.make": S.NonEmptyString2k;
126
- }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
127
- readonly Type: S.NonEmptyString2k;
128
- readonly Iso: S.NonEmptyString2k;
129
- readonly "~type.make": S.NonEmptyString2k;
130
- }>>;
131
- }>, keyof S.Top> & {
132
- make(input?: {
133
- readonly _tag?: "OperationSuccess";
134
- readonly message?: S.NonEmptyString2k | null;
135
- } | undefined, options?: S.MakeOptions): OperationSuccess;
136
- makeOption(input?: {
137
- readonly _tag?: "OperationSuccess";
138
- readonly message?: S.NonEmptyString2k | null;
139
- } | undefined, options?: S.MakeOptions): import("effect/Option").Option<OperationSuccess>;
140
- makeEffect(input?: {
141
- readonly _tag?: "OperationSuccess";
142
- readonly message?: S.NonEmptyString2k | null;
143
- } | undefined, options?: S.MakeOptions): import("effect/Effect").Effect<OperationSuccess, S.SchemaError, never>;
144
- };
145
- export declare class OperationSuccess extends OperationSuccess_base {
146
- }
147
- declare const OperationFailure_base: import("effect/Schema").Opaque<OperationFailure, Omit<S.TaggedStruct<"OperationFailure", {
148
- readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
149
- readonly Type: S.NonEmptyString2k;
150
- readonly Iso: S.NonEmptyString2k;
151
- readonly "~type.make": S.NonEmptyString2k;
152
- }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
153
- readonly Type: S.NonEmptyString2k;
154
- readonly Iso: S.NonEmptyString2k;
155
- readonly "~type.make": S.NonEmptyString2k;
156
- }>>;
157
- }>, "Encoded"> & {
158
- readonly Encoded: OperationFailure.Encoded;
159
- }, {}> & Omit<S.TaggedStruct<"OperationFailure", {
160
- readonly message: S.withConstructorDefault<import("effect/Schema").NullOr<S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
161
- readonly Type: S.NonEmptyString2k;
162
- readonly Iso: S.NonEmptyString2k;
163
- readonly "~type.make": S.NonEmptyString2k;
164
- }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
165
- readonly Type: S.NonEmptyString2k;
166
- readonly Iso: S.NonEmptyString2k;
167
- readonly "~type.make": S.NonEmptyString2k;
168
- }>>;
169
- }>, keyof S.Top> & {
170
- make(input?: {
171
- readonly _tag?: "OperationFailure";
172
- readonly message?: S.NonEmptyString2k | null;
173
- } | undefined, options?: S.MakeOptions): OperationFailure;
174
- makeOption(input?: {
175
- readonly _tag?: "OperationFailure";
176
- readonly message?: S.NonEmptyString2k | null;
177
- } | undefined, options?: S.MakeOptions): import("effect/Option").Option<OperationFailure>;
178
- makeEffect(input?: {
179
- readonly _tag?: "OperationFailure";
180
- readonly message?: S.NonEmptyString2k | null;
181
- } | undefined, options?: S.MakeOptions): import("effect/Effect").Effect<OperationFailure, S.SchemaError, never>;
182
- };
183
- export declare class OperationFailure extends OperationFailure_base {
184
- }
185
- export declare const OperationResult: S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
186
- readonly cases: {
187
- OperationFailure: typeof OperationFailure;
188
- OperationSuccess: typeof OperationSuccess;
189
- };
190
- readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: OperationFailure | OperationSuccess) => value is Extract<OperationFailure, {
191
- _tag: Keys;
192
- }> | Extract<OperationSuccess, {
193
- _tag: Keys;
194
- }>;
195
- readonly guards: {
196
- OperationFailure: (u: unknown) => u is OperationFailure;
197
- OperationSuccess: (u: unknown) => u is OperationSuccess;
198
- };
199
- readonly match: {
200
- <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(value: OperationFailure | OperationSuccess, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
201
- <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: OperationFailure | OperationSuccess) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
202
- };
203
- } & {
204
- readonly tags: import("effect/Schema").Literals<["OperationSuccess", "OperationFailure"]>;
205
- readonly generateGuards: <K extends string>(property: K) => {
206
- readonly isOperationFailure: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationFailure; };
207
- readonly isOperationSuccess: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationSuccess; };
208
- } & {
209
- readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: Extract<OperationFailure, {
210
- readonly _tag: Tags[number];
211
- }> | Extract<OperationSuccess, {
212
- readonly _tag: Tags[number];
213
- }>; };
214
- };
215
- readonly generateGuardsFor: <A>() => <K extends { [K_1 in keyof A & string]: A[K_1] extends OperationFailure | OperationSuccess ? K_1 : never; }[keyof A & string]>(property: K) => {
216
- readonly isOperationFailure: (target: A) => target is A & { readonly [P in K]: OperationFailure; };
217
- readonly isOperationSuccess: (target: A) => target is A & { readonly [P in K]: OperationSuccess; };
218
- } & {
219
- readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => (target: A) => target is A & { readonly [P in K]: Extract<OperationFailure, {
220
- readonly _tag: Tags[number];
221
- }> | Extract<OperationSuccess, {
222
- readonly _tag: Tags[number];
223
- }>; };
224
- };
225
- };
226
- export type OperationResult = S.Schema.Type<typeof OperationResult>;
227
- declare const Operation_base: import("effect/Schema").Opaque<Operation, Omit<S.Struct<{
228
- readonly id: S.WithDefaults<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
229
- readonly Type: S.StringId;
230
- readonly Iso: S.StringId;
231
- readonly "~type.make": S.StringId;
232
- } & {
233
- make: () => S.StringId;
234
- withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
235
- readonly Type: S.StringId;
236
- readonly Iso: S.StringId;
237
- readonly "~type.make": S.StringId;
238
- }>;
239
- }> & Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
240
- readonly Type: S.StringId;
241
- readonly Iso: S.StringId;
242
- readonly "~type.make": S.StringId;
243
- } & {
244
- make: () => S.StringId;
245
- withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
246
- readonly Type: S.StringId;
247
- readonly Iso: S.StringId;
248
- readonly "~type.make": S.StringId;
249
- }>;
250
- };
251
- readonly title: S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
252
- readonly Type: S.NonEmptyString2k;
253
- readonly Iso: S.NonEmptyString2k;
254
- readonly "~type.make": S.NonEmptyString2k;
255
- }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
256
- readonly Type: S.NonEmptyString2k;
257
- readonly Iso: S.NonEmptyString2k;
258
- readonly "~type.make": S.NonEmptyString2k;
259
- };
260
- readonly progress: S.optional<typeof OperationProgress>;
261
- readonly result: S.optional<S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
262
- readonly cases: {
263
- OperationFailure: typeof OperationFailure;
264
- OperationSuccess: typeof OperationSuccess;
265
- };
266
- readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: OperationFailure | OperationSuccess) => value is Extract<OperationFailure, {
267
- _tag: Keys;
268
- }> | Extract<OperationSuccess, {
269
- _tag: Keys;
270
- }>;
271
- readonly guards: {
272
- OperationFailure: (u: unknown) => u is OperationFailure;
273
- OperationSuccess: (u: unknown) => u is OperationSuccess;
274
- };
275
- readonly match: {
276
- <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(value: OperationFailure | OperationSuccess, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
277
- <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: OperationFailure | OperationSuccess) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
278
- };
279
- } & {
280
- readonly tags: import("effect/Schema").Literals<["OperationSuccess", "OperationFailure"]>;
281
- readonly generateGuards: <K extends string>(property: K) => {
282
- readonly isOperationFailure: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationFailure; };
283
- readonly isOperationSuccess: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationSuccess; };
284
- } & {
285
- readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: Extract<OperationFailure, {
286
- readonly _tag: Tags[number];
287
- }> | Extract<OperationSuccess, {
288
- readonly _tag: Tags[number];
289
- }>; };
290
- };
291
- readonly generateGuardsFor: <A>() => <K extends { [K_1 in keyof A & string]: A[K_1] extends OperationFailure | OperationSuccess ? K_1 : never; }[keyof A & string]>(property: K) => {
292
- readonly isOperationFailure: (target: A) => target is A & { readonly [P in K]: OperationFailure; };
293
- readonly isOperationSuccess: (target: A) => target is A & { readonly [P in K]: OperationSuccess; };
294
- } & {
295
- readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => (target: A) => target is A & { readonly [P in K]: Extract<OperationFailure, {
296
- readonly _tag: Tags[number];
297
- }> | Extract<OperationSuccess, {
298
- readonly _tag: Tags[number];
299
- }>; };
300
- };
301
- }>;
302
- readonly createdAt: S.withConstructorDefault<S.DateFromString>;
303
- readonly updatedAt: S.withConstructorDefault<import("effect/Schema").NullOr<S.DateFromString & {
304
- withDefault: S.withConstructorDefault<S.DateFromString>;
305
- withDecodingDefaultType: S.withDecodingDefaultType<S.DateFromString>;
306
- }>>;
307
- }>, "Encoded"> & {
308
- readonly Encoded: Operation.Encoded;
309
- }, {}> & Omit<S.Struct<{
310
- readonly id: S.WithDefaults<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
311
- readonly Type: S.StringId;
312
- readonly Iso: S.StringId;
313
- readonly "~type.make": S.StringId;
314
- } & {
315
- make: () => S.StringId;
316
- withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
317
- readonly Type: S.StringId;
318
- readonly Iso: S.StringId;
319
- readonly "~type.make": S.StringId;
320
- }>;
321
- }> & Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
322
- readonly Type: S.StringId;
323
- readonly Iso: S.StringId;
324
- readonly "~type.make": S.StringId;
325
- } & {
326
- make: () => S.StringId;
327
- withDefault: S.withConstructorDefault<Omit<S.brand<S.String, "NonEmptyString" | "NonEmptyString100" | "NonEmptyString255" | "NonEmptyString2k" | "NonEmptyString50" | "NonEmptyString64" | "NonEmptyString64k" | "NonEmptyString80" | "StringId">, "Iso" | "Type" | "~type.make"> & {
328
- readonly Type: S.StringId;
329
- readonly Iso: S.StringId;
330
- readonly "~type.make": S.StringId;
331
- }>;
332
- };
333
- readonly title: S.WithDefaults<Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
334
- readonly Type: S.NonEmptyString2k;
335
- readonly Iso: S.NonEmptyString2k;
336
- readonly "~type.make": S.NonEmptyString2k;
337
- }> & Omit<S.brand<import("effect/Schema").NonEmptyString, "NonEmptyString" | "NonEmptyString2k" | "NonEmptyString64k">, "Iso" | "Type" | "~type.make"> & {
338
- readonly Type: S.NonEmptyString2k;
339
- readonly Iso: S.NonEmptyString2k;
340
- readonly "~type.make": S.NonEmptyString2k;
341
- };
342
- readonly progress: S.optional<typeof OperationProgress>;
343
- readonly result: S.optional<S.Union<[typeof OperationSuccess, typeof OperationFailure]> & {
344
- readonly cases: {
345
- OperationFailure: typeof OperationFailure;
346
- OperationSuccess: typeof OperationSuccess;
347
- };
348
- readonly isAnyOf: <const Keys>(keys: readonly Keys[]) => (value: OperationFailure | OperationSuccess) => value is Extract<OperationFailure, {
349
- _tag: Keys;
350
- }> | Extract<OperationSuccess, {
351
- _tag: Keys;
352
- }>;
353
- readonly guards: {
354
- OperationFailure: (u: unknown) => u is OperationFailure;
355
- OperationSuccess: (u: unknown) => u is OperationSuccess;
356
- };
357
- readonly match: {
358
- <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(value: OperationFailure | OperationSuccess, cases: Cases): Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
359
- <Cases extends { [M in typeof OperationSuccess | typeof OperationFailure as M["Type"]["_tag"]]: (value: M["Type"]) => any; }>(cases: Cases): (value: OperationFailure | OperationSuccess) => Cases[keyof Cases] extends (value: any) => infer R ? import("effect/Unify").Unify<R> : never;
360
- };
361
- } & {
362
- readonly tags: import("effect/Schema").Literals<["OperationSuccess", "OperationFailure"]>;
363
- readonly generateGuards: <K extends string>(property: K) => {
364
- readonly isOperationFailure: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationFailure; };
365
- readonly isOperationSuccess: <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: OperationSuccess; };
366
- } & {
367
- readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => <T extends { readonly [P in K]: OperationFailure | OperationSuccess; }>(target: T) => target is T & { readonly [P in K]: Extract<OperationFailure, {
368
- readonly _tag: Tags[number];
369
- }> | Extract<OperationSuccess, {
370
- readonly _tag: Tags[number];
371
- }>; };
372
- };
373
- readonly generateGuardsFor: <A>() => <K extends { [K_1 in keyof A & string]: A[K_1] extends OperationFailure | OperationSuccess ? K_1 : never; }[keyof A & string]>(property: K) => {
374
- readonly isOperationFailure: (target: A) => target is A & { readonly [P in K]: OperationFailure; };
375
- readonly isOperationSuccess: (target: A) => target is A & { readonly [P in K]: OperationSuccess; };
376
- } & {
377
- readonly isAnyOf: <const Tags extends ReadonlyArray<"OperationFailure" | "OperationSuccess">>(tags: Tags) => (target: A) => target is A & { readonly [P in K]: Extract<OperationFailure, {
378
- readonly _tag: Tags[number];
379
- }> | Extract<OperationSuccess, {
380
- readonly _tag: Tags[number];
381
- }>; };
382
- };
383
- }>;
384
- readonly createdAt: S.withConstructorDefault<S.DateFromString>;
385
- readonly updatedAt: S.withConstructorDefault<import("effect/Schema").NullOr<S.DateFromString & {
386
- withDefault: S.withConstructorDefault<S.DateFromString>;
387
- withDecodingDefaultType: S.withDecodingDefaultType<S.DateFromString>;
388
- }>>;
389
- }>, keyof S.Top>;
390
- export declare class Operation extends Operation_base {
391
- }
392
- export declare namespace OperationProgress {
393
- interface Encoded extends S.StructNestedEncoded<typeof OperationProgress> {
394
- }
395
- }
396
- export declare namespace OperationSuccess {
397
- interface Encoded extends S.StructNestedEncoded<typeof OperationSuccess> {
398
- }
399
- }
400
- export declare namespace OperationFailure {
401
- interface Encoded extends S.StructNestedEncoded<typeof OperationFailure> {
402
- }
403
- }
404
- export declare namespace Operation {
405
- interface Encoded extends S.StructNestedEncoded<typeof Operation> {
406
- }
407
- }
408
- export {};
409
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL09wZXJhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLENBQUMsTUFBTSxhQUFhLENBQUE7QUFFaEMsTUFBTSxNQUFNLFdBQVcsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFBO0FBQ3BDLGVBQU8sTUFBTSxXQUFXOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBQWEsQ0FBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVyQyxxQkFBYSxpQkFBa0IsU0FBUSxzQkFNcEM7Q0FBRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVOLHFCQUFhLGdCQUNYLFNBQVEscUJBRUw7Q0FDSDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVGLHFCQUFhLGdCQUNYLFNBQVEscUJBRUw7Q0FDSDtBQUVGLGVBQU8sTUFBTSxlQUFlOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBQXNELENBQUE7QUFDbEYsTUFBTSxNQUFNLGVBQWUsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxPQUFPLGVBQWUsQ0FBQyxDQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUVuRSxxQkFBYSxTQUFVLFNBQVEsY0FPNUI7Q0FBRztBQUtOLHlCQUFpQixpQkFBaUIsQ0FBQyxDQUFDO0lBQ2xDLFVBQWlCLE9BQVEsU0FBUSxDQUFDLENBQUMsbUJBQW1CLENBQUMsT0FBTyxpQkFBaUIsQ0FBQztLQUFHO0NBQ3BGO0FBQ0QseUJBQWlCLGdCQUFnQixDQUFDLENBQUM7SUFDakMsVUFBaUIsT0FBUSxTQUFRLENBQUMsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLGdCQUFnQixDQUFDO0tBQUc7Q0FDbkY7QUFDRCx5QkFBaUIsZ0JBQWdCLENBQUMsQ0FBQztJQUNqQyxVQUFpQixPQUFRLFNBQVEsQ0FBQyxDQUFDLG1CQUFtQixDQUFDLE9BQU8sZ0JBQWdCLENBQUM7S0FBRztDQUNuRjtBQUNELHlCQUFpQixTQUFTLENBQUMsQ0FBQztJQUMxQixVQUFpQixPQUFRLFNBQVEsQ0FBQyxDQUFDLG1CQUFtQixDQUFDLE9BQU8sU0FBUyxDQUFDO0tBQUc7Q0FDNUUifQ==
package/dist/Operations.d.ts.map DELETED
@@ -1 +0,0 @@
1
- {"version":3,"file":"Operations.d.ts","sourceRoot":"","sources":["../src/Operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,aAAa,CAAA;AAEhC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,QAAQ,CAAA;AACpC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;CAAa,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErC,qBAAa,iBAAkB,SAAQ,sBAMpC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEN,qBAAa,gBACX,SAAQ,qBAEL;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,qBAAa,gBACX,SAAQ,qBAEL;CACH;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAClF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,eAAe,CAAC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnE,qBAAa,SAAU,SAAQ,cAO5B;CAAG;AAKN,yBAAiB,iBAAiB,CAAC,CAAC;IAClC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,iBAAiB,CAAC;KAAG;CACpF;AACD,yBAAiB,gBAAgB,CAAC,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,gBAAgB,CAAC;KAAG;CACnF;AACD,yBAAiB,gBAAgB,CAAC,CAAC;IACjC,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,gBAAgB,CAAC;KAAG;CACnF;AACD,yBAAiB,SAAS,CAAC,CAAC;IAC1B,UAAiB,OAAQ,SAAQ,CAAC,CAAC,mBAAmB,CAAC,OAAO,SAAS,CAAC;KAAG;CAC5E"}
package/dist/Operations.js DELETED
@@ -1,29 +0,0 @@
1
- import * as S from "./Schema.js";
2
- export const OperationId = S.StringId;
3
- export class OperationProgress extends S.Opaque()(S.Struct({
4
- completed: S.NonNegativeInt,
5
- total: S.NonNegativeInt
6
- })) {
7
- }
8
- export class OperationSuccess extends S.Opaque()(S.TaggedStruct("OperationSuccess", {
9
- message: S.NullOr(S.NonEmptyString2k).withDefault
10
- })) {
11
- }
12
- export class OperationFailure extends S.Opaque()(S.TaggedStruct("OperationFailure", {
13
- message: S.NullOr(S.NonEmptyString2k).withDefault
14
- })) {
15
- }
16
- export const OperationResult = S.TaggedUnion([OperationSuccess, OperationFailure]);
17
- export class Operation extends S.Opaque()(S.Struct({
18
- id: OperationId,
19
- title: S.NonEmptyString2k,
20
- progress: S.optional(OperationProgress),
21
- result: S.optional(OperationResult),
22
- createdAt: S.Date.withDefault,
23
- updatedAt: S.NullOr(S.Date).withDefault
24
- })) {
25
- }
26
- /* eslint-enable */
27
- //
28
- // codegen:end
29
- //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9PcGVyYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxDQUFDLE1BQU0sYUFBYSxDQUFBO0FBR2hDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxDQUFDLENBQUMsUUFBUSxDQUFBO0FBRXJDLE1BQU0sT0FBTyxpQkFBa0IsU0FBUSxDQUFDLENBQUMsTUFBTSxFQUc1QyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7SUFDWCxTQUFTLEVBQUUsQ0FBQyxDQUFDLGNBQWM7SUFDM0IsS0FBSyxFQUFFLENBQUMsQ0FBQyxjQUFjO0NBQ3hCLENBQUMsQ0FBQztDQUFHO0FBRU4sTUFBTSxPQUFPLGdCQUNYLFNBQVEsQ0FBQyxDQUFDLE1BQU0sRUFBOEMsQ0FBQyxDQUFDLENBQUMsWUFBWSxDQUFDLGtCQUFrQixFQUFFO0lBQ2hHLE9BQU8sRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLFdBQVc7Q0FDbEQsQ0FBQyxDQUFDO0NBQ0g7QUFFRixNQUFNLE9BQU8sZ0JBQ1gsU0FBUSxDQUFDLENBQUMsTUFBTSxFQUE4QyxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUMsa0JBQWtCLEVBQUU7SUFDaEcsT0FBTyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGdCQUFnQixDQUFDLENBQUMsV0FBVztDQUNsRCxDQUFDLENBQUM7Q0FDSDtBQUVGLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQyxDQUFBO0FBR2xGLE1BQU0sT0FBTyxTQUFVLFNBQVEsQ0FBQyxDQUFDLE1BQU0sRUFBZ0MsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQy9FLEVBQUUsRUFBRSxXQUFXO0lBQ2YsS0FBSyxFQUFFLENBQUMsQ0FBQyxnQkFBZ0I7SUFDekIsUUFBUSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUM7SUFDdkMsTUFBTSxFQUFFLENBQUMsQ0FBQyxRQUFRLENBQUMsZUFBZSxDQUFDO0lBQ25DLFNBQVMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVc7SUFDN0IsU0FBUyxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLFdBQVc7Q0FDeEMsQ0FBQyxDQUFDO0NBQUc7QUFpQk4sbUJBQW1CO0FBQ25CLEVBQUU7QUFDRixjQUFjIn0=
package/eslint.config.mjs DELETED
@@ -1,26 +0,0 @@
1
- import path from "node:path"
2
- import { fileURLToPath } from "node:url"
3
- // Use the shared config package instead of a non-existent local file
4
- import { augmentedConfig } from "@effect-app/eslint-shared-config/eslint.base.config"
5
-
6
- const __filename = fileURLToPath(import.meta.url)
7
- const __dirname = path.dirname(__filename)
8
-
9
- export default [
10
- ...augmentedConfig(__dirname, false, undefined, true),
11
- {
12
- ignores: [
13
- "**/*.js",
14
- "**/*.jsx",
15
- "**/*.d.ts",
16
- "node_modules/",
17
- "src/eslint.*.config.mjs"
18
- ]
19
- },
20
- {
21
- rules: {
22
- "@typescript-eslint/no-empty-interface": "off",
23
- "@typescript-eslint/no-explicit-any": "warn"
24
- }
25
- }
26
- ]