@remnawave/backend-contract 2.8.34 → 2.9.0

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,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/update-user.command.js

@@ -10,7 +10,7 @@ var 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

package/build/backend/models/response-rules/response-rule-modifications.schema.d.ts

@@ -36,6 +36,7 @@ export declare const ResponseRuleModificationsSchema: z.ZodOptional<z.ZodObject<
         key: string;
         method: "age1" | "age1pq1";
     }>>;
+    excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     headers?: {
         value: string;
@@ -51,6 +52,7 @@ export declare const ResponseRuleModificationsSchema: z.ZodOptional<z.ZodObject<
         key: string;
         method: "age1" | "age1pq1";
     } | undefined;
+    excludeHostsByTags?: string[] | undefined;
 }, {
     headers?: {
         value: string;
@@ -66,5 +68,6 @@ export declare const ResponseRuleModificationsSchema: z.ZodOptional<z.ZodObject<
         key: string;
         method: "age1" | "age1pq1";
     } | undefined;
+    excludeHostsByTags?: string[] | undefined;
 }>>;
 //# sourceMappingURL=response-rule-modifications.schema.d.ts.map

package/build/backend/models/response-rules/response-rule-modifications.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rule-modifications.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-modifications.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,4BAA4B;;;;;;;;;EAGvC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4IvC,CAAC"}
+{"version":3,"file":"response-rule-modifications.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-modifications.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,4BAA4B;;;;;;;;;EAGvC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8JvC,CAAC"}

package/build/backend/models/response-rules/response-rule-modifications.schema.js

@@ -96,6 +96,16 @@ exports.ResponseRuleModificationsSchema = zod_1.default
     encryption: exports.ResponseRuleEncryptionSchema.optional().describe(JSON.stringify({
         markdownDescription: 'Encrypt response body with given parameters. Generate keypairs with Rescue CLI: `docker exec -it remnawave cli`, select "Generate keypairs".',
     })),
+    excludeHostsByTags: zod_1.default
+        .array(zod_1.default
+        .string()
+        .regex(/^[A-Z0-9_:]+$/, 'Tag can only contain uppercase letters, numbers, underscores and colons')
+        .max(36, 'Each tag must be less than 36 characters'))
+        .min(1)
+        .optional()
+        .describe(JSON.stringify({
+        markdownDescription: 'Excludes hosts from the subscription output if at least one tag in the host matches the given tags.',
+    })),
 })
     .optional()
     .describe(JSON.stringify({

package/build/backend/models/response-rules/response-rule.schema.d.ts

@@ -74,6 +74,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         }>>;
+        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         headers?: {
             value: string;
@@ -89,6 +90,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     }, {
         headers?: {
             value: string;
@@ -104,6 +106,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -132,6 +135,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     } | undefined;
 }, {
     name: string;
@@ -160,6 +164,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     } | undefined;
 }>;
 export declare const ResponseRuleSchema: z.ZodObject<{
@@ -237,6 +242,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         }>>;
+        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         headers?: {
             value: string;
@@ -252,6 +258,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     }, {
         headers?: {
             value: string;
@@ -267,6 +274,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -295,6 +303,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     } | undefined;
 }, {
     name: string;
@@ -323,6 +332,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             key: string;
             method: "age1" | "age1pq1";
         } | undefined;
+        excludeHostsByTags?: string[] | undefined;
     } | undefined;
 }>;
 //# sourceMappingURL=response-rule.schema.d.ts.map

package/build/backend/models/response-rules/response-rule.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB9B,CAAC"}
+{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB9B,CAAC"}

package/build/backend/models/response-rules/response-rules-config.schema.d.ts

@@ -85,6 +85,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             }>>;
+            excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
             headers?: {
                 value: string;
@@ -100,6 +101,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             } | undefined;
+            excludeHostsByTags?: string[] | undefined;
         }, {
             headers?: {
                 value: string;
@@ -115,6 +117,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             } | undefined;
+            excludeHostsByTags?: string[] | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -143,6 +146,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             } | undefined;
+            excludeHostsByTags?: string[] | undefined;
         } | undefined;
     }, {
         name: string;
@@ -171,6 +175,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             } | undefined;
+            excludeHostsByTags?: string[] | undefined;
         } | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
@@ -202,6 +207,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             } | undefined;
+            excludeHostsByTags?: string[] | undefined;
         } | undefined;
     }[];
     settings?: {
@@ -236,6 +242,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: string;
                 method: "age1" | "age1pq1";
             } | undefined;
+            excludeHostsByTags?: string[] | undefined;
         } | undefined;
     }[];
     settings?: {

package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpC,CAAC"}
+{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpC,CAAC"}

package/build/backend/models/subscription-settings.schema.d.ts

@@ -119,6 +119,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 }>>;
+                excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, "strip", z.ZodTypeAny, {
                 headers?: {
                     value: string;
@@ -134,6 +135,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             }, {
                 headers?: {
                     value: string;
@@ -149,6 +151,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             }>>;
         }, "strip", z.ZodTypeAny, {
             name: string;
@@ -177,6 +180,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             } | undefined;
         }, {
             name: string;
@@ -205,6 +209,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             } | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
@@ -236,6 +241,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             } | undefined;
         }[];
         settings?: {
@@ -270,6 +276,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             } | undefined;
         }[];
         settings?: {
@@ -342,6 +349,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             } | undefined;
         }[];
         settings?: {
@@ -404,6 +412,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: string;
                     method: "age1" | "age1pq1";
                 } | undefined;
+                excludeHostsByTags?: string[] | undefined;
             } | undefined;
         }[];
         settings?: {

package/build/backend/models/subscription-settings.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCrC,CAAC"}
+{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCrC,CAAC"}

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,9 +8,9 @@ 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.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.ResponseSchema = zod_1.z.object({
         response: zod_1.z.boolean(),

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetApiTokensCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const api_tokens_schema_1 = require("../../models/api-tokens.schema");
+var GetApiTokensCommand;
+(function (GetApiTokensCommand) {
+    GetApiTokensCommand.url = api_1.REST_API.API_TOKENS.GET;
+    GetApiTokensCommand.TSQ_url = GetApiTokensCommand.url;
+    GetApiTokensCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.API_TOKENS_ROUTES.GET, 'get', 'Get all API tokens', { scope: 'list', kind: 'read' }, 'This endpoint is forbidden to use via "API-key". It can only be used with admin JWT-token.');
+    GetApiTokensCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            tokens: zod_1.z.array(api_tokens_schema_1.ApiTokensSchema),
+            docs: zod_1.z.object({
+                enabled: zod_1.z.boolean(),
+                scalarPath: zod_1.z.string().nullable(),
+                swaggerPath: zod_1.z.string().nullable(),
+            }),
+        }),
+    });
+})(GetApiTokensCommand || (exports.GetApiTokensCommand = GetApiTokensCommand = {}));

package/build/frontend/commands/api-tokens/index.js

@@ -16,5 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./create.command"), exports);
 __exportStar(require("./delete.command"), exports);
-__exportStar(require("./find.command"), exports);
+__exportStar(require("./get-api-tokens.command"), exports);
 __exportStar(require("./get-scopes.command"), exports);

package/build/frontend/commands/auth/login.command.js

@@ -9,9 +9,9 @@ var LoginCommand;
     LoginCommand.url = api_1.REST_API.AUTH.LOGIN;
     LoginCommand.TSQ_url = LoginCommand.url;
     LoginCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.AUTH_ROUTES.LOGIN, 'post', 'Login as superadmin', { scope: 'login', kind: 'write' });
-    LoginCommand.RequestSchema = zod_1.z.object({
-        username: zod_1.z.string(),
-        password: zod_1.z.string(),
+    LoginCommand.RequestBodySchema = zod_1.z.object({
+        username: zod_1.z.string().describe('Username of the user'),
+        password: zod_1.z.string().describe('Password of the user'),
     });
     LoginCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({

package/build/frontend/commands/auth/oauth2/authorize.command.js

@@ -9,7 +9,7 @@ var OAuth2AuthorizeCommand;
     OAuth2AuthorizeCommand.url = api_1.REST_API.AUTH.OAUTH2.AUTHORIZE;
     OAuth2AuthorizeCommand.TSQ_url = OAuth2AuthorizeCommand.url;
     OAuth2AuthorizeCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.AUTH_ROUTES.OAUTH2.AUTHORIZE, 'post', 'Initiate OAuth2 authorization', { scope: 'authorize', kind: 'read' });
-    OAuth2AuthorizeCommand.RequestSchema = zod_1.z.object({
+    OAuth2AuthorizeCommand.RequestBodySchema = zod_1.z.object({
         provider: zod_1.z.nativeEnum(constants_1.OAUTH2_PROVIDERS),
     });
     OAuth2AuthorizeCommand.ResponseSchema = zod_1.z.object({

package/build/frontend/commands/auth/oauth2/callback.command.js

@@ -9,7 +9,7 @@ var OAuth2CallbackCommand;
     OAuth2CallbackCommand.url = api_1.REST_API.AUTH.OAUTH2.CALLBACK;
     OAuth2CallbackCommand.TSQ_url = OAuth2CallbackCommand.url;
     OAuth2CallbackCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.AUTH_ROUTES.OAUTH2.CALLBACK, 'post', 'Callback from OAuth2', { scope: 'callback', kind: 'write' });
-    OAuth2CallbackCommand.RequestSchema = zod_1.z.object({
+    OAuth2CallbackCommand.RequestBodySchema = zod_1.z.object({
         provider: zod_1.z.nativeEnum(constants_1.OAUTH2_PROVIDERS),
         code: zod_1.z.string(),
         state: zod_1.z.string(),

package/build/frontend/commands/auth/passkey/verify-authentication.command.js

@@ -9,7 +9,7 @@ var VerifyPasskeyAuthenticationCommand;
     VerifyPasskeyAuthenticationCommand.url = api_1.REST_API.AUTH.PASSKEY.VERIFY_AUTHENTICATION;
     VerifyPasskeyAuthenticationCommand.TSQ_url = VerifyPasskeyAuthenticationCommand.url;
     VerifyPasskeyAuthenticationCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.AUTH_ROUTES.PASSKEY.VERIFY_AUTHENTICATION, 'post', 'Verify the authentication for passkey', { scope: 'verify-authentication', kind: 'write' });
-    VerifyPasskeyAuthenticationCommand.RequestSchema = zod_1.z.object({
+    VerifyPasskeyAuthenticationCommand.RequestBodySchema = zod_1.z.object({
         response: zod_1.z.unknown(),
     });
     VerifyPasskeyAuthenticationCommand.ResponseSchema = zod_1.z.object({

package/build/frontend/commands/auth/register.command.js

@@ -9,8 +9,8 @@ var RegisterCommand;
     RegisterCommand.url = api_1.REST_API.AUTH.REGISTER;
     RegisterCommand.TSQ_url = RegisterCommand.url;
     RegisterCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.AUTH_ROUTES.REGISTER, 'post', 'Register as superadmin', { scope: 'register', kind: 'write' });
-    RegisterCommand.RequestSchema = zod_1.z.object({
-        username: zod_1.z.string(),
+    RegisterCommand.RequestBodySchema = zod_1.z.object({
+        username: zod_1.z.string().describe('Username of the user'),
         password: zod_1.z
             .string()
             .min(24, 'Password must contain at least 24 characters')

package/build/frontend/commands/bandwidth-stats/legacy/get-legacy-stats-node-user-usage.command.js

@@ -9,12 +9,12 @@ var GetLegacyStatsNodeUserUsageCommand;
     GetLegacyStatsNodeUserUsageCommand.url = api_1.REST_API.BANDWIDTH_STATS.LEGACY.NODES.GET_USERS;
     GetLegacyStatsNodeUserUsageCommand.TSQ_url = GetLegacyStatsNodeUserUsageCommand.url(':uuid');
     GetLegacyStatsNodeUserUsageCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.BANDWIDTH_STATS_ROUTES.LEGACY.NODES.GET_USERS(':uuid'), 'get', 'Get Node User Usage by Range and Node UUID (Legacy)', { scope: 'node-users-usage-legacy', kind: 'read' });
-    GetLegacyStatsNodeUserUsageCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+    GetLegacyStatsNodeUserUsageCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the node'),
     });
     GetLegacyStatsNodeUserUsageCommand.RequestQuerySchema = zod_1.z.object({
-        start: zod_1.z.string(),
-        end: zod_1.z.string(),
+        start: zod_1.z.string().datetime().describe('Start date'),
+        end: zod_1.z.string().datetime().describe('End date'),
     });
     GetLegacyStatsNodeUserUsageCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.array(zod_1.z.object({

package/build/frontend/commands/bandwidth-stats/legacy/get-legacy-user-usage.command.js

@@ -9,12 +9,12 @@ var GetLegacyStatsUserUsageCommand;
     GetLegacyStatsUserUsageCommand.url = api_1.REST_API.BANDWIDTH_STATS.LEGACY.USERS.GET_BY_UUID;
     GetLegacyStatsUserUsageCommand.TSQ_url = GetLegacyStatsUserUsageCommand.url(':uuid');
     GetLegacyStatsUserUsageCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.BANDWIDTH_STATS_ROUTES.LEGACY.USERS.GET_BY_UUID(':uuid'), 'get', 'Get User Usage by Range (Legacy)', { scope: 'user-usage-legacy', kind: 'read' });
-    GetLegacyStatsUserUsageCommand.RequestSchema = zod_1.z.object({
+    GetLegacyStatsUserUsageCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     GetLegacyStatsUserUsageCommand.RequestQuerySchema = zod_1.z.object({
-        start: zod_1.z.string(),
-        end: zod_1.z.string(),
+        start: zod_1.z.string().datetime().describe('Start date'),
+        end: zod_1.z.string().datetime().describe('End date'),
     });
     GetLegacyStatsUserUsageCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.array(zod_1.z.object({

package/build/frontend/commands/bandwidth-stats/nodes/get-stats-node-users-usage.command.js

@@ -9,14 +9,14 @@ var GetStatsNodeUsersUsageCommand;
     GetStatsNodeUsersUsageCommand.url = api_1.REST_API.BANDWIDTH_STATS.NODES.GET_USERS;
     GetStatsNodeUsersUsageCommand.TSQ_url = GetStatsNodeUsersUsageCommand.url(':uuid');
     GetStatsNodeUsersUsageCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.BANDWIDTH_STATS_ROUTES.NODES.GET_USERS(':uuid'), 'get', 'Get Node Users Usage by Node UUID', { scope: 'node-users-usage', kind: 'read' });
+    GetStatsNodeUsersUsageCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
     GetStatsNodeUsersUsageCommand.RequestQuerySchema = zod_1.z.object({
-        start: zod_1.z.string().date(),
-        end: zod_1.z.string().date(),
+        start: zod_1.z.string().date().describe('Start date (YYYY-MM-DD)'),
+        end: zod_1.z.string().date().describe('End date (YYYY-MM-DD)'),
         topUsersLimit: zod_1.z.coerce.number().min(1).default(100),
     });
-    GetStatsNodeUsersUsageCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
     GetStatsNodeUsersUsageCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             categories: zod_1.z.array(zod_1.z.string()),

package/build/frontend/commands/bandwidth-stats/nodes/get-stats-nodes-usage.command.js

@@ -10,9 +10,13 @@ var GetStatsNodesUsageCommand;
     GetStatsNodesUsageCommand.TSQ_url = GetStatsNodesUsageCommand.url;
     GetStatsNodesUsageCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.BANDWIDTH_STATS_ROUTES.NODES.GET, 'get', 'Get Nodes Usage by Range', { scope: 'nodes-usage', kind: 'read' });
     GetStatsNodesUsageCommand.RequestQuerySchema = zod_1.z.object({
-        start: zod_1.z.string().date(),
-        end: zod_1.z.string().date(),
-        topNodesLimit: zod_1.z.coerce.number().min(1).default(20),
+        start: zod_1.z.string().date().describe('Start date (YYYY-MM-DD)'),
+        end: zod_1.z.string().date().describe('End date (YYYY-MM-DD)'),
+        topNodesLimit: zod_1.z.coerce
+            .number()
+            .min(1)
+            .default(20)
+            .describe('Limit of top nodes to return'),
     });
     GetStatsNodesUsageCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({

package/build/frontend/commands/bandwidth-stats/nodes/get-stats-nodes-users-usage.command.js

@@ -9,14 +9,14 @@ var GetStatsNodesUsersUsageCommand;
     GetStatsNodesUsersUsageCommand.url = api_1.REST_API.BANDWIDTH_STATS.NODES.GET_USERS_BY_NODES;
     GetStatsNodesUsersUsageCommand.TSQ_url = GetStatsNodesUsersUsageCommand.url;
     GetStatsNodesUsersUsageCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.BANDWIDTH_STATS_ROUTES.NODES.GET_USERS_BY_NODES, 'post', 'Get Nodes Users Usage by Nodes UUIDs', { scope: 'nodes-users-usage', kind: 'read' });
+    GetStatsNodesUsersUsageCommand.RequestBodySchema = zod_1.z.object({
+        nodesUuids: zod_1.z.array(zod_1.z.string().uuid()).min(1, 'Must be at least 1 node UUID'),
+    });
     GetStatsNodesUsersUsageCommand.RequestQuerySchema = zod_1.z.object({
-        start: zod_1.z.string().date(),
-        end: zod_1.z.string().date(),
+        start: zod_1.z.string().date().describe('Start date (YYYY-MM-DD)'),
+        end: zod_1.z.string().date().describe('End date (YYYY-MM-DD)'),
         topUsersLimit: zod_1.z.coerce.number().min(1).default(100),
     });
-    GetStatsNodesUsersUsageCommand.RequestSchema = zod_1.z.object({
-        nodesUuids: zod_1.z.array(zod_1.z.string().uuid()).min(1, 'Must be at least 1 node UUID'),
-    });
     GetStatsNodesUsersUsageCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             categories: zod_1.z.array(zod_1.z.string()),

package/build/frontend/commands/bandwidth-stats/users/get-stats-user-usage.command.js

@@ -9,12 +9,12 @@ var GetStatsUserUsageCommand;
     GetStatsUserUsageCommand.url = api_1.REST_API.BANDWIDTH_STATS.USERS.GET_BY_UUID;
     GetStatsUserUsageCommand.TSQ_url = GetStatsUserUsageCommand.url(':uuid');
     GetStatsUserUsageCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.BANDWIDTH_STATS_ROUTES.USERS.GET_BY_UUID(':uuid'), 'get', 'Get User Usage by Range', { scope: 'user-usage', kind: 'read' });
-    GetStatsUserUsageCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+    GetStatsUserUsageCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the user'),
     });
     GetStatsUserUsageCommand.RequestQuerySchema = zod_1.z.object({
-        start: zod_1.z.string().date(),
-        end: zod_1.z.string().date(),
+        start: zod_1.z.string().date().describe('Start date (YYYY-MM-DD)'),
+        end: zod_1.z.string().date().describe('End date (YYYY-MM-DD)'),
         topNodesLimit: zod_1.z.coerce.number().min(1).default(20),
     });
     GetStatsUserUsageCommand.ResponseSchema = zod_1.z.object({

package/build/frontend/commands/config-profiles/actions/reorder.command.js

@@ -10,7 +10,7 @@ var ReorderConfigProfileCommand;
     ReorderConfigProfileCommand.url = api_1.REST_API.CONFIG_PROFILES.ACTIONS.REORDER;
     ReorderConfigProfileCommand.TSQ_url = ReorderConfigProfileCommand.url;
     ReorderConfigProfileCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.CONFIG_PROFILES_ROUTES.ACTIONS.REORDER, 'post', 'Reorder config profiles', { scope: 'reorder', kind: 'write' });
-    ReorderConfigProfileCommand.RequestSchema = zod_1.z.object({
+    ReorderConfigProfileCommand.RequestBodySchema = zod_1.z.object({
         items: zod_1.z.array(models_1.ConfigProfileSchema.pick({
             viewPosition: true,
             uuid: true,

package/build/frontend/commands/config-profiles/create-config-profile.command.js

@@ -10,7 +10,7 @@ var CreateConfigProfileCommand;
     CreateConfigProfileCommand.url = api_1.REST_API.CONFIG_PROFILES.CREATE;
     CreateConfigProfileCommand.TSQ_url = CreateConfigProfileCommand.url;
     CreateConfigProfileCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.CONFIG_PROFILES_ROUTES.CREATE, 'post', 'Create config profile', { scope: 'create', kind: 'write' });
-    CreateConfigProfileCommand.RequestSchema = zod_1.z.object({
+    CreateConfigProfileCommand.RequestBodySchema = zod_1.z.object({
         name: zod_1.z
             .string()
             .min(2, 'Name must be at least 2 characters')

package/build/frontend/commands/config-profiles/delete-config-profile.command.js

@@ -9,8 +9,8 @@ var DeleteConfigProfileCommand;
     DeleteConfigProfileCommand.url = api_1.REST_API.CONFIG_PROFILES.DELETE;
     DeleteConfigProfileCommand.TSQ_url = DeleteConfigProfileCommand.url(':uuid');
     DeleteConfigProfileCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.CONFIG_PROFILES_ROUTES.DELETE(':uuid'), 'delete', 'Delete config profile', { scope: 'delete', kind: 'write' });
-    DeleteConfigProfileCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+    DeleteConfigProfileCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the config profile'),
     });
     DeleteConfigProfileCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({

package/build/frontend/commands/config-profiles/get-computed-config-profile-by-uuid.command.js

@@ -10,7 +10,7 @@ var GetComputedConfigProfileByUuidCommand;
     GetComputedConfigProfileByUuidCommand.url = api_1.REST_API.CONFIG_PROFILES.GET_COMPUTED_CONFIG_BY_PROFILE_UUID;
     GetComputedConfigProfileByUuidCommand.TSQ_url = GetComputedConfigProfileByUuidCommand.url(':uuid');
     GetComputedConfigProfileByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.CONFIG_PROFILES_ROUTES.GET_COMPUTED_CONFIG_BY_PROFILE_UUID(':uuid'), 'get', 'Get computed config profile by uuid', { scope: 'get-computed', kind: 'read' });
-    GetComputedConfigProfileByUuidCommand.RequestSchema = zod_1.z.object({
+    GetComputedConfigProfileByUuidCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     GetComputedConfigProfileByUuidCommand.ResponseSchema = zod_1.z.object({

package/build/frontend/commands/config-profiles/get-config-profile-by-uuid.command.js

@@ -10,7 +10,7 @@ var GetConfigProfileByUuidCommand;
     GetConfigProfileByUuidCommand.url = api_1.REST_API.CONFIG_PROFILES.GET_BY_UUID;
     GetConfigProfileByUuidCommand.TSQ_url = GetConfigProfileByUuidCommand.url(':uuid');
     GetConfigProfileByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.CONFIG_PROFILES_ROUTES.GET_BY_UUID(':uuid'), 'get', 'Get config profile by uuid', { scope: 'get', kind: 'read' });
-    GetConfigProfileByUuidCommand.RequestSchema = zod_1.z.object({
+    GetConfigProfileByUuidCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     GetConfigProfileByUuidCommand.ResponseSchema = zod_1.z.object({