@remnawave/backend-contract 2.8.35 → 2.9.0

package/build/frontend/commands/users/bulk/bulk-revoke-users-subscription.command.js

@@ -9,7 +9,7 @@ var BulkRevokeUsersSubscriptionCommand;
     BulkRevokeUsersSubscriptionCommand.url = api_1.REST_API.USERS.BULK.REVOKE_SUBSCRIPTION;
     BulkRevokeUsersSubscriptionCommand.TSQ_url = BulkRevokeUsersSubscriptionCommand.url;
     BulkRevokeUsersSubscriptionCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.BULK.REVOKE_SUBSCRIPTION, 'post', 'Revoke users subscription by User UUIDs', { scope: 'bulk-revoke-subscription', kind: 'write' });
-    BulkRevokeUsersSubscriptionCommand.RequestSchema = zod_1.z.object({
+    BulkRevokeUsersSubscriptionCommand.RequestBodySchema = zod_1.z.object({
         uuids: zod_1.z
             .array(zod_1.z.string().uuid())
             .min(1, 'Must be at least 1 user UUID')

package/build/frontend/commands/users/bulk/bulk-update-users-squads.command.js

@@ -9,7 +9,7 @@ var BulkUpdateUsersSquadsCommand;
     BulkUpdateUsersSquadsCommand.url = api_1.REST_API.USERS.BULK.UPDATE_SQUADS;
     BulkUpdateUsersSquadsCommand.TSQ_url = BulkUpdateUsersSquadsCommand.url;
     BulkUpdateUsersSquadsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.BULK.UPDATE_SQUADS, 'post', 'Bulk update users internal squads by UUIDs', { scope: 'bulk-update-squads', kind: 'write' });
-    BulkUpdateUsersSquadsCommand.RequestSchema = zod_1.z.object({
+    BulkUpdateUsersSquadsCommand.RequestBodySchema = zod_1.z.object({
         uuids: zod_1.z
             .array(zod_1.z.string().uuid())
             .min(1, 'Must be at least 1 user UUID')

package/build/frontend/commands/users/bulk/bulk-update-users.command.js

@@ -11,7 +11,7 @@ var BulkUpdateUsersCommand;
     BulkUpdateUsersCommand.url = api_1.REST_API.USERS.BULK.UPDATE;
     BulkUpdateUsersCommand.TSQ_url = BulkUpdateUsersCommand.url;
     BulkUpdateUsersCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.BULK.UPDATE, 'post', 'Bulk update users by UUIDs', { scope: 'bulk-update-users', kind: 'write' });
-    BulkUpdateUsersCommand.RequestSchema = zod_1.z.object({
+    BulkUpdateUsersCommand.RequestBodySchema = zod_1.z.object({
         uuids: zod_1.z
             .array(zod_1.z.string().uuid())
             .min(1, 'Must be at least 1 user UUID')

package/build/frontend/commands/users/bulk-all/bulk-all-extend-expiration-date.command.js

@@ -9,7 +9,7 @@ var BulkAllExtendExpirationDateCommand;
     BulkAllExtendExpirationDateCommand.url = api_1.REST_API.USERS.BULK.ALL.EXTEND_EXPIRATION_DATE;
     BulkAllExtendExpirationDateCommand.TSQ_url = BulkAllExtendExpirationDateCommand.url;
     BulkAllExtendExpirationDateCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.BULK.ALL.EXTEND_EXPIRATION_DATE, 'post', 'Extend expiration date for all users by days', { scope: 'bulk-all-extend-expiration-date', kind: 'write' });
-    BulkAllExtendExpirationDateCommand.RequestSchema = zod_1.z.object({
+    BulkAllExtendExpirationDateCommand.RequestBodySchema = zod_1.z.object({
         extendDays: zod_1.z.number().int().min(1, 'Extend days must be greater than 0'),
     });
     BulkAllExtendExpirationDateCommand.ResponseSchema = zod_1.z.object({

package/build/frontend/commands/users/bulk-all/bulk-all-update-users.command.js

@@ -11,7 +11,7 @@ var BulkAllUpdateUsersCommand;
     BulkAllUpdateUsersCommand.url = api_1.REST_API.USERS.BULK.ALL.UPDATE;
     BulkAllUpdateUsersCommand.TSQ_url = BulkAllUpdateUsersCommand.url;
     BulkAllUpdateUsersCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.BULK.ALL.UPDATE, 'post', 'Bulk update all users', { scope: 'bulk-all-update-users', kind: 'write' });
-    BulkAllUpdateUsersCommand.RequestSchema = zod_1.z.object({
+    BulkAllUpdateUsersCommand.RequestBodySchema = zod_1.z.object({
         status: models_1.UsersSchema.shape.status.optional(),
         trafficLimitBytes: zod_1.z.optional(zod_1.z
             .number({

package/build/frontend/commands/users/create-user.command.js

@@ -10,7 +10,7 @@ var CreateUserCommand;
     CreateUserCommand.url = api_1.REST_API.USERS.CREATE;
     CreateUserCommand.TSQ_url = CreateUserCommand.url;
     CreateUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.CREATE, 'post', 'Create a new user', { scope: 'create', kind: 'write' });
-    CreateUserCommand.RequestSchema = zod_1.z.object({
+    CreateUserCommand.RequestBodySchema = zod_1.z.object({
         username: zod_1.z
             .string({
             required_error: 'Username is required',

package/build/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/frontend/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/backend-contract",
-  "version": "2.8.35",
+  "version": "2.9.0",
   "description": "A contract library for Remnawave Backend. It can be used in backend and frontend.",
   "keywords": [],
   "homepage": "https://github.com/remnawave",

package/build/backend/commands/api-tokens/find.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"find.command.d.ts","sourceRoot":"","sources":["../../../../commands/api-tokens/find.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,uBAAuB,CAAC;IAC9B,MAAM,GAAG,gBAA0B,CAAC;IACpC,MAAM,OAAO,gBAAM,CAAC;IAEpB,MAAM,eAAe,2CAM3B,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/api-tokens/find.command.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FindAllApiTokensCommand = 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 FindAllApiTokensCommand;
-(function (FindAllApiTokensCommand) {
-    FindAllApiTokensCommand.url = api_1.REST_API.API_TOKENS.GET;
-    FindAllApiTokensCommand.TSQ_url = FindAllApiTokensCommand.url;
-    FindAllApiTokensCommand.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.');
-    FindAllApiTokensCommand.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(),
-            }),
-        }),
-    });
-})(FindAllApiTokensCommand || (exports.FindAllApiTokensCommand = FindAllApiTokensCommand = {}));

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-all.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/get-all.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,eAAqB,CAAC;IAC/B,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAG1B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/get-all.command.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetAllHostsCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var GetAllHostsCommand;
-(function (GetAllHostsCommand) {
-    GetAllHostsCommand.url = api_1.REST_API.HOSTS.GET;
-    GetAllHostsCommand.TSQ_url = GetAllHostsCommand.url;
-    GetAllHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.GET, 'get', 'Get all hosts', {
-        scope: 'list',
-        kind: 'read',
-    });
-    GetAllHostsCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.array(models_1.HostsSchema),
-    });
-})(GetAllHostsCommand || (exports.GetAllHostsCommand = GetAllHostsCommand = {}));

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-one.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/get-one.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,iBAAiB,CAAC;IACxB,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"}

package/build/backend/commands/hosts/get-one.command.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetOneHostCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var GetOneHostCommand;
-(function (GetOneHostCommand) {
-    GetOneHostCommand.url = api_1.REST_API.HOSTS.GET_BY_UUID;
-    GetOneHostCommand.TSQ_url = GetOneHostCommand.url(':uuid');
-    GetOneHostCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.GET_BY_UUID(':uuid'), 'get', 'Get a host by UUID', { scope: 'get', kind: 'read' });
-    GetOneHostCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    GetOneHostCommand.ResponseSchema = zod_1.z.object({
-        response: models_1.HostsSchema,
-    });
-})(GetOneHostCommand || (exports.GetOneHostCommand = GetOneHostCommand = {}));

package/build/backend/commands/hosts/tags/get-all-host-tags.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-all-host-tags.command.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/tags/get-all-host-tags.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,qBAAqB,CAAC;IAC5B,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/hosts/tags/get-all-host-tags.command.js

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

package/build/backend/commands/hwid/get-all-hwid-devices.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-all-hwid-devices.command.d.ts","sourceRoot":"","sources":["../../../../commands/hwid/get-all-hwid-devices.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,GAAG,qBAAqC,CAAC;IAC/C,MAAM,OAAO,qBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAkC,CAAC;IAClE,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAEvD,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hwid/get-all-hwid-devices.command.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetAllHwidDevicesCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var GetAllHwidDevicesCommand;
-(function (GetAllHwidDevicesCommand) {
-    GetAllHwidDevicesCommand.url = api_1.REST_API.HWID.GET_ALL_HWID_DEVICES;
-    GetAllHwidDevicesCommand.TSQ_url = GetAllHwidDevicesCommand.url;
-    GetAllHwidDevicesCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HWID_ROUTES.GET_ALL_HWID_DEVICES, 'get', 'Get all HWID devices', { scope: 'list', kind: 'read' });
-    GetAllHwidDevicesCommand.RequestQuerySchema = models_1.TanstackQueryRequestQuerySchema;
-    GetAllHwidDevicesCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.object({
-            devices: zod_1.z.array(models_1.HwidUserDeviceSchema),
-            total: zod_1.z.number(),
-        }),
-    });
-})(GetAllHwidDevicesCommand || (exports.GetAllHwidDevicesCommand = GetAllHwidDevicesCommand = {}));

package/build/backend/commands/infra-billing/delete-bill-record-by-uuid.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-bill-record-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/infra-billing/delete-bill-record-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,sCAAsC,CAAC;IAC7C,MAAM,GAAG,0BAAgD,CAAC;IAC1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAKzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/infra-billing/delete-bill-record-by-uuid.command.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteInfraBillingHistoryRecordCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var DeleteInfraBillingHistoryRecordCommand;
-(function (DeleteInfraBillingHistoryRecordCommand) {
-    DeleteInfraBillingHistoryRecordCommand.url = api_1.REST_API.INFRA_BILLING.DELETE_BILLING_HISTORY;
-    DeleteInfraBillingHistoryRecordCommand.TSQ_url = DeleteInfraBillingHistoryRecordCommand.url(':uuid');
-    DeleteInfraBillingHistoryRecordCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.INFRA_BILLING_ROUTES.DELETE_BILLING_HISTORY(':uuid'), 'delete', 'Delete infra billing history', { scope: 'delete-bill-record', kind: 'write' });
-    DeleteInfraBillingHistoryRecordCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    DeleteInfraBillingHistoryRecordCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.object({
-            records: zod_1.z.array(models_1.InfraBillingHistoryRecordSchema),
-            total: zod_1.z.number(),
-        }),
-    });
-})(DeleteInfraBillingHistoryRecordCommand || (exports.DeleteInfraBillingHistoryRecordCommand = DeleteInfraBillingHistoryRecordCommand = {}));

package/build/backend/commands/infra-billing/delete-billing-node-by-uuid.command.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteInfraBillingNodeByUuidCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var DeleteInfraBillingNodeByUuidCommand;
-(function (DeleteInfraBillingNodeByUuidCommand) {
-    DeleteInfraBillingNodeByUuidCommand.url = api_1.REST_API.INFRA_BILLING.DELETE_BILLING_NODE;
-    DeleteInfraBillingNodeByUuidCommand.TSQ_url = DeleteInfraBillingNodeByUuidCommand.url(':uuid');
-    DeleteInfraBillingNodeByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.INFRA_BILLING_ROUTES.DELETE_BILLING_NODE(':uuid'), 'delete', 'Delete infra billing node', { scope: 'delete-billing-node', kind: 'write' });
-    DeleteInfraBillingNodeByUuidCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    DeleteInfraBillingNodeByUuidCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.object({
-            totalBillingNodes: zod_1.z.number(),
-            billingNodes: zod_1.z.array(models_1.InfraBillingNodeSchema),
-            availableBillingNodes: zod_1.z.array(models_1.InfraBillingAvailableNodeSchema),
-            totalAvailableBillingNodes: zod_1.z.number(),
-            stats: zod_1.z.object({
-                upcomingNodesCount: zod_1.z.number(),
-                currentMonthPayments: zod_1.z.number(),
-                totalSpent: zod_1.z.number(),
-            }),
-        }),
-    });
-})(DeleteInfraBillingNodeByUuidCommand || (exports.DeleteInfraBillingNodeByUuidCommand = DeleteInfraBillingNodeByUuidCommand = {}));

package/build/backend/commands/infra-billing/delete-infra-provider-by-uuid.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-infra-provider-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/infra-billing/delete-infra-provider-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,gCAAgC,CAAC;IACvC,MAAM,GAAG,0BAAyC,CAAC;IACnD,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"}

package/build/backend/commands/infra-billing/delete-infra-provider-by-uuid.command.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteInfraProviderByUuidCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-var DeleteInfraProviderByUuidCommand;
-(function (DeleteInfraProviderByUuidCommand) {
-    DeleteInfraProviderByUuidCommand.url = api_1.REST_API.INFRA_BILLING.DELETE_PROVIDER;
-    DeleteInfraProviderByUuidCommand.TSQ_url = DeleteInfraProviderByUuidCommand.url(':uuid');
-    DeleteInfraProviderByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.INFRA_BILLING_ROUTES.DELETE_PROVIDER(':uuid'), 'delete', 'Delete infra provider by uuid', { scope: 'delete-provider', kind: 'write' });
-    DeleteInfraProviderByUuidCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    DeleteInfraProviderByUuidCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.object({
-            isDeleted: zod_1.z.boolean(),
-        }),
-    });
-})(DeleteInfraProviderByUuidCommand || (exports.DeleteInfraProviderByUuidCommand = DeleteInfraProviderByUuidCommand = {}));

package/build/backend/commands/infra-billing/get-infra-provider-by-uuid.command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-infra-provider-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/infra-billing/get-infra-provider-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,6BAA6B,CAAC;IACpC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/infra-billing/get-infra-provider-by-uuid.command.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetInfraProviderByUuidCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var GetInfraProviderByUuidCommand;
-(function (GetInfraProviderByUuidCommand) {
-    GetInfraProviderByUuidCommand.url = api_1.REST_API.INFRA_BILLING.GET_PROVIDER_BY_UUID;
-    GetInfraProviderByUuidCommand.TSQ_url = GetInfraProviderByUuidCommand.url(':uuid');
-    GetInfraProviderByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.INFRA_BILLING_ROUTES.GET_PROVIDER_BY_UUID(':uuid'), 'get', 'Get infra provider by uuid', { scope: 'get-provider', kind: 'read' });
-    GetInfraProviderByUuidCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    GetInfraProviderByUuidCommand.ResponseSchema = zod_1.z.object({
-        response: models_1.InfraProviderSchema,
-    });
-})(GetInfraProviderByUuidCommand || (exports.GetInfraProviderByUuidCommand = GetInfraProviderByUuidCommand = {}));

package/build/backend/commands/internal-squads/get-internal-squad-by-uuid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-internal-squad-by-uuid.d.ts","sourceRoot":"","sources":["../../../../commands/internal-squads/get-internal-squad-by-uuid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,0BAAuC,CAAC;IACjD,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"}

package/build/backend/commands/internal-squads/get-internal-squad-by-uuid.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetInternalSquadByUuidCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var GetInternalSquadByUuidCommand;
-(function (GetInternalSquadByUuidCommand) {
-    GetInternalSquadByUuidCommand.url = api_1.REST_API.INTERNAL_SQUADS.GET_BY_UUID;
-    GetInternalSquadByUuidCommand.TSQ_url = GetInternalSquadByUuidCommand.url(':uuid');
-    GetInternalSquadByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.INTERNAL_SQUADS_ROUTES.GET_BY_UUID(':uuid'), 'get', 'Get internal squad by uuid', { scope: 'get', kind: 'read' });
-    GetInternalSquadByUuidCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
-    });
-    GetInternalSquadByUuidCommand.ResponseSchema = zod_1.z.object({
-        response: models_1.InternalSquadSchema,
-    });
-})(GetInternalSquadByUuidCommand || (exports.GetInternalSquadByUuidCommand = GetInternalSquadByUuidCommand = {}));

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-pubkey.command.d.ts","sourceRoot":"","sources":["../../../../commands/keygen/get-pubkey.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,GAAG,gBAAsB,CAAC;IAChC,MAAM,OAAO,gBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/keygen/get-pubkey.command.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetPubKeyCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-var GetPubKeyCommand;
-(function (GetPubKeyCommand) {
-    GetPubKeyCommand.url = api_1.REST_API.KEYGEN.GET;
-    GetPubKeyCommand.TSQ_url = GetPubKeyCommand.url;
-    GetPubKeyCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.KEYGEN_ROUTES.GET, 'get', 'Get SECRET_KEY for Remnawave Node', { scope: 'get', kind: 'read' });
-    GetPubKeyCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.object({
-            pubKey: zod_1.z.string(),
-        }),
-    });
-})(GetPubKeyCommand || (exports.GetPubKeyCommand = GetPubKeyCommand = {}));

package/build/backend/commands/nodes/get-all.command.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetAllNodesCommand = void 0;
-const zod_1 = require("zod");
-const api_1 = require("../../api");
-const constants_1 = require("../../constants");
-const models_1 = require("../../models");
-var GetAllNodesCommand;
-(function (GetAllNodesCommand) {
-    GetAllNodesCommand.url = api_1.REST_API.NODES.GET;
-    GetAllNodesCommand.TSQ_url = GetAllNodesCommand.url;
-    GetAllNodesCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.NODES_ROUTES.GET, 'get', 'Get all nodes', {
-        scope: 'list',
-        kind: 'read',
-    });
-    GetAllNodesCommand.ResponseSchema = zod_1.z.object({
-        response: zod_1.z.array(models_1.NodesSchema),
-    });
-})(GetAllNodesCommand || (exports.GetAllNodesCommand = GetAllNodesCommand = {}));

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-one.command.d.ts","sourceRoot":"","sources":["../../../../commands/nodes/get-one.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,iBAAiB,CAAC;IACxB,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"}