@acteo/api 0.0.0-stage → 0.4.0

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.
package/dist/index.js ADDED
@@ -0,0 +1,1752 @@
1
+ import { Data, Schema, Context, Effect, Duration, Schedule, Exit, Cause, Either, ParseResult } from 'effect';
2
+
3
+ // src/client.ts
4
+ var VerificRcaError = class extends Data.Error {
5
+ /** Discriminantul erorii. Fiecare subclasa are propria valoare, ex: `"EroareLimita"`. */
6
+ _tag = "VerificRcaError";
7
+ /** Numele clasei, afisat in loguri si in stack trace. */
8
+ name = "VerificRcaError";
9
+ };
10
+ var EroareConfigurare = class extends VerificRcaError {
11
+ /** Discriminantul erorii: `"EroareConfigurare"`. Util in `switch (err._tag)`. */
12
+ _tag = "EroareConfigurare";
13
+ /** Numele clasei, afisat in loguri si in stack trace. */
14
+ name = "EroareConfigurare";
15
+ };
16
+ var EroareValidare = class extends VerificRcaError {
17
+ /** Discriminantul erorii: `"EroareValidare"`. Util in `switch (err._tag)`. */
18
+ _tag = "EroareValidare";
19
+ /** Numele clasei, afisat in loguri si in stack trace. */
20
+ name = "EroareValidare";
21
+ /**
22
+ * Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
23
+ *
24
+ * @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
25
+ */
26
+ constructor(args) {
27
+ super(args);
28
+ }
29
+ };
30
+ var EroareAutentificare = class extends VerificRcaError {
31
+ /** Discriminantul erorii: `"EroareAutentificare"`. Util in `switch (err._tag)`. */
32
+ _tag = "EroareAutentificare";
33
+ /** Numele clasei, afisat in loguri si in stack trace. */
34
+ name = "EroareAutentificare";
35
+ };
36
+ var EroarePlanInactiv = class extends VerificRcaError {
37
+ /** Discriminantul erorii: `"EroarePlanInactiv"`. Util in `switch (err._tag)`. */
38
+ _tag = "EroarePlanInactiv";
39
+ /** Numele clasei, afisat in loguri si in stack trace. */
40
+ name = "EroarePlanInactiv";
41
+ };
42
+ var EroareInterzis = class extends VerificRcaError {
43
+ /** Discriminantul erorii: `"EroareInterzis"`. Util in `switch (err._tag)`. */
44
+ _tag = "EroareInterzis";
45
+ /** Numele clasei, afisat in loguri si in stack trace. */
46
+ name = "EroareInterzis";
47
+ /**
48
+ * Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
49
+ *
50
+ * @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
51
+ */
52
+ constructor(args) {
53
+ super(args);
54
+ }
55
+ };
56
+ var EroareNegasit = class extends VerificRcaError {
57
+ /** Discriminantul erorii: `"EroareNegasit"`. Util in `switch (err._tag)`. */
58
+ _tag = "EroareNegasit";
59
+ /** Numele clasei, afisat in loguri si in stack trace. */
60
+ name = "EroareNegasit";
61
+ };
62
+ var EroareConflict = class extends VerificRcaError {
63
+ /** Discriminantul erorii: `"EroareConflict"`. Util in `switch (err._tag)`. */
64
+ _tag = "EroareConflict";
65
+ /** Numele clasei, afisat in loguri si in stack trace. */
66
+ name = "EroareConflict";
67
+ };
68
+ var EroareLimita = class extends VerificRcaError {
69
+ /** Discriminantul erorii: `"EroareLimita"`. Util in `switch (err._tag)`. */
70
+ _tag = "EroareLimita";
71
+ /** Numele clasei, afisat in loguri si in stack trace. */
72
+ name = "EroareLimita";
73
+ /**
74
+ * Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
75
+ *
76
+ * @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
77
+ */
78
+ constructor(args) {
79
+ super(args);
80
+ }
81
+ };
82
+ var EroareServer = class extends VerificRcaError {
83
+ /** Discriminantul erorii: `"EroareServer"`. Util in `switch (err._tag)`. */
84
+ _tag = "EroareServer";
85
+ /** Numele clasei, afisat in loguri si in stack trace. */
86
+ name = "EroareServer";
87
+ /**
88
+ * Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
89
+ *
90
+ * @param args mesajul, detaliile comune ({@link DateEroare}) si `retryAfterMs`.
91
+ */
92
+ constructor(args) {
93
+ super(args);
94
+ }
95
+ };
96
+ var EroareHttp = class extends VerificRcaError {
97
+ /** Discriminantul erorii: `"EroareHttp"`. Util in `switch (err._tag)`. */
98
+ _tag = "EroareHttp";
99
+ /** Numele clasei, afisat in loguri si in stack trace. */
100
+ name = "EroareHttp";
101
+ };
102
+ var EroareRetea = class extends VerificRcaError {
103
+ /** Discriminantul erorii: `"EroareRetea"`. Util in `switch (err._tag)`. */
104
+ _tag = "EroareRetea";
105
+ /** Numele clasei, afisat in loguri si in stack trace. */
106
+ name = "EroareRetea";
107
+ /**
108
+ * Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
109
+ *
110
+ * @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
111
+ */
112
+ constructor(args) {
113
+ super(args);
114
+ }
115
+ };
116
+ var EroareRaspunsInvalid = class extends VerificRcaError {
117
+ /** Discriminantul erorii: `"EroareRaspunsInvalid"`. Util in `switch (err._tag)`. */
118
+ _tag = "EroareRaspunsInvalid";
119
+ /** Numele clasei, afisat in loguri si in stack trace. */
120
+ name = "EroareRaspunsInvalid";
121
+ };
122
+ var EroareVerificare = class extends VerificRcaError {
123
+ /** Discriminantul erorii: `"EroareVerificare"`. Util in `switch (err._tag)`. */
124
+ _tag = "EroareVerificare";
125
+ /** Numele clasei, afisat in loguri si in stack trace. */
126
+ name = "EroareVerificare";
127
+ /**
128
+ * Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
129
+ *
130
+ * @param args mesajul, detaliile comune ({@link DateEroare}) si `codSursa`.
131
+ */
132
+ constructor(args) {
133
+ super(args);
134
+ }
135
+ };
136
+ var EroareTimeoutVerificare = class extends VerificRcaError {
137
+ /** Discriminantul erorii: `"EroareTimeoutVerificare"`. Util in `switch (err._tag)`. */
138
+ _tag = "EroareTimeoutVerificare";
139
+ /** Numele clasei, afisat in loguri si in stack trace. */
140
+ name = "EroareTimeoutVerificare";
141
+ };
142
+ var EroareWebhook = class extends VerificRcaError {
143
+ /** Discriminantul erorii: `"EroareWebhook"`. Util in `switch (err._tag)`. */
144
+ _tag = "EroareWebhook";
145
+ /** Numele clasei, afisat in loguri si in stack trace. */
146
+ name = "EroareWebhook";
147
+ };
148
+ var TipVerificare = Schema.Literal("rca", "itp", "rovinieta", "arr");
149
+ var StatusDocument = Schema.Literal("valid", "warning", "expired", "not_found");
150
+ var DataNullabila = Schema.NullOr(Schema.Date);
151
+ var RezultatVerificareSchema = Schema.Struct({
152
+ /** Tipul verificarii. */
153
+ tip: TipVerificare,
154
+ /** Identificatorul dupa care s-a cautat (la RCA cu VIN, acesta e VIN-ul). */
155
+ query: Schema.String,
156
+ /** Numarul de inmatriculare verificat, `null` cand cautarea s-a facut doar dupa VIN. */
157
+ numarInmatriculare: Schema.NullOr(Schema.String),
158
+ /** Seria de sasiu (VIN) verificata, `null` cand cautarea s-a facut doar dupa numar. */
159
+ serieSasiu: Schema.NullOr(Schema.String),
160
+ /** Cand a fost interogata sursa oficiala. */
161
+ checkedAt: Schema.Date,
162
+ /** Starea documentului. Vezi {@link StatusDocument}. */
163
+ status: StatusDocument,
164
+ /** Data expirarii documentului, `null` daca nu exista document valabil. */
165
+ expiresAt: DataNullabila,
166
+ /** ID-ul cererii, prezent doar cand ai trimis `callbackUrl`. Apare si in webhook. */
167
+ requestId: Schema.optional(Schema.String),
168
+ /** Recomandarea API-ului, ex: la RCA cerut doar dupa numar, sa trimiti si VIN-ul. */
169
+ hint: Schema.optional(Schema.String)
170
+ });
171
+ var InCursSchema = Schema.Struct({
172
+ tip: TipVerificare,
173
+ query: Schema.String,
174
+ status: Schema.Literal("processing"),
175
+ requestId: Schema.optional(Schema.String),
176
+ queuedAt: Schema.optional(Schema.Date),
177
+ pollUrl: Schema.optional(Schema.String),
178
+ hint: Schema.optional(Schema.String)
179
+ });
180
+ var EsuataSchema = Schema.Struct({
181
+ tip: TipVerificare,
182
+ query: Schema.String,
183
+ status: Schema.Literal("error"),
184
+ error: Schema.String,
185
+ /** Doar cand sursa a refuzat datele trimise. Vezi {@link CodRefuzSursa}. */
186
+ cod: Schema.optional(Schema.String),
187
+ hint: Schema.optional(Schema.String)
188
+ });
189
+ var RaspunsVerificareSchema = Schema.Union(RezultatVerificareSchema, InCursSchema, EsuataSchema);
190
+ var CorpEroareSchema = Schema.Struct({
191
+ error: Schema.String,
192
+ hint: Schema.optional(Schema.String),
193
+ accepted: Schema.optional(Schema.Array(Schema.String)),
194
+ code: Schema.optional(Schema.String),
195
+ limita: Schema.optional(Schema.Number),
196
+ dailyUsage: Schema.optional(Schema.String),
197
+ monthlyUsage: Schema.optional(Schema.String)
198
+ });
199
+ var VehiculSchema = Schema.Struct({
200
+ /** ID-ul vehiculului in cont, folosit la stergere. */
201
+ id: Schema.String,
202
+ /** Numarul de inmatriculare, `null` daca vehiculul a fost adaugat doar cu VIN. */
203
+ numarInmatriculare: Schema.NullOr(Schema.String),
204
+ /** Seria de sasiu (VIN), `null` daca vehiculul a fost adaugat doar cu numarul. */
205
+ serieSasiu: Schema.NullOr(Schema.String),
206
+ /** Numarul certificatului de inmatriculare (talon). Fara el rovinieta nu se verifica. */
207
+ serieTalon: Schema.optionalWith(Schema.NullOr(Schema.String), { default: () => null }),
208
+ /** Sursa oficiala a respins numarul talonului; rovinieta nu se mai verifica pana la corectarea lui. */
209
+ serieTalonRespinsa: Schema.optionalWith(Schema.Boolean, { default: () => false }),
210
+ /** Data expirarii RCA, `null` daca nu e cunoscuta inca. */
211
+ rcaExpiraLa: DataNullabila,
212
+ /** Data expirarii ITP, `null` daca nu e cunoscuta inca (ITP-ul cere VIN). */
213
+ itpExpiraLa: DataNullabila,
214
+ /** Data expirarii rovinietei, `null` daca nu e cunoscuta inca (rovinieta cere numar, VIN si numarul talonului). */
215
+ rovinietaExpiraLa: DataNullabila,
216
+ /** Data expirarii copiei conforme ARR. Completata doar cand `arrMonitorizat` e `true`. */
217
+ arrExpiraLa: DataNullabila,
218
+ /** Vehiculul e monitorizat si pentru copia conforma ARR (cere un plan activ). */
219
+ arrMonitorizat: Schema.Boolean,
220
+ /** Cand a fost adaugat vehiculul in cont. */
221
+ createdAt: Schema.Date,
222
+ /** Vehiculul e verificat automat si primeste notificari de expirare. */
223
+ activ: Schema.Boolean
224
+ });
225
+ var ListaVehiculeSchema = Schema.Struct({ vehicule: Schema.Array(VehiculSchema) });
226
+ var VehiculCreatSchema = Schema.Struct({ vehicul: VehiculSchema });
227
+ var StergereSchema = Schema.Struct({ success: Schema.Literal(true) });
228
+ var WebhookRezultatSchema = Schema.Struct({
229
+ /** ID-ul cererii, acelasi cu `requestId` primit de la `porneste()`. */
230
+ requestId: Schema.String,
231
+ /** Tipul verificarii. */
232
+ tip: TipVerificare,
233
+ /** Identificatorul dupa care s-a cautat. */
234
+ query: Schema.String,
235
+ /** Seria de sasiu trimisa in cerere, daca exista. */
236
+ serieSasiu: Schema.NullOr(Schema.String),
237
+ /** Starea documentului sau `"error"` cand sursa oficiala nu a raspuns. */
238
+ status: Schema.Union(StatusDocument, Schema.Literal("error")),
239
+ /** Rezultatul complet, `null` la `status: "error"`. */
240
+ result: Schema.NullOr(RezultatVerificareSchema),
241
+ /** Cand a fost interogata sursa, `null` la eroare. */
242
+ checkedAt: DataNullabila,
243
+ /** Mesajul de eroare, doar la `status: "error"`. */
244
+ error: Schema.optional(Schema.String)
245
+ });
246
+ var WebhookDocumentExpiraSchema = Schema.Struct({
247
+ /** Numele evenimentului. */
248
+ event: Schema.Literal("document.expira"),
249
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
250
+ id: Schema.String,
251
+ /** Vehiculul la care expira documentul. */
252
+ vehicul: Schema.Struct({
253
+ /** ID-ul vehiculului in cont, acelasi ca in `vehicule.lista()`. */
254
+ id: Schema.String,
255
+ /** Numarul de inmatriculare, daca e cunoscut. */
256
+ numarInmatriculare: Schema.NullOr(Schema.String),
257
+ /** Seria de sasiu (VIN), daca e cunoscuta. */
258
+ serieSasiu: Schema.NullOr(Schema.String)
259
+ }),
260
+ /** Documentul care expira. */
261
+ document: TipVerificare,
262
+ /** Data expirarii documentului. */
263
+ expiraLa: Schema.Date,
264
+ /** Zile intregi ramase pana la expirare (minim 0). */
265
+ zileRamase: Schema.Number,
266
+ /** Pragul de notificare atins, in zile (RCA/ITP/rovinieta: 30, 14, 3; ARR: 60, 50, 45). */
267
+ prag: Schema.Number,
268
+ /** Cand a fost trimisa notificarea. */
269
+ trimisLa: Schema.Date
270
+ });
271
+ var WebhookTestSchema = Schema.Struct({
272
+ /** Numele evenimentului. */
273
+ event: Schema.Literal("webhook.test"),
274
+ /** ID unic al testului. */
275
+ id: Schema.String,
276
+ /** Mesajul de confirmare. */
277
+ mesaj: Schema.String,
278
+ /** Cand a fost trimis testul. */
279
+ trimisLa: Schema.Date
280
+ });
281
+ var DosarWebhook = Schema.Struct({
282
+ /** ID-ul dosarului in cont. */
283
+ id: Schema.String,
284
+ /** Numarul dosarului la instanta, ex: `1234/3/2024`. */
285
+ numar: Schema.String,
286
+ /** Eticheta pusa de tine in cont. */
287
+ eticheta: Schema.NullOr(Schema.String)
288
+ });
289
+ var WebhookDosarEvenimentSchema = Schema.Struct({
290
+ /** Numele evenimentului. */
291
+ event: Schema.Literal("dosar.eveniment"),
292
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
293
+ id: Schema.String,
294
+ /** Cand a fost trimisa notificarea. */
295
+ trimisLa: Schema.Date,
296
+ /** Dosarul monitorizat. */
297
+ dosar: DosarWebhook,
298
+ /** Ce s-a intamplat in dosar. */
299
+ eveniment: Schema.Struct({
300
+ /**
301
+ * `termen_nou` (sedinta noua), `solutie`, `cale_atac` (apel, recurs), `stadiu`,
302
+ * `instanta_noua` sau `incheiat_auto` (180 de zile fara noutati: dosarul nu mai e monitorizat).
303
+ */
304
+ tip: Schema.Literal("termen_nou", "solutie", "cale_atac", "stadiu", "instanta_noua", "incheiat_auto"),
305
+ /** Textul alertei, ca in email. */
306
+ descriere: Schema.String,
307
+ /** Instanta, cand e cunoscuta. */
308
+ institutie: Schema.NullOr(Schema.String)
309
+ })
310
+ });
311
+ var WebhookDosarTermenSchema = Schema.Struct({
312
+ /** Numele evenimentului. */
313
+ event: Schema.Literal("dosar.termen"),
314
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
315
+ id: Schema.String,
316
+ /** Cand a fost trimisa notificarea. */
317
+ trimisLa: Schema.Date,
318
+ /** Dosarul monitorizat. */
319
+ dosar: DosarWebhook,
320
+ /** Sedinta care se apropie. */
321
+ sedinta: Schema.Struct({
322
+ /** Data sedintei. */
323
+ data: Schema.Date,
324
+ /** Ora sedintei, cand e cunoscuta. */
325
+ ora: Schema.NullOr(Schema.String),
326
+ /** Instanta. */
327
+ institutie: Schema.NullOr(Schema.String),
328
+ /** Completul de judecata. */
329
+ complet: Schema.NullOr(Schema.String)
330
+ }),
331
+ /** Reminder cu 3 zile si cu o zi inainte de sedinta. */
332
+ zileRamase: Schema.Literal(1, 3)
333
+ });
334
+ var FirmaWebhook = Schema.Struct({
335
+ /** ID-ul firmei in cont. */
336
+ id: Schema.String,
337
+ /** Denumirea firmei. */
338
+ denumire: Schema.String
339
+ });
340
+ var WebhookFirmaSchimbareSchema = Schema.Struct({
341
+ /** Numele evenimentului. */
342
+ event: Schema.Literal("firma.schimbare"),
343
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
344
+ id: Schema.String,
345
+ /** Cand a fost trimisa notificarea. */
346
+ trimisLa: Schema.Date,
347
+ /** Firma monitorizata. */
348
+ firma: FirmaWebhook,
349
+ /** Campurile schimbate. */
350
+ schimbari: Schema.Array(
351
+ Schema.Struct({
352
+ /** Campul schimbat. */
353
+ camp: Schema.Literal(
354
+ "radiata",
355
+ "inactiv",
356
+ "platitor_tva",
357
+ "tva_la_incasare",
358
+ "split_tva",
359
+ "e_factura",
360
+ "denumire",
361
+ "adresa",
362
+ "caen"
363
+ ),
364
+ /** Valoarea dinainte (`"da"` / `"nu"` sau textul ANAF); `null` cand nu e cunoscuta. */
365
+ valoareVeche: Schema.NullOr(Schema.String),
366
+ /** Valoarea de acum. */
367
+ valoareNoua: Schema.String,
368
+ /** Data (`yyyy-mm-dd`) de la care se aplica, cand ANAF o da. */
369
+ dataEfect: Schema.NullOr(Schema.String)
370
+ })
371
+ )
372
+ });
373
+ var WebhookFirmaDosarSchema = Schema.Struct({
374
+ /** Numele evenimentului. */
375
+ event: Schema.Literal("firma.dosar"),
376
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
377
+ id: Schema.String,
378
+ /** Cand a fost trimisa notificarea. */
379
+ trimisLa: Schema.Date,
380
+ /** Firma monitorizata. */
381
+ firma: FirmaWebhook,
382
+ /** Dosarul nou. */
383
+ dosar: Schema.Struct({
384
+ /** Numarul dosarului. */
385
+ numar: Schema.String,
386
+ /** Instanta. */
387
+ institutie: Schema.String,
388
+ /** Calitatea firmei in dosar. */
389
+ calitateParte: Schema.NullOr(Schema.String),
390
+ /** Obiectul dosarului. */
391
+ obiect: Schema.NullOr(Schema.String),
392
+ /** Categoria de pe portalul instantelor (ex: Faliment). */
393
+ categorie: Schema.NullOr(Schema.String),
394
+ /**
395
+ * Dosar de insolventa: `debitor` (firma e in procedura), `creditor` (are de
396
+ * recuperat bani in procedura altcuiva), `alta`; `null` pentru alt fel de dosar.
397
+ */
398
+ insolventa: Schema.NullOr(Schema.Literal("debitor", "creditor", "alta"))
399
+ })
400
+ });
401
+ var MarcaWebhook = Schema.Struct({
402
+ /** ID-ul marcii in cont. */
403
+ id: Schema.String,
404
+ /** ID-ul marcii in TMview (oficiul + numarul). */
405
+ st13: Schema.String,
406
+ /** Numele marcii. */
407
+ nume: Schema.String,
408
+ /** `RO` = OSIM, `EM` = EUIPO (marca a Uniunii Europene). */
409
+ oficiu: Schema.Literal("RO", "EM"),
410
+ /** Numarul de depozit. */
411
+ numarDepozit: Schema.String
412
+ });
413
+ var WebhookMarcaSchimbareSchema = Schema.Struct({
414
+ /** Numele evenimentului. */
415
+ event: Schema.Literal("marca.schimbare"),
416
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
417
+ id: Schema.String,
418
+ /** Cand a fost trimisa notificarea. */
419
+ trimisLa: Schema.Date,
420
+ /** Marca urmarita. */
421
+ marca: MarcaWebhook,
422
+ /** Ce s-a schimbat; `inregistrata` = cererea in curs a devenit marca inregistrata. */
423
+ schimbare: Schema.Literal("inregistrata", "reinnoita", "expirata", "anulata", "respinsa", "retrasa", "opozitie"),
424
+ /** La `reinnoita`: vechea data de expirare (`yyyy-mm-dd`); la `opozitie`: numarul vechi de opozitii; altfel statusul vechi. */
425
+ valoareVeche: Schema.String,
426
+ /** Ca `valoareVeche`, valoarea de acum. */
427
+ valoareNoua: Schema.String
428
+ });
429
+ var WebhookMarcaExpiraSchema = Schema.Struct({
430
+ /** Numele evenimentului. */
431
+ event: Schema.Literal("marca.expira"),
432
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
433
+ id: Schema.String,
434
+ /** Cand a fost trimisa notificarea. */
435
+ trimisLa: Schema.Date,
436
+ /** Marca urmarita. */
437
+ marca: MarcaWebhook,
438
+ /** Data expirarii, `yyyy-mm-dd`. */
439
+ expiraLa: Schema.String,
440
+ /** `6l`, `3l`, `1l` (luni), `7z` (zile) inainte; `gratie` = a expirat, se mai poate reinnoi cu taxa. */
441
+ prag: Schema.Literal("6l", "3l", "1l", "7z", "gratie"),
442
+ /** La `gratie`: ultima zi (`yyyy-mm-dd`) in care se mai poate reinnoi; altfel `null`. */
443
+ reinnoirePanaLa: Schema.NullOr(Schema.String)
444
+ });
445
+ var WebhookAsigurareSchimbareSchema = Schema.Struct({
446
+ /** Numele evenimentului. */
447
+ event: Schema.Literal("asigurare.schimbare"),
448
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
449
+ id: Schema.String,
450
+ /** Cand a fost trimisa notificarea. */
451
+ trimisLa: Schema.Date,
452
+ /** Persoana monitorizata. */
453
+ persoana: Schema.Struct({
454
+ /** ID-ul persoanei in cont. */
455
+ id: Schema.String,
456
+ /** Numele persoanei. */
457
+ nume: Schema.String
458
+ }),
459
+ /** Statutul de acum. */
460
+ statut: Schema.Literal("asigurat", "neasigurat", "necunoscut"),
461
+ /** Cardul de sanatate e emis; `null` cand CNAS nu spune. */
462
+ areCard: Schema.NullOr(Schema.Boolean),
463
+ /** Cand a fost interogat CNAS. */
464
+ verificatLa: Schema.Date
465
+ });
466
+ var WebhookTermenExpiraSchema = Schema.Struct({
467
+ /** Numele evenimentului. */
468
+ event: Schema.Literal("termen.expira"),
469
+ /** ID unic al livrarii. Foloseste-l pentru deduplicare. */
470
+ id: Schema.String,
471
+ /** Cand a fost trimisa notificarea. */
472
+ trimisLa: Schema.Date,
473
+ /** Termenul din cont. */
474
+ termen: Schema.Struct({
475
+ /** ID-ul termenului in cont. */
476
+ id: Schema.String,
477
+ /** `auto`, `personale`, `sanatate`, `afaceri` sau `casa`. */
478
+ categorie: Schema.String,
479
+ /** Tipul termenului. */
480
+ tip: Schema.String,
481
+ /** Numele termenului, ex: Pasaport sau numele dat de tine. */
482
+ eticheta: Schema.String,
483
+ /** Al cui e termenul: numarul masinii, firma sau persoana. */
484
+ al: Schema.NullOr(Schema.String),
485
+ /** Data scadentei, `yyyy-mm-dd`. */
486
+ expiraLa: Schema.String
487
+ }),
488
+ /** Zile intregi ramase pana la scadenta. */
489
+ zileRamase: Schema.Number,
490
+ /** Pragul atins, in zile. */
491
+ prag: Schema.Literal(30, 3)
492
+ });
493
+ var WebhookNotificareSchema = Schema.Union(
494
+ WebhookDocumentExpiraSchema,
495
+ WebhookDosarEvenimentSchema,
496
+ WebhookDosarTermenSchema,
497
+ WebhookFirmaSchimbareSchema,
498
+ WebhookFirmaDosarSchema,
499
+ WebhookMarcaSchimbareSchema,
500
+ WebhookMarcaExpiraSchema,
501
+ WebhookAsigurareSchimbareSchema,
502
+ WebhookTermenExpiraSchema,
503
+ WebhookTestSchema
504
+ );
505
+ var DecodareVinSchema = Schema.Struct({
506
+ /** VIN-ul normalizat. */
507
+ vin: Schema.String,
508
+ /** Marca e cunoscuta. */
509
+ gasit: Schema.Boolean,
510
+ /** S-a consumat o cerere din plan: doar cand marca si modelul sunt gasite. */
511
+ taxat: Schema.Boolean,
512
+ /** Marca, cand e gasita. */
513
+ marca: Schema.NullOr(Schema.String),
514
+ /** Modelul, cand e gasit. */
515
+ model: Schema.NullOr(Schema.String),
516
+ /** Anul fabricatiei, cand e cunoscut. */
517
+ anFabricatie: Schema.NullOr(Schema.Number),
518
+ /** De unde vine anul: `pozitia-10` confirmata, startul `generatie` sau `anunturi`. */
519
+ sursaAn: Schema.NullOr(Schema.Literal("pozitia-10", "generatie", "anunturi")),
520
+ /** Modelele posibile, cand sursele nu cad de acord. Mereu gol cand `taxat` e `false`. */
521
+ modelePosibile: Schema.Array(Schema.String),
522
+ /** Structura VIN-ului, calculata doar din cele 17 caractere. */
523
+ structura: Schema.Struct({
524
+ /** Pozitiile 1-3: producatorul. */
525
+ wmi: Schema.String,
526
+ /** Pozitiile 4-9: descrierea vehiculului. */
527
+ vds: Schema.String,
528
+ /** Pozitiile 10-17: exemplarul. */
529
+ vis: Schema.String,
530
+ /** Regiunea producatorului. */
531
+ regiune: Schema.NullOr(Schema.String),
532
+ /** Tara producatorului. */
533
+ tara: Schema.NullOr(Schema.String),
534
+ /** Cifra de control (pozitia 9): `ok`, `gresita` sau `neaplicabila`. */
535
+ cifraControl: Schema.Literal("ok", "gresita", "neaplicabila"),
536
+ /** Cifra de control asteptata, cand se aplica. */
537
+ cifraControlAsteptata: Schema.NullOr(Schema.String),
538
+ /** Anii de fabricatie posibili dupa pozitia 10. */
539
+ aniPosibili: Schema.Array(Schema.Number)
540
+ })
541
+ });
542
+ var NumarDisponibilSchema = Schema.Struct({
543
+ /** Numarul normalizat. */
544
+ numar: Schema.String,
545
+ /** Numarul e liber la DGPCI si poate fi rezervat. */
546
+ disponibil: Schema.Boolean,
547
+ /** Textul intors de DGPCI, cand exista. */
548
+ mesaj: Schema.NullOr(Schema.String)
549
+ });
550
+ var UnghiImagine = Schema.Literal(
551
+ "trei-sferturi",
552
+ "fata",
553
+ "profil",
554
+ "spate",
555
+ "trei-sferturi-dreapta",
556
+ "profil-dreapta"
557
+ );
558
+ var StatusImagine = Schema.Literal("gata", "in-lucru", "necunoscut", "indisponibil");
559
+ var ImagineMasinaSchema = Schema.Struct({
560
+ /** Poza e a masinii cerute; `false` = poza generica (masina sub husa). */
561
+ gata: Schema.Boolean,
562
+ /** Starea pozei. Vezi {@link StatusImagine}. */
563
+ status: StatusImagine,
564
+ /** S-a consumat o cerere din plan: doar cand `status` e `gata`. */
565
+ taxat: Schema.Boolean,
566
+ /** Link semnat spre poza (WebP transparent), valabil pana la `expiraLa`. `null` doar daca nici poza generica nu e disponibila. */
567
+ url: Schema.NullOr(Schema.String),
568
+ /** Cand expira `url`. `null` cand `url` e `null`. */
569
+ expiraLa: DataNullabila,
570
+ /** Unghiul pozei. */
571
+ unghi: UnghiImagine,
572
+ /** Poza are umbra sub masina. */
573
+ umbra: Schema.Boolean,
574
+ /** Latimea pozei, in pixeli. */
575
+ latime: Schema.Number,
576
+ /** Inaltimea pozei, in pixeli. */
577
+ inaltime: Schema.Number,
578
+ /** Marca canonica, sau cea trimisa daca inca nu e cunoscuta. */
579
+ marca: Schema.String,
580
+ /** Modelul canonic, sau cel trimis daca inca nu e cunoscut. */
581
+ model: Schema.String,
582
+ /** Generatia aleasa dupa an; `null` cand nu e aleasa inca. */
583
+ generatie: Schema.NullOr(
584
+ Schema.Struct({
585
+ /** Numele generatiei, ex: `Volkswagen Golf VII`. */
586
+ eticheta: Schema.String,
587
+ /** Primul an al generatiei. */
588
+ anDe: Schema.Number,
589
+ /** Ultimul an; `null` = inca in productie. */
590
+ anPana: Schema.NullOr(Schema.Number),
591
+ /** Caroseria, ex: `5-door hatchback`. */
592
+ caroserie: Schema.String
593
+ })
594
+ )
595
+ });
596
+
597
+ // src/internal/http.ts
598
+ var Setari = class extends Context.Tag("@verificrca/sdk/Setari")() {
599
+ };
600
+ var CODURI_NEAJUNSE = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN"]);
601
+ function codSistem(err) {
602
+ let curent = err;
603
+ for (let i = 0; i < 4 && curent && typeof curent === "object"; i++) {
604
+ const cod = curent.code;
605
+ if (typeof cod === "string") return cod;
606
+ curent = curent.cause;
607
+ }
608
+ return void 0;
609
+ }
610
+ function mesaj(err) {
611
+ return err instanceof Error ? err.message : String(err);
612
+ }
613
+ function citesteRetryAfter(headers) {
614
+ const valoare = headers.get("retry-after");
615
+ if (!valoare) return void 0;
616
+ const secunde = Number(valoare);
617
+ if (Number.isFinite(secunde)) return Math.max(0, secunde * 1e3);
618
+ const data = Date.parse(valoare);
619
+ return Number.isNaN(data) ? void 0 : Math.max(0, data - Date.now());
620
+ }
621
+ var decodeazaCorpEroare = Schema.decodeUnknownOption(CorpEroareSchema);
622
+ function eroareDinRaspuns(status, headers, body) {
623
+ const corp = decodeazaCorpEroare(body);
624
+ const c = corp._tag === "Some" ? corp.value : void 0;
625
+ const comun = {
626
+ message: c?.error ?? `Cererea a esuat cu HTTP ${status}.`,
627
+ status,
628
+ raspuns: body,
629
+ ...c?.hint !== void 0 && { hint: c.hint },
630
+ ...c?.code !== void 0 && { cod: c.code }
631
+ };
632
+ switch (status) {
633
+ case 400:
634
+ return new EroareValidare({ ...comun, ...c?.accepted && { acceptate: c.accepted } });
635
+ // 422: sursa oficiala refuza valoarea trimisa (ex: NUMAR_RESPINS).
636
+ case 422:
637
+ return new EroareValidare(comun);
638
+ case 401:
639
+ return new EroareAutentificare(comun);
640
+ case 402:
641
+ return new EroarePlanInactiv(comun);
642
+ case 403:
643
+ return new EroareInterzis({ ...comun, ...c?.limita !== void 0 && { limita: c.limita } });
644
+ case 404:
645
+ return new EroareNegasit(comun);
646
+ case 409:
647
+ return new EroareConflict(comun);
648
+ case 429: {
649
+ const retryAfterMs = citesteRetryAfter(headers);
650
+ const cod = c?.code ?? (c?.dailyUsage || c?.monthlyUsage ? "COTA_ATINSA" : "PREA_MULTE_CERERI");
651
+ return new EroareLimita({
652
+ ...comun,
653
+ cod,
654
+ ...retryAfterMs !== void 0 && { retryAfterMs },
655
+ ...c?.dailyUsage !== void 0 && { utilizareZi: c.dailyUsage },
656
+ ...c?.monthlyUsage !== void 0 && { utilizareLuna: c.monthlyUsage }
657
+ });
658
+ }
659
+ default: {
660
+ if (status < 500) return new EroareHttp(comun);
661
+ const retryAfterMs = citesteRetryAfter(headers);
662
+ return new EroareServer({ ...comun, ...retryAfterMs !== void 0 && { retryAfterMs } });
663
+ }
664
+ }
665
+ }
666
+ function construiesteUrl(baseUrl, cerere) {
667
+ const url = new URL(baseUrl.replace(/\/+$/, "") + cerere.cale);
668
+ for (const [cheie, valoare] of Object.entries(cerere.query ?? {})) {
669
+ if (valoare !== void 0) url.searchParams.set(cheie, valoare);
670
+ }
671
+ return url.toString();
672
+ }
673
+ var trimiteOData = (cerere) => Effect.gen(function* () {
674
+ const s = yield* Setari;
675
+ const url = construiesteUrl(s.baseUrl, cerere);
676
+ const timeoutMs = Math.max(s.timeoutMs, cerere.timeoutMinimMs ?? 0);
677
+ const headers = {
678
+ Authorization: `Bearer ${s.apiKey}`,
679
+ Accept: "application/json",
680
+ "User-Agent": s.userAgent
681
+ };
682
+ if (cerere.body !== void 0) headers["Content-Type"] = "application/json";
683
+ const res = yield* Effect.tryPromise({
684
+ try: (signal) => s.fetch(url, {
685
+ method: cerere.metoda,
686
+ headers,
687
+ signal,
688
+ ...cerere.body !== void 0 && { body: JSON.stringify(cerere.body) }
689
+ }),
690
+ catch: (err) => new EroareRetea({
691
+ message: `Cererea ${cerere.metoda} ${cerere.cale} nu a primit raspuns: ${mesaj(err)}`,
692
+ cause: err,
693
+ neajunsa: CODURI_NEAJUNSE.has(codSistem(err) ?? "")
694
+ })
695
+ }).pipe(
696
+ Effect.timeoutFail({
697
+ duration: Duration.millis(timeoutMs),
698
+ onTimeout: () => new EroareRetea({
699
+ message: `Cererea ${cerere.metoda} ${cerere.cale} a depasit ${timeoutMs} ms.`,
700
+ timeout: true
701
+ })
702
+ })
703
+ );
704
+ const text = yield* Effect.tryPromise({
705
+ try: () => res.text(),
706
+ catch: (err) => new EroareRetea({ message: `Raspunsul la ${cerere.metoda} ${cerere.cale} s-a intrerupt: ${mesaj(err)}`, cause: err })
707
+ });
708
+ let body = null;
709
+ if (text) {
710
+ try {
711
+ body = JSON.parse(text);
712
+ } catch {
713
+ if (res.ok) {
714
+ return yield* Effect.fail(
715
+ new EroareRaspunsInvalid({ message: "API-ul a raspuns cu un corp care nu e JSON.", status: res.status, raspuns: text })
716
+ );
717
+ }
718
+ body = text;
719
+ }
720
+ }
721
+ if (!res.ok) return yield* Effect.fail(eroareDinRaspuns(res.status, res.headers, body));
722
+ return { status: res.status, headers: res.headers, body };
723
+ });
724
+ function sePoateReincerca(cerere, eroare2, retry) {
725
+ switch (eroare2._tag) {
726
+ case "EroareRetea":
727
+ return cerere.idempotenta || eroare2.neajunsa === true;
728
+ case "EroareServer":
729
+ if (cerere.idempotenta) return true;
730
+ if (eroare2.cod !== void 0) {
731
+ return eroare2.cod === "OCUPAT" && (eroare2.retryAfterMs ?? 0) <= retry.intarziereMaximaMs;
732
+ }
733
+ return eroare2.status === 502 || eroare2.status === 503 || eroare2.status === 504;
734
+ case "EroareLimita":
735
+ return cerere.idempotenta && eroare2.cod === "PREA_MULTE_CERERI" && (eroare2.retryAfterMs ?? 0) <= retry.intarziereMaximaMs;
736
+ default:
737
+ return false;
738
+ }
739
+ }
740
+ function politicaRetry(retry) {
741
+ const backoff = Schedule.exponential(Duration.millis(retry.intarziereInitialaMs), 2).pipe(
742
+ Schedule.jittered,
743
+ Schedule.modifyDelay((_, d) => Duration.min(d, Duration.millis(retry.intarziereMaximaMs))),
744
+ Schedule.intersect(Schedule.recurs(retry.incercari))
745
+ );
746
+ return Schedule.intersect(Schedule.identity(), backoff).pipe(
747
+ Schedule.modifyDelay(
748
+ ([eroare2], d) => (eroare2._tag === "EroareLimita" || eroare2._tag === "EroareServer") && eroare2.retryAfterMs !== void 0 ? Duration.max(d, Duration.millis(eroare2.retryAfterMs)) : d
749
+ )
750
+ );
751
+ }
752
+ var trimite = (cerere) => Effect.gen(function* () {
753
+ const s = yield* Setari;
754
+ if (!s.retry) return yield* trimiteOData(cerere);
755
+ const retry = s.retry;
756
+ return yield* trimiteOData(cerere).pipe(
757
+ Effect.retry({ schedule: politicaRetry(retry), while: (e) => sePoateReincerca(cerere, e, retry) })
758
+ );
759
+ });
760
+ var decodeaza = (schema) => (raspuns) => Schema.decodeUnknown(schema)(raspuns.body).pipe(
761
+ Effect.mapError(
762
+ (err) => new EroareRaspunsInvalid({
763
+ message: `Raspunsul API-ului nu are forma asteptata: ${ParseResult.TreeFormatter.formatErrorSync(err)}`,
764
+ status: raspuns.status,
765
+ raspuns: raspuns.body,
766
+ cause: err
767
+ })
768
+ )
769
+ );
770
+ var JUDETE = "AB|AR|AG|BC|BH|BN|BT|BV|BR|BZ|CS|CL|CJ|CT|CV|DB|DJ|GL|GR|GJ|HD|HR|IL|IS|IF|MM|MH|MS|NT|OT|PH|SM|SJ|SB|SV|TR|TM|TL|VS|VL|VN";
771
+ var NUMAR_REGEX = new RegExp(
772
+ `^(B\\d{2,3}[A-Z]{2,3}|(${JUDETE})\\d{2}[A-Z]{2,3}|CD\\d{3}[A-Z]{1,3}|TC\\d{4}[A-Z]{2})$`,
773
+ "i"
774
+ );
775
+ var NUMAR_DGPCI_REGEX = new RegExp(`^(B\\d{2,3}|(${JUDETE})\\d{2})[A-Z]{3}$`, "i");
776
+ var VIN_REGEX = /^[A-HJ-NPR-Z0-9]{17}$/i;
777
+ var LUNGIME_VIN = 17;
778
+ var SERIE_TALON_REGEX = /^(?=.*\d)[A-Z0-9]{6,20}$/;
779
+ var TIPURI_VERIFICARE = ["rca", "itp", "rovinieta", "arr"];
780
+ function normalizeaza(valoare) {
781
+ return valoare.trim().toUpperCase().replace(/[\s\-_]/g, "");
782
+ }
783
+ function esteNumarInmatriculareValid(valoare) {
784
+ return NUMAR_REGEX.test(normalizeaza(valoare));
785
+ }
786
+ function esteVinValid(valoare) {
787
+ return VIN_REGEX.test(normalizeaza(valoare));
788
+ }
789
+ function normalizeazaSerieTalon(valoare) {
790
+ return valoare.toUpperCase().replace(/[^A-Z0-9]/g, "");
791
+ }
792
+ function esteSerieTalonValida(valoare) {
793
+ return SERIE_TALON_REGEX.test(normalizeazaSerieTalon(valoare));
794
+ }
795
+ var MESAJ_SERIE_TALON = 'numarul certificatului de inmatriculare, tiparit jos pe talon la "Numarul certificatului" (ex: I00639603F).';
796
+ function explicaVin(valoare) {
797
+ if (!valoare) return "Lipseste seria de sasiu (VIN).";
798
+ if (valoare.length !== LUNGIME_VIN) {
799
+ return `Seria de sasiu are ${valoare.length} caractere, sunt necesare exact ${LUNGIME_VIN}.`;
800
+ }
801
+ return "Seria de sasiu contine caractere neacceptate. Standardul ISO 3779 exclude literele I, O si Q.";
802
+ }
803
+ var eroare = (message, camp, acceptate) => new EroareValidare({ message, camp, cod: "VALIDARE_LOCALA", ...acceptate && { acceptate } });
804
+ function valideazaCallbackUrl(raw) {
805
+ if (raw === void 0 || raw.trim() === "") return Effect.succeed(null);
806
+ const trimis = raw.trim();
807
+ if (trimis.length > 2e3) {
808
+ return Effect.fail(eroare("`callbackUrl` e prea lung (maxim 2000 de caractere).", "callbackUrl"));
809
+ }
810
+ try {
811
+ const url = new URL(trimis);
812
+ if (url.protocol !== "http:" && url.protocol !== "https:") {
813
+ return Effect.fail(eroare("`callbackUrl` trebuie sa foloseasca http sau https.", "callbackUrl"));
814
+ }
815
+ return Effect.succeed(trimis);
816
+ } catch {
817
+ return Effect.fail(eroare("`callbackUrl` trebuie sa fie un URL absolut http(s).", "callbackUrl"));
818
+ }
819
+ }
820
+ function valideazaIdentificatori(tip, query, serieSasiu, serieTalon) {
821
+ if (!query) {
822
+ return Effect.fail(eroare("Lipseste `query` (numar de inmatriculare sau serie de sasiu).", "query"));
823
+ }
824
+ switch (tip) {
825
+ case "rca": {
826
+ if (NUMAR_REGEX.test(query)) {
827
+ if (!serieSasiu) return Effect.succeed({ tip, query, serieSasiu: null, queryPolling: query, serieTalon: null });
828
+ if (!VIN_REGEX.test(serieSasiu)) {
829
+ return Effect.fail(eroare(`\`serieSasiu\` invalid. ${explicaVin(serieSasiu)}`, "serieSasiu"));
830
+ }
831
+ return Effect.succeed({ tip, query, serieSasiu, queryPolling: serieSasiu, serieTalon: null });
832
+ }
833
+ if (VIN_REGEX.test(query)) return Effect.succeed({ tip, query, serieSasiu: null, queryPolling: query, serieTalon: null });
834
+ return Effect.fail(
835
+ eroare(
836
+ `\`query\` invalid: se accepta un numar de inmatriculare romanesc (ex: B123ABC) sau o serie de sasiu de ${LUNGIME_VIN} caractere. ${explicaVin(query)}`,
837
+ "query"
838
+ )
839
+ );
840
+ }
841
+ case "itp": {
842
+ const vin = VIN_REGEX.test(query) ? query : VIN_REGEX.test(serieSasiu) ? serieSasiu : null;
843
+ if (!vin) {
844
+ return Effect.fail(
845
+ eroare(
846
+ `Verificarea ITP cere seria de sasiu (VIN, ${LUNGIME_VIN} caractere). RAR nu cauta dupa numarul de inmatriculare. ${explicaVin(serieSasiu || query)}`,
847
+ "query"
848
+ )
849
+ );
850
+ }
851
+ return Effect.succeed({ tip, query, serieSasiu: serieSasiu || null, queryPolling: vin, serieTalon: null });
852
+ }
853
+ case "arr": {
854
+ if (!NUMAR_REGEX.test(query)) {
855
+ return Effect.fail(
856
+ eroare("Verificarea ARR cere numarul de inmatriculare in `query` (ex: B123ABC). ARR nu cauta dupa VIN.", "query")
857
+ );
858
+ }
859
+ return Effect.succeed({ tip, query, serieSasiu: null, queryPolling: query, serieTalon: null });
860
+ }
861
+ case "rovinieta": {
862
+ if (!NUMAR_REGEX.test(query)) {
863
+ return Effect.fail(
864
+ eroare("Verificarea rovinietei cere numarul de inmatriculare in `query` (ex: B123ABC).", "query")
865
+ );
866
+ }
867
+ if (!VIN_REGEX.test(serieSasiu)) {
868
+ return Effect.fail(
869
+ eroare(`Verificarea rovinietei cere si seria de sasiu in \`serieSasiu\`. ${explicaVin(serieSasiu)}`, "serieSasiu")
870
+ );
871
+ }
872
+ if (!serieTalon) {
873
+ return Effect.fail(
874
+ eroare(`Verificarea rovinietei cere si \`serieTalon\`: ${MESAJ_SERIE_TALON}`, "serieTalon")
875
+ );
876
+ }
877
+ if (!SERIE_TALON_REGEX.test(serieTalon)) {
878
+ return Effect.fail(eroare(`\`serieTalon\` invalid: se asteapta ${MESAJ_SERIE_TALON}`, "serieTalon"));
879
+ }
880
+ return Effect.succeed({ tip, query, serieSasiu, queryPolling: query, serieTalon });
881
+ }
882
+ }
883
+ }
884
+ function valideazaCerereVerificare(cerere) {
885
+ const tip = typeof cerere.tip === "string" ? cerere.tip.toLowerCase() : cerere.tip;
886
+ if (!TIPURI_VERIFICARE.includes(tip)) {
887
+ return Effect.fail(eroare("`tip` invalid.", "tip", TIPURI_VERIFICARE));
888
+ }
889
+ const query = typeof cerere.query === "string" ? normalizeaza(cerere.query) : "";
890
+ const serieSasiu = typeof cerere.serieSasiu === "string" ? normalizeaza(cerere.serieSasiu) : "";
891
+ const serieTalon = typeof cerere.serieTalon === "string" ? normalizeazaSerieTalon(cerere.serieTalon) : "";
892
+ return Effect.all({
893
+ tinta: valideazaIdentificatori(tip, query, serieSasiu, serieTalon),
894
+ callbackUrl: valideazaCallbackUrl(cerere.callbackUrl)
895
+ }).pipe(Effect.map(({ tinta, callbackUrl }) => ({ ...tinta, callbackUrl })));
896
+ }
897
+ function valideazaVehiculNou(vehicul) {
898
+ const numar = vehicul.numarInmatriculare?.trim() ?? "";
899
+ const serie = vehicul.serieSasiu?.trim() ?? "";
900
+ if (numar && (numar.length > 20 || !/^[A-Z0-9\s-]*$/i.test(numar))) {
901
+ return Effect.fail(eroare("`numarInmatriculare` poate contine doar litere, cifre, spatii si cratime (maxim 20).", "numarInmatriculare"));
902
+ }
903
+ if (serie && (serie.length > 50 || !/^[A-Z0-9]*$/i.test(serie))) {
904
+ return Effect.fail(eroare("`serieSasiu` poate contine doar litere si cifre (maxim 50).", "serieSasiu"));
905
+ }
906
+ const serieTalon = vehicul.serieTalon === void 0 ? "" : normalizeazaSerieTalon(vehicul.serieTalon);
907
+ if (serieTalon && !SERIE_TALON_REGEX.test(serieTalon)) {
908
+ return Effect.fail(eroare(`\`serieTalon\` invalid: se asteapta ${MESAJ_SERIE_TALON}`, "serieTalon"));
909
+ }
910
+ const numarNormalizat = numar.toUpperCase().replace(/[\s-]+/g, "");
911
+ const serieNormalizata = serie.toUpperCase();
912
+ if (!numarNormalizat && !serieNormalizata) {
913
+ return Effect.fail(eroare("Trimite numarul de inmatriculare sau seria de sasiu.", "numarInmatriculare"));
914
+ }
915
+ return Effect.succeed({
916
+ ...numarNormalizat && { numarInmatriculare: numarNormalizat },
917
+ ...serieNormalizata && { serieSasiu: serieNormalizata },
918
+ ...serieTalon && { serieTalon },
919
+ ...vehicul.arrMonitorizat !== void 0 && { arrMonitorizat: vehicul.arrMonitorizat }
920
+ });
921
+ }
922
+ function valideazaVinDecodare(vin) {
923
+ const n = normalizeaza(typeof vin === "string" ? vin : "");
924
+ return VIN_REGEX.test(n) ? Effect.succeed(n) : Effect.fail(eroare(explicaVin(n), "vin"));
925
+ }
926
+ function valideazaNumarDisponibil(numar) {
927
+ const brut = typeof numar === "string" ? numar : "";
928
+ if (/[?*]/.test(brut)) return Effect.fail(eroare("API-ul verifica un singur numar complet, fara `?` sau `*`.", "numar"));
929
+ const n = normalizeaza(brut);
930
+ if (!n) return Effect.fail(eroare("Lipseste numarul de inmatriculare.", "numar"));
931
+ return NUMAR_DGPCI_REGEX.test(n) ? Effect.succeed(n) : Effect.fail(eroare(`Numarul ${n} nu e complet: trimite indicativul judetului, cifrele si trei litere (ex: BV07ABC).`, "numar"));
932
+ }
933
+ var UNGHIURI_IMAGINE = [
934
+ "trei-sferturi",
935
+ "fata",
936
+ "profil",
937
+ "spate",
938
+ "trei-sferturi-dreapta",
939
+ "profil-dreapta"
940
+ ];
941
+ var TEXT_MASINA_REGEX = /^[\p{L}\p{N} ./+&'()-]+$/u;
942
+ function valideazaTextMasina(valoare, camp) {
943
+ if (typeof valoare !== "string") return eroare(`Trimite \`${camp}\` ca text.`, camp);
944
+ const t = valoare.trim();
945
+ if (!t) return eroare(`\`${camp}\` nu poate fi gol.`, camp);
946
+ if (t.length > 66) return eroare(`\`${camp}\` are cel mult 66 de caractere.`, camp);
947
+ if (!TEXT_MASINA_REGEX.test(t)) {
948
+ return eroare(`\`${camp}\` poate contine doar litere, cifre, spatii si . / + & ' ( ) -`, camp);
949
+ }
950
+ return t;
951
+ }
952
+ function valideazaCerereImagine(cerere) {
953
+ const marca = valideazaTextMasina(cerere?.marca, "marca");
954
+ if (marca instanceof EroareValidare) return Effect.fail(marca);
955
+ const model = valideazaTextMasina(cerere.model, "model");
956
+ if (model instanceof EroareValidare) return Effect.fail(model);
957
+ const anMaxim = (/* @__PURE__ */ new Date()).getFullYear() + 1;
958
+ if (!Number.isInteger(cerere.an) || cerere.an < 1950 || cerere.an > anMaxim) {
959
+ return Effect.fail(eroare(`\`an\` trebuie sa fie un numar intreg intre 1950 si ${anMaxim}.`, "an"));
960
+ }
961
+ if (cerere.unghi !== void 0 && !UNGHIURI_IMAGINE.includes(cerere.unghi)) {
962
+ return Effect.fail(eroare(`\`unghi\` poate fi: ${UNGHIURI_IMAGINE.join(", ")}.`, "unghi", UNGHIURI_IMAGINE));
963
+ }
964
+ if (cerere.umbra !== void 0 && typeof cerere.umbra !== "boolean") {
965
+ return Effect.fail(eroare("Trimite `umbra` ca true sau false.", "umbra"));
966
+ }
967
+ return Effect.succeed({
968
+ marca,
969
+ model,
970
+ an: cerere.an,
971
+ ...cerere.unghi !== void 0 && { unghi: cerere.unghi },
972
+ ...cerere.umbra !== void 0 && { umbra: cerere.umbra }
973
+ });
974
+ }
975
+
976
+ // src/internal/verificari.ts
977
+ var CALE = "/api/public/v1/verificare";
978
+ var INTERVAL_IMPLICIT_MS = 3e3;
979
+ var INTERVAL_MINIM_MS = 2e3;
980
+ var TIMEOUT_IMPLICIT_MS = 5 * 6e4;
981
+ function limiteDin(raspuns) {
982
+ const h = raspuns.headers;
983
+ const numar = (nume) => {
984
+ const v = h.get(nume);
985
+ return v === null ? NaN : Number(v);
986
+ };
987
+ const valori = [
988
+ numar("x-ratelimit-limit-day"),
989
+ numar("x-ratelimit-remaining-day"),
990
+ numar("x-ratelimit-limit-month"),
991
+ numar("x-ratelimit-remaining-month")
992
+ ];
993
+ if (!valori.every(Number.isFinite)) return void 0;
994
+ return {
995
+ zi: { limita: valori[0], ramase: valori[1] },
996
+ luna: { limita: valori[2], ramase: valori[3] }
997
+ };
998
+ }
999
+ function sinceDinPollUrl(pollUrl) {
1000
+ if (!pollUrl) return void 0;
1001
+ const intrebare = pollUrl.indexOf("?");
1002
+ if (intrebare === -1) return void 0;
1003
+ const since = Number(new URLSearchParams(pollUrl.slice(intrebare + 1)).get("since"));
1004
+ return Number.isFinite(since) && since > 0 ? since : void 0;
1005
+ }
1006
+ var interpreteaza = (raspuns, serieSasiu, sinceImplicit) => decodeaza(RaspunsVerificareSchema)(raspuns).pipe(
1007
+ Effect.flatMap((corp) => {
1008
+ const limite = limiteDin(raspuns);
1009
+ if (corp.status === "error") {
1010
+ return Effect.fail(
1011
+ new EroareVerificare({
1012
+ message: corp.error,
1013
+ cod: "VERIFICARE_ESUATA",
1014
+ raspuns: corp,
1015
+ ...corp.cod && { codSursa: corp.cod },
1016
+ ...corp.hint && { hint: corp.hint }
1017
+ })
1018
+ );
1019
+ }
1020
+ if (corp.status === "processing") {
1021
+ const since = sinceDinPollUrl(corp.pollUrl) ?? sinceImplicit ?? Date.now();
1022
+ return Effect.succeed({
1023
+ status: "processing",
1024
+ tip: corp.tip,
1025
+ query: corp.query,
1026
+ serieSasiu: corp.tip === "rovinieta" ? serieSasiu : null,
1027
+ since,
1028
+ ...corp.requestId !== void 0 && { requestId: corp.requestId },
1029
+ ...corp.queuedAt !== void 0 && { queuedAt: corp.queuedAt },
1030
+ ...corp.hint !== void 0 && { hint: corp.hint },
1031
+ ...limite && { limite }
1032
+ });
1033
+ }
1034
+ return Effect.succeed({ ...corp, ...limite && { limite } });
1035
+ })
1036
+ );
1037
+ var porneste = (cerere) => Effect.gen(function* () {
1038
+ const tinta = yield* valideazaCerereVerificare(cerere);
1039
+ const inainte = Date.now();
1040
+ const raspuns = yield* trimite({
1041
+ metoda: "POST",
1042
+ cale: CALE,
1043
+ idempotenta: false,
1044
+ body: {
1045
+ tip: tinta.tip,
1046
+ query: tinta.query,
1047
+ ...tinta.serieSasiu && { serieSasiu: tinta.serieSasiu },
1048
+ ...tinta.serieTalon && { serieTalon: tinta.serieTalon },
1049
+ ...tinta.callbackUrl && { callbackUrl: tinta.callbackUrl }
1050
+ }
1051
+ });
1052
+ return yield* interpreteaza(raspuns, tinta.serieSasiu, inainte);
1053
+ });
1054
+ var rezultat = (ref) => Effect.gen(function* () {
1055
+ const raspuns = yield* trimite({
1056
+ metoda: "GET",
1057
+ cale: CALE,
1058
+ idempotenta: true,
1059
+ query: {
1060
+ tip: ref.tip,
1061
+ query: ref.query,
1062
+ serieSasiu: ref.tip === "rovinieta" && ref.serieSasiu ? ref.serieSasiu : void 0,
1063
+ since: ref.since !== void 0 ? String(ref.since) : void 0
1064
+ }
1065
+ });
1066
+ return yield* interpreteaza(raspuns, ref.serieSasiu ?? null, ref.since);
1067
+ });
1068
+ var asteapta = (ref, optiuni = {}) => {
1069
+ const intervalMs = Math.max(INTERVAL_MINIM_MS, optiuni.intervalMs ?? INTERVAL_IMPLICIT_MS);
1070
+ const timeoutMs = optiuni.timeoutMs ?? TIMEOUT_IMPLICIT_MS;
1071
+ return rezultat(ref).pipe(
1072
+ Effect.delay(Duration.millis(intervalMs)),
1073
+ // recurWhile intoarce ultimul raspuns, deci repeat-ul iese cu rezultatul final.
1074
+ Effect.repeat(
1075
+ Schedule.recurWhile((r) => r.status === "processing").pipe(
1076
+ Schedule.addDelay(() => Duration.millis(intervalMs))
1077
+ )
1078
+ ),
1079
+ Effect.flatMap(
1080
+ (r) => r.status === "processing" ? Effect.fail(new EroareTimeoutVerificare({ message: "Verificarea nu s-a finalizat." })) : Effect.succeed(r)
1081
+ ),
1082
+ Effect.timeoutFail({
1083
+ duration: Duration.millis(timeoutMs),
1084
+ onTimeout: () => new EroareTimeoutVerificare({
1085
+ message: `Verificarea ${ref.tip} pentru ${ref.query} nu s-a finalizat in ${Math.round(timeoutMs / 1e3)} secunde.`,
1086
+ cod: "TIMEOUT_VERIFICARE"
1087
+ })
1088
+ })
1089
+ );
1090
+ };
1091
+ var verificaSiAsteapta = (cerere, optiuni = {}) => porneste(cerere).pipe(
1092
+ Effect.flatMap((r) => r.status === "processing" ? asteapta(r, optiuni) : Effect.succeed(r))
1093
+ );
1094
+ var CALE2 = "/api/public/v1/vehicule";
1095
+ var lista = () => trimite({ metoda: "GET", cale: CALE2, idempotenta: true }).pipe(
1096
+ Effect.flatMap(decodeaza(ListaVehiculeSchema)),
1097
+ Effect.map((r) => r.vehicule)
1098
+ );
1099
+ var adauga = (vehicul) => valideazaVehiculNou(vehicul).pipe(
1100
+ Effect.flatMap((body) => trimite({ metoda: "POST", cale: CALE2, idempotenta: false, body })),
1101
+ Effect.flatMap(decodeaza(VehiculCreatSchema)),
1102
+ Effect.map((r) => r.vehicul)
1103
+ );
1104
+ var sterge = (id) => id.trim() ? trimite({ metoda: "DELETE", cale: `${CALE2}/${encodeURIComponent(id.trim())}`, idempotenta: true }).pipe(
1105
+ Effect.flatMap(decodeaza(StergereSchema)),
1106
+ Effect.asVoid
1107
+ ) : Effect.fail(new EroareValidare({ message: "Lipseste ID-ul vehiculului.", camp: "id", cod: "VALIDARE_LOCALA" }));
1108
+
1109
+ // src/client.ts
1110
+ var VERSIUNE_SDK = "0.4.0";
1111
+ var URL_IMPLICIT = "https://api.acteo.ro";
1112
+ var URL_IMPLICIT_LEGACY = "https://www.verificrca.ro";
1113
+ var RETRY_IMPLICIT = { incercari: 3, intarziereInitialaMs: 500, intarziereMaximaMs: 1e4 };
1114
+ function citesteEnv(nume) {
1115
+ const proces = globalThis.process;
1116
+ return proces?.env?.[nume];
1117
+ }
1118
+ var PROFIL_ACTEO = {
1119
+ urlImplicit: URL_IMPLICIT,
1120
+ variabileCheie: ["ACTEO_API_KEY", "VERIFICRCA_API_KEY"],
1121
+ agent: "acteo-sdk-js",
1122
+ undeCheie: "https://app.acteo.ro/api/chei"
1123
+ };
1124
+ var PROFIL_LEGACY = {
1125
+ urlImplicit: URL_IMPLICIT_LEGACY,
1126
+ variabileCheie: ["VERIFICRCA_API_KEY"],
1127
+ agent: "verificrca-sdk-js",
1128
+ undeCheie: "https://www.verificrca.ro/dashboard/api"
1129
+ };
1130
+ function construiesteSetari(optiuni, profil) {
1131
+ const dinEnv = profil.variabileCheie.map(citesteEnv).find((v) => v?.trim());
1132
+ const apiKey = (optiuni.apiKey ?? dinEnv ?? "").trim();
1133
+ if (!apiKey) {
1134
+ throw new EroareConfigurare({
1135
+ message: `Lipseste cheia API. Trimite \`apiKey\` sau seteaza variabila de mediu ${profil.variabileCheie[0]}.`,
1136
+ hint: `Cheia se genereaza din ${profil.undeCheie}`
1137
+ });
1138
+ }
1139
+ if (apiKey.length < 16 || apiKey.length > 128) {
1140
+ throw new EroareConfigurare({ message: "Cheia API are un format invalid (intre 16 si 128 de caractere)." });
1141
+ }
1142
+ const baseUrl = optiuni.baseUrl ?? profil.urlImplicit;
1143
+ try {
1144
+ new URL(baseUrl);
1145
+ } catch {
1146
+ throw new EroareConfigurare({ message: `\`baseUrl\` invalid: ${baseUrl}` });
1147
+ }
1148
+ const fetchImpl = optiuni.fetch ?? globalThis.fetch;
1149
+ if (typeof fetchImpl !== "function") {
1150
+ throw new EroareConfigurare({ message: "`fetch` nu exista in acest mediu. Foloseste Node.js 18+ sau trimite optiunea `fetch`." });
1151
+ }
1152
+ const timeoutMs = optiuni.timeoutMs ?? 3e4;
1153
+ if (!(timeoutMs > 0)) throw new EroareConfigurare({ message: "`timeoutMs` trebuie sa fie pozitiv." });
1154
+ return {
1155
+ apiKey,
1156
+ baseUrl,
1157
+ timeoutMs,
1158
+ retry: optiuni.retry === false ? null : { ...RETRY_IMPLICIT, ...optiuni.retry },
1159
+ fetch: fetchImpl,
1160
+ userAgent: `${profil.agent}/${VERSIUNE_SDK}${optiuni.userAgent ? ` ${optiuni.userAgent}` : ""}`
1161
+ };
1162
+ }
1163
+ function creeazaRulare(optiuni, profil) {
1164
+ const setari = construiesteSetari(optiuni, profil);
1165
+ return (efect, opt) => Effect.runPromiseExit(
1166
+ Effect.provideService(efect, Setari, setari),
1167
+ opt?.signal ? { signal: opt.signal } : void 0
1168
+ ).then((exit) => {
1169
+ if (Exit.isSuccess(exit)) return exit.value;
1170
+ if (Cause.isInterruptedOnly(exit.cause)) {
1171
+ throw new VerificRcaError({ message: "Cererea a fost anulata.", cod: "ANULATA" });
1172
+ }
1173
+ throw Cause.squash(exit.cause);
1174
+ });
1175
+ }
1176
+ var ClientVerificari = class {
1177
+ #ruleaza;
1178
+ /** @internal */
1179
+ constructor(ruleaza2) {
1180
+ this.#ruleaza = ruleaza2;
1181
+ }
1182
+ /**
1183
+ * Porneste o verificare si consuma o unitate din cota planului.
1184
+ *
1185
+ * Daca vehiculul a fost verificat de curand, primesti imediat rezultatul
1186
+ * existent. Altfel verificarea intra in
1187
+ * coada si primesti `status: "processing"`; rezultatul il afli cu
1188
+ * {@link ClientVerificari.rezultat}, {@link ClientVerificari.asteapta} sau
1189
+ * prin webhook, daca ai trimis `callbackUrl`.
1190
+ *
1191
+ * Datele sunt validate local inainte de cerere: o greseala de tastare nu
1192
+ * pleaca pe retea si nu consuma din cota.
1193
+ *
1194
+ * @param cerere tipul verificarii, identificatorul, VIN-ul (obligatoriu la rovinieta,
1195
+ * impreuna cu `serieTalon`) si, optional, `callbackUrl`.
1196
+ * @param optiuni `signal` pentru anulare.
1197
+ * @returns rezultatul final sau o {@link VerificareInCurs}.
1198
+ * @throws {@link EroareValidare} date invalide, local sau HTTP 400.
1199
+ * @throws {@link EroareAutentificare} cheie API invalida (401).
1200
+ * @throws {@link EroarePlanInactiv} contul nu are abonament API activ (402).
1201
+ * @throws {@link EroareLimita} cota zilnica sau lunara atinsa (429, `cod: "COTA_ATINSA"`).
1202
+ * @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a
1203
+ * refuzat datele trimise (`codSursa`, ex: `"serie_talon_invalida"`).
1204
+ * @throws {@link EroareRetea} fara raspuns sau timeout.
1205
+ * @throws {@link EroareServer} eroare 5xx.
1206
+ * @example
1207
+ * const r = await vrca.verificari.porneste({ tip: "itp", query: "WVWZZZ1JZXW000001" })
1208
+ * if (r.status === "processing") {
1209
+ * const final = await vrca.verificari.asteapta(r)
1210
+ * }
1211
+ */
1212
+ porneste(cerere, optiuni) {
1213
+ return this.#ruleaza(porneste(cerere), optiuni);
1214
+ }
1215
+ /**
1216
+ * Interogheaza o singura data rezultatul unei verificari. Nu consuma din cota.
1217
+ *
1218
+ * Serverul accepta cel mult o interogare la 2 secunde pentru aceeasi
1219
+ * verificare; la depasire, SDK-ul asteapta cat cere `Retry-After` si reincearca.
1220
+ *
1221
+ * @param referinta obiectul primit de la `porneste()` sau `{ tip, query, serieSasiu?, since? }`.
1222
+ * @param optiuni `signal` pentru anulare.
1223
+ * @returns rezultatul final sau, daca sursa nu a raspuns inca, o {@link VerificareInCurs}.
1224
+ * @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata; reia cu `porneste()`.
1225
+ * @throws {@link EroareValidare} referinta invalida (400).
1226
+ * @throws {@link EroareAutentificare} cheie API invalida (401).
1227
+ * @throws {@link EroareRetea} fara raspuns sau timeout, dupa reincercari.
1228
+ * @example
1229
+ * const r = await vrca.verificari.rezultat({ tip: "rca", query: "B123ABC" })
1230
+ * if (r.status !== "processing") console.log(r.status, r.expiresAt)
1231
+ */
1232
+ rezultat(referinta, optiuni) {
1233
+ return this.#ruleaza(rezultat(referinta), optiuni);
1234
+ }
1235
+ /**
1236
+ * Interogheaza periodic pana la rezultatul final. Nu consuma din cota.
1237
+ *
1238
+ * @param referinta obiectul primit de la `porneste()` sau `{ tip, query, serieSasiu?, since? }`.
1239
+ * @param optiuni `intervalMs` (implicit 3000, minim 2000), `timeoutMs` (implicit 5 minute) si `signal`.
1240
+ * @returns rezultatul final al verificarii.
1241
+ * @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
1242
+ * @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata; reia cu `porneste()`.
1243
+ * @throws {@link EroareRetea} fara raspuns, dupa reincercari.
1244
+ * @example
1245
+ * const r = await vrca.verificari.porneste({ tip: "arr", query: "CJ45XYZ" })
1246
+ * const final = r.status === "processing" ? await vrca.verificari.asteapta(r, { intervalMs: 5000 }) : r
1247
+ */
1248
+ asteapta(referinta, optiuni) {
1249
+ return this.#ruleaza(asteapta(referinta, optiuni), optiuni);
1250
+ }
1251
+ /**
1252
+ * Porneste verificarea si asteapta rezultatul final, intr-un singur apel.
1253
+ * Consuma o unitate din cota (doar pornirea; pollingul e gratuit).
1254
+ *
1255
+ * @param cerere tipul verificarii, identificatorul, VIN-ul (obligatoriu la rovinieta,
1256
+ * impreuna cu `serieTalon`) si, optional, `callbackUrl`.
1257
+ * @param optiuni `intervalMs`, `timeoutMs` si `signal`, ca la {@link ClientVerificari.asteapta}.
1258
+ * @returns rezultatul final al verificarii.
1259
+ * @throws {@link EroareValidare} date invalide, local sau HTTP 400.
1260
+ * @throws {@link EroareLimita} cota atinsa (`cod: "COTA_ATINSA"`).
1261
+ * @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
1262
+ * @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a
1263
+ * refuzat datele trimise (`codSursa`, ex: `"serie_talon_invalida"`).
1264
+ * @throws {@link VerificRcaError} orice alta eroare de la API sau de retea.
1265
+ * @example
1266
+ * const rovinieta = await vrca.verificari.verificaSiAsteapta({
1267
+ * tip: "rovinieta",
1268
+ * query: "B123ABC",
1269
+ * serieSasiu: "WVWZZZ1JZXW000001",
1270
+ * serieTalon: "I00639603F",
1271
+ * })
1272
+ * console.log(rovinieta.status, rovinieta.expiresAt)
1273
+ */
1274
+ verificaSiAsteapta(cerere, optiuni) {
1275
+ return this.#ruleaza(verificaSiAsteapta(cerere, optiuni), optiuni);
1276
+ }
1277
+ };
1278
+ var ClientVehicule = class {
1279
+ #ruleaza;
1280
+ /** @internal */
1281
+ constructor(ruleaza2) {
1282
+ this.#ruleaza = ruleaza2;
1283
+ }
1284
+ /**
1285
+ * Listeaza toate vehiculele din cont, cu datele de expirare RCA, ITP,
1286
+ * rovinieta si ARR.
1287
+ *
1288
+ * @param optiuni `signal` pentru anulare.
1289
+ * @returns vehiculele contului; lista goala daca nu ai niciunul.
1290
+ * @throws {@link EroareAutentificare} cheie API invalida (401).
1291
+ * @throws {@link EroarePlanInactiv} contul nu are un plan activ (402).
1292
+ * @throws {@link EroareRetea} fara raspuns, dupa reincercari.
1293
+ * @example
1294
+ * for (const v of await acteo.auto.flota.lista()) {
1295
+ * console.log(v.numarInmatriculare, v.rcaExpiraLa, v.itpExpiraLa)
1296
+ * }
1297
+ */
1298
+ lista(optiuni) {
1299
+ return this.#ruleaza(lista(), optiuni);
1300
+ }
1301
+ /**
1302
+ * Adauga un vehicul in monitorizare. Trimite cel putin numarul de
1303
+ * inmatriculare sau seria de sasiu. ITP-ul cere VIN, iar rovinieta cere
1304
+ * numarul, VIN-ul si `serieTalon` (numarul certificatului de inmatriculare);
1305
+ * fara `serieTalon`, rovinieta nu se verifica.
1306
+ *
1307
+ * @param vehicul numarul, VIN-ul si, optional, `serieTalon` si `arrMonitorizat`.
1308
+ * @param optiuni `signal` pentru anulare.
1309
+ * @returns vehiculul creat, cu `id`-ul folosit la stergere.
1310
+ * @throws {@link EroareValidare} lipseste identificatorul, are caractere nepermise sau `serieTalon` e invalida.
1311
+ * @throws {@link EroareInterzis} `LIMIT_ATINS` (ai atins numarul de masini din plan, vezi `limita`) sau `ARR_NECESITA_PLAN`.
1312
+ * @throws {@link EroareConflict} vehiculul exista deja in cont (`VEHICUL_EXISTENT`).
1313
+ * @throws {@link EroareLimita} plafonul zilnic de adaugari prin API (`LIMITA_FLOTA_ATINSA`).
1314
+ * @throws {@link EroarePlanInactiv} contul nu are un plan activ (402).
1315
+ * @example
1316
+ * const v = await acteo.auto.flota.adauga({
1317
+ * numarInmatriculare: "B123ABC",
1318
+ * serieSasiu: "WVWZZZ1JZXW000001",
1319
+ * serieTalon: "I00639603F",
1320
+ * })
1321
+ * console.log(v.id)
1322
+ */
1323
+ adauga(vehicul, optiuni) {
1324
+ return this.#ruleaza(adauga(vehicul), optiuni);
1325
+ }
1326
+ /**
1327
+ * Scoate un vehicul din cont. Monitorizarea si notificarile lui se opresc.
1328
+ *
1329
+ * @param id `id`-ul vehiculului, din {@link ClientVehicule.lista} sau {@link ClientVehicule.adauga}.
1330
+ * @param optiuni `signal` pentru anulare.
1331
+ * @returns se rezolva fara valoare cand vehiculul a fost sters.
1332
+ * @throws {@link EroareNegasit} vehiculul nu exista in contul cheii (404).
1333
+ * @throws {@link EroareLimita} plafonul zilnic de stergeri prin API (`LIMITA_FLOTA_ATINSA`).
1334
+ * @throws {@link EroareValidare} `id` gol.
1335
+ * @example
1336
+ * await acteo.auto.flota.sterge("6f2c1b9e-0000-4000-8000-000000000001")
1337
+ */
1338
+ sterge(id, optiuni) {
1339
+ return this.#ruleaza(sterge(id), optiuni);
1340
+ }
1341
+ };
1342
+ var VerificRca = class {
1343
+ /** Verificari la cerere RCA, ITP, rovinieta si ARR. */
1344
+ verificari;
1345
+ /** Vehiculele monitorizate din cont. */
1346
+ vehicule;
1347
+ /**
1348
+ * Creeaza un client. Nu face nicio cerere pe retea.
1349
+ *
1350
+ * @param optiuni cheia API si setarile de retea; toate sunt optionale daca
1351
+ * `VERIFICRCA_API_KEY` e setata.
1352
+ * @throws {@link EroareConfigurare} lipseste cheia API sau o optiune e invalida.
1353
+ * @example
1354
+ * const vrca = new VerificRca({
1355
+ * apiKey: process.env.VERIFICRCA_API_KEY,
1356
+ * timeoutMs: 15_000,
1357
+ * retry: { incercari: 5 },
1358
+ * })
1359
+ */
1360
+ constructor(optiuni = {}) {
1361
+ const ruleaza2 = creeazaRulare(optiuni, PROFIL_LEGACY);
1362
+ this.verificari = new ClientVerificari(ruleaza2);
1363
+ this.vehicule = new ClientVehicule(ruleaza2);
1364
+ }
1365
+ };
1366
+ var TIMEOUT_NUMAR_MS = 15e4;
1367
+ var decodeazaVin = (vin) => valideazaVinDecodare(vin).pipe(
1368
+ Effect.flatMap(
1369
+ (v) => trimite({ metoda: "POST", cale: "/api/public/v1/decodare-vin", idempotenta: false, body: { vin: v } })
1370
+ ),
1371
+ Effect.flatMap((r) => decodeaza(DecodareVinSchema)(r).pipe(Effect.map((d) => cuLimite(d, limiteDin(r)))))
1372
+ );
1373
+ var verificaNumar = (numar) => valideazaNumarDisponibil(numar).pipe(
1374
+ Effect.flatMap(
1375
+ (n) => trimite({
1376
+ metoda: "POST",
1377
+ cale: "/api/public/v1/numere-disponibile",
1378
+ idempotenta: false,
1379
+ body: { numar: n },
1380
+ timeoutMinimMs: TIMEOUT_NUMAR_MS
1381
+ })
1382
+ ),
1383
+ Effect.flatMap((r) => decodeaza(NumarDisponibilSchema)(r).pipe(Effect.map((d) => cuLimite(d, limiteDin(r)))))
1384
+ );
1385
+ var imagine = (cerere) => valideazaCerereImagine(cerere).pipe(
1386
+ Effect.flatMap((body) => trimite({ metoda: "POST", cale: "/api/public/v1/imagini-masini", idempotenta: false, body })),
1387
+ Effect.flatMap(
1388
+ (r) => decodeaza(ImagineMasinaSchema)(r).pipe(
1389
+ Effect.map((d) => {
1390
+ const retryAfterMs = d.status === "in-lucru" ? citesteRetryAfter(r.headers) : void 0;
1391
+ return { ...cuLimite(d, limiteDin(r)), ...retryAfterMs !== void 0 && { retryAfterMs } };
1392
+ })
1393
+ )
1394
+ )
1395
+ );
1396
+ var TIMEOUT_IMAGINE_MS = 2 * 6e4;
1397
+ var PAUZA_IMAGINE_MS = 1e4;
1398
+ var imagineAsteptata = (cerere, optiuni = {}) => Effect.gen(function* () {
1399
+ const timeoutMs = optiuni.timeoutMs ?? TIMEOUT_IMAGINE_MS;
1400
+ const termen = Date.now() + timeoutMs;
1401
+ for (; ; ) {
1402
+ const raspuns = yield* imagine(cerere);
1403
+ if (raspuns.status !== "in-lucru") return raspuns;
1404
+ const pauza = Math.max(PAUZA_IMAGINE_MS, raspuns.retryAfterMs ?? 0);
1405
+ if (Date.now() + pauza > termen) {
1406
+ return yield* Effect.fail(
1407
+ new EroareTimeoutVerificare({
1408
+ message: `Poza nu a fost gata in ${timeoutMs} ms. Cere-o din nou mai tarziu.`,
1409
+ cod: "TIMEOUT_IMAGINE"
1410
+ })
1411
+ );
1412
+ }
1413
+ yield* Effect.sleep(Duration.millis(pauza));
1414
+ }
1415
+ });
1416
+ function cuLimite(date, limite) {
1417
+ return limite ? { ...date, limite } : date;
1418
+ }
1419
+ var HEADER_CHEIE_WEBHOOK = "x-acteo-key";
1420
+ var HEADER_EVENIMENT_WEBHOOK = "x-acteo-event";
1421
+ var HEADER_CHEIE_WEBHOOK_VECHI = "x-verificrca-key";
1422
+ function citesteHeader(headers, nume) {
1423
+ if (typeof headers.get === "function") return headers.get(nume) ?? void 0;
1424
+ const obiect = headers;
1425
+ for (const [cheie, valoare] of Object.entries(obiect)) {
1426
+ if (cheie.toLowerCase() !== nume) continue;
1427
+ return typeof valoare === "string" ? valoare : valoare?.[0];
1428
+ }
1429
+ return void 0;
1430
+ }
1431
+ function egaleConstant(a, b) {
1432
+ const ea = new TextEncoder().encode(a);
1433
+ const eb = new TextEncoder().encode(b);
1434
+ let diferenta = ea.length ^ eb.length;
1435
+ const lungime = Math.max(ea.length, eb.length);
1436
+ for (let i = 0; i < lungime; i++) diferenta |= (ea[i] ?? 0) ^ (eb[i] ?? 0);
1437
+ return diferenta === 0;
1438
+ }
1439
+ var parseazaCorp = (corp) => {
1440
+ if (typeof corp !== "string" && !(corp instanceof Uint8Array)) return Effect.succeed(corp);
1441
+ const text = typeof corp === "string" ? corp : new TextDecoder().decode(corp);
1442
+ return Effect.try({
1443
+ try: () => JSON.parse(text),
1444
+ catch: (err) => new EroareWebhook({ message: "Corpul webhook-ului nu e JSON valid.", cod: "JSON_INVALID", cause: err })
1445
+ });
1446
+ };
1447
+ var decodeazaWebhook = (schema) => (corp) => Schema.decodeUnknown(schema)(corp).pipe(
1448
+ Effect.mapError(
1449
+ (err) => new EroareWebhook({
1450
+ message: `Payload webhook invalid: ${ParseResult.TreeFormatter.formatErrorSync(err)}`,
1451
+ cod: "PAYLOAD_INVALID",
1452
+ raspuns: corp,
1453
+ cause: err
1454
+ })
1455
+ )
1456
+ );
1457
+ function ruleaza(efect) {
1458
+ const rezultat2 = Effect.runSync(Effect.either(efect));
1459
+ if (Either.isLeft(rezultat2)) throw rezultat2.left;
1460
+ return rezultat2.right;
1461
+ }
1462
+ function parseazaWebhookRezultat(corp) {
1463
+ return ruleaza(parseazaCorp(corp).pipe(Effect.flatMap(decodeazaWebhook(WebhookRezultatSchema))));
1464
+ }
1465
+ function verificaWebhookNotificare(corp, headers, optiuni) {
1466
+ return ruleaza(
1467
+ Effect.gen(function* () {
1468
+ if (!optiuni.cheie) {
1469
+ return yield* Effect.fail(new EroareWebhook({ message: "Lipseste cheia de webhook din optiuni.", cod: "CHEIE_NECONFIGURATA" }));
1470
+ }
1471
+ const primita = citesteHeader(headers, HEADER_CHEIE_WEBHOOK) ?? citesteHeader(headers, HEADER_CHEIE_WEBHOOK_VECHI);
1472
+ if (!primita || !egaleConstant(primita, optiuni.cheie)) {
1473
+ return yield* Effect.fail(
1474
+ new EroareWebhook({ message: "Cheia din headerul X-Acteo-Key lipseste sau nu se potriveste.", cod: "CHEIE_INVALIDA" })
1475
+ );
1476
+ }
1477
+ const json = yield* parseazaCorp(corp);
1478
+ return yield* decodeazaWebhook(WebhookNotificareSchema)(json);
1479
+ })
1480
+ );
1481
+ }
1482
+
1483
+ // src/acteo.ts
1484
+ var VIN_REGEX2 = /^[A-HJ-NPR-Z0-9]{17}$/;
1485
+ function esteInCurs(x) {
1486
+ return typeof x === "object" && x !== null && x.status === "processing";
1487
+ }
1488
+ var ClientDocument = class {
1489
+ #ruleaza;
1490
+ #mapare;
1491
+ /** @internal */
1492
+ constructor(ruleaza2, mapare) {
1493
+ this.#ruleaza = ruleaza2;
1494
+ this.#mapare = mapare;
1495
+ }
1496
+ /**
1497
+ * Verifica documentul si asteapta rezultatul final de la sursa oficiala.
1498
+ * Daca vehiculul a fost verificat de curand, rezultatul vine imediat.
1499
+ *
1500
+ * @param identificator ce cere sursa oficiala pentru acest document.
1501
+ * @param optiuni `timeoutMs`, `intervalMs` pentru asteptare si `signal`.
1502
+ * @returns rezultatul final.
1503
+ * @throws {@link EroareValidare} identificator invalid, local sau HTTP 400.
1504
+ * @throws {@link EroareLimita} cota zilnica sau lunara atinsa.
1505
+ * @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a refuzat datele.
1506
+ * @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
1507
+ */
1508
+ verifica(identificator, optiuni) {
1509
+ return this.#ruleaza(
1510
+ verificaSiAsteapta(this.#mapare.cerere(identificator), optiuni),
1511
+ optiuni
1512
+ );
1513
+ }
1514
+ /**
1515
+ * Porneste verificarea fara sa astepte. Primesti rezultatul imediat, daca
1516
+ * vehiculul a fost verificat de curand, sau `status: "processing"`; atunci
1517
+ * afli raspunsul cu {@link ClientDocument.asteapta}, {@link ClientDocument.rezultat}
1518
+ * sau prin webhook la `callbackUrl`.
1519
+ *
1520
+ * @param identificator ce cere sursa oficiala pentru acest document.
1521
+ * @param optiuni `callbackUrl` si `signal`.
1522
+ * @returns rezultatul final sau verificarea in curs.
1523
+ */
1524
+ porneste(identificator, optiuni) {
1525
+ const cerere = {
1526
+ ...this.#mapare.cerere(identificator),
1527
+ ...optiuni?.callbackUrl !== void 0 && { callbackUrl: optiuni.callbackUrl }
1528
+ };
1529
+ return this.#ruleaza(porneste(cerere), optiuni);
1530
+ }
1531
+ /**
1532
+ * Interogheaza o singura data rezultatul. Nu consuma din cota.
1533
+ *
1534
+ * @param referinta verificarea in curs primita de la `porneste()` sau identificatorul documentului.
1535
+ * @param optiuni `signal` pentru anulare.
1536
+ * @returns rezultatul final sau verificarea inca in curs.
1537
+ */
1538
+ rezultat(referinta, optiuni) {
1539
+ return this.#ruleaza(rezultat(this.#referinta(referinta)), optiuni);
1540
+ }
1541
+ /**
1542
+ * Interogheaza periodic pana la rezultatul final. Nu consuma din cota.
1543
+ *
1544
+ * @param referinta verificarea in curs primita de la `porneste()` sau identificatorul documentului.
1545
+ * @param optiuni `timeoutMs`, `intervalMs` si `signal`.
1546
+ * @returns rezultatul final.
1547
+ * @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
1548
+ */
1549
+ asteapta(referinta, optiuni) {
1550
+ return this.#ruleaza(
1551
+ asteapta(this.#referinta(referinta), optiuni),
1552
+ optiuni
1553
+ );
1554
+ }
1555
+ #referinta(x) {
1556
+ return esteInCurs(x) ? x : this.#mapare.referinta(x);
1557
+ }
1558
+ };
1559
+ function rcaPe(id) {
1560
+ if (typeof id !== "string") return id;
1561
+ const n = normalizeaza(id);
1562
+ return VIN_REGEX2.test(n) ? { vin: n } : { numar: n };
1563
+ }
1564
+ var MAPARE_RCA = {
1565
+ cerere: (id) => {
1566
+ const { numar, vin } = rcaPe(id);
1567
+ return numar ? { tip: "rca", query: numar, ...vin && { serieSasiu: vin } } : { tip: "rca", query: vin ?? "" };
1568
+ },
1569
+ // Cu VIN, API-ul cauta doar dupa VIN, deci pollingul merge pe VIN.
1570
+ referinta: (id) => {
1571
+ const { numar, vin } = rcaPe(id);
1572
+ return { tip: "rca", query: normalizeaza(vin ?? numar ?? "") };
1573
+ }
1574
+ };
1575
+ var MAPARE_ITP = {
1576
+ cerere: (vin) => ({ tip: "itp", query: vin }),
1577
+ referinta: (vin) => ({ tip: "itp", query: normalizeaza(vin) })
1578
+ };
1579
+ var MAPARE_ARR = {
1580
+ cerere: (numar) => ({ tip: "arr", query: numar }),
1581
+ referinta: (numar) => ({ tip: "arr", query: normalizeaza(numar) })
1582
+ };
1583
+ var MAPARE_ROVINIETA = {
1584
+ cerere: (id) => ({ tip: "rovinieta", query: id.numar, serieSasiu: id.vin, serieTalon: id.serieTalon }),
1585
+ referinta: (id) => ({ tip: "rovinieta", query: normalizeaza(id.numar), serieSasiu: normalizeaza(id.vin) })
1586
+ };
1587
+ var ClientVin = class {
1588
+ #ruleaza;
1589
+ /** @internal */
1590
+ constructor(ruleaza2) {
1591
+ this.#ruleaza = ruleaza2;
1592
+ }
1593
+ /**
1594
+ * Decodeaza un VIN: marca, model, an si structura lui. Consuma din cota doar
1595
+ * cand marca si modelul sunt gasite (`taxat: true`).
1596
+ *
1597
+ * @param vin seria de sasiu, 17 caractere (spatiile si literele mici sunt acceptate).
1598
+ * @param optiuni `signal` pentru anulare.
1599
+ * @returns decodarea, completa, partiala sau doar structura.
1600
+ * @throws {@link EroareValidare} VIN invalid, local sau HTTP 400.
1601
+ * @throws {@link EroarePlanInactiv} lipseste abonamentul de decodare VIN.
1602
+ * @throws {@link EroareLimita} cota atinsa (`LIMIT_ATINS`) sau prea multe decodari fara rezultat (`PLAFON_NETAXAT`).
1603
+ * @example
1604
+ * const d = await acteo.auto.vin.decodeaza("WVWZZZ1KZBW000000")
1605
+ * console.log(d.marca, d.model, d.anFabricatie)
1606
+ */
1607
+ decodeaza(vin, optiuni) {
1608
+ return this.#ruleaza(decodeazaVin(vin), optiuni);
1609
+ }
1610
+ };
1611
+ var ClientNumere = class {
1612
+ #ruleaza;
1613
+ /** @internal */
1614
+ constructor(ruleaza2) {
1615
+ this.#ruleaza = ruleaza2;
1616
+ }
1617
+ /**
1618
+ * Verifica la DGPCI daca un numar de inmatriculare e liber. Raspunsul vine
1619
+ * sincron si poate dura pana la doua minute; cererea are un timeout minim
1620
+ * potrivit, oricat de mic e `timeoutMs` din client. Consuma din cota doar cand
1621
+ * DGPCI da un verdict.
1622
+ *
1623
+ * @param numar numarul complet: judetul, cifrele si trei litere, ex: `BV07ABC`.
1624
+ * @param optiuni `signal` pentru anulare.
1625
+ * @returns verdictul DGPCI.
1626
+ * @throws {@link EroareValidare} numar invalid sau incomplet, ori refuzat de DGPCI (`NUMAR_RESPINS`).
1627
+ * @throws {@link EroarePlanInactiv} lipseste abonamentul de numere disponibile.
1628
+ * @throws {@link EroareLimita} cota atinsa.
1629
+ * @throws {@link EroareServer} `OCUPAT`, `INDISPONIBIL`, `EROARE_DGPCI` sau `TIMEOUT`; cererea nu s-a taxat.
1630
+ * @example
1631
+ * const r = await acteo.auto.numere.verifica("BV07ABC")
1632
+ * if (r.disponibil) console.log("Numarul e liber")
1633
+ */
1634
+ verifica(numar, optiuni) {
1635
+ return this.#ruleaza(verificaNumar(numar), optiuni);
1636
+ }
1637
+ };
1638
+ var ClientImagini = class {
1639
+ #ruleaza;
1640
+ /** @internal */
1641
+ constructor(ruleaza2) {
1642
+ this.#ruleaza = ruleaza2;
1643
+ }
1644
+ /**
1645
+ * Cere poza unei masini si raspunde imediat. Cu `status: "gata"` primesti poza
1646
+ * reala si se taxeaza; altfel primesti poza generica (masina sub husa),
1647
+ * netaxata. La `"in-lucru"`, cere din nou dupa `retryAfterMs` sau foloseste
1648
+ * {@link ClientImagini.asteapta}. Linkul din `url` expira la `expiraLa`.
1649
+ *
1650
+ * @param cerere `marca`, `model`, `an` si optional `unghi`, `umbra`.
1651
+ * @param optiuni `signal` pentru anulare.
1652
+ * @returns poza masinii sau poza generica.
1653
+ * @throws {@link EroareValidare} marca, model, an, unghi sau umbra invalide.
1654
+ * @throws {@link EroarePlanInactiv} lipseste abonamentul de imagini masini.
1655
+ * @throws {@link EroareLimita} cota atinsa (`LIMIT_ATINS`) sau prea multe poze generice azi (`PLAFON_NETAXAT`).
1656
+ * @example
1657
+ * const p = await acteo.auto.imagini.obtine({ marca: "Volkswagen", model: "Golf", an: 2015 })
1658
+ * if (p.status === "gata") afiseaza(p.url)
1659
+ */
1660
+ obtine(cerere, optiuni) {
1661
+ return this.#ruleaza(imagine(cerere), optiuni);
1662
+ }
1663
+ /**
1664
+ * Ca {@link ClientImagini.obtine}, dar cat timp poza e `"in-lucru"` o cere din
1665
+ * nou, cu pauzele din `Retry-After`. Fiecare cerere intermediara e netaxata,
1666
+ * dar intra in plafonul zilnic de poze generice.
1667
+ *
1668
+ * @param cerere `marca`, `model`, `an` si optional `unghi`, `umbra`.
1669
+ * @param optiuni `timeoutMs` (implicit 2 minute) si `signal`.
1670
+ * @returns poza cu orice status in afara de `"in-lucru"`.
1671
+ * @throws {@link EroareTimeoutVerificare} poza nu a fost gata in `timeoutMs`.
1672
+ */
1673
+ asteapta(cerere, optiuni) {
1674
+ return this.#ruleaza(imagineAsteptata(cerere, optiuni), optiuni);
1675
+ }
1676
+ };
1677
+ var ClientAuto = class {
1678
+ /** Asigurarea RCA: `acteo.auto.rca.verifica("B123ABC")`. */
1679
+ rca;
1680
+ /** ITP: `acteo.auto.itp.verifica("WVWZZZ1JZXW000001")`. */
1681
+ itp;
1682
+ /** Rovinieta: `acteo.auto.rovinieta.verifica({ numar, vin, serieTalon })`. */
1683
+ rovinieta;
1684
+ /** Copia conforma ARR: `acteo.auto.arr.verifica("B123ABC")`. */
1685
+ arr;
1686
+ /** Vehiculele monitorizate din cont: `lista()`, `adauga()`, `sterge()`. */
1687
+ flota;
1688
+ /** Decodarea VIN: `acteo.auto.vin.decodeaza("WVWZZZ1KZBW000000")`. */
1689
+ vin;
1690
+ /** Numere disponibile la DGPCI: `acteo.auto.numere.verifica("BV07ABC")`. */
1691
+ numere;
1692
+ /** Pozele masinilor: `acteo.auto.imagini.obtine({ marca, model, an })`. */
1693
+ imagini;
1694
+ /** @internal */
1695
+ constructor(ruleaza2) {
1696
+ this.rca = new ClientDocument(ruleaza2, MAPARE_RCA);
1697
+ this.itp = new ClientDocument(ruleaza2, MAPARE_ITP);
1698
+ this.rovinieta = new ClientDocument(ruleaza2, MAPARE_ROVINIETA);
1699
+ this.arr = new ClientDocument(ruleaza2, MAPARE_ARR);
1700
+ this.flota = new ClientVehicule(ruleaza2);
1701
+ this.vin = new ClientVin(ruleaza2);
1702
+ this.numere = new ClientNumere(ruleaza2);
1703
+ this.imagini = new ClientImagini(ruleaza2);
1704
+ }
1705
+ };
1706
+ var ClientWebhooks = class {
1707
+ /**
1708
+ * Valideaza corpul unui webhook de rezultat (trimis la `callbackUrl`).
1709
+ *
1710
+ * @param corp corpul cererii, ca string sau obiect deja parsat.
1711
+ * @returns rezultatul verificarii.
1712
+ * @throws {@link EroareWebhook} corp invalid.
1713
+ */
1714
+ parseazaRezultat(corp) {
1715
+ return parseazaWebhookRezultat(corp);
1716
+ }
1717
+ /**
1718
+ * Verifica cheia si corpul unui webhook de notificare (`document.expira`,
1719
+ * evenimentele celorlalte servicii sau `webhook.test`).
1720
+ *
1721
+ * @param corp corpul cererii.
1722
+ * @param headers headerele cererii.
1723
+ * @param optiuni `cheie`, cheia de webhook din dashboard.
1724
+ * @returns notificarea validata.
1725
+ * @throws {@link EroareWebhook} cheie lipsa, gresita sau corp invalid.
1726
+ */
1727
+ verificaNotificare(corp, headers, optiuni) {
1728
+ return verificaWebhookNotificare(corp, headers, optiuni);
1729
+ }
1730
+ };
1731
+ var Acteo = class {
1732
+ /** Documentele unei masini (RCA, ITP, rovinieta, ARR), flota, VIN, numere si poze. */
1733
+ auto;
1734
+ /** Citirea webhook-urilor. */
1735
+ webhooks;
1736
+ /**
1737
+ * Creeaza un client. Nu face nicio cerere pe retea.
1738
+ *
1739
+ * @param optiuni cheia API si setarile de retea; toate sunt optionale daca
1740
+ * `ACTEO_API_KEY` e setata.
1741
+ * @throws {@link EroareConfigurare} lipseste cheia API sau o optiune e invalida.
1742
+ */
1743
+ constructor(optiuni = {}) {
1744
+ const ruleaza2 = creeazaRulare(optiuni, PROFIL_ACTEO);
1745
+ this.auto = new ClientAuto(ruleaza2);
1746
+ this.webhooks = new ClientWebhooks();
1747
+ }
1748
+ };
1749
+
1750
+ export { Acteo, VerificRcaError as ActeoError, ClientAuto, ClientDocument, ClientImagini, ClientNumere, ClientVehicule, ClientVerificari, ClientVin, ClientWebhooks, EroareAutentificare, EroareConfigurare, EroareConflict, EroareHttp, EroareInterzis, EroareLimita, EroareNegasit, EroarePlanInactiv, EroareRaspunsInvalid, EroareRetea, EroareServer, EroareTimeoutVerificare, EroareValidare, EroareVerificare, EroareWebhook, HEADER_CHEIE_WEBHOOK, HEADER_EVENIMENT_WEBHOOK, TIPURI_VERIFICARE, UNGHIURI_IMAGINE, URL_IMPLICIT, URL_IMPLICIT_LEGACY, VERSIUNE_SDK, VerificRca, VerificRcaError, esteNumarInmatriculareValid, esteSerieTalonValida, esteVinValid, normalizeaza, normalizeazaSerieTalon, parseazaWebhookRezultat, verificaWebhookNotificare };
1751
+ //# sourceMappingURL=index.js.map
1752
+ //# sourceMappingURL=index.js.map