@remnawave/backend-contract 2.2.2 → 2.2.5

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

@@ -68,7 +68,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                 readonly SINGBOX: "SINGBOX";
             }>;
             responseModifications: z.ZodOptional<z.ZodObject<{
-                headers: z.ZodArray<z.ZodObject<{
+                headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
                     key: z.ZodString;
                     value: z.ZodString;
                 }, "strip", z.ZodTypeAny, {
@@ -77,17 +77,20 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                 }, {
                     value: string;
                     key: string;
-                }>, "many">;
+                }>, "many">>;
+                subscriptionTemplate: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             }, {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             }>>;
         }, "strip", z.ZodTypeAny, {
             name: string;
@@ -102,10 +105,11 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
             description?: string | undefined;
             responseModifications?: {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             } | undefined;
         }, {
             name: string;
@@ -120,10 +124,11 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
             description?: string | undefined;
             responseModifications?: {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             } | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
@@ -141,10 +146,11 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
             description?: string | undefined;
             responseModifications?: {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             } | undefined;
         }[];
     }, {
@@ -162,10 +168,11 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
             description?: string | undefined;
             responseModifications?: {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             } | undefined;
         }[];
     }>>;
@@ -204,10 +211,11 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
             description?: string | undefined;
             responseModifications?: {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             } | undefined;
         }[];
     } | null;
@@ -244,10 +252,11 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
             description?: string | undefined;
             responseModifications?: {
-                headers: {
+                headers?: {
                     value: string;
                     key: string;
-                }[];
+                }[] | undefined;
+                subscriptionTemplate?: string | undefined;
             } | undefined;
         }[];
     } | null;

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;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCrC,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;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCrC,CAAC"}

package/build/backend/models/users.schema.d.ts

@@ -46,6 +46,7 @@ export declare const UsersSchema: z.ZodObject<{
         uuid: string;
         name: string;
     }>, "many">;
+    externalSquadUuid: z.ZodNullable<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
     uuid: string;
@@ -77,6 +78,7 @@ export declare const UsersSchema: z.ZodObject<{
         uuid: string;
         name: string;
     }[];
+    externalSquadUuid: string | null;
 }, {
     uuid: string;
     createdAt: string;
@@ -104,6 +106,7 @@ export declare const UsersSchema: z.ZodObject<{
         uuid: string;
         name: string;
     }[];
+    externalSquadUuid: string | null;
     status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
     trafficLimitBytes?: number | undefined;
     trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | undefined;

package/build/backend/models/users.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"users.schema.d.ts","sourceRoot":"","sources":["../../../models/users.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+EtB,CAAC"}
+{"version":3,"file":"users.schema.d.ts","sourceRoot":"","sources":["../../../models/users.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgFtB,CAAC"}

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

@@ -60,4 +60,5 @@ exports.UsersSchema = zod_1.z.object({
         .datetime()
         .transform((str) => new Date(str)),
     activeInternalSquads: zod_1.z.array(base_internal_squad_schema_1.BaseInternalSquadSchema),
+    externalSquadUuid: zod_1.z.nullable(zod_1.z.string().uuid()),
 });

package/build/frontend/api/controllers/external-squads.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTERNAL_SQUADS_ROUTES = exports.EXTERNAL_SQUADS_CONTROLLER = void 0;
+exports.EXTERNAL_SQUADS_CONTROLLER = 'external-squads';
+const BULK_ACTIONS_ROUTE = 'bulk-actions';
+exports.EXTERNAL_SQUADS_ROUTES = {
+    GET: '', // Get list of all external squads // get
+    CREATE: '', // Create new external squad // post
+    UPDATE: '', // Update external squad by uuid // patch
+    GET_BY_UUID: (uuid) => `${uuid}`, // Get external squad by uuid // get
+    DELETE: (uuid) => `${uuid}`, // Delete external squad by uuid // delete
+    BULK_ACTIONS: {
+        ADD_USERS: (uuid) => `${uuid}/${BULK_ACTIONS_ROUTE}/add-users`, // Add users to external squad // post
+        REMOVE_USERS: (uuid) => `${uuid}/${BULK_ACTIONS_ROUTE}/remove-users`, // Remove users from external squad // delete
+    },
+};

package/build/frontend/api/controllers/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api-tokens"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./config-profiles"), exports);
+__exportStar(require("./external-squads"), exports);
 __exportStar(require("./hosts"), exports);
 __exportStar(require("./hwid"), exports);
 __exportStar(require("./infra-billing"), exports);

package/build/frontend/api/controllers/subscription-template.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUBSCRIPTION_TEMPLATE_ROUTES = exports.SUBSCRIPTION_TEMPLATE_CONTROLLER = void 0;
 exports.SUBSCRIPTION_TEMPLATE_CONTROLLER = 'subscription-templates';
 exports.SUBSCRIPTION_TEMPLATE_ROUTES = {
-    GET: (templateType) => `${templateType}`,
-    UPDATE: '',
+    GET_ALL: '', // get
+    GET: (uuid) => `${uuid}`, // get
+    UPDATE: '', // patch
+    DELETE: (uuid) => `${uuid}`, // delete
+    CREATE: '', // post
 };

package/build/frontend/api/controllers-info.js

@@ -42,6 +42,10 @@ exports.CONTROLLERS_INFO = {
         tag: 'Internal Squads Controller',
         description: 'Management of Internal Squads.',
     },
+    EXTERNAL_SQUADS: {
+        tag: 'External Squads Controller',
+        description: 'Management of External Squads.',
+    },
     NODES: {
         tag: 'Nodes Controller',
         description: '',

package/build/frontend/api/routes.js

@@ -160,8 +160,11 @@ exports.REST_API = {
         },
     },
     SUBSCRIPTION_TEMPLATE: {
-        GET: (templateType) => `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_ROUTES.GET(templateType)}`,
+        GET: (uuid) => `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_ROUTES.GET(uuid)}`,
         UPDATE: `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_ROUTES.UPDATE}`,
+        DELETE: (uuid) => `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_ROUTES.DELETE(uuid)}`,
+        GET_ALL: `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_ROUTES.GET_ALL}`,
+        CREATE: `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_TEMPLATE_ROUTES.CREATE}`,
     },
     SUBSCRIPTION_SETTINGS: {
         GET: `${exports.ROOT}/${CONTROLLERS.SUBSCRIPTION_SETTINGS_CONTROLLER}/${CONTROLLERS.SUBSCRIPTION_SETTINGS_ROUTES.GET}`,
@@ -229,4 +232,15 @@ exports.REST_API = {
         UPDATE: `${exports.ROOT}/${CONTROLLERS.SNIPPETS_CONTROLLER}/${CONTROLLERS.SNIPPETS_ROUTES.UPDATE}`,
         DELETE: `${exports.ROOT}/${CONTROLLERS.SNIPPETS_CONTROLLER}/${CONTROLLERS.SNIPPETS_ROUTES.DELETE}`,
     },
+    EXTERNAL_SQUADS: {
+        GET: `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.GET}`,
+        CREATE: `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.CREATE}`,
+        UPDATE: `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.UPDATE}`,
+        GET_BY_UUID: (uuid) => `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.GET_BY_UUID(uuid)}`,
+        DELETE: (uuid) => `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.DELETE(uuid)}`,
+        BULK_ACTIONS: {
+            ADD_USERS: (uuid) => `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.BULK_ACTIONS.ADD_USERS(uuid)}`,
+            REMOVE_USERS: (uuid) => `${exports.ROOT}/${CONTROLLERS.EXTERNAL_SQUADS_CONTROLLER}/${CONTROLLERS.EXTERNAL_SQUADS_ROUTES.BULK_ACTIONS.REMOVE_USERS(uuid)}`,
+        },
+    },
 };

package/build/frontend/commands/external-squads/bulk-actions/add-users-to-external-squad.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddUsersToExternalSquadCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+var AddUsersToExternalSquadCommand;
+(function (AddUsersToExternalSquadCommand) {
+    AddUsersToExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.BULK_ACTIONS.ADD_USERS;
+    AddUsersToExternalSquadCommand.TSQ_url = AddUsersToExternalSquadCommand.url(':uuid');
+    AddUsersToExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.BULK_ACTIONS.ADD_USERS(':uuid'), 'post', 'Add all users to external squad');
+    AddUsersToExternalSquadCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    AddUsersToExternalSquadCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            eventSent: zod_1.z.boolean(),
+        }),
+    });
+})(AddUsersToExternalSquadCommand || (exports.AddUsersToExternalSquadCommand = AddUsersToExternalSquadCommand = {}));

package/build/frontend/commands/external-squads/bulk-actions/delete-users-from-external-squad.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteUsersFromExternalSquadCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+var DeleteUsersFromExternalSquadCommand;
+(function (DeleteUsersFromExternalSquadCommand) {
+    DeleteUsersFromExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.BULK_ACTIONS.REMOVE_USERS;
+    DeleteUsersFromExternalSquadCommand.TSQ_url = DeleteUsersFromExternalSquadCommand.url(':uuid');
+    DeleteUsersFromExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.BULK_ACTIONS.REMOVE_USERS(':uuid'), 'delete', 'Delete users from external squad');
+    DeleteUsersFromExternalSquadCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    DeleteUsersFromExternalSquadCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            eventSent: zod_1.z.boolean(),
+        }),
+    });
+})(DeleteUsersFromExternalSquadCommand || (exports.DeleteUsersFromExternalSquadCommand = DeleteUsersFromExternalSquadCommand = {}));

package/build/frontend/commands/external-squads/bulk-actions/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./add-users-to-external-squad.command"), exports);
+__exportStar(require("./delete-users-from-external-squad.command"), exports);

package/build/frontend/commands/external-squads/create-external-squad.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateExternalSquadCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const models_1 = require("../../models");
+var CreateExternalSquadCommand;
+(function (CreateExternalSquadCommand) {
+    CreateExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.CREATE;
+    CreateExternalSquadCommand.TSQ_url = CreateExternalSquadCommand.url;
+    CreateExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.CREATE, 'post', 'Create external squad');
+    CreateExternalSquadCommand.RequestSchema = zod_1.z.object({
+        name: zod_1.z
+            .string()
+            .min(2, 'Name must be at least 2 characters')
+            .max(30, 'Name must be less than 30 characters')
+            .regex(/^[A-Za-z0-9_\s-]+$/, 'Name can only contain letters, numbers, underscores, dashes and spaces'),
+    });
+    CreateExternalSquadCommand.ResponseSchema = zod_1.z.object({
+        response: models_1.ExternalSquadSchema,
+    });
+})(CreateExternalSquadCommand || (exports.CreateExternalSquadCommand = CreateExternalSquadCommand = {}));

package/build/frontend/commands/external-squads/delete-external-squad.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteExternalSquadCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+var DeleteExternalSquadCommand;
+(function (DeleteExternalSquadCommand) {
+    DeleteExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.DELETE;
+    DeleteExternalSquadCommand.TSQ_url = DeleteExternalSquadCommand.url(':uuid');
+    DeleteExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.DELETE(':uuid'), 'delete', 'Delete external squad');
+    DeleteExternalSquadCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    DeleteExternalSquadCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isDeleted: zod_1.z.boolean(),
+        }),
+    });
+})(DeleteExternalSquadCommand || (exports.DeleteExternalSquadCommand = DeleteExternalSquadCommand = {}));

package/build/frontend/commands/external-squads/get-external-squad-by-uuid.js

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

package/build/frontend/commands/external-squads/get-external-squads.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetExternalSquadsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const models_1 = require("../../models");
+var GetExternalSquadsCommand;
+(function (GetExternalSquadsCommand) {
+    GetExternalSquadsCommand.url = api_1.REST_API.EXTERNAL_SQUADS.GET;
+    GetExternalSquadsCommand.TSQ_url = GetExternalSquadsCommand.url;
+    GetExternalSquadsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.GET, 'get', 'Get all external squads');
+    GetExternalSquadsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            total: zod_1.z.number(),
+            externalSquads: zod_1.z.array(models_1.ExternalSquadSchema),
+        }),
+    });
+})(GetExternalSquadsCommand || (exports.GetExternalSquadsCommand = GetExternalSquadsCommand = {}));

package/build/frontend/commands/external-squads/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./bulk-actions"), exports);
+__exportStar(require("./create-external-squad.command"), exports);
+__exportStar(require("./delete-external-squad.command"), exports);
+__exportStar(require("./get-external-squad-by-uuid"), exports);
+__exportStar(require("./get-external-squads.command"), exports);
+__exportStar(require("./update-external-squad.command"), exports);

package/build/frontend/commands/external-squads/update-external-squad.command.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateExternalSquadCommand = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const api_1 = require("../../api");
+const models_1 = require("../../models");
+var UpdateExternalSquadCommand;
+(function (UpdateExternalSquadCommand) {
+    UpdateExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.UPDATE;
+    UpdateExternalSquadCommand.TSQ_url = UpdateExternalSquadCommand.url;
+    UpdateExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.UPDATE, 'patch', 'Update external squad');
+    UpdateExternalSquadCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        name: zod_1.z
+            .string()
+            .min(2, 'Name must be at least 2 characters')
+            .max(30, 'Name must be less than 30 characters')
+            .regex(/^[A-Za-z0-9_\s-]+$/, 'Name can only contain letters, numbers, underscores, dashes and spaces')
+            .optional(),
+        templates: zod_1.z
+            .array(zod_1.z.object({
+            templateUuid: zod_1.z.string().uuid(),
+            templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+        }))
+            .optional(),
+    });
+    UpdateExternalSquadCommand.ResponseSchema = zod_1.z.object({
+        response: models_1.ExternalSquadSchema,
+    });
+})(UpdateExternalSquadCommand || (exports.UpdateExternalSquadCommand = UpdateExternalSquadCommand = {}));

package/build/frontend/commands/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api-tokens"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./config-profiles"), exports);
+__exportStar(require("./external-squads"), exports);
 __exportStar(require("./hosts"), exports);
 __exportStar(require("./hwid"), exports);
 __exportStar(require("./infra-billing"), exports);

package/build/frontend/commands/subscription-template/create-template.command.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSubscriptionTemplateCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const constants_2 = require("../../constants");
+var CreateSubscriptionTemplateCommand;
+(function (CreateSubscriptionTemplateCommand) {
+    CreateSubscriptionTemplateCommand.url = api_1.REST_API.SUBSCRIPTION_TEMPLATE.CREATE;
+    CreateSubscriptionTemplateCommand.TSQ_url = CreateSubscriptionTemplateCommand.url;
+    CreateSubscriptionTemplateCommand.endpointDetails = (0, constants_2.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.CREATE, 'post', 'Create subscription template');
+    CreateSubscriptionTemplateCommand.RequestSchema = zod_1.z.object({
+        name: zod_1.z
+            .string()
+            .min(2, 'Name must be at least 2 characters')
+            .max(255, 'Name must be less than 255 characters')
+            .regex(/^[A-Za-z0-9_\s-]+$/, 'Name can only contain letters, numbers, underscores, dashes and spaces'),
+        templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+    });
+    CreateSubscriptionTemplateCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            uuid: zod_1.z.string().uuid(),
+            name: zod_1.z.string(),
+            templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+            templateJson: zod_1.z.nullable(zod_1.z.unknown()),
+            encodedTemplateYaml: zod_1.z.nullable(zod_1.z.string()),
+        }),
+    });
+})(CreateSubscriptionTemplateCommand || (exports.CreateSubscriptionTemplateCommand = CreateSubscriptionTemplateCommand = {}));

package/build/frontend/commands/subscription-template/delete-subscription-template.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSubscriptionTemplateCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+var DeleteSubscriptionTemplateCommand;
+(function (DeleteSubscriptionTemplateCommand) {
+    DeleteSubscriptionTemplateCommand.url = api_1.REST_API.SUBSCRIPTION_TEMPLATE.DELETE;
+    DeleteSubscriptionTemplateCommand.TSQ_url = DeleteSubscriptionTemplateCommand.url(':uuid');
+    DeleteSubscriptionTemplateCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.DELETE(':uuid'), 'delete', 'Delete subscription template');
+    DeleteSubscriptionTemplateCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    DeleteSubscriptionTemplateCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isDeleted: zod_1.z.boolean(),
+        }),
+    });
+})(DeleteSubscriptionTemplateCommand || (exports.DeleteSubscriptionTemplateCommand = DeleteSubscriptionTemplateCommand = {}));

package/build/frontend/commands/subscription-template/get-template.command.js

@@ -8,14 +8,15 @@ const constants_2 = require("../../constants");
 var GetSubscriptionTemplateCommand;
 (function (GetSubscriptionTemplateCommand) {
     GetSubscriptionTemplateCommand.url = api_1.REST_API.SUBSCRIPTION_TEMPLATE.GET;
-    GetSubscriptionTemplateCommand.TSQ_url = GetSubscriptionTemplateCommand.url(':templateType');
-    GetSubscriptionTemplateCommand.endpointDetails = (0, constants_2.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.GET(':templateType'), 'get', 'Get subscription template');
+    GetSubscriptionTemplateCommand.TSQ_url = GetSubscriptionTemplateCommand.url(':uuid');
+    GetSubscriptionTemplateCommand.endpointDetails = (0, constants_2.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.GET(':uuid'), 'get', 'Get subscription template by uuid');
     GetSubscriptionTemplateCommand.RequestSchema = zod_1.z.object({
-        templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+        uuid: zod_1.z.string().uuid(),
     });
     GetSubscriptionTemplateCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             uuid: zod_1.z.string().uuid(),
+            name: zod_1.z.string(),
             templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
             templateJson: zod_1.z.nullable(zod_1.z.unknown()),
             encodedTemplateYaml: zod_1.z.nullable(zod_1.z.string()),

package/build/frontend/commands/subscription-template/get-templates.command.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSubscriptionTemplatesCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const constants_2 = require("../../constants");
+var GetSubscriptionTemplatesCommand;
+(function (GetSubscriptionTemplatesCommand) {
+    GetSubscriptionTemplatesCommand.url = api_1.REST_API.SUBSCRIPTION_TEMPLATE.GET_ALL;
+    GetSubscriptionTemplatesCommand.TSQ_url = GetSubscriptionTemplatesCommand.url;
+    GetSubscriptionTemplatesCommand.endpointDetails = (0, constants_2.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.GET_ALL, 'get', 'Get all subscription templates (wihout content)');
+    GetSubscriptionTemplatesCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            total: zod_1.z.number(),
+            templates: zod_1.z.array(zod_1.z.object({
+                uuid: zod_1.z.string().uuid(),
+                name: zod_1.z.string(),
+                templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+                templateJson: zod_1.z.nullable(zod_1.z.unknown()),
+                encodedTemplateYaml: zod_1.z.nullable(zod_1.z.string()),
+            })),
+        }),
+    });
+})(GetSubscriptionTemplatesCommand || (exports.GetSubscriptionTemplatesCommand = GetSubscriptionTemplatesCommand = {}));

package/build/frontend/commands/subscription-template/index.js

@@ -14,5 +14,8 @@ 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("./create-template.command"), exports);
+__exportStar(require("./delete-subscription-template.command"), exports);
 __exportStar(require("./get-template.command"), exports);
+__exportStar(require("./get-templates.command"), exports);
 __exportStar(require("./update-template.command"), exports);

package/build/frontend/commands/subscription-template/update-template.command.js

@@ -9,15 +9,21 @@ var UpdateSubscriptionTemplateCommand;
 (function (UpdateSubscriptionTemplateCommand) {
     UpdateSubscriptionTemplateCommand.url = api_1.REST_API.SUBSCRIPTION_TEMPLATE.UPDATE;
     UpdateSubscriptionTemplateCommand.TSQ_url = UpdateSubscriptionTemplateCommand.url;
-    UpdateSubscriptionTemplateCommand.endpointDetails = (0, constants_2.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.UPDATE, 'put', 'Update subscription template');
+    UpdateSubscriptionTemplateCommand.endpointDetails = (0, constants_2.getEndpointDetails)(api_1.SUBSCRIPTION_TEMPLATE_ROUTES.UPDATE, 'patch', 'Update subscription template');
     UpdateSubscriptionTemplateCommand.RequestSchema = zod_1.z.object({
-        templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+        uuid: zod_1.z.string().uuid(),
+        name: zod_1.z
+            .string()
+            .min(2, 'Name must be at least 2 characters')
+            .max(255, 'Name must be less than 255 characters')
+            .regex(/^[A-Za-z0-9_\s-]+$/, 'Name can only contain letters, numbers, underscores, dashes and spaces'),
         templateJson: zod_1.z.optional(zod_1.z.object({}).passthrough()),
         encodedTemplateYaml: zod_1.z.optional(zod_1.z.string()),
     });
     UpdateSubscriptionTemplateCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             uuid: zod_1.z.string().uuid(),
+            name: zod_1.z.string(),
             templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
             templateJson: zod_1.z.nullable(zod_1.z.unknown()),
             encodedTemplateYaml: zod_1.z.nullable(zod_1.z.string()),

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

@@ -44,6 +44,9 @@ var BulkUpdateUsersCommand;
                 .max(16, 'Tag must be less than 16 characters')
                 .nullable()),
             hwidDeviceLimit: zod_1.z.optional(zod_1.z.number().int().min(0, 'Device limit must be non-negative').nullable()),
+            externalSquadUuid: zod_1.z
+                .optional(zod_1.z.nullable(zod_1.z.string().uuid()))
+                .describe('Optional. External squad UUID.'),
         }),
     });
     BulkUpdateUsersCommand.ResponseSchema = zod_1.z.object({

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

@@ -130,6 +130,9 @@ var CreateUserCommand;
             .string()
             .uuid()
             .describe('Optional. Pass UUID to create user with specific UUID, otherwise it will be generated automatically.')),
+        externalSquadUuid: zod_1.z
+            .optional(zod_1.z.nullable(zod_1.z.string().uuid()))
+            .describe('Optional. External squad UUID.'),
     });
     CreateUserCommand.ResponseSchema = zod_1.z.object({
         response: models_1.ExtendedUsersSchema,

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

@@ -69,6 +69,9 @@ var UpdateUserCommand;
             invalid_type_error: 'Enabled internal squads must be an array of UUIDs',
         })
             .optional(),
+        externalSquadUuid: zod_1.z
+            .optional(zod_1.z.nullable(zod_1.z.string().uuid()))
+            .describe('Optional. External squad UUID.'),
     })
         .refine((data) => data.uuid || data.username, {
         message: 'Either uuid or username must be provided',

package/build/frontend/constants/cache-keys/cache-keys.constants.js

@@ -3,4 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CACHE_KEYS = void 0;
 exports.CACHE_KEYS = {
     SUBSCRIPTION_SETTINGS: 'subscription_settings',
+    SUBSCRIPTION_TEMPLATE: (name, type) => `subscription_template:${name}:${type}`,
 };