@esb-market-contracts/backend 1.0.60 → 1.0.61

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/api.d.ts +1429 -1663
  2. package/config.d.ts +8 -8
  3. package/config.js +8 -13
  4. package/constants.d.ts +2 -2
  5. package/constants.js +4 -2
  6. package/enums.d.ts +17 -30
  7. package/enums.js +23 -23
  8. package/package.json +1 -1
  9. package/types.d.ts +1261 -2181
package/api.d.ts CHANGED
@@ -1,1328 +1,1186 @@
1
- import { SessionPayload } from '@esb-market-contracts/admin-backend';
2
- import 'drizzle-orm';
3
- import 'hono';
4
- import 'hono/http-exception';
5
- import 'ky';
6
- import 'postgres';
7
- import { z } from 'zod';
1
+ import { SessionPayload } from "@esb-market-contracts/admin-backend";
2
+ import "hono";
3
+ import "ky";
4
+ import "hono/http-exception";
5
+ import { z } from "zod";
6
+ import "postgres";
7
+ import "drizzle-orm";
8
8
  //#region src/app/flows/global/authentication/authentication.middleware.d.ts
9
9
  type VariablesWithActor = {
10
10
  actorSession: SessionPayload;
11
11
  };
12
12
  //#endregion
13
13
  //#region src/app/routes/(catalog)/brands.routes.d.ts
14
- declare const brandsRouter: import('hono/hono-base').HonoBase<
15
- {
16
- Variables: VariablesWithActor;
17
- },
18
- {
19
- '/catalog/brands/one': {
20
- $get: {
21
- output:
22
- | import('@kalutskii/foundation').APIError<string>
23
- | import('@kalutskii/foundation').APISuccess<{
24
- brand: {
25
- id: number;
26
- slug: string;
27
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
28
- websiteUrl: string | null;
29
- notes: string | null;
30
- logotypeUrl: string;
31
- countryId: number;
32
- updatedAt: Date | null;
33
- createdAt: Date;
34
- };
35
- }>;
36
- outputFormat: 'json';
37
- status: 200;
38
- input: {
39
- query:
40
- | {
41
- id: string | string[];
42
- slug?: string | undefined;
43
- }
44
- | {
45
- id?: number | undefined;
46
- slug: string | string[];
47
- };
14
+ declare const brandsRouter: import("hono/hono-base").HonoBase<{
15
+ Variables: VariablesWithActor;
16
+ }, {
17
+ "/catalog/brands/one": {
18
+ $get: {
19
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
20
+ brand: {
21
+ id: number;
22
+ slug: string;
23
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
24
+ websiteUrl: string | null;
25
+ notes: string | null;
26
+ logotypeUrl: string;
27
+ countryId: number;
28
+ updatedAt: Date | null;
29
+ createdAt: Date;
30
+ };
31
+ }>;
32
+ outputFormat: "json";
33
+ status: 200;
34
+ input: {
35
+ query: {
36
+ id: string | string[];
37
+ slug?: string | undefined;
38
+ } | {
39
+ id?: number | undefined;
40
+ slug: string | string[];
48
41
  };
49
42
  };
50
43
  };
51
- } & {
52
- '/catalog/brands/create': {
53
- $post: {
54
- output:
55
- | import('@kalutskii/foundation').APIError<string>
56
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
57
- outputFormat: 'json';
58
- status: 201;
59
- input: {
60
- form: {
61
- slug: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
62
- name: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
63
- websiteUrl: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
64
- notes?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
65
- countryId: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
66
- logotype: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
67
- };
44
+ };
45
+ } & {
46
+ "/catalog/brands/create": {
47
+ $post: {
48
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
49
+ outputFormat: "json";
50
+ status: 201;
51
+ input: {
52
+ form: {
53
+ slug: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
54
+ name: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
55
+ websiteUrl: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
56
+ notes?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
57
+ countryId: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
58
+ logotype: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
68
59
  };
69
60
  };
70
61
  };
71
- } & {
72
- '/catalog/brands/search': {
73
- $post: {
74
- output:
75
- | import('@kalutskii/foundation').APIError<string>
76
- | import('@kalutskii/foundation').APISuccess<{
77
- brands: {
78
- id: number;
79
- slug: string;
80
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
81
- websiteUrl: string | null;
82
- notes: string | null;
83
- logotypeUrl: string;
84
- countryId: number;
85
- updatedAt: Date | null;
86
- createdAt: Date;
87
- }[];
88
- total: number;
89
- }>;
90
- outputFormat: 'json';
91
- status: 200;
92
- input: {
93
- json: {
94
- where?:
95
- | {
96
- countryId?: number | undefined;
97
- }
98
- | undefined;
99
- query?: string | undefined;
100
- pagination: {
101
- offset?: unknown;
102
- limit?: unknown;
103
- };
62
+ };
63
+ } & {
64
+ "/catalog/brands/search": {
65
+ $post: {
66
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
67
+ brands: {
68
+ id: number;
69
+ slug: string;
70
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
71
+ websiteUrl: string | null;
72
+ notes: string | null;
73
+ logotypeUrl: string;
74
+ countryId: number;
75
+ updatedAt: Date | null;
76
+ createdAt: Date;
77
+ }[];
78
+ total: number;
79
+ }>;
80
+ outputFormat: "json";
81
+ status: 200;
82
+ input: {
83
+ json: {
84
+ where?: {
85
+ countryId?: number | undefined;
86
+ } | undefined;
87
+ query?: string | undefined;
88
+ pagination: {
89
+ offset?: unknown;
90
+ limit?: unknown;
104
91
  };
105
92
  };
106
93
  };
107
94
  };
108
- } & {
109
- '/catalog/brands/update': {
110
- $post: {
111
- output:
112
- | import('@kalutskii/foundation').APIError<string>
113
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
114
- outputFormat: 'json';
115
- status: 200;
116
- input: {
117
- form: {
118
- slug?: string | undefined;
119
- name?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
120
- websiteUrl?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
121
- notes?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
122
- countryId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
123
- logotype?: import('zod/v4/core').File | undefined;
124
- brandId: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
125
- };
95
+ };
96
+ } & {
97
+ "/catalog/brands/update": {
98
+ $post: {
99
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
100
+ outputFormat: "json";
101
+ status: 200;
102
+ input: {
103
+ form: {
104
+ slug?: string | undefined;
105
+ name?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
106
+ websiteUrl?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
107
+ notes?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
108
+ countryId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
109
+ logotype?: import("zod/v4/core").File | undefined;
110
+ brandId: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
126
111
  };
127
112
  };
128
113
  };
129
- },
130
- '/catalog/brands',
131
- '/catalog/brands/update'
132
- >;
114
+ };
115
+ }, "/catalog/brands", "/catalog/brands/update">;
133
116
  type BrandsRouter = typeof brandsRouter;
134
117
  //#endregion
135
118
  //#region src/app/routes/(catalog)/categories.routes.d.ts
136
- declare const categoriesRouter: import('hono/hono-base').HonoBase<
137
- {
138
- Variables: VariablesWithActor;
139
- },
140
- {
141
- '/catalog/categories/one': {
142
- $get: {
143
- output:
144
- | import('@kalutskii/foundation').APIError<string>
145
- | import('@kalutskii/foundation').APISuccess<{
146
- category: {
147
- id: number;
148
- slug: string;
149
- parentId: number | null;
150
- status: 'active' | 'archived';
151
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
152
- updatedAt: Date | null;
153
- createdAt: Date;
154
- };
155
- }>;
156
- outputFormat: 'json';
157
- status: 200;
158
- input: {
159
- query:
160
- | {
161
- id: string | string[];
162
- slug?: string | undefined;
163
- }
164
- | {
165
- id?: number | undefined;
166
- slug: string | string[];
167
- };
119
+ declare const categoriesRouter: import("hono/hono-base").HonoBase<{
120
+ Variables: VariablesWithActor;
121
+ }, {
122
+ "/catalog/categories/one": {
123
+ $get: {
124
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
125
+ category: {
126
+ id: number;
127
+ slug: string;
128
+ parentId: number | null;
129
+ status: "active" | "archived";
130
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
131
+ updatedAt: Date | null;
132
+ createdAt: Date;
133
+ };
134
+ }>;
135
+ outputFormat: "json";
136
+ status: 200;
137
+ input: {
138
+ query: {
139
+ id: string | string[];
140
+ slug?: string | undefined;
141
+ } | {
142
+ id?: number | undefined;
143
+ slug: string | string[];
168
144
  };
169
145
  };
170
146
  };
171
- } & {
172
- '/catalog/categories/create': {
173
- $post: {
174
- output:
175
- | import('@kalutskii/foundation').APIError<string>
176
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
177
- outputFormat: 'json';
178
- status: 201;
179
- input: {
180
- json: {
181
- slug: string;
182
- parentId?: number | null | undefined;
183
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
184
- };
147
+ };
148
+ } & {
149
+ "/catalog/categories/create": {
150
+ $post: {
151
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
152
+ outputFormat: "json";
153
+ status: 201;
154
+ input: {
155
+ json: {
156
+ slug: string;
157
+ parentId?: number | null | undefined;
158
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
185
159
  };
186
160
  };
187
161
  };
188
- } & {
189
- '/catalog/categories/search': {
190
- $post: {
191
- output:
192
- | import('@kalutskii/foundation').APIError<string>
193
- | import('@kalutskii/foundation').APISuccess<{
194
- categories: {
195
- id: number;
196
- slug: string;
197
- parentId: number | null;
198
- status: 'active' | 'archived';
199
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
200
- updatedAt: Date | null;
201
- createdAt: Date;
202
- }[];
203
- total: number;
204
- }>;
205
- outputFormat: 'json';
206
- status: 200;
207
- input: {
208
- json: {
209
- where?:
210
- | {
211
- parentId?: number | null | undefined;
212
- status?: 'active' | 'archived' | undefined;
213
- }
214
- | undefined;
215
- query?: string | undefined;
216
- pagination: {
217
- offset?: unknown;
218
- limit?: unknown;
219
- };
162
+ };
163
+ } & {
164
+ "/catalog/categories/search": {
165
+ $post: {
166
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
167
+ categories: {
168
+ id: number;
169
+ slug: string;
170
+ parentId: number | null;
171
+ status: "active" | "archived";
172
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
173
+ updatedAt: Date | null;
174
+ createdAt: Date;
175
+ }[];
176
+ total: number;
177
+ }>;
178
+ outputFormat: "json";
179
+ status: 200;
180
+ input: {
181
+ json: {
182
+ where?: {
183
+ parentId?: number | null | undefined;
184
+ status?: "active" | "archived" | undefined;
185
+ } | undefined;
186
+ query?: string | undefined;
187
+ pagination: {
188
+ offset?: unknown;
189
+ limit?: unknown;
220
190
  };
221
191
  };
222
192
  };
223
193
  };
224
- } & {
225
- '/catalog/categories/update': {
226
- $post: {
227
- output:
228
- | import('@kalutskii/foundation').APIError<string>
229
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
230
- outputFormat: 'json';
231
- status: 200;
232
- input: {
233
- json: {
234
- slug?: string | undefined;
235
- parentId?: number | null | undefined;
236
- status?: 'active' | 'archived' | undefined;
237
- name?: Partial<Record<'en' | 'ka' | 'ru', string>> | undefined;
238
- categoryId: number;
239
- };
194
+ };
195
+ } & {
196
+ "/catalog/categories/update": {
197
+ $post: {
198
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
199
+ outputFormat: "json";
200
+ status: 200;
201
+ input: {
202
+ json: {
203
+ slug?: string | undefined;
204
+ parentId?: number | null | undefined;
205
+ status?: "active" | "archived" | undefined;
206
+ name?: Partial<Record<"en" | "ka" | "ru", string>> | undefined;
207
+ categoryId: number;
240
208
  };
241
209
  };
242
210
  };
243
- },
244
- '/catalog/categories',
245
- '/catalog/categories/update'
246
- >;
211
+ };
212
+ }, "/catalog/categories", "/catalog/categories/update">;
247
213
  type CategoriesRouter = typeof categoriesRouter;
248
214
  //#endregion
249
215
  //#region src/app/routes/(catalog)/countries.routes.d.ts
250
- declare const countriesRouter: import('hono/hono-base').HonoBase<
251
- {
252
- Variables: VariablesWithActor;
253
- },
254
- {
255
- '/catalog/countries/one': {
256
- $get: {
257
- output:
258
- | import('@kalutskii/foundation').APIError<string>
259
- | import('@kalutskii/foundation').APISuccess<{
260
- country: {
261
- id: number;
262
- code: string;
263
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
264
- flagImageUrl: string;
265
- updatedAt: Date | null;
266
- createdAt: Date;
267
- };
268
- }>;
269
- outputFormat: 'json';
270
- status: 200;
271
- input: {
272
- query: {
273
- id: string | string[];
274
- };
216
+ declare const countriesRouter: import("hono/hono-base").HonoBase<{
217
+ Variables: VariablesWithActor;
218
+ }, {
219
+ "/catalog/countries/one": {
220
+ $get: {
221
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
222
+ country: {
223
+ id: number;
224
+ code: string;
225
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
226
+ flagImageUrl: string;
227
+ updatedAt: Date | null;
228
+ createdAt: Date;
229
+ };
230
+ }>;
231
+ outputFormat: "json";
232
+ status: 200;
233
+ input: {
234
+ query: {
235
+ id: string | string[];
275
236
  };
276
237
  };
277
238
  };
278
- } & {
279
- '/catalog/countries/create': {
280
- $post: {
281
- output:
282
- | import('@kalutskii/foundation').APIError<string>
283
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
284
- outputFormat: 'json';
285
- status: 201;
286
- input: {
287
- form: {
288
- code: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
289
- name: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
290
- flagImage: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
291
- };
239
+ };
240
+ } & {
241
+ "/catalog/countries/create": {
242
+ $post: {
243
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
244
+ outputFormat: "json";
245
+ status: 201;
246
+ input: {
247
+ form: {
248
+ code: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
249
+ name: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
250
+ flagImage: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
292
251
  };
293
252
  };
294
253
  };
295
- } & {
296
- '/catalog/countries/search': {
297
- $post: {
298
- output:
299
- | import('@kalutskii/foundation').APIError<string>
300
- | import('@kalutskii/foundation').APISuccess<{
301
- countries: {
302
- id: number;
303
- code: string;
304
- name: Partial<Record<'en' | 'ka' | 'ru', string>>;
305
- flagImageUrl: string;
306
- updatedAt: Date | null;
307
- createdAt: Date;
308
- }[];
309
- total: number;
310
- }>;
311
- outputFormat: 'json';
312
- status: 200;
313
- input: {
314
- json: {
315
- where?:
316
- | {
317
- code?: string | undefined;
318
- }
319
- | undefined;
320
- query?: string | undefined;
321
- pagination: {
322
- offset?: unknown;
323
- limit?: unknown;
324
- };
254
+ };
255
+ } & {
256
+ "/catalog/countries/search": {
257
+ $post: {
258
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
259
+ countries: {
260
+ id: number;
261
+ code: string;
262
+ name: Partial<Record<"en" | "ka" | "ru", string>>;
263
+ flagImageUrl: string;
264
+ updatedAt: Date | null;
265
+ createdAt: Date;
266
+ }[];
267
+ total: number;
268
+ }>;
269
+ outputFormat: "json";
270
+ status: 200;
271
+ input: {
272
+ json: {
273
+ where?: {
274
+ code?: string | undefined;
275
+ } | undefined;
276
+ query?: string | undefined;
277
+ pagination: {
278
+ offset?: unknown;
279
+ limit?: unknown;
325
280
  };
326
281
  };
327
282
  };
328
283
  };
329
- } & {
330
- '/catalog/countries/update': {
331
- $post: {
332
- output:
333
- | import('@kalutskii/foundation').APIError<string>
334
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
335
- outputFormat: 'json';
336
- status: 200;
337
- input: {
338
- form: {
339
- code?: string | undefined;
340
- name?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
341
- flagImage?: import('zod/v4/core').File | undefined;
342
- countryId: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
343
- };
284
+ };
285
+ } & {
286
+ "/catalog/countries/update": {
287
+ $post: {
288
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
289
+ outputFormat: "json";
290
+ status: 200;
291
+ input: {
292
+ form: {
293
+ code?: string | undefined;
294
+ name?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
295
+ flagImage?: import("zod/v4/core").File | undefined;
296
+ countryId: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
344
297
  };
345
298
  };
346
299
  };
347
- },
348
- '/catalog/countries',
349
- '/catalog/countries/update'
350
- >;
300
+ };
301
+ }, "/catalog/countries", "/catalog/countries/update">;
351
302
  type CountriesRouter = typeof countriesRouter;
352
303
  //#endregion
353
304
  //#region src/app/routes/(catalog)/measurement-units.routes.d.ts
354
- declare const measurementUnitsRouter: import('hono/hono-base').HonoBase<
355
- {
356
- Variables: VariablesWithActor;
357
- },
358
- {
359
- '/catalog/measurement-units/list': {
360
- $get: {
361
- output:
362
- | import('@kalutskii/foundation').APIError<string>
363
- | import('@kalutskii/foundation').APISuccess<{
364
- measurementUnits: {
365
- id: number;
366
- code: string;
367
- name: string;
368
- decimalPlaces: number;
369
- }[];
370
- }>;
371
- outputFormat: 'json';
372
- status: 200;
373
- input: {};
374
- };
305
+ declare const measurementUnitsRouter: import("hono/hono-base").HonoBase<{
306
+ Variables: VariablesWithActor;
307
+ }, {
308
+ "/catalog/measurement-units/list": {
309
+ $get: {
310
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
311
+ measurementUnits: {
312
+ id: number;
313
+ code: string;
314
+ name: string;
315
+ decimalPlaces: number;
316
+ }[];
317
+ }>;
318
+ outputFormat: "json";
319
+ status: 200;
320
+ input: {};
375
321
  };
376
- },
377
- '/catalog/measurement-units',
378
- '/catalog/measurement-units/list'
379
- >;
322
+ };
323
+ }, "/catalog/measurement-units", "/catalog/measurement-units/list">;
380
324
  type MeasurementUnitsRouter = typeof measurementUnitsRouter;
381
325
  //#endregion
382
326
  //#region src/app/routes/(catalog)/product-variants.routes.d.ts
383
- declare const productVariantsRouter: import('hono/hono-base').HonoBase<
384
- {
385
- Variables: VariablesWithActor;
386
- },
387
- {
388
- '/catalog/product-variants/one': {
389
- $get: {
390
- output:
391
- | import('@kalutskii/foundation').APIError<string>
392
- | import('@kalutskii/foundation').APISuccess<{
393
- productVariant: {
394
- id: number;
395
- productId: number;
396
- measurementUnitId: number | null;
397
- taxCategoryId: number | null;
398
- status: 'active' | 'archived' | 'draft';
399
- sku: string | null;
400
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
401
- updatedAt: Date | null;
402
- createdAt: Date;
403
- barcodes: string[];
404
- };
405
- }>;
406
- outputFormat: 'json';
407
- status: 200;
408
- input: {
409
- query: {
410
- id: string | string[];
411
- };
327
+ declare const productVariantsRouter: import("hono/hono-base").HonoBase<{
328
+ Variables: VariablesWithActor;
329
+ }, {
330
+ "/catalog/product-variants/one": {
331
+ $get: {
332
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
333
+ productVariant: {
334
+ id: number;
335
+ productId: number;
336
+ measurementUnitId: number | null;
337
+ taxCategoryId: number | null;
338
+ status: "active" | "archived" | "draft";
339
+ sku: string | null;
340
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
341
+ updatedAt: Date | null;
342
+ createdAt: Date;
343
+ barcodes: string[];
344
+ };
345
+ }>;
346
+ outputFormat: "json";
347
+ status: 200;
348
+ input: {
349
+ query: {
350
+ id: string | string[];
412
351
  };
413
352
  };
414
353
  };
415
- } & {
416
- '/catalog/product-variants/create': {
417
- $post: {
418
- output:
419
- | import('@kalutskii/foundation').APIError<string>
420
- | import('@kalutskii/foundation').APISuccess<{
421
- productVariant: {
422
- id: number;
423
- productId: number;
424
- measurementUnitId: number | null;
425
- taxCategoryId: number | null;
426
- status: 'active' | 'archived' | 'draft';
427
- sku: string | null;
428
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
429
- updatedAt: Date | null;
430
- createdAt: Date;
431
- barcodes: string[];
432
- };
433
- }>;
434
- outputFormat: 'json';
435
- status: 201;
436
- input: {
437
- json: {
438
- productId: number;
439
- measurementUnitId?: number | null | undefined;
440
- taxCategoryId?: number | null | undefined;
441
- status?: 'active' | 'archived' | 'draft' | undefined;
442
- sku?: string | null | undefined;
443
- name?: Partial<Record<'en' | 'ka' | 'ru', string>> | null | undefined;
444
- barcodes: string[];
445
- };
354
+ };
355
+ } & {
356
+ "/catalog/product-variants/create": {
357
+ $post: {
358
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
359
+ productVariant: {
360
+ id: number;
361
+ productId: number;
362
+ measurementUnitId: number | null;
363
+ taxCategoryId: number | null;
364
+ status: "active" | "archived" | "draft";
365
+ sku: string | null;
366
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
367
+ updatedAt: Date | null;
368
+ createdAt: Date;
369
+ barcodes: string[];
370
+ };
371
+ }>;
372
+ outputFormat: "json";
373
+ status: 201;
374
+ input: {
375
+ json: {
376
+ productId: number;
377
+ measurementUnitId?: number | null | undefined;
378
+ taxCategoryId?: number | null | undefined;
379
+ status?: "active" | "archived" | "draft" | undefined;
380
+ sku?: string | null | undefined;
381
+ name?: Partial<Record<"en" | "ka" | "ru", string>> | null | undefined;
382
+ barcodes: string[];
446
383
  };
447
384
  };
448
385
  };
449
- } & {
450
- '/catalog/product-variants/search': {
451
- $post: {
452
- output:
453
- | import('@kalutskii/foundation').APIError<string>
454
- | import('@kalutskii/foundation').APISuccess<{
455
- productVariants: {
456
- id: number;
457
- productId: number;
458
- measurementUnitId: number | null;
459
- taxCategoryId: number | null;
460
- status: 'active' | 'archived' | 'draft';
461
- sku: string | null;
462
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
463
- updatedAt: Date | null;
464
- createdAt: Date;
465
- barcodes: string[];
466
- }[];
467
- total: number;
468
- }>;
469
- outputFormat: 'json';
470
- status: 200;
471
- input: {
472
- json: {
473
- where: {
474
- productId: number;
475
- measurementUnitId?: number | null | undefined;
476
- status?: 'active' | 'archived' | 'draft' | undefined;
477
- };
478
- query?: string | undefined;
479
- pagination: {
480
- offset?: unknown;
481
- limit?: unknown;
482
- };
386
+ };
387
+ } & {
388
+ "/catalog/product-variants/search": {
389
+ $post: {
390
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
391
+ productVariants: {
392
+ id: number;
393
+ productId: number;
394
+ measurementUnitId: number | null;
395
+ taxCategoryId: number | null;
396
+ status: "active" | "archived" | "draft";
397
+ sku: string | null;
398
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
399
+ updatedAt: Date | null;
400
+ createdAt: Date;
401
+ barcodes: string[];
402
+ }[];
403
+ total: number;
404
+ }>;
405
+ outputFormat: "json";
406
+ status: 200;
407
+ input: {
408
+ json: {
409
+ where: {
410
+ productId: number;
411
+ measurementUnitId?: number | null | undefined;
412
+ status?: "active" | "archived" | "draft" | undefined;
413
+ };
414
+ query?: string | undefined;
415
+ pagination: {
416
+ offset?: unknown;
417
+ limit?: unknown;
483
418
  };
484
419
  };
485
420
  };
486
421
  };
487
- } & {
488
- '/catalog/product-variants/update': {
489
- $post: {
490
- output:
491
- | import('@kalutskii/foundation').APIError<string>
492
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
493
- outputFormat: 'json';
494
- status: 200;
495
- input: {
496
- json: {
497
- measurementUnitId?: number | null | undefined;
498
- taxCategoryId?: number | null | undefined;
499
- status?: 'active' | 'archived' | 'draft' | undefined;
500
- sku?: string | null | undefined;
501
- name?: Partial<Record<'en' | 'ka' | 'ru', string>> | null | undefined;
502
- productVariantId: number;
503
- barcodes?: string[] | undefined;
504
- };
422
+ };
423
+ } & {
424
+ "/catalog/product-variants/update": {
425
+ $post: {
426
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
427
+ outputFormat: "json";
428
+ status: 200;
429
+ input: {
430
+ json: {
431
+ measurementUnitId?: number | null | undefined;
432
+ taxCategoryId?: number | null | undefined;
433
+ status?: "active" | "archived" | "draft" | undefined;
434
+ sku?: string | null | undefined;
435
+ name?: Partial<Record<"en" | "ka" | "ru", string>> | null | undefined;
436
+ productVariantId: number;
437
+ barcodes?: string[] | undefined;
505
438
  };
506
439
  };
507
440
  };
508
- } & {
509
- '/catalog/product-variants/delete': {
510
- $post: {
511
- output:
512
- | import('@kalutskii/foundation').APIError<string>
513
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
514
- outputFormat: 'json';
515
- status: 200;
516
- input: {
517
- json: {
518
- productVariantId: number;
519
- };
441
+ };
442
+ } & {
443
+ "/catalog/product-variants/delete": {
444
+ $post: {
445
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
446
+ outputFormat: "json";
447
+ status: 200;
448
+ input: {
449
+ json: {
450
+ productVariantId: number;
520
451
  };
521
452
  };
522
453
  };
523
- },
524
- '/catalog/product-variants',
525
- '/catalog/product-variants/delete'
526
- >;
454
+ };
455
+ }, "/catalog/product-variants", "/catalog/product-variants/delete">;
527
456
  type ProductVariantsRouter = typeof productVariantsRouter;
528
457
  //#endregion
529
458
  //#region src/app/routes/(catalog)/products.routes.d.ts
530
- declare const productsRouter: import('hono/hono-base').HonoBase<
531
- {
532
- Variables: VariablesWithActor;
533
- },
534
- {
535
- '/catalog/products/one': {
536
- $get: {
537
- output:
538
- | import('@kalutskii/foundation').APIError<string>
539
- | import('@kalutskii/foundation').APISuccess<{
540
- product: {
541
- id: number;
542
- slug: string | null;
543
- model: string | null;
544
- status: 'active' | 'archived' | 'draft';
545
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
546
- description: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
547
- images: {
548
- src: string;
549
- isBanner: boolean;
550
- }[];
551
- categoryId: number | null;
552
- brandId: number | null;
553
- taxCategoryId: number | null;
554
- updatedAt: Date | null;
555
- createdAt: Date;
556
- };
557
- }>;
558
- outputFormat: 'json';
559
- status: 200;
560
- input: {
561
- query:
562
- | {
563
- id: string | string[];
564
- slug?: string | undefined;
565
- }
566
- | {
567
- id?: number | undefined;
568
- slug: string | string[];
569
- };
459
+ declare const productsRouter: import("hono/hono-base").HonoBase<{
460
+ Variables: VariablesWithActor;
461
+ }, {
462
+ "/catalog/products/one": {
463
+ $get: {
464
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
465
+ product: {
466
+ id: number;
467
+ slug: string | null;
468
+ model: string | null;
469
+ status: "active" | "archived" | "draft";
470
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
471
+ description: Partial<Record<"en" | "ka" | "ru", string>> | null;
472
+ images: {
473
+ src: string;
474
+ isBanner: boolean;
475
+ }[];
476
+ categoryId: number | null;
477
+ brandId: number | null;
478
+ taxCategoryId: number | null;
479
+ updatedAt: Date | null;
480
+ createdAt: Date;
481
+ };
482
+ }>;
483
+ outputFormat: "json";
484
+ status: 200;
485
+ input: {
486
+ query: {
487
+ id: string | string[];
488
+ slug?: string | undefined;
489
+ } | {
490
+ id?: number | undefined;
491
+ slug: string | string[];
570
492
  };
571
493
  };
572
494
  };
573
- } & {
574
- '/catalog/products/create': {
575
- $post: {
576
- output:
577
- | import('@kalutskii/foundation').APIError<string>
578
- | import('@kalutskii/foundation').APISuccess<{
579
- product: {
580
- id: number;
581
- slug: string | null;
582
- model: string | null;
583
- status: 'active' | 'archived' | 'draft';
584
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
585
- description: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
586
- images: {
587
- src: string;
588
- isBanner: boolean;
589
- }[];
590
- categoryId: number | null;
591
- brandId: number | null;
592
- taxCategoryId: number | null;
593
- updatedAt: Date | null;
594
- createdAt: Date;
595
- };
596
- }>;
597
- outputFormat: 'json';
598
- status: 201;
599
- input: {
600
- form: {
601
- slug?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
602
- model?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
603
- name?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
604
- description?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
605
- categoryId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
606
- brandId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
607
- taxCategoryId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
608
- images?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
609
- bannerImageIndex?:
610
- | import('hono/types').ParsedFormValue[]
611
- | import('hono/types').ParsedFormValue
612
- | undefined;
613
- };
495
+ };
496
+ } & {
497
+ "/catalog/products/create": {
498
+ $post: {
499
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
500
+ product: {
501
+ id: number;
502
+ slug: string | null;
503
+ model: string | null;
504
+ status: "active" | "archived" | "draft";
505
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
506
+ description: Partial<Record<"en" | "ka" | "ru", string>> | null;
507
+ images: {
508
+ src: string;
509
+ isBanner: boolean;
510
+ }[];
511
+ categoryId: number | null;
512
+ brandId: number | null;
513
+ taxCategoryId: number | null;
514
+ updatedAt: Date | null;
515
+ createdAt: Date;
516
+ };
517
+ }>;
518
+ outputFormat: "json";
519
+ status: 201;
520
+ input: {
521
+ form: {
522
+ slug?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
523
+ model?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
524
+ name?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
525
+ description?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
526
+ categoryId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
527
+ brandId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
528
+ taxCategoryId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
529
+ images?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
530
+ bannerImageIndex?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
614
531
  };
615
532
  };
616
533
  };
617
- } & {
618
- '/catalog/products/search': {
619
- $post: {
620
- output:
621
- | import('@kalutskii/foundation').APIError<string>
622
- | import('@kalutskii/foundation').APISuccess<{
623
- products: {
624
- id: number;
625
- slug: string | null;
626
- model: string | null;
627
- status: 'active' | 'archived' | 'draft';
628
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
629
- description: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
630
- images: {
631
- src: string;
632
- isBanner: boolean;
633
- }[];
634
- categoryId: number | null;
635
- brandId: number | null;
636
- taxCategoryId: number | null;
637
- updatedAt: Date | null;
638
- createdAt: Date;
639
- }[];
640
- total: number;
641
- }>;
642
- outputFormat: 'json';
643
- status: 200;
644
- input: {
645
- json: {
646
- where?:
647
- | {
648
- status?: 'active' | 'archived' | 'draft' | undefined;
649
- categoryId?: number | null | undefined;
650
- brandId?: number | null | undefined;
651
- }
652
- | undefined;
653
- query?: string | undefined;
654
- pagination: {
655
- offset?: unknown;
656
- limit?: unknown;
657
- };
534
+ };
535
+ } & {
536
+ "/catalog/products/search": {
537
+ $post: {
538
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
539
+ products: {
540
+ id: number;
541
+ slug: string | null;
542
+ model: string | null;
543
+ status: "active" | "archived" | "draft";
544
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
545
+ description: Partial<Record<"en" | "ka" | "ru", string>> | null;
546
+ images: {
547
+ src: string;
548
+ isBanner: boolean;
549
+ }[];
550
+ categoryId: number | null;
551
+ brandId: number | null;
552
+ taxCategoryId: number | null;
553
+ updatedAt: Date | null;
554
+ createdAt: Date;
555
+ }[];
556
+ total: number;
557
+ }>;
558
+ outputFormat: "json";
559
+ status: 200;
560
+ input: {
561
+ json: {
562
+ where?: {
563
+ status?: "active" | "archived" | "draft" | undefined;
564
+ categoryId?: number | null | undefined;
565
+ brandId?: number | null | undefined;
566
+ } | undefined;
567
+ query?: string | undefined;
568
+ pagination: {
569
+ offset?: unknown;
570
+ limit?: unknown;
658
571
  };
659
572
  };
660
573
  };
661
574
  };
662
- } & {
663
- '/catalog/products/update': {
664
- $post: {
665
- output:
666
- | import('@kalutskii/foundation').APIError<string>
667
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
668
- outputFormat: 'json';
669
- status: 200;
670
- input: {
671
- form: {
672
- status?: 'active' | 'archived' | 'draft' | undefined;
673
- slug?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
674
- model?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
675
- name?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
676
- description?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
677
- categoryId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
678
- brandId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
679
- taxCategoryId?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
680
- images?: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue | undefined;
681
- bannerImageIndex?:
682
- | import('hono/types').ParsedFormValue[]
683
- | import('hono/types').ParsedFormValue
684
- | undefined;
685
- productId: import('hono/types').ParsedFormValue[] | import('hono/types').ParsedFormValue;
686
- };
575
+ };
576
+ } & {
577
+ "/catalog/products/update": {
578
+ $post: {
579
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
580
+ outputFormat: "json";
581
+ status: 200;
582
+ input: {
583
+ form: {
584
+ status?: "active" | "archived" | "draft" | undefined;
585
+ slug?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
586
+ model?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
587
+ name?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
588
+ description?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
589
+ categoryId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
590
+ brandId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
591
+ taxCategoryId?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
592
+ images?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
593
+ bannerImageIndex?: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue | undefined;
594
+ productId: import("hono/types").ParsedFormValue[] | import("hono/types").ParsedFormValue;
687
595
  };
688
596
  };
689
597
  };
690
- } & {
691
- '/catalog/products/delete': {
692
- $post: {
693
- output:
694
- | import('@kalutskii/foundation').APIError<string>
695
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
696
- outputFormat: 'json';
697
- status: 200;
698
- input: {
699
- json: {
700
- productId: number;
701
- };
598
+ };
599
+ } & {
600
+ "/catalog/products/delete": {
601
+ $post: {
602
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
603
+ outputFormat: "json";
604
+ status: 200;
605
+ input: {
606
+ json: {
607
+ productId: number;
702
608
  };
703
609
  };
704
610
  };
705
- },
706
- '/catalog/products',
707
- '/catalog/products/delete'
708
- >;
611
+ };
612
+ }, "/catalog/products", "/catalog/products/delete">;
709
613
  type ProductsRouter = typeof productsRouter;
710
614
  //#endregion
711
615
  //#region src/app/routes/(finance)/exchange-rates.routes.d.ts
712
- declare const exchangeRatesRouter: import('hono/hono-base').HonoBase<
713
- {
714
- Variables: VariablesWithActor;
715
- },
716
- {
717
- '/finance/exchange-rates/currencies': {
718
- $get: {
719
- output:
720
- | import('@kalutskii/foundation').APIError<string>
721
- | import('@kalutskii/foundation').APISuccess<{
722
- currencies: {
723
- id: number;
724
- code: string;
725
- name: string;
726
- sortOrder: number;
727
- }[];
728
- baseCurrency: {
729
- id: number;
730
- code: string;
731
- name: string;
732
- sortOrder: number;
733
- };
734
- }>;
735
- outputFormat: 'json';
736
- status: 200;
737
- input: {};
738
- };
616
+ declare const exchangeRatesRouter: import("hono/hono-base").HonoBase<{
617
+ Variables: VariablesWithActor;
618
+ }, {
619
+ "/finance/exchange-rates/currencies": {
620
+ $get: {
621
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
622
+ currencies: {
623
+ id: number;
624
+ code: string;
625
+ name: string;
626
+ sortOrder: number;
627
+ }[];
628
+ baseCurrency: {
629
+ id: number;
630
+ code: string;
631
+ name: string;
632
+ sortOrder: number;
633
+ };
634
+ }>;
635
+ outputFormat: "json";
636
+ status: 200;
637
+ input: {};
739
638
  };
740
- } & {
741
- '/finance/exchange-rates/dates/search': {
742
- $post: {
743
- output:
744
- | import('@kalutskii/foundation').APIError<string>
745
- | import('@kalutskii/foundation').APISuccess<{
746
- dates: string[];
747
- total: number;
748
- }>;
749
- outputFormat: 'json';
750
- status: 200;
751
- input: {
752
- json: {
753
- where?:
754
- | {
755
- currencyId?: number | undefined;
756
- validFromDate?: string | undefined;
757
- }
758
- | undefined;
759
- pagination: {
760
- offset?: unknown;
761
- limit?: unknown;
762
- };
639
+ };
640
+ } & {
641
+ "/finance/exchange-rates/dates/search": {
642
+ $post: {
643
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
644
+ dates: string[];
645
+ total: number;
646
+ }>;
647
+ outputFormat: "json";
648
+ status: 200;
649
+ input: {
650
+ json: {
651
+ where?: {
652
+ currencyId?: number | undefined;
653
+ validFromDate?: string | undefined;
654
+ } | undefined;
655
+ pagination: {
656
+ offset?: unknown;
657
+ limit?: unknown;
763
658
  };
764
659
  };
765
660
  };
766
661
  };
767
- } & {
768
- '/finance/exchange-rates/search': {
769
- $post: {
770
- output:
771
- | import('@kalutskii/foundation').APIError<string>
772
- | import('@kalutskii/foundation').APISuccess<{
773
- exchangeRates: {
774
- id: number;
775
- currencyId: number;
776
- rate: string;
777
- validFromDate: string;
778
- }[];
779
- total: number;
780
- }>;
781
- outputFormat: 'json';
782
- status: 200;
783
- input: {
784
- json: {
785
- where?:
786
- | {
787
- currencyId?: number | undefined;
788
- validFromDate?: string | undefined;
789
- }
790
- | undefined;
791
- pagination: {
792
- offset?: unknown;
793
- limit?: unknown;
794
- };
662
+ };
663
+ } & {
664
+ "/finance/exchange-rates/search": {
665
+ $post: {
666
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
667
+ exchangeRates: {
668
+ id: number;
669
+ currencyId: number;
670
+ rate: string;
671
+ validFromDate: string;
672
+ }[];
673
+ total: number;
674
+ }>;
675
+ outputFormat: "json";
676
+ status: 200;
677
+ input: {
678
+ json: {
679
+ where?: {
680
+ currencyId?: number | undefined;
681
+ validFromDate?: string | undefined;
682
+ } | undefined;
683
+ pagination: {
684
+ offset?: unknown;
685
+ limit?: unknown;
795
686
  };
796
687
  };
797
688
  };
798
689
  };
799
- },
800
- '/finance/exchange-rates',
801
- '/finance/exchange-rates/search'
802
- >;
690
+ };
691
+ }, "/finance/exchange-rates", "/finance/exchange-rates/search">;
803
692
  type ExchangeRatesRouter = typeof exchangeRatesRouter;
804
693
  //#endregion
805
694
  //#region src/app/routes/(procurement)/deliveries.routes.d.ts
806
- declare const deliveriesRouter: import('hono/hono-base').HonoBase<
807
- {
808
- Variables: VariablesWithActor;
809
- },
810
- {
811
- '/operations/deliveries/one': {
812
- $get: {
813
- output:
814
- | import('@kalutskii/foundation').APIError<string>
815
- | import('@kalutskii/foundation').APISuccess<{
816
- delivery: {
817
- id: number;
818
- code: string;
819
- supplierId: number;
820
- warehouseId: number;
821
- currencyId: number;
822
- status: 'draft' | 'posted';
823
- exchangeRateId: number | null;
824
- exchangeRate: string | null;
825
- exchangeRateValidFromDate: string | null;
826
- postedAt: Date | null;
827
- updatedAt: Date | null;
828
- createdAt: Date;
829
- items: {
830
- id: number;
831
- deliveryId: number;
832
- productVariantId: number;
833
- quantity: number | null;
834
- unitCost: string | null;
835
- unitCostBase: string | null;
836
- supplierLotNumber: string | null;
837
- expiresOn: string | null;
838
- revision: number;
839
- updatedAt: Date | null;
840
- createdAt: Date;
841
- product: {
842
- id: number;
843
- model: string | null;
844
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
845
- image: {
846
- src: string;
847
- isBanner: boolean;
848
- } | null;
849
- };
850
- productVariant: {
851
- id: number;
852
- sku: string | null;
853
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
854
- barcodes: string[];
855
- };
856
- measurementUnit: {
857
- id: number;
858
- code: string;
859
- name: string;
860
- decimalPlaces: number;
861
- };
862
- updatedByEmployee: {
863
- id: number;
864
- fullName: string;
865
- } | null;
866
- }[];
867
- };
868
- }>;
869
- outputFormat: 'json';
870
- status: 200;
871
- input: {
872
- query: {
873
- id: string | string[];
874
- };
695
+ declare const deliveriesRouter: import("hono/hono-base").HonoBase<{
696
+ Variables: VariablesWithActor;
697
+ }, {
698
+ "/operations/deliveries/one": {
699
+ $get: {
700
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
701
+ delivery: {
702
+ id: number;
703
+ code: string;
704
+ supplierId: number;
705
+ warehouseId: number;
706
+ currencyId: number;
707
+ status: "draft" | "posted";
708
+ exchangeRateId: number | null;
709
+ exchangeRate: string | null;
710
+ exchangeRateValidFromDate: string | null;
711
+ postedAt: Date | null;
712
+ updatedAt: Date | null;
713
+ createdAt: Date;
714
+ items: {
715
+ id: number;
716
+ deliveryId: number;
717
+ productVariantId: number;
718
+ quantity: number | null;
719
+ unitCost: string | null;
720
+ unitCostBase: string | null;
721
+ supplierLotNumber: string | null;
722
+ expiresOn: string | null;
723
+ revision: number;
724
+ updatedAt: Date | null;
725
+ createdAt: Date;
726
+ product: {
727
+ id: number;
728
+ model: string | null;
729
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
730
+ image: {
731
+ src: string;
732
+ isBanner: boolean;
733
+ } | null;
734
+ };
735
+ productVariant: {
736
+ id: number;
737
+ sku: string | null;
738
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
739
+ barcodes: string[];
740
+ };
741
+ measurementUnit: {
742
+ id: number;
743
+ code: string;
744
+ name: string;
745
+ decimalPlaces: number;
746
+ };
747
+ updatedByEmployee: {
748
+ id: number;
749
+ fullName: string;
750
+ } | null;
751
+ }[];
875
752
  };
876
- };
877
- };
878
- } & {
879
- '/operations/deliveries/create': {
880
- $post: {
881
- output:
882
- | import('@kalutskii/foundation').APIError<string>
883
- | import('@kalutskii/foundation').APISuccess<{
884
- delivery: {
885
- id: number;
886
- code: string;
887
- supplierId: number;
888
- warehouseId: number;
889
- currencyId: number;
890
- status: 'draft' | 'posted';
891
- exchangeRateId: number | null;
892
- exchangeRate: string | null;
893
- exchangeRateValidFromDate: string | null;
894
- postedAt: Date | null;
895
- updatedAt: Date | null;
896
- createdAt: Date;
897
- items: {
898
- id: number;
899
- deliveryId: number;
900
- productVariantId: number;
901
- quantity: number | null;
902
- unitCost: string | null;
903
- unitCostBase: string | null;
904
- supplierLotNumber: string | null;
905
- expiresOn: string | null;
906
- revision: number;
907
- updatedAt: Date | null;
908
- createdAt: Date;
909
- product: {
910
- id: number;
911
- model: string | null;
912
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
913
- image: {
914
- src: string;
915
- isBanner: boolean;
916
- } | null;
917
- };
918
- productVariant: {
919
- id: number;
920
- sku: string | null;
921
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
922
- barcodes: string[];
923
- };
924
- measurementUnit: {
925
- id: number;
926
- code: string;
927
- name: string;
928
- decimalPlaces: number;
929
- };
930
- updatedByEmployee: {
931
- id: number;
932
- fullName: string;
933
- } | null;
934
- }[];
935
- };
936
- }>;
937
- outputFormat: 'json';
938
- status: 201;
939
- input: {
940
- json: {
941
- supplierId: number;
942
- warehouseId: number;
943
- currencyId: number;
944
- exchangeRateId?: number | null | undefined;
945
- };
753
+ }>;
754
+ outputFormat: "json";
755
+ status: 200;
756
+ input: {
757
+ query: {
758
+ id: string | string[];
946
759
  };
947
760
  };
948
761
  };
949
- } & {
950
- '/operations/deliveries/search': {
951
- $post: {
952
- output:
953
- | import('@kalutskii/foundation').APIError<string>
954
- | import('@kalutskii/foundation').APISuccess<{
955
- deliveries: {
956
- id: number;
957
- code: string;
958
- supplierId: number;
959
- warehouseId: number;
960
- currencyId: number;
961
- status: 'draft' | 'posted';
962
- exchangeRateId: number | null;
963
- exchangeRate: string | null;
964
- exchangeRateValidFromDate: string | null;
965
- postedAt: Date | null;
966
- updatedAt: Date | null;
967
- createdAt: Date;
968
- supplierName: string;
969
- warehouseName: string;
970
- currencyCode: string;
971
- }[];
972
- total: number;
973
- }>;
974
- outputFormat: 'json';
975
- status: 200;
976
- input: {
977
- json: {
978
- where?:
979
- | {
980
- supplierId?: number | undefined;
981
- warehouseId?: number | undefined;
982
- currencyId?: number | undefined;
983
- status?: 'draft' | 'posted' | undefined;
984
- createdAtFrom?: unknown;
985
- createdAtTo?: unknown;
986
- }
987
- | undefined;
988
- query?: string | undefined;
989
- pagination: {
990
- offset?: unknown;
991
- limit?: unknown;
762
+ };
763
+ } & {
764
+ "/operations/deliveries/create": {
765
+ $post: {
766
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
767
+ delivery: {
768
+ id: number;
769
+ code: string;
770
+ supplierId: number;
771
+ warehouseId: number;
772
+ currencyId: number;
773
+ status: "draft" | "posted";
774
+ exchangeRateId: number | null;
775
+ exchangeRate: string | null;
776
+ exchangeRateValidFromDate: string | null;
777
+ postedAt: Date | null;
778
+ updatedAt: Date | null;
779
+ createdAt: Date;
780
+ items: {
781
+ id: number;
782
+ deliveryId: number;
783
+ productVariantId: number;
784
+ quantity: number | null;
785
+ unitCost: string | null;
786
+ unitCostBase: string | null;
787
+ supplierLotNumber: string | null;
788
+ expiresOn: string | null;
789
+ revision: number;
790
+ updatedAt: Date | null;
791
+ createdAt: Date;
792
+ product: {
793
+ id: number;
794
+ model: string | null;
795
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
796
+ image: {
797
+ src: string;
798
+ isBanner: boolean;
799
+ } | null;
992
800
  };
993
- };
801
+ productVariant: {
802
+ id: number;
803
+ sku: string | null;
804
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
805
+ barcodes: string[];
806
+ };
807
+ measurementUnit: {
808
+ id: number;
809
+ code: string;
810
+ name: string;
811
+ decimalPlaces: number;
812
+ };
813
+ updatedByEmployee: {
814
+ id: number;
815
+ fullName: string;
816
+ } | null;
817
+ }[];
818
+ };
819
+ }>;
820
+ outputFormat: "json";
821
+ status: 201;
822
+ input: {
823
+ json: {
824
+ supplierId: number;
825
+ warehouseId: number;
826
+ currencyId: number;
827
+ exchangeRateId?: number | null | undefined;
994
828
  };
995
829
  };
996
830
  };
997
- } & {
998
- '/operations/deliveries/update': {
999
- $post: {
1000
- output:
1001
- | import('@kalutskii/foundation').APIError<string>
1002
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1003
- outputFormat: 'json';
1004
- status: 200;
1005
- input: {
1006
- json: {
831
+ };
832
+ } & {
833
+ "/operations/deliveries/search": {
834
+ $post: {
835
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
836
+ deliveries: {
837
+ id: number;
838
+ code: string;
839
+ supplierId: number;
840
+ warehouseId: number;
841
+ currencyId: number;
842
+ status: "draft" | "posted";
843
+ exchangeRateId: number | null;
844
+ exchangeRate: string | null;
845
+ exchangeRateValidFromDate: string | null;
846
+ postedAt: Date | null;
847
+ updatedAt: Date | null;
848
+ createdAt: Date;
849
+ supplierName: string;
850
+ warehouseName: string;
851
+ currencyCode: string;
852
+ }[];
853
+ total: number;
854
+ }>;
855
+ outputFormat: "json";
856
+ status: 200;
857
+ input: {
858
+ json: {
859
+ where?: {
1007
860
  supplierId?: number | undefined;
1008
861
  warehouseId?: number | undefined;
1009
862
  currencyId?: number | undefined;
1010
- exchangeRateId?: number | null | undefined;
1011
- deliveryId: number;
863
+ status?: "draft" | "posted" | undefined;
864
+ createdAtFrom?: unknown;
865
+ createdAtTo?: unknown;
866
+ } | undefined;
867
+ query?: string | undefined;
868
+ pagination: {
869
+ offset?: unknown;
870
+ limit?: unknown;
1012
871
  };
1013
872
  };
1014
873
  };
1015
874
  };
1016
- } & {
1017
- '/operations/deliveries/delete': {
1018
- $post: {
1019
- output:
1020
- | import('@kalutskii/foundation').APIError<string>
1021
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1022
- outputFormat: 'json';
1023
- status: 200;
1024
- input: {
1025
- json: {
1026
- deliveryId: number;
1027
- };
875
+ };
876
+ } & {
877
+ "/operations/deliveries/update": {
878
+ $post: {
879
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
880
+ outputFormat: "json";
881
+ status: 200;
882
+ input: {
883
+ json: {
884
+ supplierId?: number | undefined;
885
+ warehouseId?: number | undefined;
886
+ currencyId?: number | undefined;
887
+ exchangeRateId?: number | null | undefined;
888
+ deliveryId: number;
1028
889
  };
1029
890
  };
1030
891
  };
1031
- } & {
1032
- '/operations/deliveries/post': {
1033
- $post: {
1034
- output:
1035
- | import('@kalutskii/foundation').APIError<string>
1036
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1037
- outputFormat: 'json';
1038
- status: 200;
1039
- input: {
1040
- json: {
1041
- deliveryId: number;
1042
- };
892
+ };
893
+ } & {
894
+ "/operations/deliveries/delete": {
895
+ $post: {
896
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
897
+ outputFormat: "json";
898
+ status: 200;
899
+ input: {
900
+ json: {
901
+ deliveryId: number;
1043
902
  };
1044
903
  };
1045
904
  };
1046
- } & {
1047
- '/operations/deliveries/item/add': {
1048
- $post: {
1049
- output:
1050
- | import('@kalutskii/foundation').APIError<string>
1051
- | import('@kalutskii/foundation').APISuccess<{
1052
- deliveryItem: {
1053
- id: number;
1054
- deliveryId: number;
1055
- productVariantId: number;
1056
- quantity: number | null;
1057
- unitCost: string | null;
1058
- unitCostBase: string | null;
1059
- supplierLotNumber: string | null;
1060
- expiresOn: string | null;
1061
- revision: number;
1062
- updatedAt: Date | null;
1063
- createdAt: Date;
1064
- product: {
1065
- id: number;
1066
- model: string | null;
1067
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1068
- image: {
1069
- src: string;
1070
- isBanner: boolean;
1071
- } | null;
1072
- };
1073
- productVariant: {
1074
- id: number;
1075
- sku: string | null;
1076
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1077
- barcodes: string[];
1078
- };
1079
- measurementUnit: {
1080
- id: number;
1081
- code: string;
1082
- name: string;
1083
- decimalPlaces: number;
1084
- };
1085
- updatedByEmployee: {
1086
- id: number;
1087
- fullName: string;
1088
- } | null;
1089
- };
1090
- }>;
1091
- outputFormat: 'json';
1092
- status: 200;
1093
- input: {
1094
- json: {
1095
- deliveryId: number;
1096
- productVariantId: number;
1097
- unitCost: string | null;
1098
- supplierLotNumber?: string | null | undefined;
1099
- expiresOn?: string | null | undefined;
1100
- quantity?: number | undefined;
905
+ };
906
+ } & {
907
+ "/operations/deliveries/post": {
908
+ $post: {
909
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
910
+ outputFormat: "json";
911
+ status: 200;
912
+ input: {
913
+ json: {
914
+ deliveryId: number;
915
+ };
916
+ };
917
+ };
918
+ };
919
+ } & {
920
+ "/operations/deliveries/item/add": {
921
+ $post: {
922
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
923
+ deliveryItem: {
924
+ id: number;
925
+ deliveryId: number;
926
+ productVariantId: number;
927
+ quantity: number | null;
928
+ unitCost: string | null;
929
+ unitCostBase: string | null;
930
+ supplierLotNumber: string | null;
931
+ expiresOn: string | null;
932
+ revision: number;
933
+ updatedAt: Date | null;
934
+ createdAt: Date;
935
+ product: {
936
+ id: number;
937
+ model: string | null;
938
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
939
+ image: {
940
+ src: string;
941
+ isBanner: boolean;
942
+ } | null;
943
+ };
944
+ productVariant: {
945
+ id: number;
946
+ sku: string | null;
947
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
948
+ barcodes: string[];
949
+ };
950
+ measurementUnit: {
951
+ id: number;
952
+ code: string;
953
+ name: string;
954
+ decimalPlaces: number;
1101
955
  };
956
+ updatedByEmployee: {
957
+ id: number;
958
+ fullName: string;
959
+ } | null;
960
+ };
961
+ }>;
962
+ outputFormat: "json";
963
+ status: 200;
964
+ input: {
965
+ json: {
966
+ deliveryId: number;
967
+ productVariantId: number;
968
+ unitCost: string | null;
969
+ supplierLotNumber?: string | null | undefined;
970
+ expiresOn?: string | null | undefined;
971
+ quantity?: number | undefined;
1102
972
  };
1103
973
  };
1104
974
  };
1105
- } & {
1106
- '/operations/deliveries/item/scan': {
1107
- $post: {
1108
- output:
1109
- | import('@kalutskii/foundation').APIError<string>
1110
- | import('@kalutskii/foundation').APISuccess<
1111
- | {
1112
- outcome: 'added';
1113
- deliveryItem: {
1114
- id: number;
1115
- deliveryId: number;
1116
- productVariantId: number;
1117
- quantity: number | null;
1118
- unitCost: string | null;
1119
- unitCostBase: string | null;
1120
- supplierLotNumber: string | null;
1121
- expiresOn: string | null;
1122
- revision: number;
1123
- updatedAt: Date | null;
1124
- createdAt: Date;
1125
- product: {
1126
- id: number;
1127
- model: string | null;
1128
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1129
- image: {
1130
- src: string;
1131
- isBanner: boolean;
1132
- } | null;
1133
- };
1134
- productVariant: {
1135
- id: number;
1136
- sku: string | null;
1137
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1138
- barcodes: string[];
1139
- };
1140
- measurementUnit: {
1141
- id: number;
1142
- code: string;
1143
- name: string;
1144
- decimalPlaces: number;
1145
- };
1146
- updatedByEmployee: {
1147
- id: number;
1148
- fullName: string;
1149
- } | null;
1150
- };
1151
- }
1152
- | {
1153
- outcome: 'unchanged';
1154
- deliveryItem: {
1155
- id: number;
1156
- deliveryId: number;
1157
- productVariantId: number;
1158
- quantity: number | null;
1159
- unitCost: string | null;
1160
- unitCostBase: string | null;
1161
- supplierLotNumber: string | null;
1162
- expiresOn: string | null;
1163
- revision: number;
1164
- updatedAt: Date | null;
1165
- createdAt: Date;
1166
- product: {
1167
- id: number;
1168
- model: string | null;
1169
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1170
- image: {
1171
- src: string;
1172
- isBanner: boolean;
1173
- } | null;
1174
- };
1175
- productVariant: {
1176
- id: number;
1177
- sku: string | null;
1178
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1179
- barcodes: string[];
1180
- };
1181
- measurementUnit: {
1182
- id: number;
1183
- code: string;
1184
- name: string;
1185
- decimalPlaces: number;
1186
- };
1187
- updatedByEmployee: {
1188
- id: number;
1189
- fullName: string;
1190
- } | null;
1191
- };
1192
- }
1193
- | {
1194
- outcome: 'product-variant-not-found';
1195
- barcode: string;
1196
- }
1197
- >;
1198
- outputFormat: 'json';
1199
- status: 200;
1200
- input: {
1201
- json: {
1202
- deliveryId: number;
1203
- barcode: string;
975
+ };
976
+ } & {
977
+ "/operations/deliveries/item/scan": {
978
+ $post: {
979
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
980
+ outcome: "added";
981
+ deliveryItem: {
982
+ id: number;
983
+ deliveryId: number;
984
+ productVariantId: number;
985
+ quantity: number | null;
986
+ unitCost: string | null;
987
+ unitCostBase: string | null;
988
+ supplierLotNumber: string | null;
989
+ expiresOn: string | null;
990
+ revision: number;
991
+ updatedAt: Date | null;
992
+ createdAt: Date;
993
+ product: {
994
+ id: number;
995
+ model: string | null;
996
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
997
+ image: {
998
+ src: string;
999
+ isBanner: boolean;
1000
+ } | null;
1001
+ };
1002
+ productVariant: {
1003
+ id: number;
1004
+ sku: string | null;
1005
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1006
+ barcodes: string[];
1007
+ };
1008
+ measurementUnit: {
1009
+ id: number;
1010
+ code: string;
1011
+ name: string;
1012
+ decimalPlaces: number;
1013
+ };
1014
+ updatedByEmployee: {
1015
+ id: number;
1016
+ fullName: string;
1017
+ } | null;
1018
+ };
1019
+ } | {
1020
+ outcome: "unchanged";
1021
+ deliveryItem: {
1022
+ id: number;
1023
+ deliveryId: number;
1024
+ productVariantId: number;
1025
+ quantity: number | null;
1026
+ unitCost: string | null;
1027
+ unitCostBase: string | null;
1028
+ supplierLotNumber: string | null;
1029
+ expiresOn: string | null;
1030
+ revision: number;
1031
+ updatedAt: Date | null;
1032
+ createdAt: Date;
1033
+ product: {
1034
+ id: number;
1035
+ model: string | null;
1036
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1037
+ image: {
1038
+ src: string;
1039
+ isBanner: boolean;
1040
+ } | null;
1041
+ };
1042
+ productVariant: {
1043
+ id: number;
1044
+ sku: string | null;
1045
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1046
+ barcodes: string[];
1047
+ };
1048
+ measurementUnit: {
1049
+ id: number;
1050
+ code: string;
1051
+ name: string;
1052
+ decimalPlaces: number;
1204
1053
  };
1054
+ updatedByEmployee: {
1055
+ id: number;
1056
+ fullName: string;
1057
+ } | null;
1058
+ };
1059
+ } | {
1060
+ outcome: "product-variant-not-found";
1061
+ barcode: string;
1062
+ }>;
1063
+ outputFormat: "json";
1064
+ status: 200;
1065
+ input: {
1066
+ json: {
1067
+ deliveryId: number;
1068
+ barcode: string;
1205
1069
  };
1206
1070
  };
1207
1071
  };
1208
- } & {
1209
- '/operations/deliveries/item/update': {
1210
- $post: {
1211
- output:
1212
- | import('@kalutskii/foundation').APIError<string>
1213
- | import('@kalutskii/foundation').APISuccess<{
1214
- deliveryItem: {
1215
- id: number;
1216
- deliveryId: number;
1217
- productVariantId: number;
1218
- quantity: number | null;
1219
- unitCost: string | null;
1220
- unitCostBase: string | null;
1221
- supplierLotNumber: string | null;
1222
- expiresOn: string | null;
1223
- revision: number;
1224
- updatedAt: Date | null;
1225
- createdAt: Date;
1226
- product: {
1227
- id: number;
1228
- model: string | null;
1229
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1230
- image: {
1231
- src: string;
1232
- isBanner: boolean;
1233
- } | null;
1234
- };
1235
- productVariant: {
1236
- id: number;
1237
- sku: string | null;
1238
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1239
- barcodes: string[];
1240
- };
1241
- measurementUnit: {
1242
- id: number;
1243
- code: string;
1244
- name: string;
1245
- decimalPlaces: number;
1246
- };
1247
- updatedByEmployee: {
1248
- id: number;
1249
- fullName: string;
1250
- } | null;
1251
- };
1252
- }>;
1253
- outputFormat: 'json';
1254
- status: 200;
1255
- input: {
1256
- json: {
1257
- quantity?: number | null | undefined;
1258
- unitCost?: string | null | undefined;
1259
- supplierLotNumber?: string | null | undefined;
1260
- expiresOn?: string | null | undefined;
1261
- deliveryItemId: number;
1262
- expectedRevision: number;
1072
+ };
1073
+ } & {
1074
+ "/operations/deliveries/item/update": {
1075
+ $post: {
1076
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1077
+ deliveryItem: {
1078
+ id: number;
1079
+ deliveryId: number;
1080
+ productVariantId: number;
1081
+ quantity: number | null;
1082
+ unitCost: string | null;
1083
+ unitCostBase: string | null;
1084
+ supplierLotNumber: string | null;
1085
+ expiresOn: string | null;
1086
+ revision: number;
1087
+ updatedAt: Date | null;
1088
+ createdAt: Date;
1089
+ product: {
1090
+ id: number;
1091
+ model: string | null;
1092
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1093
+ image: {
1094
+ src: string;
1095
+ isBanner: boolean;
1096
+ } | null;
1097
+ };
1098
+ productVariant: {
1099
+ id: number;
1100
+ sku: string | null;
1101
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1102
+ barcodes: string[];
1103
+ };
1104
+ measurementUnit: {
1105
+ id: number;
1106
+ code: string;
1107
+ name: string;
1108
+ decimalPlaces: number;
1263
1109
  };
1110
+ updatedByEmployee: {
1111
+ id: number;
1112
+ fullName: string;
1113
+ } | null;
1114
+ };
1115
+ }>;
1116
+ outputFormat: "json";
1117
+ status: 200;
1118
+ input: {
1119
+ json: {
1120
+ quantity?: number | null | undefined;
1121
+ unitCost?: string | null | undefined;
1122
+ supplierLotNumber?: string | null | undefined;
1123
+ expiresOn?: string | null | undefined;
1124
+ deliveryItemId: number;
1125
+ expectedRevision: number;
1264
1126
  };
1265
1127
  };
1266
1128
  };
1267
- } & {
1268
- '/operations/deliveries/item/delete': {
1269
- $post: {
1270
- output:
1271
- | import('@kalutskii/foundation').APIError<string>
1272
- | import('@kalutskii/foundation').APISuccess<{
1273
- deliveryItem: {
1274
- id: number;
1275
- deliveryId: number;
1276
- productVariantId: number;
1277
- quantity: number | null;
1278
- unitCost: string | null;
1279
- unitCostBase: string | null;
1280
- supplierLotNumber: string | null;
1281
- expiresOn: string | null;
1282
- revision: number;
1283
- updatedAt: Date | null;
1284
- createdAt: Date;
1285
- product: {
1286
- id: number;
1287
- model: string | null;
1288
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1289
- image: {
1290
- src: string;
1291
- isBanner: boolean;
1292
- } | null;
1293
- };
1294
- productVariant: {
1295
- id: number;
1296
- sku: string | null;
1297
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1298
- barcodes: string[];
1299
- };
1300
- measurementUnit: {
1301
- id: number;
1302
- code: string;
1303
- name: string;
1304
- decimalPlaces: number;
1305
- };
1306
- updatedByEmployee: {
1307
- id: number;
1308
- fullName: string;
1309
- } | null;
1310
- };
1311
- }>;
1312
- outputFormat: 'json';
1313
- status: 200;
1314
- input: {
1315
- json: {
1316
- deliveryItemId: number;
1317
- expectedRevision: number;
1129
+ };
1130
+ } & {
1131
+ "/operations/deliveries/item/delete": {
1132
+ $post: {
1133
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1134
+ deliveryItem: {
1135
+ id: number;
1136
+ deliveryId: number;
1137
+ productVariantId: number;
1138
+ quantity: number | null;
1139
+ unitCost: string | null;
1140
+ unitCostBase: string | null;
1141
+ supplierLotNumber: string | null;
1142
+ expiresOn: string | null;
1143
+ revision: number;
1144
+ updatedAt: Date | null;
1145
+ createdAt: Date;
1146
+ product: {
1147
+ id: number;
1148
+ model: string | null;
1149
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1150
+ image: {
1151
+ src: string;
1152
+ isBanner: boolean;
1153
+ } | null;
1154
+ };
1155
+ productVariant: {
1156
+ id: number;
1157
+ sku: string | null;
1158
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1159
+ barcodes: string[];
1318
1160
  };
1161
+ measurementUnit: {
1162
+ id: number;
1163
+ code: string;
1164
+ name: string;
1165
+ decimalPlaces: number;
1166
+ };
1167
+ updatedByEmployee: {
1168
+ id: number;
1169
+ fullName: string;
1170
+ } | null;
1171
+ };
1172
+ }>;
1173
+ outputFormat: "json";
1174
+ status: 200;
1175
+ input: {
1176
+ json: {
1177
+ deliveryItemId: number;
1178
+ expectedRevision: number;
1319
1179
  };
1320
1180
  };
1321
1181
  };
1322
- },
1323
- '/operations/deliveries',
1324
- '/operations/deliveries/item/delete'
1325
- >;
1182
+ };
1183
+ }, "/operations/deliveries", "/operations/deliveries/item/delete">;
1326
1184
  type DeliveriesRouter = typeof deliveriesRouter;
1327
1185
  //#endregion
1328
1186
  //#region src/app/flows/(audit)/audit/audit.enums.d.ts
@@ -1330,20 +1188,13 @@ declare const auditLogSourcesArray: readonly ['admin', 'backend'];
1330
1188
  type AuditLogSource = (typeof auditLogSourcesArray)[number];
1331
1189
  //#endregion
1332
1190
  //#region src/app/domain/(audit)/audit-logs/audit-logs.schemas.d.ts
1333
- declare const auditLogSchema: z.ZodObject<
1334
- {
1335
- id: z.ZodInt;
1336
- event: z.ZodString;
1337
- actorEmployeeId: z.ZodNullable<z.ZodInt>;
1338
- payload: z.ZodType<
1339
- import('drizzle-orm').Json,
1340
- unknown,
1341
- z.core.$ZodTypeInternals<import('drizzle-orm').Json, unknown>
1342
- >;
1343
- createdAt: z.ZodDate;
1344
- },
1345
- z.core.$strip
1346
- >;
1191
+ declare const auditLogSchema: z.ZodObject<{
1192
+ id: z.ZodInt;
1193
+ event: z.ZodString;
1194
+ actorEmployeeId: z.ZodNullable<z.ZodInt>;
1195
+ payload: z.ZodType<import("drizzle-orm").Json, unknown, z.core.$ZodTypeInternals<import("drizzle-orm").Json, unknown>>;
1196
+ createdAt: z.ZodDate;
1197
+ }, z.core.$strip>;
1347
1198
  //#endregion
1348
1199
  //#region src/app/flows/(audit)/audit/audit.schemas.d.ts
1349
1200
  type AuditLogResult = z.infer<typeof auditLogSchema> & {
@@ -1351,543 +1202,458 @@ type AuditLogResult = z.infer<typeof auditLogSchema> & {
1351
1202
  };
1352
1203
  //#endregion
1353
1204
  //#region src/app/routes/(audit)/audit-logs.routes.d.ts
1354
- declare const auditLogsRouter: import('hono/hono-base').HonoBase<
1355
- {
1356
- Variables: VariablesWithActor;
1357
- },
1358
- {
1359
- '/operations/audit-logs/existing-events': {
1360
- $get: {
1361
- output:
1362
- | import('@kalutskii/foundation').APIError<string>
1363
- | import('@kalutskii/foundation').APISuccess<{
1364
- auditEvents: string[];
1365
- }>;
1366
- outputFormat: 'json';
1367
- status: 200;
1368
- input: {};
1369
- };
1205
+ declare const auditLogsRouter: import("hono/hono-base").HonoBase<{
1206
+ Variables: VariablesWithActor;
1207
+ }, {
1208
+ "/operations/audit-logs/existing-events": {
1209
+ $get: {
1210
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1211
+ auditEvents: string[];
1212
+ }>;
1213
+ outputFormat: "json";
1214
+ status: 200;
1215
+ input: {};
1370
1216
  };
1371
- } & {
1372
- '/operations/audit-logs/one': {
1373
- $get: {
1374
- output:
1375
- | import('@kalutskii/foundation').APIError<string>
1376
- | import('@kalutskii/foundation').APISuccess<{
1377
- auditLog: AuditLogResult;
1378
- }>;
1379
- outputFormat: 'json';
1380
- status: 200;
1381
- input: {
1382
- query: {
1383
- id: string | string[];
1384
- source: 'admin' | 'backend';
1385
- };
1217
+ };
1218
+ } & {
1219
+ "/operations/audit-logs/one": {
1220
+ $get: {
1221
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1222
+ auditLog: AuditLogResult;
1223
+ }>;
1224
+ outputFormat: "json";
1225
+ status: 200;
1226
+ input: {
1227
+ query: {
1228
+ id: string | string[];
1229
+ source: "admin" | "backend";
1386
1230
  };
1387
1231
  };
1388
1232
  };
1389
- } & {
1390
- '/operations/audit-logs/search': {
1391
- $post: {
1392
- output:
1393
- | import('@kalutskii/foundation').APIError<string>
1394
- | import('@kalutskii/foundation').APISuccess<{
1395
- auditLogs: AuditLogResult[];
1396
- total: number;
1397
- }>;
1398
- outputFormat: 'json';
1399
- status: 200;
1400
- input: {
1401
- json: {
1402
- where?:
1403
- | {
1404
- event?: string | undefined;
1405
- actorEmployeeId?: number | null | undefined;
1406
- }
1407
- | undefined;
1408
- query?: string | undefined;
1409
- pagination: {
1410
- offset?: unknown;
1411
- limit?: unknown;
1412
- };
1233
+ };
1234
+ } & {
1235
+ "/operations/audit-logs/search": {
1236
+ $post: {
1237
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1238
+ auditLogs: AuditLogResult[];
1239
+ total: number;
1240
+ }>;
1241
+ outputFormat: "json";
1242
+ status: 200;
1243
+ input: {
1244
+ json: {
1245
+ where?: {
1246
+ event?: string | undefined;
1247
+ actorEmployeeId?: number | null | undefined;
1248
+ } | undefined;
1249
+ query?: string | undefined;
1250
+ pagination: {
1251
+ offset?: unknown;
1252
+ limit?: unknown;
1413
1253
  };
1414
1254
  };
1415
1255
  };
1416
1256
  };
1417
- },
1418
- '/operations/audit-logs',
1419
- '/operations/audit-logs/search'
1420
- >;
1257
+ };
1258
+ }, "/operations/audit-logs", "/operations/audit-logs/search">;
1421
1259
  type AuditLogsRouter = typeof auditLogsRouter;
1422
1260
  //#endregion
1423
1261
  //#region src/app/routes/(sales)/customers.routes.d.ts
1424
- declare const customersRouter: import('hono/hono-base').HonoBase<
1425
- {
1426
- Variables: VariablesWithActor;
1427
- },
1428
- {
1429
- '/operations/customers/one': {
1430
- $get: {
1431
- output:
1432
- | import('@kalutskii/foundation').APIError<string>
1433
- | import('@kalutskii/foundation').APISuccess<{
1434
- customer: {
1435
- id: number;
1436
- type: 'individual' | 'individual_entrepreneur' | 'legal_entity';
1437
- name: string;
1438
- identificationNumber: string | null;
1439
- emailAddress: string | null;
1440
- phoneNumber: string | null;
1441
- notes: string | null;
1442
- updatedAt: Date | null;
1443
- createdAt: Date;
1444
- };
1445
- }>;
1446
- outputFormat: 'json';
1447
- status: 200;
1448
- input: {
1449
- query: {
1450
- id: string | string[];
1451
- };
1262
+ declare const customersRouter: import("hono/hono-base").HonoBase<{
1263
+ Variables: VariablesWithActor;
1264
+ }, {
1265
+ "/operations/customers/one": {
1266
+ $get: {
1267
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1268
+ customer: {
1269
+ id: number;
1270
+ type: "individual" | "individual_entrepreneur" | "legal_entity";
1271
+ name: string;
1272
+ identificationNumber: string | null;
1273
+ emailAddress: string | null;
1274
+ phoneNumber: string | null;
1275
+ notes: string | null;
1276
+ updatedAt: Date | null;
1277
+ createdAt: Date;
1278
+ };
1279
+ }>;
1280
+ outputFormat: "json";
1281
+ status: 200;
1282
+ input: {
1283
+ query: {
1284
+ id: string | string[];
1452
1285
  };
1453
1286
  };
1454
1287
  };
1455
- } & {
1456
- '/operations/customers/create': {
1457
- $post: {
1458
- output:
1459
- | import('@kalutskii/foundation').APIError<string>
1460
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1461
- outputFormat: 'json';
1462
- status: 201;
1463
- input: {
1464
- json: {
1465
- type: 'individual' | 'individual_entrepreneur' | 'legal_entity';
1466
- name: string;
1467
- identificationNumber?: string | null | undefined;
1468
- emailAddress?: string | null | undefined;
1469
- phoneNumber?: string | null | undefined;
1470
- notes?: string | null | undefined;
1471
- };
1288
+ };
1289
+ } & {
1290
+ "/operations/customers/create": {
1291
+ $post: {
1292
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1293
+ outputFormat: "json";
1294
+ status: 201;
1295
+ input: {
1296
+ json: {
1297
+ type: "individual" | "individual_entrepreneur" | "legal_entity";
1298
+ name: string;
1299
+ identificationNumber?: string | null | undefined;
1300
+ emailAddress?: string | null | undefined;
1301
+ phoneNumber?: string | null | undefined;
1302
+ notes?: string | null | undefined;
1472
1303
  };
1473
1304
  };
1474
1305
  };
1475
- } & {
1476
- '/operations/customers/search': {
1477
- $post: {
1478
- output:
1479
- | import('@kalutskii/foundation').APIError<string>
1480
- | import('@kalutskii/foundation').APISuccess<{
1481
- customers: {
1482
- id: number;
1483
- type: 'individual' | 'individual_entrepreneur' | 'legal_entity';
1484
- name: string;
1485
- identificationNumber: string | null;
1486
- emailAddress: string | null;
1487
- phoneNumber: string | null;
1488
- notes: string | null;
1489
- updatedAt: Date | null;
1490
- createdAt: Date;
1491
- }[];
1492
- total: number;
1493
- }>;
1494
- outputFormat: 'json';
1495
- status: 200;
1496
- input: {
1497
- json: {
1498
- where?:
1499
- | {
1500
- type?: 'individual' | 'individual_entrepreneur' | 'legal_entity' | undefined;
1501
- }
1502
- | undefined;
1503
- query?: string | undefined;
1504
- pagination: {
1505
- offset?: unknown;
1506
- limit?: unknown;
1507
- };
1306
+ };
1307
+ } & {
1308
+ "/operations/customers/search": {
1309
+ $post: {
1310
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1311
+ customers: {
1312
+ id: number;
1313
+ type: "individual" | "individual_entrepreneur" | "legal_entity";
1314
+ name: string;
1315
+ identificationNumber: string | null;
1316
+ emailAddress: string | null;
1317
+ phoneNumber: string | null;
1318
+ notes: string | null;
1319
+ updatedAt: Date | null;
1320
+ createdAt: Date;
1321
+ }[];
1322
+ total: number;
1323
+ }>;
1324
+ outputFormat: "json";
1325
+ status: 200;
1326
+ input: {
1327
+ json: {
1328
+ where?: {
1329
+ type?: "individual" | "individual_entrepreneur" | "legal_entity" | undefined;
1330
+ } | undefined;
1331
+ query?: string | undefined;
1332
+ pagination: {
1333
+ offset?: unknown;
1334
+ limit?: unknown;
1508
1335
  };
1509
1336
  };
1510
1337
  };
1511
1338
  };
1512
- } & {
1513
- '/operations/customers/update': {
1514
- $post: {
1515
- output:
1516
- | import('@kalutskii/foundation').APIError<string>
1517
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1518
- outputFormat: 'json';
1519
- status: 200;
1520
- input: {
1521
- json: {
1522
- name?: string | undefined;
1523
- identificationNumber?: string | null | undefined;
1524
- emailAddress?: string | null | undefined;
1525
- phoneNumber?: string | null | undefined;
1526
- notes?: string | null | undefined;
1527
- customerId: number;
1528
- };
1339
+ };
1340
+ } & {
1341
+ "/operations/customers/update": {
1342
+ $post: {
1343
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1344
+ outputFormat: "json";
1345
+ status: 200;
1346
+ input: {
1347
+ json: {
1348
+ name?: string | undefined;
1349
+ identificationNumber?: string | null | undefined;
1350
+ emailAddress?: string | null | undefined;
1351
+ phoneNumber?: string | null | undefined;
1352
+ notes?: string | null | undefined;
1353
+ customerId: number;
1529
1354
  };
1530
1355
  };
1531
1356
  };
1532
- },
1533
- '/operations/customers',
1534
- '/operations/customers/update'
1535
- >;
1357
+ };
1358
+ }, "/operations/customers", "/operations/customers/update">;
1536
1359
  type CustomersRouter = typeof customersRouter;
1537
1360
  //#endregion
1538
1361
  //#region src/app/routes/(procurement)/suppliers.routes.d.ts
1539
- declare const suppliersRouter: import('hono/hono-base').HonoBase<
1540
- {
1541
- Variables: VariablesWithActor;
1542
- },
1543
- {
1544
- '/operations/suppliers/one': {
1545
- $get: {
1546
- output:
1547
- | import('@kalutskii/foundation').APIError<string>
1548
- | import('@kalutskii/foundation').APISuccess<{
1549
- supplier: {
1550
- id: number;
1551
- status: 'active' | 'archived';
1552
- name: string;
1553
- identificationNumber: string | null;
1554
- countryId: number | null;
1555
- emailAddress: string | null;
1556
- phoneNumber: string | null;
1557
- websiteUrl: string | null;
1558
- notes: string | null;
1559
- updatedAt: Date | null;
1560
- createdAt: Date;
1561
- };
1562
- }>;
1563
- outputFormat: 'json';
1564
- status: 200;
1565
- input: {
1566
- query: {
1567
- id: string | string[];
1568
- };
1362
+ declare const suppliersRouter: import("hono/hono-base").HonoBase<{
1363
+ Variables: VariablesWithActor;
1364
+ }, {
1365
+ "/operations/suppliers/one": {
1366
+ $get: {
1367
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1368
+ supplier: {
1369
+ id: number;
1370
+ status: "active" | "archived";
1371
+ name: string;
1372
+ identificationNumber: string | null;
1373
+ countryId: number | null;
1374
+ emailAddress: string | null;
1375
+ phoneNumber: string | null;
1376
+ websiteUrl: string | null;
1377
+ notes: string | null;
1378
+ updatedAt: Date | null;
1379
+ createdAt: Date;
1380
+ };
1381
+ }>;
1382
+ outputFormat: "json";
1383
+ status: 200;
1384
+ input: {
1385
+ query: {
1386
+ id: string | string[];
1569
1387
  };
1570
1388
  };
1571
1389
  };
1572
- } & {
1573
- '/operations/suppliers/create': {
1574
- $post: {
1575
- output:
1576
- | import('@kalutskii/foundation').APIError<string>
1577
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1578
- outputFormat: 'json';
1579
- status: 201;
1580
- input: {
1581
- json: {
1582
- name: string;
1583
- identificationNumber?: string | null | undefined;
1584
- countryId?: number | null | undefined;
1585
- emailAddress?: string | null | undefined;
1586
- phoneNumber?: string | null | undefined;
1587
- websiteUrl: string | null;
1588
- notes?: string | null | undefined;
1589
- };
1390
+ };
1391
+ } & {
1392
+ "/operations/suppliers/create": {
1393
+ $post: {
1394
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1395
+ outputFormat: "json";
1396
+ status: 201;
1397
+ input: {
1398
+ json: {
1399
+ name: string;
1400
+ identificationNumber?: string | null | undefined;
1401
+ countryId?: number | null | undefined;
1402
+ emailAddress?: string | null | undefined;
1403
+ phoneNumber?: string | null | undefined;
1404
+ websiteUrl: string | null;
1405
+ notes?: string | null | undefined;
1590
1406
  };
1591
1407
  };
1592
1408
  };
1593
- } & {
1594
- '/operations/suppliers/search': {
1595
- $post: {
1596
- output:
1597
- | import('@kalutskii/foundation').APIError<string>
1598
- | import('@kalutskii/foundation').APISuccess<{
1599
- suppliers: {
1600
- id: number;
1601
- status: 'active' | 'archived';
1602
- name: string;
1603
- identificationNumber: string | null;
1604
- countryId: number | null;
1605
- emailAddress: string | null;
1606
- phoneNumber: string | null;
1607
- websiteUrl: string | null;
1608
- notes: string | null;
1609
- updatedAt: Date | null;
1610
- createdAt: Date;
1611
- }[];
1612
- total: number;
1613
- }>;
1614
- outputFormat: 'json';
1615
- status: 200;
1616
- input: {
1617
- json: {
1618
- where?:
1619
- | {
1620
- status?: 'active' | 'archived' | undefined;
1621
- countryId?: number | null | undefined;
1622
- }
1623
- | undefined;
1624
- query?: string | undefined;
1625
- pagination: {
1626
- offset?: unknown;
1627
- limit?: unknown;
1628
- };
1409
+ };
1410
+ } & {
1411
+ "/operations/suppliers/search": {
1412
+ $post: {
1413
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1414
+ suppliers: {
1415
+ id: number;
1416
+ status: "active" | "archived";
1417
+ name: string;
1418
+ identificationNumber: string | null;
1419
+ countryId: number | null;
1420
+ emailAddress: string | null;
1421
+ phoneNumber: string | null;
1422
+ websiteUrl: string | null;
1423
+ notes: string | null;
1424
+ updatedAt: Date | null;
1425
+ createdAt: Date;
1426
+ }[];
1427
+ total: number;
1428
+ }>;
1429
+ outputFormat: "json";
1430
+ status: 200;
1431
+ input: {
1432
+ json: {
1433
+ where?: {
1434
+ status?: "active" | "archived" | undefined;
1435
+ countryId?: number | null | undefined;
1436
+ } | undefined;
1437
+ query?: string | undefined;
1438
+ pagination: {
1439
+ offset?: unknown;
1440
+ limit?: unknown;
1629
1441
  };
1630
1442
  };
1631
1443
  };
1632
1444
  };
1633
- } & {
1634
- '/operations/suppliers/update': {
1635
- $post: {
1636
- output:
1637
- | import('@kalutskii/foundation').APIError<string>
1638
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1639
- outputFormat: 'json';
1640
- status: 200;
1641
- input: {
1642
- json: {
1643
- name?: string | undefined;
1644
- identificationNumber?: string | null | undefined;
1645
- countryId?: number | null | undefined;
1646
- emailAddress?: string | null | undefined;
1647
- phoneNumber?: string | null | undefined;
1648
- websiteUrl?: string | null | undefined;
1649
- notes?: string | null | undefined;
1650
- supplierId: number;
1651
- };
1445
+ };
1446
+ } & {
1447
+ "/operations/suppliers/update": {
1448
+ $post: {
1449
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1450
+ outputFormat: "json";
1451
+ status: 200;
1452
+ input: {
1453
+ json: {
1454
+ name?: string | undefined;
1455
+ identificationNumber?: string | null | undefined;
1456
+ countryId?: number | null | undefined;
1457
+ emailAddress?: string | null | undefined;
1458
+ phoneNumber?: string | null | undefined;
1459
+ websiteUrl?: string | null | undefined;
1460
+ notes?: string | null | undefined;
1461
+ supplierId: number;
1652
1462
  };
1653
1463
  };
1654
1464
  };
1655
- } & {
1656
- '/operations/suppliers/switch-status': {
1657
- $post: {
1658
- output:
1659
- | import('@kalutskii/foundation').APIError<string>
1660
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1661
- outputFormat: 'json';
1662
- status: 200;
1663
- input: {
1664
- json: {
1665
- status: 'active' | 'archived';
1666
- supplierId: number;
1667
- };
1465
+ };
1466
+ } & {
1467
+ "/operations/suppliers/switch-status": {
1468
+ $post: {
1469
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1470
+ outputFormat: "json";
1471
+ status: 200;
1472
+ input: {
1473
+ json: {
1474
+ status: "active" | "archived";
1475
+ supplierId: number;
1668
1476
  };
1669
1477
  };
1670
1478
  };
1671
- },
1672
- '/operations/suppliers',
1673
- '/operations/suppliers/switch-status'
1674
- >;
1479
+ };
1480
+ }, "/operations/suppliers", "/operations/suppliers/switch-status">;
1675
1481
  type SuppliersRouter = typeof suppliersRouter;
1676
1482
  //#endregion
1677
1483
  //#region src/app/routes/(warehouse)/stock-balances.routes.d.ts
1678
- declare const stockBalancesRouter: import('hono/hono-base').HonoBase<
1679
- {
1680
- Variables: VariablesWithActor;
1681
- },
1682
- {
1683
- '/operations/stock-balances/search': {
1684
- $post: {
1685
- output:
1686
- | import('@kalutskii/foundation').APIError<string>
1687
- | import('@kalutskii/foundation').APISuccess<{
1688
- stockBalances: {
1689
- id: number;
1690
- warehouseId: number;
1691
- productVariantId: number;
1692
- onHand: number;
1693
- reserved: number;
1694
- averageUnitCostBase: string | null;
1695
- updatedAt: Date | null;
1696
- createdAt: Date;
1697
- available: number;
1698
- warehouse: {
1699
- id: number;
1700
- code: string;
1701
- name: string;
1702
- };
1703
- product: {
1704
- id: number;
1705
- model: string | null;
1706
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1707
- image: {
1708
- src: string;
1709
- isBanner: boolean;
1710
- } | null;
1711
- };
1712
- productVariant: {
1713
- id: number;
1714
- sku: string | null;
1715
- name: Partial<Record<'en' | 'ka' | 'ru', string>> | null;
1716
- barcodes: string[];
1717
- };
1718
- measurementUnit: {
1719
- id: number;
1720
- code: string;
1721
- name: string;
1722
- decimalPlaces: number;
1723
- };
1724
- }[];
1725
- total: number;
1726
- }>;
1727
- outputFormat: 'json';
1728
- status: 200;
1729
- input: {
1730
- json: {
1731
- where?:
1732
- | {
1733
- warehouseId?: number | undefined;
1734
- productVariantId?: number | undefined;
1735
- }
1736
- | undefined;
1737
- query?: string | undefined;
1738
- pagination: {
1739
- offset?: unknown;
1740
- limit?: unknown;
1741
- };
1484
+ declare const stockBalancesRouter: import("hono/hono-base").HonoBase<{
1485
+ Variables: VariablesWithActor;
1486
+ }, {
1487
+ "/operations/stock-balances/search": {
1488
+ $post: {
1489
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1490
+ stockBalances: {
1491
+ id: number;
1492
+ warehouseId: number;
1493
+ productVariantId: number;
1494
+ onHand: number;
1495
+ reserved: number;
1496
+ averageUnitCostBase: string | null;
1497
+ updatedAt: Date | null;
1498
+ createdAt: Date;
1499
+ available: number;
1500
+ warehouse: {
1501
+ id: number;
1502
+ code: string;
1503
+ name: string;
1504
+ };
1505
+ product: {
1506
+ id: number;
1507
+ model: string | null;
1508
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1509
+ image: {
1510
+ src: string;
1511
+ isBanner: boolean;
1512
+ } | null;
1513
+ };
1514
+ productVariant: {
1515
+ id: number;
1516
+ sku: string | null;
1517
+ name: Partial<Record<"en" | "ka" | "ru", string>> | null;
1518
+ barcodes: string[];
1519
+ };
1520
+ measurementUnit: {
1521
+ id: number;
1522
+ code: string;
1523
+ name: string;
1524
+ decimalPlaces: number;
1525
+ };
1526
+ }[];
1527
+ total: number;
1528
+ }>;
1529
+ outputFormat: "json";
1530
+ status: 200;
1531
+ input: {
1532
+ json: {
1533
+ where?: {
1534
+ warehouseId?: number | undefined;
1535
+ productVariantId?: number | undefined;
1536
+ } | undefined;
1537
+ query?: string | undefined;
1538
+ pagination: {
1539
+ offset?: unknown;
1540
+ limit?: unknown;
1742
1541
  };
1743
1542
  };
1744
1543
  };
1745
1544
  };
1746
- },
1747
- '/operations/stock-balances',
1748
- '/operations/stock-balances/search'
1749
- >;
1545
+ };
1546
+ }, "/operations/stock-balances", "/operations/stock-balances/search">;
1750
1547
  type StockBalancesRouter = typeof stockBalancesRouter;
1751
1548
  //#endregion
1752
1549
  //#region src/app/routes/(warehouse)/warehouses.routes.d.ts
1753
- declare const warehousesRouter: import('hono/hono-base').HonoBase<
1754
- {
1755
- Variables: VariablesWithActor;
1756
- },
1757
- {
1758
- '/operations/warehouses/one': {
1759
- $get: {
1760
- output:
1761
- | import('@kalutskii/foundation').APIError<string>
1762
- | import('@kalutskii/foundation').APISuccess<{
1763
- warehouse: {
1764
- id: number;
1765
- code: string;
1766
- name: string;
1767
- address: string;
1768
- status: 'active' | 'archived';
1769
- salesEnabled: boolean;
1770
- updatedAt: Date | null;
1771
- createdAt: Date;
1772
- };
1773
- }>;
1774
- outputFormat: 'json';
1775
- status: 200;
1776
- input: {
1777
- query: {
1778
- id: string | string[];
1779
- };
1550
+ declare const warehousesRouter: import("hono/hono-base").HonoBase<{
1551
+ Variables: VariablesWithActor;
1552
+ }, {
1553
+ "/operations/warehouses/one": {
1554
+ $get: {
1555
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1556
+ warehouse: {
1557
+ id: number;
1558
+ code: string;
1559
+ name: string;
1560
+ address: string;
1561
+ status: "active" | "archived";
1562
+ salesEnabled: boolean;
1563
+ updatedAt: Date | null;
1564
+ createdAt: Date;
1565
+ };
1566
+ }>;
1567
+ outputFormat: "json";
1568
+ status: 200;
1569
+ input: {
1570
+ query: {
1571
+ id: string | string[];
1780
1572
  };
1781
1573
  };
1782
1574
  };
1783
- } & {
1784
- '/operations/warehouses/create': {
1785
- $post: {
1786
- output:
1787
- | import('@kalutskii/foundation').APIError<string>
1788
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1789
- outputFormat: 'json';
1790
- status: 201;
1791
- input: {
1792
- json: {
1793
- code: string;
1794
- name: string;
1795
- address: string;
1796
- salesEnabled?: boolean | undefined;
1797
- };
1575
+ };
1576
+ } & {
1577
+ "/operations/warehouses/create": {
1578
+ $post: {
1579
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1580
+ outputFormat: "json";
1581
+ status: 201;
1582
+ input: {
1583
+ json: {
1584
+ code: string;
1585
+ name: string;
1586
+ address: string;
1587
+ salesEnabled?: boolean | undefined;
1798
1588
  };
1799
1589
  };
1800
1590
  };
1801
- } & {
1802
- '/operations/warehouses/search': {
1803
- $post: {
1804
- output:
1805
- | import('@kalutskii/foundation').APIError<string>
1806
- | import('@kalutskii/foundation').APISuccess<{
1807
- warehouses: {
1808
- id: number;
1809
- code: string;
1810
- name: string;
1811
- address: string;
1812
- status: 'active' | 'archived';
1813
- salesEnabled: boolean;
1814
- updatedAt: Date | null;
1815
- createdAt: Date;
1816
- }[];
1817
- total: number;
1818
- }>;
1819
- outputFormat: 'json';
1820
- status: 200;
1821
- input: {
1822
- json: {
1823
- where?:
1824
- | {
1825
- status?: 'active' | 'archived' | undefined;
1826
- salesEnabled?: boolean | undefined;
1827
- }
1828
- | undefined;
1829
- query?: string | undefined;
1830
- pagination: {
1831
- offset?: unknown;
1832
- limit?: unknown;
1833
- };
1591
+ };
1592
+ } & {
1593
+ "/operations/warehouses/search": {
1594
+ $post: {
1595
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<{
1596
+ warehouses: {
1597
+ id: number;
1598
+ code: string;
1599
+ name: string;
1600
+ address: string;
1601
+ status: "active" | "archived";
1602
+ salesEnabled: boolean;
1603
+ updatedAt: Date | null;
1604
+ createdAt: Date;
1605
+ }[];
1606
+ total: number;
1607
+ }>;
1608
+ outputFormat: "json";
1609
+ status: 200;
1610
+ input: {
1611
+ json: {
1612
+ where?: {
1613
+ status?: "active" | "archived" | undefined;
1614
+ salesEnabled?: boolean | undefined;
1615
+ } | undefined;
1616
+ query?: string | undefined;
1617
+ pagination: {
1618
+ offset?: unknown;
1619
+ limit?: unknown;
1834
1620
  };
1835
1621
  };
1836
1622
  };
1837
1623
  };
1838
- } & {
1839
- '/operations/warehouses/update': {
1840
- $post: {
1841
- output:
1842
- | import('@kalutskii/foundation').APIError<string>
1843
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1844
- outputFormat: 'json';
1845
- status: 200;
1846
- input: {
1847
- json: {
1848
- code?: string | undefined;
1849
- name?: string | undefined;
1850
- address?: string | undefined;
1851
- salesEnabled?: boolean | undefined;
1852
- warehouseId: number;
1853
- };
1624
+ };
1625
+ } & {
1626
+ "/operations/warehouses/update": {
1627
+ $post: {
1628
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1629
+ outputFormat: "json";
1630
+ status: 200;
1631
+ input: {
1632
+ json: {
1633
+ code?: string | undefined;
1634
+ name?: string | undefined;
1635
+ address?: string | undefined;
1636
+ salesEnabled?: boolean | undefined;
1637
+ warehouseId: number;
1854
1638
  };
1855
1639
  };
1856
1640
  };
1857
- } & {
1858
- '/operations/warehouses/switch-status': {
1859
- $post: {
1860
- output:
1861
- | import('@kalutskii/foundation').APIError<string>
1862
- | import('@kalutskii/foundation').APISuccess<Record<string, never>>;
1863
- outputFormat: 'json';
1864
- status: 200;
1865
- input: {
1866
- json: {
1867
- status: 'active' | 'archived';
1868
- warehouseId: number;
1869
- };
1641
+ };
1642
+ } & {
1643
+ "/operations/warehouses/switch-status": {
1644
+ $post: {
1645
+ output: import("@kalutskii/foundation").APIError<string> | import("@kalutskii/foundation").APISuccess<Record<string, never>>;
1646
+ outputFormat: "json";
1647
+ status: 200;
1648
+ input: {
1649
+ json: {
1650
+ status: "active" | "archived";
1651
+ warehouseId: number;
1870
1652
  };
1871
1653
  };
1872
1654
  };
1873
- },
1874
- '/operations/warehouses',
1875
- '/operations/warehouses/switch-status'
1876
- >;
1655
+ };
1656
+ }, "/operations/warehouses", "/operations/warehouses/switch-status">;
1877
1657
  type WarehousesRouter = typeof warehousesRouter;
1878
1658
  //#endregion
1879
- export type {
1880
- AuditLogsRouter,
1881
- BrandsRouter,
1882
- CategoriesRouter,
1883
- CountriesRouter,
1884
- CustomersRouter,
1885
- DeliveriesRouter,
1886
- ExchangeRatesRouter,
1887
- MeasurementUnitsRouter,
1888
- ProductVariantsRouter,
1889
- ProductsRouter,
1890
- StockBalancesRouter,
1891
- SuppliersRouter,
1892
- WarehousesRouter,
1893
- };
1659
+ export type { AuditLogsRouter, BrandsRouter, CategoriesRouter, CountriesRouter, CustomersRouter, DeliveriesRouter, ExchangeRatesRouter, MeasurementUnitsRouter, ProductVariantsRouter, ProductsRouter, StockBalancesRouter, SuppliersRouter, WarehousesRouter };