@remnawave/backend-contract 2.8.35 → 2.9.1

package/build/backend/commands/users/get-user-subscription-request-history.command.js

@@ -9,7 +9,7 @@ var GetUserSubscriptionRequestHistoryCommand;
     GetUserSubscriptionRequestHistoryCommand.url = api_1.REST_API.USERS.SUBSCRIPTION_REQUEST_HISTORY;
     GetUserSubscriptionRequestHistoryCommand.TSQ_url = GetUserSubscriptionRequestHistoryCommand.url(':uuid');
     GetUserSubscriptionRequestHistoryCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.SUBSCRIPTION_REQUEST_HISTORY(':uuid'), 'get', 'Get user subscription request history, recent 24 records', { scope: 'subscription-request-history', kind: 'read' });
-    GetUserSubscriptionRequestHistoryCommand.RequestSchema = zod_1.z.object({
+    GetUserSubscriptionRequestHistoryCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     GetUserSubscriptionRequestHistoryCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/users/get-users-stream.command.d.ts

@@ -4,16 +4,44 @@ export declare namespace GetUsersStreamCommand {
     const TSQ_url: "/api/users/stream";
     const endpointDetails: import("../../constants").EndpointDetails;
     const RequestQuerySchema: z.ZodObject<{
-        cursor: z.ZodOptional<z.ZodString>;
-        size: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodNumber>;
+        size: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        status: z.ZodOptional<z.ZodNativeEnum<{
+            readonly ACTIVE: "ACTIVE";
+            readonly DISABLED: "DISABLED";
+            readonly LIMITED: "LIMITED";
+            readonly EXPIRED: "EXPIRED";
+        }>>;
+        trafficLimitStrategy: z.ZodOptional<z.ZodNativeEnum<{
+            readonly NO_RESET: "NO_RESET";
+            readonly DAY: "DAY";
+            readonly WEEK: "WEEK";
+            readonly MONTH: "MONTH";
+            readonly MONTH_ROLLING: "MONTH_ROLLING";
+        }>>;
+        telegramId: z.ZodOptional<z.ZodBigInt>;
+        email: z.ZodOptional<z.ZodString>;
+        tag: z.ZodOptional<z.ZodString>;
+        externalSquadUuid: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         size: number;
-        cursor?: string | undefined;
+        status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
+        tag?: string | undefined;
+        trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
+        telegramId?: bigint | undefined;
+        email?: string | undefined;
+        externalSquadUuid?: string | undefined;
+        cursor?: number | undefined;
     }, {
+        status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
+        tag?: string | undefined;
+        trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
+        telegramId?: bigint | undefined;
+        email?: string | undefined;
+        externalSquadUuid?: string | undefined;
         size?: number | undefined;
-        cursor?: string | undefined;
+        cursor?: number | undefined;
     }>;
-    type RequestQuery = z.infer<typeof RequestQuerySchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             users: z.ZodArray<z.ZodObject<{
@@ -316,6 +344,7 @@ export declare namespace GetUsersStreamCommand {
             hasMore: boolean;
         };
     }>;
+    type RequestQuery = z.infer<typeof RequestQuerySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-users-stream.command.d.ts.map

package/build/backend/commands/users/get-users-stream.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-users-stream.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-users-stream.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,qBAAwB,CAAC;IAClC,MAAM,OAAO,qBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;;;;MAe7B,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAEvD,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-users-stream.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-users-stream.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,qBAAwB,CAAC;IAClC,MAAM,OAAO,qBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8B7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASzB,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC9D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/users/get-users-stream.command.js

@@ -9,11 +9,10 @@ var GetUsersStreamCommand;
 (function (GetUsersStreamCommand) {
     GetUsersStreamCommand.url = api_1.REST_API.USERS.STREAM;
     GetUsersStreamCommand.TSQ_url = GetUsersStreamCommand.url;
-    GetUsersStreamCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.STREAM, 'get', 'Get all users using cursor-based (keyset) pagination', { scope: 'stream', kind: 'read' });
+    GetUsersStreamCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.STREAM, 'get', 'Get all users using cursor-based (keyset) pagination with filtering options', { scope: 'stream', kind: 'read' });
     GetUsersStreamCommand.RequestQuerySchema = zod_1.z.object({
-        cursor: zod_1.z
-            .string()
-            .regex(/^\d+$/, 'Cursor must be a positive integer string')
+        cursor: zod_1.z.coerce
+            .number()
             .optional()
             .describe('Cursor for pagination — pass the nextCursor from the previous response. Omit on the first request.'),
         size: zod_1.z.coerce
@@ -22,7 +21,22 @@ var GetUsersStreamCommand;
             .min(1, 'Size (limit) must be greater than 0')
             .max(1000, 'Size (limit) must be less than 1000')
             .describe('Number of results to return, no more than 1000')
+            .optional()
             .default(250),
+        // Filtering
+        status: zod_1.z.nativeEnum(constants_1.USERS_STATUS).optional().describe('Status to filter users by'),
+        trafficLimitStrategy: zod_1.z
+            .nativeEnum(constants_1.RESET_PERIODS)
+            .optional()
+            .describe('Traffic limit strategy to filter users by'),
+        telegramId: zod_1.z.coerce.bigint().optional().describe('Telegram ID to filter users by'),
+        email: zod_1.z.string().email().optional().describe('Email to filter users by'),
+        tag: zod_1.z.string().optional().describe('Tag to filter users by'),
+        externalSquadUuid: zod_1.z
+            .string()
+            .uuid()
+            .optional()
+            .describe('External squad UUID to filter users by'),
     });
     GetUsersStreamCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({

package/build/backend/commands/users/{get-all-users.command.d.ts → get-users.command.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare namespace GetAllUsersCommand {
+export declare namespace GetUsersCommand {
     const url: "/api/users/";
     const TSQ_url: "/api/users/";
     const endpointDetails: import("../../constants").EndpointDetails;
@@ -55,7 +55,6 @@ export declare namespace GetAllUsersCommand {
         globalFilterMode?: string | undefined;
         sorting?: unknown;
     }>;
-    type RequestQuery = z.infer<typeof RequestQuerySchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             users: z.ZodArray<z.ZodObject<{
@@ -353,6 +352,7 @@ export declare namespace GetAllUsersCommand {
             total: number;
         };
     }>;
+    type RequestQuery = z.infer<typeof RequestQuerySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
-//# sourceMappingURL=get-all-users.command.d.ts.map
+//# sourceMappingURL=get-users.command.d.ts.map

package/build/backend/commands/users/get-users.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-users.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-users.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,eAAe,CAAC;IACtB,MAAM,GAAG,eAAqB,CAAC;IAC/B,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAS3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAkC,CAAC;IAE3D,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKzB,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC9D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/users/get-users.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUsersCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const models_1 = require("../../models");
+var GetUsersCommand;
+(function (GetUsersCommand) {
+    GetUsersCommand.url = api_1.REST_API.USERS.GET;
+    GetUsersCommand.TSQ_url = GetUsersCommand.url;
+    GetUsersCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.GET, 'get', 'Get all users using offset-based pagination', {
+        scope: 'list',
+        kind: 'read',
+    }, 'Please note that the filters here are primarily intended for use by the frontend and rely on expensive operators such as LIKE under the hood. Misusing these filters may negatively impact the performance of your database.');
+    GetUsersCommand.RequestQuerySchema = models_1.TanstackQueryRequestQuerySchema;
+    GetUsersCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            users: zod_1.z.array(models_1.ExtendedUsersSchema),
+            total: zod_1.z.number(),
+        }),
+    });
+})(GetUsersCommand || (exports.GetUsersCommand = GetUsersCommand = {}));

package/build/backend/commands/users/index.d.ts

@@ -3,7 +3,7 @@ export * from './bulk';
 export * from './bulk-all';
 export * from './create-user.command';
 export * from './delete-user.command';
-export * from './get-all-users.command';
+export * from './get-users.command';
 export * from './get-by';
 export * from './get-user-accessible-nodes.command';
 export * from './get-user-by-uuid.command';

package/build/backend/commands/users/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/users/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAE3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,UAAU,CAAC;AACzB,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4BAA4B,CAAC;AAE3C,cAAc,iDAAiD,CAAC;AAChE,cAAc,4BAA4B,CAAC;AAE3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/users/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAE3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,UAAU,CAAC;AACzB,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4BAA4B,CAAC;AAE3C,cAAc,iDAAiD,CAAC;AAChE,cAAc,4BAA4B,CAAC;AAE3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC"}

package/build/backend/commands/users/index.js

@@ -19,7 +19,7 @@ __exportStar(require("./bulk"), exports);
 __exportStar(require("./bulk-all"), exports);
 __exportStar(require("./create-user.command"), exports);
 __exportStar(require("./delete-user.command"), exports);
-__exportStar(require("./get-all-users.command"), exports);
+__exportStar(require("./get-users.command"), exports);
 __exportStar(require("./get-by"), exports);
 __exportStar(require("./get-user-accessible-nodes.command"), exports);
 __exportStar(require("./get-user-by-uuid.command"), exports);

package/build/backend/commands/users/resolve-user.command.d.ts

@@ -3,7 +3,7 @@ export declare namespace ResolveUserCommand {
     const url: "/api/users/resolve";
     const TSQ_url: "/api/users/resolve";
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodEffects<z.ZodObject<{
+    const RequestBodySchema: z.ZodEffects<z.ZodObject<{
         uuid: z.ZodOptional<z.ZodString>;
         id: z.ZodOptional<z.ZodNumber>;
         shortUuid: z.ZodOptional<z.ZodString>;
@@ -29,7 +29,6 @@ export declare namespace ResolveUserCommand {
         id?: number | undefined;
         shortUuid?: string | undefined;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -62,6 +61,7 @@ export declare namespace ResolveUserCommand {
             shortUuid: string;
         };
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=resolve-user.command.d.ts.map

package/build/backend/commands/users/resolve-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/resolve-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,sBAAyB,CAAC;IACnC,MAAM,OAAO,sBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;MAiBrB,CAAC;IAEN,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"resolve-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/resolve-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,sBAAyB,CAAC;IACnC,MAAM,OAAO,sBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;MAiBzB,CAAC;IAEC,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/users/resolve-user.command.js

@@ -9,7 +9,7 @@ var ResolveUserCommand;
     ResolveUserCommand.url = api_1.REST_API.USERS.RESOLVE;
     ResolveUserCommand.TSQ_url = ResolveUserCommand.url;
     ResolveUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.RESOLVE, 'post', 'Resolve a user', { scope: 'resolve', kind: 'read' });
-    ResolveUserCommand.RequestSchema = zod_1.z
+    ResolveUserCommand.RequestBodySchema = zod_1.z
         .object({
         uuid: zod_1.z.string().uuid().optional(),
         id: zod_1.z.number().optional(),

package/build/backend/commands/users/tags/{get-all-tags.command.d.ts → get-users-tags.command.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare namespace GetAllTagsCommand {
+export declare namespace GetUsersTagsCommand {
     const url: "/api/users/tags";
     const TSQ_url: "/api/users/tags";
     const endpointDetails: import("../../../constants").EndpointDetails;
@@ -22,4 +22,4 @@ export declare namespace GetAllTagsCommand {
     }>;
     type Response = z.infer<typeof ResponseSchema>;
 }
-//# sourceMappingURL=get-all-tags.command.d.ts.map
+//# sourceMappingURL=get-users-tags.command.d.ts.map

package/build/backend/commands/users/tags/get-users-tags.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-users-tags.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/tags/get-users-tags.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,mBAAmB,CAAC;IAC1B,MAAM,GAAG,mBAA0B,CAAC;IACpC,MAAM,OAAO,mBAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/users/tags/get-users-tags.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetUsersTagsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+var GetUsersTagsCommand;
+(function (GetUsersTagsCommand) {
+    GetUsersTagsCommand.url = api_1.REST_API.USERS.TAGS.GET;
+    GetUsersTagsCommand.TSQ_url = GetUsersTagsCommand.url;
+    GetUsersTagsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.TAGS.GET, 'get', 'Get users tags', { scope: 'list-tags', kind: 'read' });
+    GetUsersTagsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            tags: zod_1.z.array(zod_1.z.string()),
+        }),
+    });
+})(GetUsersTagsCommand || (exports.GetUsersTagsCommand = GetUsersTagsCommand = {}));

package/build/backend/commands/users/tags/index.d.ts

@@ -1,2 +1,2 @@
-export * from './get-all-tags.command';
+export * from './get-users-tags.command';
 //# sourceMappingURL=index.d.ts.map

package/build/backend/commands/users/tags/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../commands/users/tags/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../commands/users/tags/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/build/backend/commands/users/tags/index.js

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./get-all-tags.command"), exports);
+__exportStar(require("./get-users-tags.command"), exports);

package/build/backend/commands/users/update-user.command.d.ts

@@ -3,7 +3,7 @@ export declare namespace UpdateUserCommand {
     const url: "/api/users/";
     const TSQ_url: "/api/users/";
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodEffects<z.ZodObject<{
+    const RequestBodySchema: z.ZodEffects<z.ZodObject<{
         username: z.ZodOptional<z.ZodString>;
         uuid: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodEnum<["ACTIVE", "DISABLED"]>>;
@@ -80,7 +80,6 @@ export declare namespace UpdateUserCommand {
         externalSquadUuid?: string | null | undefined;
         activeInternalSquads?: string[] | undefined;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -293,6 +292,7 @@ export declare namespace UpdateUserCommand {
             lastTriggeredThreshold?: number | undefined;
         };
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=update-user.command.d.ts.map

package/build/backend/commands/users/update-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/update-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,eAAwB,CAAC;IAClC,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6EpB,CAAC;IAEP,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"update-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/update-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,eAAwB,CAAC;IAClC,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6ExB,CAAC;IAEA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAqB,CAAC;IAEjD,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/users/update-user.command.js

@@ -5,12 +5,13 @@ const zod_1 = require("zod");
 const api_1 = require("../../api");
 const constants_1 = require("../../constants");
 const models_1 = require("../../models");
+const user_response_1 = require("./user.response");
 var UpdateUserCommand;
 (function (UpdateUserCommand) {
     UpdateUserCommand.url = api_1.REST_API.USERS.UPDATE;
     UpdateUserCommand.TSQ_url = UpdateUserCommand.url;
     UpdateUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.UPDATE, 'patch', 'Update a user by UUID or username', { scope: 'update', kind: 'write' });
-    UpdateUserCommand.RequestSchema = zod_1.z
+    UpdateUserCommand.RequestBodySchema = zod_1.z
         .object({
         username: zod_1.z.optional(zod_1.z.string().describe('Username of the user')),
         uuid: zod_1.z.optional(zod_1.z
@@ -75,7 +76,5 @@ var UpdateUserCommand;
         .refine((data) => data.uuid || data.username, {
         message: 'Either uuid or username must be provided',
     });
-    UpdateUserCommand.ResponseSchema = zod_1.z.object({
-        response: models_1.ExtendedUsersSchema,
-    });
+    UpdateUserCommand.ResponseSchema = user_response_1.UserResponseSchema;
 })(UpdateUserCommand || (exports.UpdateUserCommand = UpdateUserCommand = {}));

package/build/backend/commands/users/user.response.d.ts

@@ -0,0 +1,214 @@
+import z from 'zod';
+export declare const UserResponseSchema: z.ZodObject<{
+    response: z.ZodObject<{
+        uuid: z.ZodString;
+        id: z.ZodNumber;
+        shortUuid: z.ZodString;
+        username: z.ZodString;
+        status: z.ZodDefault<z.ZodNativeEnum<{
+            readonly ACTIVE: "ACTIVE";
+            readonly DISABLED: "DISABLED";
+            readonly LIMITED: "LIMITED";
+            readonly EXPIRED: "EXPIRED";
+        }>>;
+        trafficLimitBytes: z.ZodDefault<z.ZodNumber>;
+        trafficLimitStrategy: z.ZodDefault<z.ZodNativeEnum<{
+            readonly NO_RESET: "NO_RESET";
+            readonly DAY: "DAY";
+            readonly WEEK: "WEEK";
+            readonly MONTH: "MONTH";
+            readonly MONTH_ROLLING: "MONTH_ROLLING";
+        }>>;
+        expireAt: z.ZodEffects<z.ZodString, Date, string>;
+        telegramId: z.ZodNullable<z.ZodNumber>;
+        email: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        tag: z.ZodNullable<z.ZodString>;
+        hwidDeviceLimit: z.ZodNullable<z.ZodNumber>;
+        externalSquadUuid: z.ZodNullable<z.ZodString>;
+        trojanPassword: z.ZodString;
+        vlessUuid: z.ZodString;
+        ssPassword: z.ZodString;
+        lastTriggeredThreshold: z.ZodDefault<z.ZodNumber>;
+        subRevokedAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
+        lastTrafficResetAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
+        createdAt: z.ZodEffects<z.ZodString, Date, string>;
+        updatedAt: z.ZodEffects<z.ZodString, Date, string>;
+    } & {
+        subscriptionUrl: z.ZodString;
+        activeInternalSquads: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            name: string;
+        }, {
+            uuid: string;
+            name: string;
+        }>, "many">;
+        userTraffic: z.ZodObject<{
+            usedTrafficBytes: z.ZodNumber;
+            lifetimeUsedTrafficBytes: z.ZodNumber;
+            onlineAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
+            firstConnectedAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
+            lastConnectedNodeUuid: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            usedTrafficBytes: number;
+            lifetimeUsedTrafficBytes: number;
+            onlineAt: Date | null;
+            firstConnectedAt: Date | null;
+            lastConnectedNodeUuid: string | null;
+        }, {
+            usedTrafficBytes: number;
+            lifetimeUsedTrafficBytes: number;
+            onlineAt: string | null;
+            firstConnectedAt: string | null;
+            lastConnectedNodeUuid: string | null;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
+        uuid: string;
+        expireAt: Date;
+        createdAt: Date;
+        updatedAt: Date;
+        description: string | null;
+        username: string;
+        tag: string | null;
+        id: number;
+        shortUuid: string;
+        trafficLimitBytes: number;
+        trafficLimitStrategy: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING";
+        telegramId: number | null;
+        email: string | null;
+        hwidDeviceLimit: number | null;
+        externalSquadUuid: string | null;
+        trojanPassword: string;
+        vlessUuid: string;
+        ssPassword: string;
+        lastTriggeredThreshold: number;
+        subRevokedAt: Date | null;
+        lastTrafficResetAt: Date | null;
+        subscriptionUrl: string;
+        activeInternalSquads: {
+            uuid: string;
+            name: string;
+        }[];
+        userTraffic: {
+            usedTrafficBytes: number;
+            lifetimeUsedTrafficBytes: number;
+            onlineAt: Date | null;
+            firstConnectedAt: Date | null;
+            lastConnectedNodeUuid: string | null;
+        };
+    }, {
+        uuid: string;
+        expireAt: string;
+        createdAt: string;
+        updatedAt: string;
+        description: string | null;
+        username: string;
+        tag: string | null;
+        id: number;
+        shortUuid: string;
+        telegramId: number | null;
+        email: string | null;
+        hwidDeviceLimit: number | null;
+        externalSquadUuid: string | null;
+        trojanPassword: string;
+        vlessUuid: string;
+        ssPassword: string;
+        subRevokedAt: string | null;
+        lastTrafficResetAt: string | null;
+        subscriptionUrl: string;
+        activeInternalSquads: {
+            uuid: string;
+            name: string;
+        }[];
+        userTraffic: {
+            usedTrafficBytes: number;
+            lifetimeUsedTrafficBytes: number;
+            onlineAt: string | null;
+            firstConnectedAt: string | null;
+            lastConnectedNodeUuid: string | null;
+        };
+        status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
+        trafficLimitBytes?: number | undefined;
+        trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
+        lastTriggeredThreshold?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    response: {
+        status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
+        uuid: string;
+        expireAt: Date;
+        createdAt: Date;
+        updatedAt: Date;
+        description: string | null;
+        username: string;
+        tag: string | null;
+        id: number;
+        shortUuid: string;
+        trafficLimitBytes: number;
+        trafficLimitStrategy: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING";
+        telegramId: number | null;
+        email: string | null;
+        hwidDeviceLimit: number | null;
+        externalSquadUuid: string | null;
+        trojanPassword: string;
+        vlessUuid: string;
+        ssPassword: string;
+        lastTriggeredThreshold: number;
+        subRevokedAt: Date | null;
+        lastTrafficResetAt: Date | null;
+        subscriptionUrl: string;
+        activeInternalSquads: {
+            uuid: string;
+            name: string;
+        }[];
+        userTraffic: {
+            usedTrafficBytes: number;
+            lifetimeUsedTrafficBytes: number;
+            onlineAt: Date | null;
+            firstConnectedAt: Date | null;
+            lastConnectedNodeUuid: string | null;
+        };
+    };
+}, {
+    response: {
+        uuid: string;
+        expireAt: string;
+        createdAt: string;
+        updatedAt: string;
+        description: string | null;
+        username: string;
+        tag: string | null;
+        id: number;
+        shortUuid: string;
+        telegramId: number | null;
+        email: string | null;
+        hwidDeviceLimit: number | null;
+        externalSquadUuid: string | null;
+        trojanPassword: string;
+        vlessUuid: string;
+        ssPassword: string;
+        subRevokedAt: string | null;
+        lastTrafficResetAt: string | null;
+        subscriptionUrl: string;
+        activeInternalSquads: {
+            uuid: string;
+            name: string;
+        }[];
+        userTraffic: {
+            usedTrafficBytes: number;
+            lifetimeUsedTrafficBytes: number;
+            onlineAt: string | null;
+            firstConnectedAt: string | null;
+            lastConnectedNodeUuid: string | null;
+        };
+        status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
+        trafficLimitBytes?: number | undefined;
+        trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
+        lastTriggeredThreshold?: number | undefined;
+    };
+}>;
+//# sourceMappingURL=user.response.d.ts.map

package/build/backend/commands/users/user.response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.response.d.ts","sourceRoot":"","sources":["../../../../commands/users/user.response.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7B,CAAC"}

package/build/backend/commands/users/user.response.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserResponseSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const extended_users_schema_1 = require("../../models/extended-users.schema");
+exports.UserResponseSchema = zod_1.default.object({
+    response: extended_users_schema_1.ExtendedUsersSchema,
+});

package/build/backend/models/users.schema.js

@@ -19,7 +19,7 @@ exports.UsersSchema = zod_1.z.object({
         .string()
         .datetime()
         .transform((str) => new Date(str)),
-    telegramId: zod_1.z.nullable(zod_1.z.number().int()),
+    telegramId: zod_1.z.nullable(zod_1.z.number()),
     email: zod_1.z.nullable(zod_1.z.string().email()),
     description: zod_1.z.nullable(zod_1.z.string()),
     tag: zod_1.z.nullable(zod_1.z.string()),

package/build/frontend/api/routes.js

@@ -112,10 +112,6 @@ exports.REST_API = {
             ID: (id) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.ID(id)}`,
             SHORT_UUID: (shortUuid) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.SHORT_UUID(shortUuid)}`,
             USERNAME: (username) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.USERNAME(username)}`,
-            SUBSCRIPTION_UUID: (subscriptionUuid) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.SUBSCRIPTION_UUID(subscriptionUuid)}`,
-            TELEGRAM_ID: (telegramId) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.TELEGRAM_ID(telegramId)}`,
-            EMAIL: (email) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.EMAIL(email)}`,
-            TAG: (tag) => `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.GET_BY.TAG(tag)}`,
         },
         RESOLVE: `${exports.ROOT}/${CONTROLLERS.USERS_CONTROLLER}/${CONTROLLERS.USERS_ROUTES.RESOLVE}`,
         BULK: {

package/build/frontend/commands/api-tokens/create.command.js

@@ -10,10 +10,10 @@ var CreateApiTokenCommand;
     CreateApiTokenCommand.url = api_1.REST_API.API_TOKENS.CREATE;
     CreateApiTokenCommand.TSQ_url = CreateApiTokenCommand.url;
     CreateApiTokenCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.API_TOKENS_ROUTES.CREATE, 'post', 'Create a new API token', { scope: 'create', kind: 'write' }, 'This endpoint is forbidden to use via "API-key". It can only be used with an admin JWT-token.');
-    CreateApiTokenCommand.RequestSchema = zod_1.z.object({
-        name: zod_1.z.string().min(2).max(30),
-        expiresInDays: zod_1.z.number().min(1),
-        scopes: zod_1.z.array(zod_1.z.string()).optional().default(['*']),
+    CreateApiTokenCommand.RequestBodySchema = zod_1.z.object({
+        name: zod_1.z.string().min(2).max(30).describe('Name of the API token'),
+        expiresInDays: zod_1.z.number().min(1).describe('Expiration days of the API token'),
+        scopes: zod_1.z.array(zod_1.z.string()).optional().default(['*']).describe('Scopes of the API token'),
     });
     CreateApiTokenCommand.ResponseSchema = zod_1.z.object({
         response: api_tokens_schema_1.ApiTokensSchema.extend({

package/build/frontend/commands/api-tokens/delete.command.js

@@ -8,11 +8,8 @@ var DeleteApiTokenCommand;
 (function (DeleteApiTokenCommand) {
     DeleteApiTokenCommand.url = api_1.REST_API.API_TOKENS.DELETE;
     DeleteApiTokenCommand.TSQ_url = DeleteApiTokenCommand.url(':uuid');
-    DeleteApiTokenCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.API_TOKENS_ROUTES.DELETE(':uuid'), 'delete', 'Delete an API token by UUID', { scope: 'delete', kind: 'write' }, 'This endpoint is forbidden to use via "API-key". It can be used only with an admin JWT-token.');
-    DeleteApiTokenCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    DeleteApiTokenCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.boolean(),
+    DeleteApiTokenCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.API_TOKENS_ROUTES.DELETE(':uuid'), 'delete', 'Delete API token', { scope: 'delete', kind: 'write' }, 'This endpoint is forbidden to use via "API-key". It can be used only with an admin JWT-token.');
+    DeleteApiTokenCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the API token'),
     });
 })(DeleteApiTokenCommand || (exports.DeleteApiTokenCommand = DeleteApiTokenCommand = {}));