@esb-market-contracts/backend 1.0.58 → 1.0.60

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 +1663 -1429
  2. package/config.d.ts +5 -5
  3. package/config.js +9 -10
  4. package/constants.d.ts +2 -2
  5. package/constants.js +2 -4
  6. package/enums.d.ts +30 -17
  7. package/enums.js +23 -23
  8. package/package.json +1 -1
  9. package/types.d.ts +2181 -1258
package/api.d.ts CHANGED
@@ -1,1186 +1,1328 @@
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";
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';
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
- 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[];
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
+ };
41
48
  };
42
49
  };
43
50
  };
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;
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
+ };
59
68
  };
60
69
  };
61
70
  };
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;
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
+ };
91
104
  };
92
105
  };
93
106
  };
94
107
  };
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;
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
+ };
111
126
  };
112
127
  };
113
128
  };
114
- };
115
- }, "/catalog/brands", "/catalog/brands/update">;
129
+ },
130
+ '/catalog/brands',
131
+ '/catalog/brands/update'
132
+ >;
116
133
  type BrandsRouter = typeof brandsRouter;
117
134
  //#endregion
118
135
  //#region src/app/routes/(catalog)/categories.routes.d.ts
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[];
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
+ };
144
168
  };
145
169
  };
146
170
  };
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>>;
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
+ };
159
185
  };
160
186
  };
161
187
  };
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;
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
+ };
190
220
  };
191
221
  };
192
222
  };
193
223
  };
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;
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
+ };
208
240
  };
209
241
  };
210
242
  };
211
- };
212
- }, "/catalog/categories", "/catalog/categories/update">;
243
+ },
244
+ '/catalog/categories',
245
+ '/catalog/categories/update'
246
+ >;
213
247
  type CategoriesRouter = typeof categoriesRouter;
214
248
  //#endregion
215
249
  //#region src/app/routes/(catalog)/countries.routes.d.ts
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[];
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
+ };
236
275
  };
237
276
  };
238
277
  };
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;
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
+ };
251
292
  };
252
293
  };
253
294
  };
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;
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
+ };
280
325
  };
281
326
  };
282
327
  };
283
328
  };
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;
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
+ };
297
344
  };
298
345
  };
299
346
  };
300
- };
301
- }, "/catalog/countries", "/catalog/countries/update">;
347
+ },
348
+ '/catalog/countries',
349
+ '/catalog/countries/update'
350
+ >;
302
351
  type CountriesRouter = typeof countriesRouter;
303
352
  //#endregion
304
353
  //#region src/app/routes/(catalog)/measurement-units.routes.d.ts
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: {};
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
+ };
321
375
  };
322
- };
323
- }, "/catalog/measurement-units", "/catalog/measurement-units/list">;
376
+ },
377
+ '/catalog/measurement-units',
378
+ '/catalog/measurement-units/list'
379
+ >;
324
380
  type MeasurementUnitsRouter = typeof measurementUnitsRouter;
325
381
  //#endregion
326
382
  //#region src/app/routes/(catalog)/product-variants.routes.d.ts
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[];
351
- };
352
- };
353
- };
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[];
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
+ };
383
412
  };
384
413
  };
385
414
  };
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: {
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: {
410
438
  productId: number;
411
439
  measurementUnitId?: number | null | undefined;
412
- status?: "active" | "archived" | "draft" | 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[];
413
445
  };
414
- query?: string | undefined;
415
- pagination: {
416
- offset?: unknown;
417
- limit?: unknown;
446
+ };
447
+ };
448
+ };
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
+ };
418
483
  };
419
484
  };
420
485
  };
421
486
  };
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;
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
+ };
438
505
  };
439
506
  };
440
507
  };
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;
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
+ };
451
520
  };
452
521
  };
453
522
  };
454
- };
455
- }, "/catalog/product-variants", "/catalog/product-variants/delete">;
523
+ },
524
+ '/catalog/product-variants',
525
+ '/catalog/product-variants/delete'
526
+ >;
456
527
  type ProductVariantsRouter = typeof productVariantsRouter;
457
528
  //#endregion
458
529
  //#region src/app/routes/(catalog)/products.routes.d.ts
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[];
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
+ };
492
570
  };
493
571
  };
494
572
  };
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;
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
+ };
531
614
  };
532
615
  };
533
616
  };
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;
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
+ };
571
658
  };
572
659
  };
573
660
  };
574
661
  };
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;
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
+ };
595
687
  };
596
688
  };
597
689
  };
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;
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
+ };
608
702
  };
609
703
  };
610
704
  };
611
- };
612
- }, "/catalog/products", "/catalog/products/delete">;
705
+ },
706
+ '/catalog/products',
707
+ '/catalog/products/delete'
708
+ >;
613
709
  type ProductsRouter = typeof productsRouter;
614
710
  //#endregion
615
711
  //#region src/app/routes/(finance)/exchange-rates.routes.d.ts
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: {};
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
+ };
638
739
  };
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;
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
+ };
658
763
  };
659
764
  };
660
765
  };
661
766
  };
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;
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
+ };
686
795
  };
687
796
  };
688
797
  };
689
798
  };
690
- };
691
- }, "/finance/exchange-rates", "/finance/exchange-rates/search">;
799
+ },
800
+ '/finance/exchange-rates',
801
+ '/finance/exchange-rates/search'
802
+ >;
692
803
  type ExchangeRatesRouter = typeof exchangeRatesRouter;
693
804
  //#endregion
694
805
  //#region src/app/routes/(procurement)/deliveries.routes.d.ts
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
- }[];
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
+ };
752
875
  };
753
- }>;
754
- outputFormat: "json";
755
- status: 200;
756
- input: {
757
- query: {
758
- id: string | string[];
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
+ };
759
946
  };
760
947
  };
761
948
  };
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;
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;
800
992
  };
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;
993
+ };
828
994
  };
829
995
  };
830
996
  };
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?: {
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: {
860
1007
  supplierId?: number | undefined;
861
1008
  warehouseId?: number | undefined;
862
1009
  currencyId?: number | undefined;
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;
1010
+ exchangeRateId?: number | null | undefined;
1011
+ deliveryId: number;
871
1012
  };
872
1013
  };
873
1014
  };
874
1015
  };
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;
889
- };
890
- };
891
- };
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;
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
+ };
902
1028
  };
903
1029
  };
904
1030
  };
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;
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
+ };
915
1043
  };
916
1044
  };
917
1045
  };
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;
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;
955
1101
  };
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;
972
1102
  };
973
1103
  };
974
1104
  };
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;
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;
1053
1204
  };
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;
1069
1205
  };
1070
1206
  };
1071
1207
  };
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;
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;
1109
1263
  };
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;
1126
1264
  };
1127
1265
  };
1128
1266
  };
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[];
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;
1160
1318
  };
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;
1179
1319
  };
1180
1320
  };
1181
1321
  };
1182
- };
1183
- }, "/operations/deliveries", "/operations/deliveries/item/delete">;
1322
+ },
1323
+ '/operations/deliveries',
1324
+ '/operations/deliveries/item/delete'
1325
+ >;
1184
1326
  type DeliveriesRouter = typeof deliveriesRouter;
1185
1327
  //#endregion
1186
1328
  //#region src/app/flows/(audit)/audit/audit.enums.d.ts
@@ -1188,13 +1330,20 @@ declare const auditLogSourcesArray: readonly ['admin', 'backend'];
1188
1330
  type AuditLogSource = (typeof auditLogSourcesArray)[number];
1189
1331
  //#endregion
1190
1332
  //#region src/app/domain/(audit)/audit-logs/audit-logs.schemas.d.ts
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>;
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
+ >;
1198
1347
  //#endregion
1199
1348
  //#region src/app/flows/(audit)/audit/audit.schemas.d.ts
1200
1349
  type AuditLogResult = z.infer<typeof auditLogSchema> & {
@@ -1202,458 +1351,543 @@ type AuditLogResult = z.infer<typeof auditLogSchema> & {
1202
1351
  };
1203
1352
  //#endregion
1204
1353
  //#region src/app/routes/(audit)/audit-logs.routes.d.ts
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: {};
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
+ };
1216
1370
  };
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";
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
+ };
1230
1386
  };
1231
1387
  };
1232
1388
  };
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;
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
+ };
1253
1413
  };
1254
1414
  };
1255
1415
  };
1256
1416
  };
1257
- };
1258
- }, "/operations/audit-logs", "/operations/audit-logs/search">;
1417
+ },
1418
+ '/operations/audit-logs',
1419
+ '/operations/audit-logs/search'
1420
+ >;
1259
1421
  type AuditLogsRouter = typeof auditLogsRouter;
1260
1422
  //#endregion
1261
1423
  //#region src/app/routes/(sales)/customers.routes.d.ts
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[];
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
+ };
1285
1452
  };
1286
1453
  };
1287
1454
  };
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;
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
+ };
1303
1472
  };
1304
1473
  };
1305
1474
  };
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;
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
+ };
1335
1508
  };
1336
1509
  };
1337
1510
  };
1338
1511
  };
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;
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
+ };
1354
1529
  };
1355
1530
  };
1356
1531
  };
1357
- };
1358
- }, "/operations/customers", "/operations/customers/update">;
1532
+ },
1533
+ '/operations/customers',
1534
+ '/operations/customers/update'
1535
+ >;
1359
1536
  type CustomersRouter = typeof customersRouter;
1360
1537
  //#endregion
1361
1538
  //#region src/app/routes/(procurement)/suppliers.routes.d.ts
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[];
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
+ };
1387
1569
  };
1388
1570
  };
1389
1571
  };
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;
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
+ };
1406
1590
  };
1407
1591
  };
1408
1592
  };
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;
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
+ };
1441
1629
  };
1442
1630
  };
1443
1631
  };
1444
1632
  };
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;
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
+ };
1462
1652
  };
1463
1653
  };
1464
1654
  };
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;
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
+ };
1476
1668
  };
1477
1669
  };
1478
1670
  };
1479
- };
1480
- }, "/operations/suppliers", "/operations/suppliers/switch-status">;
1671
+ },
1672
+ '/operations/suppliers',
1673
+ '/operations/suppliers/switch-status'
1674
+ >;
1481
1675
  type SuppliersRouter = typeof suppliersRouter;
1482
1676
  //#endregion
1483
1677
  //#region src/app/routes/(warehouse)/stock-balances.routes.d.ts
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;
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
+ };
1541
1742
  };
1542
1743
  };
1543
1744
  };
1544
1745
  };
1545
- };
1546
- }, "/operations/stock-balances", "/operations/stock-balances/search">;
1746
+ },
1747
+ '/operations/stock-balances',
1748
+ '/operations/stock-balances/search'
1749
+ >;
1547
1750
  type StockBalancesRouter = typeof stockBalancesRouter;
1548
1751
  //#endregion
1549
1752
  //#region src/app/routes/(warehouse)/warehouses.routes.d.ts
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[];
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
+ };
1572
1780
  };
1573
1781
  };
1574
1782
  };
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;
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
+ };
1588
1798
  };
1589
1799
  };
1590
1800
  };
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;
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
+ };
1620
1834
  };
1621
1835
  };
1622
1836
  };
1623
1837
  };
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;
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
+ };
1638
1854
  };
1639
1855
  };
1640
1856
  };
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;
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
+ };
1652
1870
  };
1653
1871
  };
1654
1872
  };
1655
- };
1656
- }, "/operations/warehouses", "/operations/warehouses/switch-status">;
1873
+ },
1874
+ '/operations/warehouses',
1875
+ '/operations/warehouses/switch-status'
1876
+ >;
1657
1877
  type WarehousesRouter = typeof warehousesRouter;
1658
1878
  //#endregion
1659
- export type { AuditLogsRouter, BrandsRouter, CategoriesRouter, CountriesRouter, CustomersRouter, DeliveriesRouter, ExchangeRatesRouter, MeasurementUnitsRouter, ProductVariantsRouter, ProductsRouter, StockBalancesRouter, SuppliersRouter, WarehousesRouter };
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
+ };