@remnawave/backend-contract 2.8.34 → 2.9.0

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

@@ -3,14 +3,13 @@ export declare namespace DeleteUserCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             isDeleted: z.ZodBoolean;
@@ -28,6 +27,7 @@ export declare namespace DeleteUserCommand {
             isDeleted: boolean;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=delete-user.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"delete-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/delete-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,0BAAwB,CAAC;IAClC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"delete-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/delete-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,0BAAwB,CAAC;IAClC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,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/delete-user.command.js

@@ -9,7 +9,7 @@ var DeleteUserCommand;
     DeleteUserCommand.url = api_1.REST_API.USERS.DELETE;
     DeleteUserCommand.TSQ_url = DeleteUserCommand.url(':uuid');
     DeleteUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.DELETE(':uuid'), 'delete', 'Delete user', { scope: 'delete', kind: 'write' });
-    DeleteUserCommand.RequestSchema = zod_1.z.object({
+    DeleteUserCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     DeleteUserCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/users/get-by/get-user-by-id.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace GetUserByIdCommand {
     const url: (id: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         id: z.ZodBigInt;
     }, "strip", z.ZodTypeAny, {
         id: bigint;
     }, {
         id: bigint;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -223,6 +222,7 @@ export declare namespace GetUserByIdCommand {
             lastTriggeredThreshold?: number | undefined;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-user-by-id.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-user-by-id.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/get-user-by-id.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,wBAA2B,CAAC;IACrC,MAAM,OAAO,QAAa,CAAC;IAE3B,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,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":"get-user-by-id.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/get-user-by-id.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,wBAA2B,CAAC;IACrC,MAAM,OAAO,QAAa,CAAC;IAE3B,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,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-by/get-user-by-id.command.js

@@ -10,7 +10,7 @@ var GetUserByIdCommand;
     GetUserByIdCommand.url = api_1.REST_API.USERS.GET_BY.ID;
     GetUserByIdCommand.TSQ_url = GetUserByIdCommand.url(':id');
     GetUserByIdCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.GET_BY.ID(':id'), 'get', 'Get user by ID', { scope: 'by-id', kind: 'read' });
-    GetUserByIdCommand.RequestSchema = zod_1.z.object({
+    GetUserByIdCommand.RequestParamSchema = zod_1.z.object({
         id: zod_1.z.coerce.bigint(),
     });
     GetUserByIdCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/users/get-by/get-user-by-short-uuid.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace GetUserByShortUuidCommand {
     const url: (shortUuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         shortUuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         shortUuid: string;
     }, {
         shortUuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -223,6 +222,7 @@ export declare namespace GetUserByShortUuidCommand {
             lastTriggeredThreshold?: number | undefined;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-user-by-short-uuid.command.d.ts.map

package/build/backend/commands/users/get-by/get-user-by-short-uuid.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-user-by-short-uuid.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/get-user-by-short-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,GAAG,+BAAmC,CAAC;IAC7C,MAAM,OAAO,QAAoB,CAAC;IAElC,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,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":"get-user-by-short-uuid.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/get-user-by-short-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,GAAG,+BAAmC,CAAC;IAC7C,MAAM,OAAO,QAAoB,CAAC;IAElC,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,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-by/get-user-by-short-uuid.command.js

@@ -10,7 +10,7 @@ var GetUserByShortUuidCommand;
     GetUserByShortUuidCommand.url = api_1.REST_API.USERS.GET_BY.SHORT_UUID;
     GetUserByShortUuidCommand.TSQ_url = GetUserByShortUuidCommand.url(':shortUuid');
     GetUserByShortUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.GET_BY.SHORT_UUID(':shortUuid'), 'get', 'Get user by Short UUID', { scope: 'by-short-uuid', kind: 'read' });
-    GetUserByShortUuidCommand.RequestSchema = zod_1.z.object({
+    GetUserByShortUuidCommand.RequestParamSchema = zod_1.z.object({
         shortUuid: zod_1.z.string(),
     });
     GetUserByShortUuidCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/users/get-by/get-user-by-username.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace GetUserByUsernameCommand {
     const url: (username: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         username: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         username: string;
     }, {
         username: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -223,6 +222,7 @@ export declare namespace GetUserByUsernameCommand {
             lastTriggeredThreshold?: number | undefined;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-user-by-username.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-user-by-username.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/get-user-by-username.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,GAAG,8BAAiC,CAAC;IAC3C,MAAM,OAAO,QAAmB,CAAC;IAEjC,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,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":"get-user-by-username.command.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/get-user-by-username.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,GAAG,8BAAiC,CAAC;IAC3C,MAAM,OAAO,QAAmB,CAAC;IAEjC,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,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-by/get-user-by-username.command.js

@@ -10,7 +10,7 @@ var GetUserByUsernameCommand;
     GetUserByUsernameCommand.url = api_1.REST_API.USERS.GET_BY.USERNAME;
     GetUserByUsernameCommand.TSQ_url = GetUserByUsernameCommand.url(':username');
     GetUserByUsernameCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.GET_BY.USERNAME(':username'), 'get', 'Get user by username', { scope: 'by-username', kind: 'read' });
-    GetUserByUsernameCommand.RequestSchema = zod_1.z.object({
+    GetUserByUsernameCommand.RequestParamSchema = zod_1.z.object({
         username: zod_1.z.string(),
     });
     GetUserByUsernameCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/users/get-by/index.d.ts

@@ -1,7 +1,4 @@
-export * from './get-user-by-email.command';
 export * from './get-user-by-id.command';
 export * from './get-user-by-short-uuid.command';
-export * from './get-user-by-tag.command';
-export * from './get-user-by-telegram-id.command';
 export * from './get-user-by-username.command';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../commands/users/get-by/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC"}

package/build/backend/commands/users/get-by/index.js

@@ -14,9 +14,6 @@ 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-user-by-email.command"), exports);
 __exportStar(require("./get-user-by-id.command"), exports);
 __exportStar(require("./get-user-by-short-uuid.command"), exports);
-__exportStar(require("./get-user-by-tag.command"), exports);
-__exportStar(require("./get-user-by-telegram-id.command"), exports);
 __exportStar(require("./get-user-by-username.command"), exports);

package/build/backend/commands/users/get-user-accessible-nodes.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace GetUserAccessibleNodesCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             userUuid: z.ZodString;
@@ -109,6 +108,7 @@ export declare namespace GetUserAccessibleNodesCommand {
             }[];
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-user-accessible-nodes.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-user-accessible-nodes.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-user-accessible-nodes.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,0BAAkC,CAAC;IAC5C,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-user-accessible-nodes.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-user-accessible-nodes.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,0BAAkC,CAAC;IAC5C,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmBzB,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-user-accessible-nodes.command.js

@@ -9,7 +9,7 @@ var GetUserAccessibleNodesCommand;
     GetUserAccessibleNodesCommand.url = api_1.REST_API.USERS.ACCESSIBLE_NODES;
     GetUserAccessibleNodesCommand.TSQ_url = GetUserAccessibleNodesCommand.url(':uuid');
     GetUserAccessibleNodesCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.ACCESSIBLE_NODES(':uuid'), 'get', 'Get user accessible nodes', { scope: 'accessible-nodes', kind: 'read' });
-    GetUserAccessibleNodesCommand.RequestSchema = zod_1.z.object({
+    GetUserAccessibleNodesCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     GetUserAccessibleNodesCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/users/get-user-by-uuid.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace GetUserByUuidCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -223,6 +222,7 @@ export declare namespace GetUserByUuidCommand {
             lastTriggeredThreshold?: number | undefined;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-user-by-uuid.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-user-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-user-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,oBAAoB,CAAC;IAC3B,MAAM,GAAG,0BAA6B,CAAC;IACvC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,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":"get-user-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-user-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,oBAAoB,CAAC;IAC3B,MAAM,GAAG,0BAA6B,CAAC;IACvC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,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-user-by-uuid.command.js

@@ -10,7 +10,7 @@ var GetUserByUuidCommand;
     GetUserByUuidCommand.url = api_1.REST_API.USERS.GET_BY_UUID;
     GetUserByUuidCommand.TSQ_url = GetUserByUuidCommand.url(':uuid');
     GetUserByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.GET_BY_UUID(':uuid'), 'get', 'Get user by UUID', { scope: 'by-uuid', kind: 'read' });
-    GetUserByUuidCommand.RequestSchema = zod_1.z.object({
+    GetUserByUuidCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     GetUserByUuidCommand.ResponseSchema = zod_1.z.object({

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

@@ -3,14 +3,13 @@ export declare namespace GetUserSubscriptionRequestHistoryCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             total: z.ZodNumber;
@@ -75,6 +74,7 @@ export declare namespace GetUserSubscriptionRequestHistoryCommand {
             }[];
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-user-subscription-request-history.command.d.ts.map

package/build/backend/commands/users/get-user-subscription-request-history.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-user-subscription-request-history.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-user-subscription-request-history.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,wCAAwC,CAAC;IAC/C,MAAM,GAAG,0BAA8C,CAAC;IACxD,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-user-subscription-request-history.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/get-user-subscription-request-history.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,wCAAwC,CAAC;IAC/C,MAAM,GAAG,0BAA8C,CAAC;IACxD,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBzB,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-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);