@acteo/api 0.0.0-stage → 0.3.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/CHANGELOG.md +34 -0
- package/LICENSE +21 -0
- package/README.md +492 -2
- package/dist/index.cjs +1249 -0
- package/dist/index.cjs.map +1 -0
- package/dist/index.d.cts +1058 -0
- package/dist/index.d.ts +1058 -0
- package/dist/index.js +1211 -0
- package/dist/index.js.map +1 -0
- package/package.json +105 -5
package/dist/index.d.ts
ADDED
|
@@ -0,0 +1,1058 @@
|
|
|
1
|
+
import { Schema, Data, Context, Effect } from 'effect';
|
|
2
|
+
|
|
3
|
+
/** Tipurile de verificare: RCA (AIDA/BAAR), ITP (RAR), rovinieta (CNAIR), ARR (copie conforma). */
|
|
4
|
+
declare const TipVerificare: Schema.Literal<["rca", "itp", "rovinieta", "arr"]>;
|
|
5
|
+
/** Tipul verificarii: `"rca"`, `"itp"`, `"rovinieta"` sau `"arr"`. */
|
|
6
|
+
type TipVerificare = typeof TipVerificare.Type;
|
|
7
|
+
/**
|
|
8
|
+
* Starea documentului:
|
|
9
|
+
* - `valid`: valabil si departe de expirare;
|
|
10
|
+
* - `warning`: expira curand (RCA 14 zile, ITP 30, rovinieta 7, ARR 14);
|
|
11
|
+
* - `expired`: expirat sau inexistent, confirmat de sursa oficiala;
|
|
12
|
+
* - `not_found`: sursa nu a gasit vehiculul.
|
|
13
|
+
*/
|
|
14
|
+
declare const StatusDocument: Schema.Literal<["valid", "warning", "expired", "not_found"]>;
|
|
15
|
+
/** Starea documentului: `"valid"`, `"warning"`, `"expired"` sau `"not_found"`. Vezi {@link StatusDocument}. */
|
|
16
|
+
type StatusDocument = typeof StatusDocument.Type;
|
|
17
|
+
declare const RezultatVerificareSchema: Schema.Struct<{
|
|
18
|
+
/** Tipul verificarii. */
|
|
19
|
+
tip: Schema.Literal<["rca", "itp", "rovinieta", "arr"]>;
|
|
20
|
+
/** Identificatorul dupa care s-a cautat (la RCA cu VIN, acesta e VIN-ul). */
|
|
21
|
+
query: typeof Schema.String;
|
|
22
|
+
/** Numarul de inmatriculare verificat, `null` cand cautarea s-a facut doar dupa VIN. */
|
|
23
|
+
numarInmatriculare: Schema.NullOr<typeof Schema.String>;
|
|
24
|
+
/** Seria de sasiu (VIN) verificata, `null` cand cautarea s-a facut doar dupa numar. */
|
|
25
|
+
serieSasiu: Schema.NullOr<typeof Schema.String>;
|
|
26
|
+
/** Cand a fost interogata sursa oficiala. */
|
|
27
|
+
checkedAt: typeof Schema.Date;
|
|
28
|
+
/** Starea documentului. Vezi {@link StatusDocument}. */
|
|
29
|
+
status: Schema.Literal<["valid", "warning", "expired", "not_found"]>;
|
|
30
|
+
/** Data expirarii documentului, `null` daca nu exista document valabil. */
|
|
31
|
+
expiresAt: Schema.NullOr<typeof Schema.Date>;
|
|
32
|
+
/** ID-ul cererii, prezent doar cand ai trimis `callbackUrl`. Apare si in webhook. */
|
|
33
|
+
requestId: Schema.optional<typeof Schema.String>;
|
|
34
|
+
/** Recomandarea API-ului, ex: la RCA cerut doar dupa numar, sa trimiti si VIN-ul. */
|
|
35
|
+
hint: Schema.optional<typeof Schema.String>;
|
|
36
|
+
}>;
|
|
37
|
+
/**
|
|
38
|
+
* Codurile cu care sursa oficiala refuza datele trimise. O reincercare cu
|
|
39
|
+
* aceleasi date nu ajuta; trebuie corectat campul indicat:
|
|
40
|
+
* - `serie_talon_invalida`: numarul certificatului de inmatriculare (talon);
|
|
41
|
+
* - `vin_invalid`: seria de sasiu;
|
|
42
|
+
* - `numar_invalid`: numarul de inmatriculare.
|
|
43
|
+
*
|
|
44
|
+
* Tipul accepta si alte valori, pentru coduri adaugate ulterior de API.
|
|
45
|
+
*/
|
|
46
|
+
type CodRefuzSursa = "serie_talon_invalida" | "vin_invalid" | "numar_invalid" | (string & {});
|
|
47
|
+
declare const VehiculSchema: Schema.Struct<{
|
|
48
|
+
/** ID-ul vehiculului in cont, folosit la stergere. */
|
|
49
|
+
id: typeof Schema.String;
|
|
50
|
+
/** Numarul de inmatriculare, `null` daca vehiculul a fost adaugat doar cu VIN. */
|
|
51
|
+
numarInmatriculare: Schema.NullOr<typeof Schema.String>;
|
|
52
|
+
/** Seria de sasiu (VIN), `null` daca vehiculul a fost adaugat doar cu numarul. */
|
|
53
|
+
serieSasiu: Schema.NullOr<typeof Schema.String>;
|
|
54
|
+
/** Numarul certificatului de inmatriculare (talon). Fara el rovinieta nu se verifica. */
|
|
55
|
+
serieTalon: Schema.optionalWith<Schema.NullOr<typeof Schema.String>, {
|
|
56
|
+
default: () => null;
|
|
57
|
+
}>;
|
|
58
|
+
/** Sursa oficiala a respins numarul talonului; rovinieta nu se mai verifica pana la corectarea lui. */
|
|
59
|
+
serieTalonRespinsa: Schema.optionalWith<typeof Schema.Boolean, {
|
|
60
|
+
default: () => false;
|
|
61
|
+
}>;
|
|
62
|
+
/** Data expirarii RCA, `null` daca nu e cunoscuta inca. */
|
|
63
|
+
rcaExpiraLa: Schema.NullOr<typeof Schema.Date>;
|
|
64
|
+
/** Data expirarii ITP, `null` daca nu e cunoscuta inca (ITP-ul cere VIN). */
|
|
65
|
+
itpExpiraLa: Schema.NullOr<typeof Schema.Date>;
|
|
66
|
+
/** Data expirarii rovinietei, `null` daca nu e cunoscuta inca (rovinieta cere numar, VIN si numarul talonului). */
|
|
67
|
+
rovinietaExpiraLa: Schema.NullOr<typeof Schema.Date>;
|
|
68
|
+
/** Data expirarii copiei conforme ARR. Completata doar cand `arrMonitorizat` e `true`. */
|
|
69
|
+
arrExpiraLa: Schema.NullOr<typeof Schema.Date>;
|
|
70
|
+
/** Vehiculul e monitorizat si pentru copia conforma ARR (cere un plan activ). */
|
|
71
|
+
arrMonitorizat: typeof Schema.Boolean;
|
|
72
|
+
/** Cand a fost adaugat vehiculul in cont. */
|
|
73
|
+
createdAt: typeof Schema.Date;
|
|
74
|
+
/** Vehiculul e verificat automat si primeste notificari de expirare. */
|
|
75
|
+
activ: typeof Schema.Boolean;
|
|
76
|
+
}>;
|
|
77
|
+
/** Un vehicul monitorizat din cont, cu datele de expirare ale documentelor. */
|
|
78
|
+
type Vehicul = typeof VehiculSchema.Type;
|
|
79
|
+
/** Rezultatul livrat la `callbackUrl` dupa o verificare. */
|
|
80
|
+
declare const WebhookRezultatSchema: Schema.Struct<{
|
|
81
|
+
/** ID-ul cererii, acelasi cu `requestId` primit de la `porneste()`. */
|
|
82
|
+
requestId: typeof Schema.String;
|
|
83
|
+
/** Tipul verificarii. */
|
|
84
|
+
tip: Schema.Literal<["rca", "itp", "rovinieta", "arr"]>;
|
|
85
|
+
/** Identificatorul dupa care s-a cautat. */
|
|
86
|
+
query: typeof Schema.String;
|
|
87
|
+
/** Seria de sasiu trimisa in cerere, daca exista. */
|
|
88
|
+
serieSasiu: Schema.NullOr<typeof Schema.String>;
|
|
89
|
+
/** Starea documentului sau `"error"` cand sursa oficiala nu a raspuns. */
|
|
90
|
+
status: Schema.Union<[Schema.Literal<["valid", "warning", "expired", "not_found"]>, Schema.Literal<["error"]>]>;
|
|
91
|
+
/** Rezultatul complet, `null` la `status: "error"`. */
|
|
92
|
+
result: Schema.NullOr<Schema.Struct<{
|
|
93
|
+
/** Tipul verificarii. */
|
|
94
|
+
tip: Schema.Literal<["rca", "itp", "rovinieta", "arr"]>;
|
|
95
|
+
/** Identificatorul dupa care s-a cautat (la RCA cu VIN, acesta e VIN-ul). */
|
|
96
|
+
query: typeof Schema.String;
|
|
97
|
+
/** Numarul de inmatriculare verificat, `null` cand cautarea s-a facut doar dupa VIN. */
|
|
98
|
+
numarInmatriculare: Schema.NullOr<typeof Schema.String>;
|
|
99
|
+
/** Seria de sasiu (VIN) verificata, `null` cand cautarea s-a facut doar dupa numar. */
|
|
100
|
+
serieSasiu: Schema.NullOr<typeof Schema.String>;
|
|
101
|
+
/** Cand a fost interogata sursa oficiala. */
|
|
102
|
+
checkedAt: typeof Schema.Date;
|
|
103
|
+
/** Starea documentului. Vezi {@link StatusDocument}. */
|
|
104
|
+
status: Schema.Literal<["valid", "warning", "expired", "not_found"]>;
|
|
105
|
+
/** Data expirarii documentului, `null` daca nu exista document valabil. */
|
|
106
|
+
expiresAt: Schema.NullOr<typeof Schema.Date>;
|
|
107
|
+
/** ID-ul cererii, prezent doar cand ai trimis `callbackUrl`. Apare si in webhook. */
|
|
108
|
+
requestId: Schema.optional<typeof Schema.String>;
|
|
109
|
+
/** Recomandarea API-ului, ex: la RCA cerut doar dupa numar, sa trimiti si VIN-ul. */
|
|
110
|
+
hint: Schema.optional<typeof Schema.String>;
|
|
111
|
+
}>>;
|
|
112
|
+
/** Cand a fost interogata sursa, `null` la eroare. */
|
|
113
|
+
checkedAt: Schema.NullOr<typeof Schema.Date>;
|
|
114
|
+
/** Mesajul de eroare, doar la `status: "error"`. */
|
|
115
|
+
error: Schema.optional<typeof Schema.String>;
|
|
116
|
+
}>;
|
|
117
|
+
/** Payloadul POST trimis la `callbackUrl` cand o verificare se termina. */
|
|
118
|
+
type WebhookRezultat = typeof WebhookRezultatSchema.Type;
|
|
119
|
+
/** Evenimentul `document.expira`: un document a intrat intr-un prag de expirare. */
|
|
120
|
+
declare const WebhookDocumentExpiraSchema: Schema.Struct<{
|
|
121
|
+
/** Numele evenimentului. */
|
|
122
|
+
event: Schema.Literal<["document.expira"]>;
|
|
123
|
+
/** ID unic al livrarii. Foloseste-l pentru deduplicare. */
|
|
124
|
+
id: typeof Schema.String;
|
|
125
|
+
/** Vehiculul la care expira documentul. */
|
|
126
|
+
vehicul: Schema.Struct<{
|
|
127
|
+
/** ID-ul vehiculului in cont, acelasi ca in `vehicule.lista()`. */
|
|
128
|
+
id: typeof Schema.String;
|
|
129
|
+
/** Numarul de inmatriculare, daca e cunoscut. */
|
|
130
|
+
numarInmatriculare: Schema.NullOr<typeof Schema.String>;
|
|
131
|
+
/** Seria de sasiu (VIN), daca e cunoscuta. */
|
|
132
|
+
serieSasiu: Schema.NullOr<typeof Schema.String>;
|
|
133
|
+
}>;
|
|
134
|
+
/** Documentul care expira. */
|
|
135
|
+
document: Schema.Literal<["rca", "itp", "rovinieta", "arr"]>;
|
|
136
|
+
/** Data expirarii documentului. */
|
|
137
|
+
expiraLa: typeof Schema.Date;
|
|
138
|
+
/** Zile intregi ramase pana la expirare (minim 0). */
|
|
139
|
+
zileRamase: typeof Schema.Number;
|
|
140
|
+
/** Pragul de notificare atins, in zile (RCA/ITP/rovinieta: 30, 14, 3; ARR: 60, 50, 45). */
|
|
141
|
+
prag: typeof Schema.Number;
|
|
142
|
+
/** Cand a fost trimisa notificarea. */
|
|
143
|
+
trimisLa: typeof Schema.Date;
|
|
144
|
+
}>;
|
|
145
|
+
/** Notificarea trimisa cand un document intra intr-un prag de expirare. */
|
|
146
|
+
type WebhookDocumentExpira = typeof WebhookDocumentExpiraSchema.Type;
|
|
147
|
+
/** Evenimentul `webhook.test`, trimis din butonul de test din dashboard. */
|
|
148
|
+
declare const WebhookTestSchema: Schema.Struct<{
|
|
149
|
+
/** Numele evenimentului. */
|
|
150
|
+
event: Schema.Literal<["webhook.test"]>;
|
|
151
|
+
/** ID unic al testului. */
|
|
152
|
+
id: typeof Schema.String;
|
|
153
|
+
/** Mesajul de confirmare. */
|
|
154
|
+
mesaj: typeof Schema.String;
|
|
155
|
+
/** Cand a fost trimis testul. */
|
|
156
|
+
trimisLa: typeof Schema.Date;
|
|
157
|
+
}>;
|
|
158
|
+
/** Evenimentul trimis de butonul de test din dashboard. */
|
|
159
|
+
type WebhookTest = typeof WebhookTestSchema.Type;
|
|
160
|
+
declare const WebhookNotificareSchema: Schema.Union<[Schema.Struct<{
|
|
161
|
+
/** Numele evenimentului. */
|
|
162
|
+
event: Schema.Literal<["document.expira"]>;
|
|
163
|
+
/** ID unic al livrarii. Foloseste-l pentru deduplicare. */
|
|
164
|
+
id: typeof Schema.String;
|
|
165
|
+
/** Vehiculul la care expira documentul. */
|
|
166
|
+
vehicul: Schema.Struct<{
|
|
167
|
+
/** ID-ul vehiculului in cont, acelasi ca in `vehicule.lista()`. */
|
|
168
|
+
id: typeof Schema.String;
|
|
169
|
+
/** Numarul de inmatriculare, daca e cunoscut. */
|
|
170
|
+
numarInmatriculare: Schema.NullOr<typeof Schema.String>;
|
|
171
|
+
/** Seria de sasiu (VIN), daca e cunoscuta. */
|
|
172
|
+
serieSasiu: Schema.NullOr<typeof Schema.String>;
|
|
173
|
+
}>;
|
|
174
|
+
/** Documentul care expira. */
|
|
175
|
+
document: Schema.Literal<["rca", "itp", "rovinieta", "arr"]>;
|
|
176
|
+
/** Data expirarii documentului. */
|
|
177
|
+
expiraLa: typeof Schema.Date;
|
|
178
|
+
/** Zile intregi ramase pana la expirare (minim 0). */
|
|
179
|
+
zileRamase: typeof Schema.Number;
|
|
180
|
+
/** Pragul de notificare atins, in zile (RCA/ITP/rovinieta: 30, 14, 3; ARR: 60, 50, 45). */
|
|
181
|
+
prag: typeof Schema.Number;
|
|
182
|
+
/** Cand a fost trimisa notificarea. */
|
|
183
|
+
trimisLa: typeof Schema.Date;
|
|
184
|
+
}>, Schema.Struct<{
|
|
185
|
+
/** Numele evenimentului. */
|
|
186
|
+
event: Schema.Literal<["webhook.test"]>;
|
|
187
|
+
/** ID unic al testului. */
|
|
188
|
+
id: typeof Schema.String;
|
|
189
|
+
/** Mesajul de confirmare. */
|
|
190
|
+
mesaj: typeof Schema.String;
|
|
191
|
+
/** Cand a fost trimis testul. */
|
|
192
|
+
trimisLa: typeof Schema.Date;
|
|
193
|
+
}>]>;
|
|
194
|
+
/** Orice notificare trimisa la URL-ul de webhook al contului. Distinge-le dupa `event`. */
|
|
195
|
+
type WebhookNotificare = typeof WebhookNotificareSchema.Type;
|
|
196
|
+
|
|
197
|
+
/** Campurile comune tuturor erorilor SDK-ului. */
|
|
198
|
+
interface DateEroare {
|
|
199
|
+
/** Mesajul, in romana, exact cum vine de la API cand exista. */
|
|
200
|
+
readonly message: string;
|
|
201
|
+
/** Statusul HTTP, cand eroarea vine dintr-un raspuns. */
|
|
202
|
+
readonly status?: number;
|
|
203
|
+
/** Codul masinii (`LIMIT_ATINS`, `VEHICUL_EXISTENT`, `NEGASIT` etc.). */
|
|
204
|
+
readonly cod?: string;
|
|
205
|
+
/** Indicatia API-ului despre cum se rezolva problema. */
|
|
206
|
+
readonly hint?: string;
|
|
207
|
+
/** Corpul brut al raspunsului, pentru depanare. */
|
|
208
|
+
readonly raspuns?: unknown;
|
|
209
|
+
/** Eroarea originala (de retea, de parsare), cand exista. */
|
|
210
|
+
readonly cause?: unknown;
|
|
211
|
+
}
|
|
212
|
+
/**
|
|
213
|
+
* Baza tuturor erorilor aruncate de SDK. `instanceof VerificRcaError` prinde
|
|
214
|
+
* orice eroare de la API, iar `_tag` spune exact care e.
|
|
215
|
+
*/
|
|
216
|
+
declare class VerificRcaError extends Data.Error<DateEroare> {
|
|
217
|
+
/** Discriminantul erorii. Fiecare subclasa are propria valoare, ex: `"EroareLimita"`. */
|
|
218
|
+
readonly _tag: string;
|
|
219
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
220
|
+
readonly name: string;
|
|
221
|
+
}
|
|
222
|
+
/** Optiunile clientului sunt invalide (cheie API lipsa, URL gresit etc.). */
|
|
223
|
+
declare class EroareConfigurare extends VerificRcaError {
|
|
224
|
+
/** Discriminantul erorii: `"EroareConfigurare"`. Util in `switch (err._tag)`. */
|
|
225
|
+
readonly _tag = "EroareConfigurare";
|
|
226
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
227
|
+
readonly name = "EroareConfigurare";
|
|
228
|
+
}
|
|
229
|
+
/**
|
|
230
|
+
* Datele trimise sunt invalide. Apare fie local, inainte de orice cerere (nu se
|
|
231
|
+
* consuma nimic din cota), fie ca raspuns 400 de la API.
|
|
232
|
+
*/
|
|
233
|
+
declare class EroareValidare extends VerificRcaError {
|
|
234
|
+
/** Discriminantul erorii: `"EroareValidare"`. Util in `switch (err._tag)`. */
|
|
235
|
+
readonly _tag = "EroareValidare";
|
|
236
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
237
|
+
readonly name = "EroareValidare";
|
|
238
|
+
/** Valorile acceptate, cand API-ul le trimite (ex: tipurile de verificare). */
|
|
239
|
+
readonly acceptate?: readonly string[];
|
|
240
|
+
/** Campul cu problema, cand eroarea e detectata local. */
|
|
241
|
+
readonly camp?: string;
|
|
242
|
+
/**
|
|
243
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
244
|
+
*
|
|
245
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
246
|
+
*/
|
|
247
|
+
constructor(args: DateEroare & {
|
|
248
|
+
readonly acceptate?: readonly string[];
|
|
249
|
+
readonly camp?: string;
|
|
250
|
+
});
|
|
251
|
+
}
|
|
252
|
+
/** 401: cheia API lipseste, e invalida sau a fost dezactivata. */
|
|
253
|
+
declare class EroareAutentificare extends VerificRcaError {
|
|
254
|
+
/** Discriminantul erorii: `"EroareAutentificare"`. Util in `switch (err._tag)`. */
|
|
255
|
+
readonly _tag = "EroareAutentificare";
|
|
256
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
257
|
+
readonly name = "EroareAutentificare";
|
|
258
|
+
}
|
|
259
|
+
/** 402: contul nu are un abonament activ pentru operatia ceruta. */
|
|
260
|
+
declare class EroarePlanInactiv extends VerificRcaError {
|
|
261
|
+
/** Discriminantul erorii: `"EroarePlanInactiv"`. Util in `switch (err._tag)`. */
|
|
262
|
+
readonly _tag = "EroarePlanInactiv";
|
|
263
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
264
|
+
readonly name = "EroarePlanInactiv";
|
|
265
|
+
}
|
|
266
|
+
/** 403: operatia nu e permisa pe planul curent (`LIMIT_ATINS`, `ARR_NECESITA_PLAN`). */
|
|
267
|
+
declare class EroareInterzis extends VerificRcaError {
|
|
268
|
+
/** Discriminantul erorii: `"EroareInterzis"`. Util in `switch (err._tag)`. */
|
|
269
|
+
readonly _tag = "EroareInterzis";
|
|
270
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
271
|
+
readonly name = "EroareInterzis";
|
|
272
|
+
/** Numarul de masini permis de plan, la `LIMIT_ATINS`. */
|
|
273
|
+
readonly limita?: number;
|
|
274
|
+
/**
|
|
275
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
276
|
+
*
|
|
277
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
278
|
+
*/
|
|
279
|
+
constructor(args: DateEroare & {
|
|
280
|
+
readonly limita?: number;
|
|
281
|
+
});
|
|
282
|
+
}
|
|
283
|
+
/** 404: resursa nu exista sau nu apartine contului cheii. */
|
|
284
|
+
declare class EroareNegasit extends VerificRcaError {
|
|
285
|
+
/** Discriminantul erorii: `"EroareNegasit"`. Util in `switch (err._tag)`. */
|
|
286
|
+
readonly _tag = "EroareNegasit";
|
|
287
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
288
|
+
readonly name = "EroareNegasit";
|
|
289
|
+
}
|
|
290
|
+
/** 409: vehiculul exista deja in cont (`VEHICUL_EXISTENT`). */
|
|
291
|
+
declare class EroareConflict extends VerificRcaError {
|
|
292
|
+
/** Discriminantul erorii: `"EroareConflict"`. Util in `switch (err._tag)`. */
|
|
293
|
+
readonly _tag = "EroareConflict";
|
|
294
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
295
|
+
readonly name = "EroareConflict";
|
|
296
|
+
}
|
|
297
|
+
/**
|
|
298
|
+
* 429: limita a fost atinsa. `cod` spune care:
|
|
299
|
+
* - `COTA_ATINSA`: cota zilnica sau lunara de verificari a planului;
|
|
300
|
+
* - `LIMITA_FLOTA_ATINSA`: plafonul zilnic de adaugari/stergeri de vehicule;
|
|
301
|
+
* - `PREA_MULTE_CERERI`: polling prea des (SDK-ul reincearca singur).
|
|
302
|
+
*/
|
|
303
|
+
declare class EroareLimita extends VerificRcaError {
|
|
304
|
+
/** Discriminantul erorii: `"EroareLimita"`. Util in `switch (err._tag)`. */
|
|
305
|
+
readonly _tag = "EroareLimita";
|
|
306
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
307
|
+
readonly name = "EroareLimita";
|
|
308
|
+
/** Cat sa astepti inainte de o cerere noua, din headerul `Retry-After`. */
|
|
309
|
+
readonly retryAfterMs?: number;
|
|
310
|
+
/** Consumul zilnic, ex: `"300/300"`. */
|
|
311
|
+
readonly utilizareZi?: string;
|
|
312
|
+
/** Consumul lunar, ex: `"4120/10000"`. */
|
|
313
|
+
readonly utilizareLuna?: string;
|
|
314
|
+
/**
|
|
315
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
316
|
+
*
|
|
317
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
318
|
+
*/
|
|
319
|
+
constructor(args: DateEroare & {
|
|
320
|
+
readonly retryAfterMs?: number;
|
|
321
|
+
readonly utilizareZi?: string;
|
|
322
|
+
readonly utilizareLuna?: string;
|
|
323
|
+
});
|
|
324
|
+
}
|
|
325
|
+
/** 5xx: eroare pe serverul API-ului. Cererile sigure se reincearca automat. */
|
|
326
|
+
declare class EroareServer extends VerificRcaError {
|
|
327
|
+
/** Discriminantul erorii: `"EroareServer"`. Util in `switch (err._tag)`. */
|
|
328
|
+
readonly _tag = "EroareServer";
|
|
329
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
330
|
+
readonly name = "EroareServer";
|
|
331
|
+
}
|
|
332
|
+
/** Orice alt status HTTP neasteptat. */
|
|
333
|
+
declare class EroareHttp extends VerificRcaError {
|
|
334
|
+
/** Discriminantul erorii: `"EroareHttp"`. Util in `switch (err._tag)`. */
|
|
335
|
+
readonly _tag = "EroareHttp";
|
|
336
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
337
|
+
readonly name = "EroareHttp";
|
|
338
|
+
}
|
|
339
|
+
/** Cererea nu a primit raspuns: retea cazuta, DNS, conexiune refuzata sau timeout. */
|
|
340
|
+
declare class EroareRetea extends VerificRcaError {
|
|
341
|
+
/** Discriminantul erorii: `"EroareRetea"`. Util in `switch (err._tag)`. */
|
|
342
|
+
readonly _tag = "EroareRetea";
|
|
343
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
344
|
+
readonly name = "EroareRetea";
|
|
345
|
+
/** Adevarat cand cererea a depasit `timeoutMs`. */
|
|
346
|
+
readonly timeout?: boolean;
|
|
347
|
+
/**
|
|
348
|
+
* Adevarat cand e sigur ca cererea nu a ajuns la server (DNS, conexiune
|
|
349
|
+
* refuzata), deci se poate repeta fara risc chiar si pentru un POST.
|
|
350
|
+
*/
|
|
351
|
+
readonly neajunsa?: boolean;
|
|
352
|
+
/**
|
|
353
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
354
|
+
*
|
|
355
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si campurile specifice acestei erori.
|
|
356
|
+
*/
|
|
357
|
+
constructor(args: DateEroare & {
|
|
358
|
+
readonly timeout?: boolean;
|
|
359
|
+
readonly neajunsa?: boolean;
|
|
360
|
+
});
|
|
361
|
+
}
|
|
362
|
+
/** Raspunsul API-ului nu are forma asteptata (JSON invalid sau campuri lipsa). */
|
|
363
|
+
declare class EroareRaspunsInvalid extends VerificRcaError {
|
|
364
|
+
/** Discriminantul erorii: `"EroareRaspunsInvalid"`. Util in `switch (err._tag)`. */
|
|
365
|
+
readonly _tag = "EroareRaspunsInvalid";
|
|
366
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
367
|
+
readonly name = "EroareRaspunsInvalid";
|
|
368
|
+
}
|
|
369
|
+
/**
|
|
370
|
+
* Verificarea s-a incheiat cu statusul `error`. Doua situatii:
|
|
371
|
+
* - sursa oficiala nu a raspuns la timp: `codSursa` lipseste si verificarea
|
|
372
|
+
* poate fi reluata cu o cerere noua;
|
|
373
|
+
* - sursa a refuzat datele trimise: `codSursa` spune ce camp e gresit
|
|
374
|
+
* (`serie_talon_invalida`, `vin_invalid`, `numar_invalid`). O reincercare cu
|
|
375
|
+
* aceleasi date nu ajuta; corecteaza campul intai.
|
|
376
|
+
*/
|
|
377
|
+
declare class EroareVerificare extends VerificRcaError {
|
|
378
|
+
/** Discriminantul erorii: `"EroareVerificare"`. Util in `switch (err._tag)`. */
|
|
379
|
+
readonly _tag = "EroareVerificare";
|
|
380
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
381
|
+
readonly name = "EroareVerificare";
|
|
382
|
+
/**
|
|
383
|
+
* Codul API-ului cand sursa a refuzat datele trimise, ex: `"serie_talon_invalida"`.
|
|
384
|
+
* Lipseste cand sursa doar nu a raspuns. Vezi {@link CodRefuzSursa}.
|
|
385
|
+
*/
|
|
386
|
+
readonly codSursa?: CodRefuzSursa;
|
|
387
|
+
/**
|
|
388
|
+
* Creeaza eroarea. SDK-ul o construieste singur; o creezi manual doar in teste.
|
|
389
|
+
*
|
|
390
|
+
* @param args mesajul, detaliile comune ({@link DateEroare}) si `codSursa`.
|
|
391
|
+
*/
|
|
392
|
+
constructor(args: DateEroare & {
|
|
393
|
+
readonly codSursa?: CodRefuzSursa;
|
|
394
|
+
});
|
|
395
|
+
}
|
|
396
|
+
/** `verificaSiAsteapta` a depasit timpul maxim de asteptare. */
|
|
397
|
+
declare class EroareTimeoutVerificare extends VerificRcaError {
|
|
398
|
+
/** Discriminantul erorii: `"EroareTimeoutVerificare"`. Util in `switch (err._tag)`. */
|
|
399
|
+
readonly _tag = "EroareTimeoutVerificare";
|
|
400
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
401
|
+
readonly name = "EroareTimeoutVerificare";
|
|
402
|
+
}
|
|
403
|
+
/** Un webhook primit nu poate fi acceptat: cheie gresita sau payload invalid. */
|
|
404
|
+
declare class EroareWebhook extends VerificRcaError {
|
|
405
|
+
/** Discriminantul erorii: `"EroareWebhook"`. Util in `switch (err._tag)`. */
|
|
406
|
+
readonly _tag = "EroareWebhook";
|
|
407
|
+
/** Numele clasei, afisat in loguri si in stack trace. */
|
|
408
|
+
readonly name = "EroareWebhook";
|
|
409
|
+
}
|
|
410
|
+
/** Erorile pe care le poate produce o cerere HTTP catre API. */
|
|
411
|
+
type EroareCerere = EroareValidare | EroareAutentificare | EroarePlanInactiv | EroareInterzis | EroareNegasit | EroareConflict | EroareLimita | EroareServer | EroareHttp | EroareRetea | EroareRaspunsInvalid;
|
|
412
|
+
|
|
413
|
+
/**
|
|
414
|
+
* Politica de reincercare pentru erorile trecatoare. Pauzele cresc exponential
|
|
415
|
+
* (x2), cu jitter, si nu scad sub `Retry-After` cand serverul il trimite.
|
|
416
|
+
*/
|
|
417
|
+
interface SetariRetry {
|
|
418
|
+
/** Numarul maxim de reincercari dupa prima cerere. */
|
|
419
|
+
readonly incercari: number;
|
|
420
|
+
/** Prima pauza; creste exponential (x2) cu jitter. */
|
|
421
|
+
readonly intarziereInitialaMs: number;
|
|
422
|
+
/** Plafonul unei singure pauze. */
|
|
423
|
+
readonly intarziereMaximaMs: number;
|
|
424
|
+
}
|
|
425
|
+
interface SetariClient {
|
|
426
|
+
readonly apiKey: string;
|
|
427
|
+
readonly baseUrl: string;
|
|
428
|
+
readonly timeoutMs: number;
|
|
429
|
+
readonly retry: SetariRetry | null;
|
|
430
|
+
readonly fetch: typeof globalThis.fetch;
|
|
431
|
+
readonly userAgent: string;
|
|
432
|
+
}
|
|
433
|
+
declare const Setari_base: Context.TagClass<Setari, "@verificrca/sdk/Setari", SetariClient>;
|
|
434
|
+
declare class Setari extends Setari_base {
|
|
435
|
+
}
|
|
436
|
+
|
|
437
|
+
/** Toate tipurile de verificare acceptate de API, in ordine: `["rca", "itp", "rovinieta", "arr"]`. */
|
|
438
|
+
declare const TIPURI_VERIFICARE: readonly TipVerificare[];
|
|
439
|
+
/**
|
|
440
|
+
* Aduce un numar de inmatriculare sau un VIN la forma canonica: fara spatii,
|
|
441
|
+
* cratime sau underscore, cu majuscule.
|
|
442
|
+
*
|
|
443
|
+
* @param valoare textul introdus de utilizator.
|
|
444
|
+
* @returns forma normalizata.
|
|
445
|
+
* @example
|
|
446
|
+
* normalizeaza(" b-123 abc ") // "B123ABC"
|
|
447
|
+
*/
|
|
448
|
+
declare function normalizeaza(valoare: string): string;
|
|
449
|
+
/**
|
|
450
|
+
* Verifica un numar de inmatriculare romanesc: Bucuresti (`B123ABC`), judete
|
|
451
|
+
* (`CJ45XYZ`), corp diplomatic (`CD123A`) si numere temporare (`TC1234AB`).
|
|
452
|
+
* Accepta si forme cu spatii sau cratime.
|
|
453
|
+
*
|
|
454
|
+
* @param valoare numarul de verificat.
|
|
455
|
+
* @returns `true` daca numarul are un format valid.
|
|
456
|
+
* @example
|
|
457
|
+
* esteNumarInmatriculareValid("CJ 45 XYZ") // true
|
|
458
|
+
* esteNumarInmatriculareValid("XX12ABC") // false: XX nu e un judet
|
|
459
|
+
*/
|
|
460
|
+
declare function esteNumarInmatriculareValid(valoare: string): boolean;
|
|
461
|
+
/**
|
|
462
|
+
* Verifica o serie de sasiu (VIN) dupa ISO 3779: exact 17 caractere, cifre si
|
|
463
|
+
* litere, fara I, O si Q.
|
|
464
|
+
*
|
|
465
|
+
* @param valoare VIN-ul de verificat (spatiile si cratimele sunt ignorate).
|
|
466
|
+
* @returns `true` daca VIN-ul are un format valid.
|
|
467
|
+
* @example
|
|
468
|
+
* esteVinValid("WVWZZZ1JZXW000001") // true
|
|
469
|
+
* esteVinValid("WVWZZZ1JZXW00000I") // false: litera I nu e permisa
|
|
470
|
+
*/
|
|
471
|
+
declare function esteVinValid(valoare: string): boolean;
|
|
472
|
+
/**
|
|
473
|
+
* Aduce numarul certificatului de inmatriculare (talon) la forma canonica:
|
|
474
|
+
* doar litere si cifre, cu majuscule.
|
|
475
|
+
*
|
|
476
|
+
* @param valoare textul introdus de utilizator.
|
|
477
|
+
* @returns forma normalizata.
|
|
478
|
+
* @example
|
|
479
|
+
* normalizeazaSerieTalon(" i 00639603-f ") // "I00639603F"
|
|
480
|
+
*/
|
|
481
|
+
declare function normalizeazaSerieTalon(valoare: string): string;
|
|
482
|
+
/**
|
|
483
|
+
* Verifica forma numarului certificatului de inmatriculare (talon), tiparit jos
|
|
484
|
+
* pe talon: 6-20 litere si cifre, cel putin o cifra. Corectitudinea lui o
|
|
485
|
+
* confirma doar sursa oficiala, impreuna cu numarul si VIN-ul.
|
|
486
|
+
*
|
|
487
|
+
* @param valoare numarul certificatului (spatiile si cratimele sunt ignorate).
|
|
488
|
+
* @returns `true` daca are o forma valida.
|
|
489
|
+
* @example
|
|
490
|
+
* esteSerieTalonValida("I00639603F") // true
|
|
491
|
+
* esteSerieTalonValida("ABCDEF") // false: nu contine nicio cifra
|
|
492
|
+
*/
|
|
493
|
+
declare function esteSerieTalonValida(valoare: string): boolean;
|
|
494
|
+
/** Datele pentru pornirea unei verificari. */
|
|
495
|
+
interface CerereVerificare {
|
|
496
|
+
/** `rca`, `itp`, `rovinieta` sau `arr`. */
|
|
497
|
+
readonly tip: TipVerificare;
|
|
498
|
+
/**
|
|
499
|
+
* Identificatorul principal:
|
|
500
|
+
* - `rca`: numar de inmatriculare sau VIN;
|
|
501
|
+
* - `itp`: VIN (RAR nu cauta dupa numar);
|
|
502
|
+
* - `rovinieta`: numar de inmatriculare (VIN-ul merge in `serieSasiu`);
|
|
503
|
+
* - `arr`: numar de inmatriculare (ARR nu cauta dupa VIN).
|
|
504
|
+
*/
|
|
505
|
+
readonly query: string;
|
|
506
|
+
/** Seria de sasiu (VIN). Obligatorie la rovinieta, recomandata la RCA. */
|
|
507
|
+
readonly serieSasiu?: string;
|
|
508
|
+
/**
|
|
509
|
+
* Numarul certificatului de inmatriculare (talon), tiparit jos pe talon, ex:
|
|
510
|
+
* `I00639603F`. Obligatoriu la rovinieta: sursa oficiala il valideaza impreuna
|
|
511
|
+
* cu numarul si VIN-ul. Ignorat la celelalte tipuri.
|
|
512
|
+
*/
|
|
513
|
+
readonly serieTalon?: string;
|
|
514
|
+
/** URL http(s) unde API-ul trimite rezultatul prin POST cand e gata. */
|
|
515
|
+
readonly callbackUrl?: string;
|
|
516
|
+
}
|
|
517
|
+
/** Datele unui vehicul adaugat in flota. */
|
|
518
|
+
interface VehiculNou {
|
|
519
|
+
/** Numarul de inmatriculare. Spatiile si cratimele sunt eliminate. Maxim 20 de caractere. */
|
|
520
|
+
readonly numarInmatriculare?: string;
|
|
521
|
+
/** Seria de sasiu (VIN). Necesara pentru ITP si rovinieta. Maxim 50 de caractere. */
|
|
522
|
+
readonly serieSasiu?: string;
|
|
523
|
+
/**
|
|
524
|
+
* Numarul certificatului de inmatriculare (talon), ex: `I00639603F`. Necesar
|
|
525
|
+
* pentru monitorizarea automata a rovinietei: fara el, rovinieta nu se verifica.
|
|
526
|
+
*/
|
|
527
|
+
readonly serieTalon?: string;
|
|
528
|
+
/** Monitorizeaza si copia conforma ARR. Cere un plan activ. */
|
|
529
|
+
readonly arrMonitorizat?: boolean;
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
/** Cat mai ai din cota planului, din headerele `X-RateLimit-*`. */
|
|
533
|
+
interface Limite {
|
|
534
|
+
/** Cota zilnica; se reseteaza la miezul noptii. */
|
|
535
|
+
readonly zi: {
|
|
536
|
+
/** Verificari permise pe zi de plan. */
|
|
537
|
+
readonly limita: number;
|
|
538
|
+
/** Verificari ramase azi, dupa aceasta cerere. */
|
|
539
|
+
readonly ramase: number;
|
|
540
|
+
};
|
|
541
|
+
/** Cota lunara. */
|
|
542
|
+
readonly luna: {
|
|
543
|
+
/** Verificari permise pe luna de plan. */
|
|
544
|
+
readonly limita: number;
|
|
545
|
+
/** Verificari ramase luna aceasta, dupa aceasta cerere. */
|
|
546
|
+
readonly ramase: number;
|
|
547
|
+
};
|
|
548
|
+
}
|
|
549
|
+
/** Rezultatul final al unei verificari. */
|
|
550
|
+
type VerificareFinala = typeof RezultatVerificareSchema.Type & {
|
|
551
|
+
/** Cota ramasa dupa aceasta cerere, cand API-ul o trimite. */
|
|
552
|
+
readonly limite?: Limite;
|
|
553
|
+
};
|
|
554
|
+
/**
|
|
555
|
+
* Verificare pusa in coada: sursa oficiala e interogata acum. Paseaz-o la
|
|
556
|
+
* `rezultat()` sau `asteapta()` ca sa afli raspunsul.
|
|
557
|
+
*/
|
|
558
|
+
interface VerificareInCurs {
|
|
559
|
+
/** Mereu `"processing"`: sursa oficiala e interogata acum. */
|
|
560
|
+
readonly status: "processing";
|
|
561
|
+
/** Tipul verificarii. */
|
|
562
|
+
readonly tip: TipVerificare;
|
|
563
|
+
/** Identificatorul dupa care se face pollingul. */
|
|
564
|
+
readonly query: string;
|
|
565
|
+
/** Seria de sasiu trimisa la polling; completata doar la rovinieta. */
|
|
566
|
+
readonly serieSasiu: string | null;
|
|
567
|
+
/** Momentul (ms) de la care un rezultat e considerat nou. */
|
|
568
|
+
readonly since: number;
|
|
569
|
+
/** Prezent cand ai trimis `callbackUrl`; apare si in webhook. */
|
|
570
|
+
readonly requestId?: string;
|
|
571
|
+
/** Cand a intrat verificarea in coada. */
|
|
572
|
+
readonly queuedAt?: Date;
|
|
573
|
+
/** Recomandarea API-ului, ex: sa trimiti si VIN-ul la RCA. */
|
|
574
|
+
readonly hint?: string;
|
|
575
|
+
/** Cota ramasa dupa cererea POST. */
|
|
576
|
+
readonly limite?: Limite;
|
|
577
|
+
}
|
|
578
|
+
/**
|
|
579
|
+
* Raspunsul la `porneste()` sau `rezultat()`: rezultatul final sau verificarea
|
|
580
|
+
* in curs. Distinge-le dupa `status === "processing"`.
|
|
581
|
+
*/
|
|
582
|
+
type RaspunsVerificare = VerificareFinala | VerificareInCurs;
|
|
583
|
+
/** Ce trebuie ca sa interoghezi rezultatul unei verificari. */
|
|
584
|
+
interface ReferintaVerificare {
|
|
585
|
+
/** Tipul verificarii. */
|
|
586
|
+
readonly tip: TipVerificare;
|
|
587
|
+
/** Identificatorul dupa care se face pollingul (la RCA cu VIN, VIN-ul). */
|
|
588
|
+
readonly query: string;
|
|
589
|
+
/** Doar la rovinieta. */
|
|
590
|
+
readonly serieSasiu?: string | null;
|
|
591
|
+
/**
|
|
592
|
+
* Momentul (ms) cererii POST. Fara el, orice rezultat din ultima perioada e
|
|
593
|
+
* acceptat, chiar daca e mai vechi decat cererea ta.
|
|
594
|
+
*/
|
|
595
|
+
readonly since?: number;
|
|
596
|
+
}
|
|
597
|
+
/** Optiunile pentru `asteapta()` si `verificaSiAsteapta()`. */
|
|
598
|
+
interface OptiuniAsteptare {
|
|
599
|
+
/** Pauza intre doua interogari. Implicit 3000 ms, minim 2000 ms (plafonul API-ului). */
|
|
600
|
+
readonly intervalMs?: number;
|
|
601
|
+
/** Cat asteptam in total. Implicit 5 minute. */
|
|
602
|
+
readonly timeoutMs?: number;
|
|
603
|
+
}
|
|
604
|
+
|
|
605
|
+
/** Versiunea acestui SDK, trimisa si in headerul `User-Agent`. */
|
|
606
|
+
declare const VERSIUNE_SDK = "0.3.0";
|
|
607
|
+
/** Adresa implicita a API-ului pentru clientul {@link Acteo}. */
|
|
608
|
+
declare const URL_IMPLICIT = "https://api.acteo.ro";
|
|
609
|
+
/** Adresa implicita a clientului legacy {@link VerificRca}. */
|
|
610
|
+
declare const URL_IMPLICIT_LEGACY = "https://www.verificrca.ro";
|
|
611
|
+
/** Optiunile constructorului {@link Acteo}. Toate sunt optionale. */
|
|
612
|
+
interface OptiuniClient {
|
|
613
|
+
/**
|
|
614
|
+
* Cheia API. Implicit se citeste din variabila de mediu `ACTEO_API_KEY`
|
|
615
|
+
* (sau `VERIFICRCA_API_KEY`, daca prima lipseste).
|
|
616
|
+
*/
|
|
617
|
+
readonly apiKey?: string;
|
|
618
|
+
/** Adresa API-ului. Implicit `https://api.acteo.ro`; schimb-o doar pentru medii de test. */
|
|
619
|
+
readonly baseUrl?: string;
|
|
620
|
+
/** Timeout per cerere HTTP. Implicit 30000 ms. */
|
|
621
|
+
readonly timeoutMs?: number;
|
|
622
|
+
/**
|
|
623
|
+
* Reincercari pentru erori trecatoare (retea, 5xx, throttle la polling), cu
|
|
624
|
+
* backoff exponential si jitter. `false` le dezactiveaza.
|
|
625
|
+
* Implicit: 3 reincercari, de la 500 ms, maxim 10 s pe pauza.
|
|
626
|
+
*/
|
|
627
|
+
readonly retry?: Partial<SetariRetry> | false;
|
|
628
|
+
/** Implementare `fetch` proprie (proxy, teste). Implicit `globalThis.fetch`. */
|
|
629
|
+
readonly fetch?: typeof globalThis.fetch;
|
|
630
|
+
/** Adaugat la `User-Agent`, ex: `"flota-mea/2.1"`. */
|
|
631
|
+
readonly userAgent?: string;
|
|
632
|
+
}
|
|
633
|
+
/** Optiuni acceptate de orice metoda a clientului, ca ultim argument. */
|
|
634
|
+
interface OptiuniCerere {
|
|
635
|
+
/** Anuleaza cererea (si reincercarile sau asteptarea ei). */
|
|
636
|
+
readonly signal?: AbortSignal;
|
|
637
|
+
}
|
|
638
|
+
/** @internal Ruleaza un efect intern si il transforma in Promise. */
|
|
639
|
+
type Rulare = <A, E>(efect: Effect.Effect<A, E, Setari>, optiuni?: OptiuniCerere) => Promise<A>;
|
|
640
|
+
/**
|
|
641
|
+
* Verificarile la cerere: RCA, ITP, rovinieta si ARR. Il accesezi prin
|
|
642
|
+
* `vrca.verificari`, nu il construiesti direct.
|
|
643
|
+
*
|
|
644
|
+
* Doar `porneste()` si `verificaSiAsteapta()` consuma din cota planului API.
|
|
645
|
+
* `rezultat()` si `asteapta()` sunt gratuite.
|
|
646
|
+
*/
|
|
647
|
+
declare class ClientVerificari {
|
|
648
|
+
#private;
|
|
649
|
+
/** @internal */
|
|
650
|
+
constructor(ruleaza: Rulare);
|
|
651
|
+
/**
|
|
652
|
+
* Porneste o verificare si consuma o unitate din cota planului.
|
|
653
|
+
*
|
|
654
|
+
* Daca vehiculul a fost verificat de curand, primesti imediat rezultatul
|
|
655
|
+
* existent. Altfel verificarea intra in
|
|
656
|
+
* coada si primesti `status: "processing"`; rezultatul il afli cu
|
|
657
|
+
* {@link ClientVerificari.rezultat}, {@link ClientVerificari.asteapta} sau
|
|
658
|
+
* prin webhook, daca ai trimis `callbackUrl`.
|
|
659
|
+
*
|
|
660
|
+
* Datele sunt validate local inainte de cerere: o greseala de tastare nu
|
|
661
|
+
* pleaca pe retea si nu consuma din cota.
|
|
662
|
+
*
|
|
663
|
+
* @param cerere tipul verificarii, identificatorul, VIN-ul (obligatoriu la rovinieta,
|
|
664
|
+
* impreuna cu `serieTalon`) si, optional, `callbackUrl`.
|
|
665
|
+
* @param optiuni `signal` pentru anulare.
|
|
666
|
+
* @returns rezultatul final sau o {@link VerificareInCurs}.
|
|
667
|
+
* @throws {@link EroareValidare} date invalide, local sau HTTP 400.
|
|
668
|
+
* @throws {@link EroareAutentificare} cheie API invalida (401).
|
|
669
|
+
* @throws {@link EroarePlanInactiv} contul nu are abonament API activ (402).
|
|
670
|
+
* @throws {@link EroareLimita} cota zilnica sau lunara atinsa (429, `cod: "COTA_ATINSA"`).
|
|
671
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a
|
|
672
|
+
* refuzat datele trimise (`codSursa`, ex: `"serie_talon_invalida"`).
|
|
673
|
+
* @throws {@link EroareRetea} fara raspuns sau timeout.
|
|
674
|
+
* @throws {@link EroareServer} eroare 5xx.
|
|
675
|
+
* @example
|
|
676
|
+
* const r = await vrca.verificari.porneste({ tip: "itp", query: "WVWZZZ1JZXW000001" })
|
|
677
|
+
* if (r.status === "processing") {
|
|
678
|
+
* const final = await vrca.verificari.asteapta(r)
|
|
679
|
+
* }
|
|
680
|
+
*/
|
|
681
|
+
porneste(cerere: CerereVerificare, optiuni?: OptiuniCerere): Promise<RaspunsVerificare>;
|
|
682
|
+
/**
|
|
683
|
+
* Interogheaza o singura data rezultatul unei verificari. Nu consuma din cota.
|
|
684
|
+
*
|
|
685
|
+
* Serverul accepta cel mult o interogare la 2 secunde pentru aceeasi
|
|
686
|
+
* verificare; la depasire, SDK-ul asteapta cat cere `Retry-After` si reincearca.
|
|
687
|
+
*
|
|
688
|
+
* @param referinta obiectul primit de la `porneste()` sau `{ tip, query, serieSasiu?, since? }`.
|
|
689
|
+
* @param optiuni `signal` pentru anulare.
|
|
690
|
+
* @returns rezultatul final sau, daca sursa nu a raspuns inca, o {@link VerificareInCurs}.
|
|
691
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata; reia cu `porneste()`.
|
|
692
|
+
* @throws {@link EroareValidare} referinta invalida (400).
|
|
693
|
+
* @throws {@link EroareAutentificare} cheie API invalida (401).
|
|
694
|
+
* @throws {@link EroareRetea} fara raspuns sau timeout, dupa reincercari.
|
|
695
|
+
* @example
|
|
696
|
+
* const r = await vrca.verificari.rezultat({ tip: "rca", query: "B123ABC" })
|
|
697
|
+
* if (r.status !== "processing") console.log(r.status, r.expiresAt)
|
|
698
|
+
*/
|
|
699
|
+
rezultat(referinta: ReferintaVerificare, optiuni?: OptiuniCerere): Promise<RaspunsVerificare>;
|
|
700
|
+
/**
|
|
701
|
+
* Interogheaza periodic pana la rezultatul final. Nu consuma din cota.
|
|
702
|
+
*
|
|
703
|
+
* @param referinta obiectul primit de la `porneste()` sau `{ tip, query, serieSasiu?, since? }`.
|
|
704
|
+
* @param optiuni `intervalMs` (implicit 3000, minim 2000), `timeoutMs` (implicit 5 minute) si `signal`.
|
|
705
|
+
* @returns rezultatul final al verificarii.
|
|
706
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
707
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata; reia cu `porneste()`.
|
|
708
|
+
* @throws {@link EroareRetea} fara raspuns, dupa reincercari.
|
|
709
|
+
* @example
|
|
710
|
+
* const r = await vrca.verificari.porneste({ tip: "arr", query: "CJ45XYZ" })
|
|
711
|
+
* const final = r.status === "processing" ? await vrca.verificari.asteapta(r, { intervalMs: 5000 }) : r
|
|
712
|
+
*/
|
|
713
|
+
asteapta(referinta: ReferintaVerificare, optiuni?: OptiuniAsteptare & OptiuniCerere): Promise<VerificareFinala>;
|
|
714
|
+
/**
|
|
715
|
+
* Porneste verificarea si asteapta rezultatul final, intr-un singur apel.
|
|
716
|
+
* Consuma o unitate din cota (doar pornirea; pollingul e gratuit).
|
|
717
|
+
*
|
|
718
|
+
* @param cerere tipul verificarii, identificatorul, VIN-ul (obligatoriu la rovinieta,
|
|
719
|
+
* impreuna cu `serieTalon`) si, optional, `callbackUrl`.
|
|
720
|
+
* @param optiuni `intervalMs`, `timeoutMs` si `signal`, ca la {@link ClientVerificari.asteapta}.
|
|
721
|
+
* @returns rezultatul final al verificarii.
|
|
722
|
+
* @throws {@link EroareValidare} date invalide, local sau HTTP 400.
|
|
723
|
+
* @throws {@link EroareLimita} cota atinsa (`cod: "COTA_ATINSA"`).
|
|
724
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
725
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a
|
|
726
|
+
* refuzat datele trimise (`codSursa`, ex: `"serie_talon_invalida"`).
|
|
727
|
+
* @throws {@link VerificRcaError} orice alta eroare de la API sau de retea.
|
|
728
|
+
* @example
|
|
729
|
+
* const rovinieta = await vrca.verificari.verificaSiAsteapta({
|
|
730
|
+
* tip: "rovinieta",
|
|
731
|
+
* query: "B123ABC",
|
|
732
|
+
* serieSasiu: "WVWZZZ1JZXW000001",
|
|
733
|
+
* serieTalon: "I00639603F",
|
|
734
|
+
* })
|
|
735
|
+
* console.log(rovinieta.status, rovinieta.expiresAt)
|
|
736
|
+
*/
|
|
737
|
+
verificaSiAsteapta(cerere: CerereVerificare, optiuni?: OptiuniAsteptare & OptiuniCerere): Promise<VerificareFinala>;
|
|
738
|
+
}
|
|
739
|
+
/**
|
|
740
|
+
* Vehiculele monitorizate din cont. Il accesezi prin `acteo.auto.flota`, nu il
|
|
741
|
+
* construiesti direct.
|
|
742
|
+
*
|
|
743
|
+
* Operatiile sunt gratuite (nu consuma din cota de verificari), dar cer un plan
|
|
744
|
+
* activ: abonament API sau plan de cont. Vehiculele din cont sunt verificate
|
|
745
|
+
* automat si periodic, iar la apropierea expirarilor primesti notificari.
|
|
746
|
+
*/
|
|
747
|
+
declare class ClientVehicule {
|
|
748
|
+
#private;
|
|
749
|
+
/** @internal */
|
|
750
|
+
constructor(ruleaza: Rulare);
|
|
751
|
+
/**
|
|
752
|
+
* Listeaza toate vehiculele din cont, cu datele de expirare RCA, ITP,
|
|
753
|
+
* rovinieta si ARR.
|
|
754
|
+
*
|
|
755
|
+
* @param optiuni `signal` pentru anulare.
|
|
756
|
+
* @returns vehiculele contului; lista goala daca nu ai niciunul.
|
|
757
|
+
* @throws {@link EroareAutentificare} cheie API invalida (401).
|
|
758
|
+
* @throws {@link EroarePlanInactiv} contul nu are un plan activ (402).
|
|
759
|
+
* @throws {@link EroareRetea} fara raspuns, dupa reincercari.
|
|
760
|
+
* @example
|
|
761
|
+
* for (const v of await acteo.auto.flota.lista()) {
|
|
762
|
+
* console.log(v.numarInmatriculare, v.rcaExpiraLa, v.itpExpiraLa)
|
|
763
|
+
* }
|
|
764
|
+
*/
|
|
765
|
+
lista(optiuni?: OptiuniCerere): Promise<readonly Vehicul[]>;
|
|
766
|
+
/**
|
|
767
|
+
* Adauga un vehicul in monitorizare. Trimite cel putin numarul de
|
|
768
|
+
* inmatriculare sau seria de sasiu. ITP-ul cere VIN, iar rovinieta cere
|
|
769
|
+
* numarul, VIN-ul si `serieTalon` (numarul certificatului de inmatriculare);
|
|
770
|
+
* fara `serieTalon`, rovinieta nu se verifica.
|
|
771
|
+
*
|
|
772
|
+
* @param vehicul numarul, VIN-ul si, optional, `serieTalon` si `arrMonitorizat`.
|
|
773
|
+
* @param optiuni `signal` pentru anulare.
|
|
774
|
+
* @returns vehiculul creat, cu `id`-ul folosit la stergere.
|
|
775
|
+
* @throws {@link EroareValidare} lipseste identificatorul, are caractere nepermise sau `serieTalon` e invalida.
|
|
776
|
+
* @throws {@link EroareInterzis} `LIMIT_ATINS` (ai atins numarul de masini din plan, vezi `limita`) sau `ARR_NECESITA_PLAN`.
|
|
777
|
+
* @throws {@link EroareConflict} vehiculul exista deja in cont (`VEHICUL_EXISTENT`).
|
|
778
|
+
* @throws {@link EroareLimita} plafonul zilnic de adaugari prin API (`LIMITA_FLOTA_ATINSA`).
|
|
779
|
+
* @throws {@link EroarePlanInactiv} contul nu are un plan activ (402).
|
|
780
|
+
* @example
|
|
781
|
+
* const v = await acteo.auto.flota.adauga({
|
|
782
|
+
* numarInmatriculare: "B123ABC",
|
|
783
|
+
* serieSasiu: "WVWZZZ1JZXW000001",
|
|
784
|
+
* serieTalon: "I00639603F",
|
|
785
|
+
* })
|
|
786
|
+
* console.log(v.id)
|
|
787
|
+
*/
|
|
788
|
+
adauga(vehicul: VehiculNou, optiuni?: OptiuniCerere): Promise<Vehicul>;
|
|
789
|
+
/**
|
|
790
|
+
* Scoate un vehicul din cont. Monitorizarea si notificarile lui se opresc.
|
|
791
|
+
*
|
|
792
|
+
* @param id `id`-ul vehiculului, din {@link ClientVehicule.lista} sau {@link ClientVehicule.adauga}.
|
|
793
|
+
* @param optiuni `signal` pentru anulare.
|
|
794
|
+
* @returns se rezolva fara valoare cand vehiculul a fost sters.
|
|
795
|
+
* @throws {@link EroareNegasit} vehiculul nu exista in contul cheii (404).
|
|
796
|
+
* @throws {@link EroareLimita} plafonul zilnic de stergeri prin API (`LIMITA_FLOTA_ATINSA`).
|
|
797
|
+
* @throws {@link EroareValidare} `id` gol.
|
|
798
|
+
* @example
|
|
799
|
+
* await acteo.auto.flota.sterge("6f2c1b9e-0000-4000-8000-000000000001")
|
|
800
|
+
*/
|
|
801
|
+
sterge(id: string, optiuni?: OptiuniCerere): Promise<void>;
|
|
802
|
+
}
|
|
803
|
+
/**
|
|
804
|
+
* Clientul legacy, pastrat pentru codul existent; pentru cod nou foloseste {@link Acteo}.
|
|
805
|
+
* Verificare RCA, ITP, rovinieta si ARR, plus
|
|
806
|
+
* gestionarea vehiculelor monitorizate.
|
|
807
|
+
*
|
|
808
|
+
* Toate metodele intorc `Promise` si arunca subclase de {@link VerificRcaError}.
|
|
809
|
+
* Erorile trecatoare (retea, 5xx, throttle la polling) sunt reincercate automat,
|
|
810
|
+
* fara sa repete vreodata o verificare taxata.
|
|
811
|
+
*
|
|
812
|
+
* @example
|
|
813
|
+
* import { VerificRca } from "@acteo/api"
|
|
814
|
+
*
|
|
815
|
+
* const vrca = new VerificRca({ apiKey: process.env.VERIFICRCA_API_KEY })
|
|
816
|
+
* const rca = await vrca.verificari.verificaSiAsteapta({ tip: "rca", query: "B123ABC" })
|
|
817
|
+
* console.log(rca.status, rca.expiresAt)
|
|
818
|
+
*/
|
|
819
|
+
declare class VerificRca {
|
|
820
|
+
/** Verificari la cerere RCA, ITP, rovinieta si ARR. */
|
|
821
|
+
readonly verificari: ClientVerificari;
|
|
822
|
+
/** Vehiculele monitorizate din cont. */
|
|
823
|
+
readonly vehicule: ClientVehicule;
|
|
824
|
+
/**
|
|
825
|
+
* Creeaza un client. Nu face nicio cerere pe retea.
|
|
826
|
+
*
|
|
827
|
+
* @param optiuni cheia API si setarile de retea; toate sunt optionale daca
|
|
828
|
+
* `VERIFICRCA_API_KEY` e setata.
|
|
829
|
+
* @throws {@link EroareConfigurare} lipseste cheia API sau o optiune e invalida.
|
|
830
|
+
* @example
|
|
831
|
+
* const vrca = new VerificRca({
|
|
832
|
+
* apiKey: process.env.VERIFICRCA_API_KEY,
|
|
833
|
+
* timeoutMs: 15_000,
|
|
834
|
+
* retry: { incercari: 5 },
|
|
835
|
+
* })
|
|
836
|
+
*/
|
|
837
|
+
constructor(optiuni?: OptiuniClient);
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
/** Headerul cu cheia de webhook a contului (`whsec_...`). */
|
|
841
|
+
declare const HEADER_CHEIE_WEBHOOK = "x-verificrca-key";
|
|
842
|
+
/** Headerul cu numele evenimentului (`document.expira`, `webhook.test`). */
|
|
843
|
+
declare const HEADER_EVENIMENT_WEBHOOK = "x-verificrca-event";
|
|
844
|
+
/** Headerele unei cereri, fie `Headers` (fetch, Next.js), fie obiectul din Node/Express. */
|
|
845
|
+
type HeadereCerere = Headers | Readonly<Record<string, string | readonly string[] | undefined>>;
|
|
846
|
+
/**
|
|
847
|
+
* Citeste rezultatul trimis la `callbackUrl` dupa o verificare.
|
|
848
|
+
*
|
|
849
|
+
* Foloseste un `callbackUrl` pe HTTPS, greu de ghicit (de exemplu cu un token
|
|
850
|
+
* secret in cale), si potriveste `requestId` cu cel primit la `porneste()`
|
|
851
|
+
* inainte sa ai incredere in continut.
|
|
852
|
+
*
|
|
853
|
+
* @param corp corpul cererii: string, Buffer/Uint8Array sau obiect deja parsat.
|
|
854
|
+
* @returns rezultatul tipat, cu datele ca `Date`.
|
|
855
|
+
* @throws {@link EroareWebhook} corpul nu e JSON (`JSON_INVALID`) sau nu e un rezultat valid (`PAYLOAD_INVALID`).
|
|
856
|
+
* @example
|
|
857
|
+
* app.post("/webhooks/acteo/9f3k2", express.raw({ type: "application/json" }), (req, res) => {
|
|
858
|
+
* const r = parseazaWebhookRezultat(req.body)
|
|
859
|
+
* if (r.status !== "error") salveaza(r.requestId, r.result?.expiresAt)
|
|
860
|
+
* res.sendStatus(200)
|
|
861
|
+
* })
|
|
862
|
+
*/
|
|
863
|
+
declare function parseazaWebhookRezultat(corp: unknown): WebhookRezultat;
|
|
864
|
+
/** Optiunile pentru {@link verificaWebhookNotificare}. */
|
|
865
|
+
interface OptiuniWebhookNotificare {
|
|
866
|
+
/** Cheia de webhook din dashboard (`whsec_...`). */
|
|
867
|
+
readonly cheie: string;
|
|
868
|
+
}
|
|
869
|
+
/**
|
|
870
|
+
* Verifica si citeste o notificare de expirare (`document.expira`) sau un test
|
|
871
|
+
* (`webhook.test`) trimise la URL-ul de webhook al contului.
|
|
872
|
+
*
|
|
873
|
+
* Cheia vine in clar in headerul `X-Verificrca-Key` si e comparata in timp
|
|
874
|
+
* constant cu cea din dashboard. Pastreaza URL-ul pe HTTPS.
|
|
875
|
+
*
|
|
876
|
+
* @param corp corpul cererii: string, Buffer/Uint8Array sau obiect deja parsat.
|
|
877
|
+
* @param headers headerele cererii: `Headers` (fetch, Next.js) sau `req.headers` din Node/Express.
|
|
878
|
+
* @param optiuni cheia de webhook din dashboard.
|
|
879
|
+
* @returns evenimentul tipat; distinge-l dupa `event`.
|
|
880
|
+
* @throws {@link EroareWebhook} cheia lipseste din optiuni (`CHEIE_NECONFIGURATA`), din header sau nu se
|
|
881
|
+
* potriveste (`CHEIE_INVALIDA`), ori payloadul e invalid (`JSON_INVALID`, `PAYLOAD_INVALID`).
|
|
882
|
+
* @example
|
|
883
|
+
* const ev = verificaWebhookNotificare(req.body, req.headers, { cheie: process.env.VERIFICRCA_WEBHOOK_KEY! })
|
|
884
|
+
* if (ev.event === "document.expira") {
|
|
885
|
+
* console.log(`${ev.vehicul.numarInmatriculare}: ${ev.document} expira in ${ev.zileRamase} zile`)
|
|
886
|
+
* }
|
|
887
|
+
*/
|
|
888
|
+
declare function verificaWebhookNotificare(corp: unknown, headers: HeadereCerere, optiuni: OptiuniWebhookNotificare): WebhookNotificare;
|
|
889
|
+
|
|
890
|
+
/** Rezultatul final al unei verificari, ingustat pe documentul ei. */
|
|
891
|
+
type RezultatDocument<T extends TipVerificare> = VerificareFinala & {
|
|
892
|
+
/** Documentul verificat. */
|
|
893
|
+
readonly tip: T;
|
|
894
|
+
};
|
|
895
|
+
/** Verificare pusa in coada, ingustata pe documentul ei. */
|
|
896
|
+
type VerificareInCursDocument<T extends TipVerificare> = VerificareInCurs & {
|
|
897
|
+
/** Documentul verificat. */
|
|
898
|
+
readonly tip: T;
|
|
899
|
+
};
|
|
900
|
+
/** Raspunsul la `porneste()` sau `rezultat()`: final sau in curs (`status === "processing"`). */
|
|
901
|
+
type RaspunsDocument<T extends TipVerificare> = RezultatDocument<T> | VerificareInCursDocument<T>;
|
|
902
|
+
/** Optiunile pentru `porneste()`. */
|
|
903
|
+
interface OptiuniPornire extends OptiuniCerere {
|
|
904
|
+
/** URL http(s) unde API-ul trimite rezultatul prin POST cand e gata. */
|
|
905
|
+
readonly callbackUrl?: string;
|
|
906
|
+
}
|
|
907
|
+
/** Optiunile pentru `verifica()` si `asteapta()`. */
|
|
908
|
+
type OptiuniVerifica = OptiuniAsteptare & OptiuniCerere;
|
|
909
|
+
/** Identificatorul unei verificari RCA: numar de inmatriculare sau VIN, ori amandoua. */
|
|
910
|
+
type IdentificatorRca = string | {
|
|
911
|
+
/** Numarul de inmatriculare. */
|
|
912
|
+
readonly numar?: string;
|
|
913
|
+
/** Seria de sasiu (VIN). Cu ea, cautarea in AIDA e mai exacta. */
|
|
914
|
+
readonly vin?: string;
|
|
915
|
+
};
|
|
916
|
+
/** Identificatorii unei verificari de rovinieta, toti obligatorii. */
|
|
917
|
+
interface IdentificatorRovinieta {
|
|
918
|
+
/** Numarul de inmatriculare. */
|
|
919
|
+
readonly numar: string;
|
|
920
|
+
/** Seria de sasiu (VIN). */
|
|
921
|
+
readonly vin: string;
|
|
922
|
+
/** Numarul certificatului de inmatriculare (talon), ex: `I00639603F`. */
|
|
923
|
+
readonly serieTalon: string;
|
|
924
|
+
}
|
|
925
|
+
/** Cum se transforma identificatorul unui document in cererea si referinta API-ului. */
|
|
926
|
+
interface Mapare<I> {
|
|
927
|
+
readonly cerere: (id: I) => Omit<CerereVerificare, "callbackUrl">;
|
|
928
|
+
readonly referinta: (id: I) => ReferintaVerificare;
|
|
929
|
+
}
|
|
930
|
+
/**
|
|
931
|
+
* Verificarile pentru un singur document (RCA, ITP, rovinieta sau ARR). Il
|
|
932
|
+
* accesezi prin `acteo.auto.rca`, `acteo.auto.itp` etc., nu il construiesti direct.
|
|
933
|
+
*
|
|
934
|
+
* `verifica()` si `porneste()` consuma din cota planului; `rezultat()` si
|
|
935
|
+
* `asteapta()` sunt gratuite.
|
|
936
|
+
*/
|
|
937
|
+
declare class ClientDocument<T extends TipVerificare, I> {
|
|
938
|
+
#private;
|
|
939
|
+
/** @internal */
|
|
940
|
+
constructor(ruleaza: Rulare, mapare: Mapare<I>);
|
|
941
|
+
/**
|
|
942
|
+
* Verifica documentul si asteapta rezultatul final de la sursa oficiala.
|
|
943
|
+
* Daca vehiculul a fost verificat de curand, rezultatul vine imediat.
|
|
944
|
+
*
|
|
945
|
+
* @param identificator ce cere sursa oficiala pentru acest document.
|
|
946
|
+
* @param optiuni `timeoutMs`, `intervalMs` pentru asteptare si `signal`.
|
|
947
|
+
* @returns rezultatul final.
|
|
948
|
+
* @throws {@link EroareValidare} identificator invalid, local sau HTTP 400.
|
|
949
|
+
* @throws {@link EroareLimita} cota zilnica sau lunara atinsa.
|
|
950
|
+
* @throws {@link EroareVerificare} sursa oficiala nu a putut fi interogata sau a refuzat datele.
|
|
951
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
952
|
+
*/
|
|
953
|
+
verifica(identificator: I, optiuni?: OptiuniVerifica): Promise<RezultatDocument<T>>;
|
|
954
|
+
/**
|
|
955
|
+
* Porneste verificarea fara sa astepte. Primesti rezultatul imediat, daca
|
|
956
|
+
* vehiculul a fost verificat de curand, sau `status: "processing"`; atunci
|
|
957
|
+
* afli raspunsul cu {@link ClientDocument.asteapta}, {@link ClientDocument.rezultat}
|
|
958
|
+
* sau prin webhook la `callbackUrl`.
|
|
959
|
+
*
|
|
960
|
+
* @param identificator ce cere sursa oficiala pentru acest document.
|
|
961
|
+
* @param optiuni `callbackUrl` si `signal`.
|
|
962
|
+
* @returns rezultatul final sau verificarea in curs.
|
|
963
|
+
*/
|
|
964
|
+
porneste(identificator: I, optiuni?: OptiuniPornire): Promise<RaspunsDocument<T>>;
|
|
965
|
+
/**
|
|
966
|
+
* Interogheaza o singura data rezultatul. Nu consuma din cota.
|
|
967
|
+
*
|
|
968
|
+
* @param referinta verificarea in curs primita de la `porneste()` sau identificatorul documentului.
|
|
969
|
+
* @param optiuni `signal` pentru anulare.
|
|
970
|
+
* @returns rezultatul final sau verificarea inca in curs.
|
|
971
|
+
*/
|
|
972
|
+
rezultat(referinta: VerificareInCursDocument<T> | I, optiuni?: OptiuniCerere): Promise<RaspunsDocument<T>>;
|
|
973
|
+
/**
|
|
974
|
+
* Interogheaza periodic pana la rezultatul final. Nu consuma din cota.
|
|
975
|
+
*
|
|
976
|
+
* @param referinta verificarea in curs primita de la `porneste()` sau identificatorul documentului.
|
|
977
|
+
* @param optiuni `timeoutMs`, `intervalMs` si `signal`.
|
|
978
|
+
* @returns rezultatul final.
|
|
979
|
+
* @throws {@link EroareTimeoutVerificare} rezultatul nu a venit in `timeoutMs`.
|
|
980
|
+
*/
|
|
981
|
+
asteapta(referinta: VerificareInCursDocument<T> | I, optiuni?: OptiuniVerifica): Promise<RezultatDocument<T>>;
|
|
982
|
+
}
|
|
983
|
+
/** Asigurarea RCA, din baza AIDA. Accepta numar de inmatriculare, VIN sau amandoua. */
|
|
984
|
+
type ClientRca = ClientDocument<"rca", IdentificatorRca>;
|
|
985
|
+
/** Inspectia tehnica periodica, din RAR. Accepta doar VIN-ul. */
|
|
986
|
+
type ClientItp = ClientDocument<"itp", string>;
|
|
987
|
+
/** Rovinieta, din CNAIR. Cere numarul, VIN-ul si numarul talonului. */
|
|
988
|
+
type ClientRovinieta = ClientDocument<"rovinieta", IdentificatorRovinieta>;
|
|
989
|
+
/** Copia conforma ARR. Accepta doar numarul de inmatriculare. */
|
|
990
|
+
type ClientArr = ClientDocument<"arr", string>;
|
|
991
|
+
/** Domeniul auto: documentele unei masini si flota monitorizata. */
|
|
992
|
+
declare class ClientAuto {
|
|
993
|
+
/** Asigurarea RCA: `acteo.auto.rca.verifica("B123ABC")`. */
|
|
994
|
+
readonly rca: ClientRca;
|
|
995
|
+
/** ITP: `acteo.auto.itp.verifica("WVWZZZ1JZXW000001")`. */
|
|
996
|
+
readonly itp: ClientItp;
|
|
997
|
+
/** Rovinieta: `acteo.auto.rovinieta.verifica({ numar, vin, serieTalon })`. */
|
|
998
|
+
readonly rovinieta: ClientRovinieta;
|
|
999
|
+
/** Copia conforma ARR: `acteo.auto.arr.verifica("B123ABC")`. */
|
|
1000
|
+
readonly arr: ClientArr;
|
|
1001
|
+
/** Vehiculele monitorizate din cont: `lista()`, `adauga()`, `sterge()`. */
|
|
1002
|
+
readonly flota: ClientVehicule;
|
|
1003
|
+
/** @internal */
|
|
1004
|
+
constructor(ruleaza: Rulare);
|
|
1005
|
+
}
|
|
1006
|
+
/** Citirea webhook-urilor trimise de API. Nu face cereri pe retea. */
|
|
1007
|
+
declare class ClientWebhooks {
|
|
1008
|
+
/**
|
|
1009
|
+
* Valideaza corpul unui webhook de rezultat (trimis la `callbackUrl`).
|
|
1010
|
+
*
|
|
1011
|
+
* @param corp corpul cererii, ca string sau obiect deja parsat.
|
|
1012
|
+
* @returns rezultatul verificarii.
|
|
1013
|
+
* @throws {@link EroareWebhook} corp invalid.
|
|
1014
|
+
*/
|
|
1015
|
+
parseazaRezultat(corp: unknown): WebhookRezultat;
|
|
1016
|
+
/**
|
|
1017
|
+
* Verifica cheia si corpul unui webhook de notificare (ex: `document.expira`).
|
|
1018
|
+
*
|
|
1019
|
+
* @param corp corpul cererii.
|
|
1020
|
+
* @param headers headerele cererii.
|
|
1021
|
+
* @param optiuni `cheie`, cheia de webhook din dashboard.
|
|
1022
|
+
* @returns notificarea validata.
|
|
1023
|
+
* @throws {@link EroareWebhook} cheie lipsa, gresita sau corp invalid.
|
|
1024
|
+
*/
|
|
1025
|
+
verificaNotificare(corp: unknown, headers: HeadereCerere, optiuni: OptiuniWebhookNotificare): WebhookNotificare;
|
|
1026
|
+
}
|
|
1027
|
+
/**
|
|
1028
|
+
* Clientul API-ului Acteo, organizat pe domenii: `acteo.auto.rca`,
|
|
1029
|
+
* `acteo.auto.itp`, `acteo.auto.rovinieta`, `acteo.auto.arr`, `acteo.auto.flota`
|
|
1030
|
+
* si `acteo.webhooks`.
|
|
1031
|
+
*
|
|
1032
|
+
* Toate metodele intorc `Promise` si arunca subclase de {@link VerificRcaError}.
|
|
1033
|
+
* Erorile trecatoare sunt reincercate automat, fara sa repete vreodata o
|
|
1034
|
+
* verificare taxata.
|
|
1035
|
+
*
|
|
1036
|
+
* @example
|
|
1037
|
+
* import { Acteo } from "@acteo/api"
|
|
1038
|
+
*
|
|
1039
|
+
* const acteo = new Acteo({ apiKey: process.env.ACTEO_API_KEY })
|
|
1040
|
+
* const rca = await acteo.auto.rca.verifica("B123ABC")
|
|
1041
|
+
* console.log(rca.status, rca.expiresAt)
|
|
1042
|
+
*/
|
|
1043
|
+
declare class Acteo {
|
|
1044
|
+
/** Documentele unei masini (RCA, ITP, rovinieta, ARR) si flota. */
|
|
1045
|
+
readonly auto: ClientAuto;
|
|
1046
|
+
/** Citirea webhook-urilor. */
|
|
1047
|
+
readonly webhooks: ClientWebhooks;
|
|
1048
|
+
/**
|
|
1049
|
+
* Creeaza un client. Nu face nicio cerere pe retea.
|
|
1050
|
+
*
|
|
1051
|
+
* @param optiuni cheia API si setarile de retea; toate sunt optionale daca
|
|
1052
|
+
* `ACTEO_API_KEY` e setata.
|
|
1053
|
+
* @throws {@link EroareConfigurare} lipseste cheia API sau o optiune e invalida.
|
|
1054
|
+
*/
|
|
1055
|
+
constructor(optiuni?: OptiuniClient);
|
|
1056
|
+
}
|
|
1057
|
+
|
|
1058
|
+
export { Acteo, VerificRcaError as ActeoError, type CerereVerificare, type ClientArr, ClientAuto, ClientDocument, type ClientItp, type ClientRca, type ClientRovinieta, ClientVehicule, ClientVerificari, ClientWebhooks, type CodRefuzSursa, type DateEroare, EroareAutentificare, type EroareCerere, EroareConfigurare, EroareConflict, EroareHttp, EroareInterzis, EroareLimita, EroareNegasit, EroarePlanInactiv, EroareRaspunsInvalid, EroareRetea, EroareServer, EroareTimeoutVerificare, EroareValidare, EroareVerificare, EroareWebhook, HEADER_CHEIE_WEBHOOK, HEADER_EVENIMENT_WEBHOOK, type HeadereCerere, type IdentificatorRca, type IdentificatorRovinieta, type Limite, type OptiuniAsteptare, type OptiuniCerere, type OptiuniClient, type OptiuniPornire, type OptiuniVerifica, type OptiuniWebhookNotificare, type RaspunsDocument, type RaspunsVerificare, type ReferintaVerificare, type RezultatDocument, type SetariRetry, StatusDocument, TIPURI_VERIFICARE, TipVerificare, URL_IMPLICIT, URL_IMPLICIT_LEGACY, VERSIUNE_SDK, type Vehicul, type VehiculNou, VerificRca, VerificRcaError, type VerificareFinala, type VerificareInCurs, type VerificareInCursDocument, type WebhookDocumentExpira, type WebhookNotificare, type WebhookRezultat, type WebhookTest, esteNumarInmatriculareValid, esteSerieTalonValida, esteVinValid, normalizeaza, normalizeazaSerieTalon, parseazaWebhookRezultat, verificaWebhookNotificare };
|