@sonoransoftware/sonoran.js 1.0.0 → 1.0.3

package/dist/managers/CMSManager.d.ts

@@ -0,0 +1,81 @@
+import { Instance } from '../instance/Instance';
+import { CMSSubscriptionVersionEnum } from '../constants';
+import { REST } from '../libs/rest/src';
+import { BaseManager } from './BaseManager';
+import * as globalTypes from '../constants';
+import { CMSServerManager } from './CMSServerManager';
+/**
+ * Manages all Sonoran CMS data and methods to interact with the public API.
+ */
+export declare class CMSManager extends BaseManager {
+    readonly ready: boolean;
+    readonly version: CMSSubscriptionVersionEnum;
+    rest: REST | undefined;
+    servers: CMSServerManager | undefined;
+    constructor(instance: Instance);
+    protected buildManager(instance: Instance): Promise<void>;
+    /**
+     * Verifies the whitelist of a given account with the given parameters to search of said account.
+     * @param {Object | string} data The object or [accId | apiId as a string] that contains data to get a community account to verify if it has whitelist to the specified server. *If given as a string it will default to the set or default cms server id (1).
+     * @param {string} [data.accId] The account id to find a community account.
+     * @param {string} [data.apiId] The api id to find a community account.
+     * @param {string} [data.serverId] The username to find a community account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    verifyWhitelist(data: {
+        accId?: string;
+        apiId?: string;
+        serverId?: number;
+    } | string): Promise<globalTypes.CMSVerifyWhitelistPromiseResult>;
+    /**
+     * Gets a full whitelist allowed list for a specific server.
+     * @param {number} serverId (Optional) Server ID to get the whole allow list for, if not specified it will grab the default server ID that is set.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    getFullWhitelist(serverId?: number): Promise<globalTypes.CMSGetFullWhitelistPromiseResult>;
+    /**
+     * Gets a community account by `accId`, `apiId`, or `username`.
+     * @param {Object} params The object that contains parameters to get a community account.
+     * @param {string} [data.accId] The account id to find a community account.
+     * @param {string} [data.apiId] The api id to find a community account.
+     * @param {string} [data.username] The username to find a community account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    getComAccount(params: {
+        accId?: string;
+        apiId?: string;
+        username?: string;
+    }): Promise<globalTypes.CMSGetComAccountPromiseResult>;
+    /**
+     * Gets a community account by `accId`, `apiId`, or `username`.
+     * @param {Object} params The object that contains parameters to get a community account.
+     * @param {string} [data.accId] (Optional) The account id to find a community account.
+     * @param {string} [data.apiId] (Optional) The api id to find a community account.
+     * @param {string} [data.username] (Optional) The username to find a community account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    getAccountRanks(params: {
+        accId?: string;
+        apiId?: string;
+        username?: string;
+    }): Promise<globalTypes.CMSGetAccountRanksPromiseResult>;
+    /**
+     * Clocks in or out an account by `accId` or `apiId`.
+     * @param {Object} data The object that contains critical data to clock in or out an account.
+     * @param {string} [data.accId] (Optional) The account id to clock in or out.
+     * @param {string} [data.apiId] (Optional) The api id to clock in or out.
+     * @param {boolean} [data.forceClockIn] If true, it will override any current clock in with a new clock in at the time of the request.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed.
+     */
+    clockInOut(data: {
+        accId?: string;
+        apiId?: string;
+        forceClockIn?: boolean;
+    }): Promise<globalTypes.CMSClockInOutPromiseResult>;
+    /**
+     * Check if a given [apiId] is attached to any account within the community CMS.
+     * @param {string} apiId The api id to check for an account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed.
+     */
+    checkComApiId(apiId: string): Promise<globalTypes.CMSCheckComApiIdPromiseResult>;
+}

package/dist/managers/CMSManager.js

@@ -0,0 +1,212 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMSManager = void 0;
+const src_1 = require("../libs/rest/src");
+const BaseManager_1 = require("./BaseManager");
+const globalTypes = __importStar(require("../constants"));
+const CMSServerManager_1 = require("./CMSServerManager");
+/**
+ * Manages all Sonoran CMS data and methods to interact with the public API.
+ */
+class CMSManager extends BaseManager_1.BaseManager {
+    constructor(instance) {
+        super(instance);
+        this.ready = false;
+        this.version = 0;
+        this.rest = new src_1.REST(instance, this, globalTypes.productEnums.CMS, src_1.DefaultCMSRestOptions);
+        this.buildManager(instance);
+    }
+    async buildManager(instance) {
+        var _a;
+        try {
+            const versionResp = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_SUB_VERSION'));
+            const mutableThis = this;
+            mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i, '$1'));
+            if (this.version >= globalTypes.CMSSubscriptionVersionEnum.STANDARD) {
+                this.servers = new CMSServerManager_1.CMSServerManager(instance, this);
+            }
+            mutableThis.ready = true;
+            instance.isCMSSuccessful = true;
+            instance.emit('CMS_SETUP_SUCCESSFUL');
+        }
+        catch (err) {
+            instance.emit('CMS_SETUP_UNSUCCESSFUL', err);
+            throw err;
+        }
+    }
+    /**
+     * Verifies the whitelist of a given account with the given parameters to search of said account.
+     * @param {Object | string} data The object or [accId | apiId as a string] that contains data to get a community account to verify if it has whitelist to the specified server. *If given as a string it will default to the set or default cms server id (1).
+     * @param {string} [data.accId] The account id to find a community account.
+     * @param {string} [data.apiId] The api id to find a community account.
+     * @param {string} [data.serverId] The username to find a community account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    async verifyWhitelist(data) {
+        return new Promise(async (resolve, reject) => {
+            var _a, _b;
+            try {
+                const isString = typeof data === 'string';
+                const whitelistRequest = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('VERIFY_WHITELIST', isString ? data : data.apiId, isString ? data : data.accId, isString ? this.instance.cmsDefaultServerId : (_b = data.serverId) !== null && _b !== void 0 ? _b : this.instance.cmsDefaultServerId));
+                if (typeof whitelistRequest === 'string') {
+                    resolve({ success: true, reason: whitelistRequest });
+                }
+                else {
+                    resolve({ success: false, reason: whitelistRequest });
+                }
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Gets a full whitelist allowed list for a specific server.
+     * @param {number} serverId (Optional) Server ID to get the whole allow list for, if not specified it will grab the default server ID that is set.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    async getFullWhitelist(serverId) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const getFullWhitelistRequest = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('FULL_WHITELIST', serverId !== null && serverId !== void 0 ? serverId : this.instance.cmsDefaultServerId));
+                resolve({ success: true, data: getFullWhitelistRequest });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Gets a community account by `accId`, `apiId`, or `username`.
+     * @param {Object} params The object that contains parameters to get a community account.
+     * @param {string} [data.accId] The account id to find a community account.
+     * @param {string} [data.apiId] The api id to find a community account.
+     * @param {string} [data.username] The username to find a community account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    async getComAccount(params) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const getAccountRequest = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_COM_ACCOUNT', params.apiId, params.username, params.accId));
+                resolve({ success: true, data: getAccountRequest });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Gets a community account by `accId`, `apiId`, or `username`.
+     * @param {Object} params The object that contains parameters to get a community account.
+     * @param {string} [data.accId] (Optional) The account id to find a community account.
+     * @param {string} [data.apiId] (Optional) The api id to find a community account.
+     * @param {string} [data.username] (Optional) The username to find a community account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+     */
+    async getAccountRanks(params) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const getAccountRanksRequest = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_ACCOUNT_RANKS', params.apiId, params.username, params.accId));
+                resolve({ success: true, data: getAccountRanksRequest });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Clocks in or out an account by `accId` or `apiId`.
+     * @param {Object} data The object that contains critical data to clock in or out an account.
+     * @param {string} [data.accId] (Optional) The account id to clock in or out.
+     * @param {string} [data.apiId] (Optional) The api id to clock in or out.
+     * @param {boolean} [data.forceClockIn] If true, it will override any current clock in with a new clock in at the time of the request.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed.
+     */
+    async clockInOut(data) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const clockInOutRequest = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('CLOCK_IN_OUT', data.apiId, data.accId, !!data.forceClockIn));
+                const clockInOutRequestString = clockInOutRequest;
+                resolve({ success: true, clockedIn: clockInOutRequestString.includes('CLOCKED IN') });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Check if a given [apiId] is attached to any account within the community CMS.
+     * @param {string} apiId The api id to check for an account.
+     * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed.
+     */
+    async checkComApiId(apiId) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const checkComApiIdRequest = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('CHECK_COM_APIID', apiId));
+                resolve({ success: true, username: checkComApiIdRequest });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+}
+exports.CMSManager = CMSManager;

package/dist/managers/CMSServerManager.d.ts

@@ -0,0 +1,8 @@
+import { Instance } from '../instance/Instance';
+import { CMSServerAPIStruct } from '../libs/rest/src';
+import { CMSServer } from '../structures/CMSServer';
+import { CacheManager } from './CacheManager';
+import { CMSManager } from './CMSManager';
+export declare class CMSServerManager extends CacheManager<number, CMSServer, CMSServerAPIStruct> {
+    constructor(instance: Instance, manager: CMSManager);
+}

package/dist/managers/CMSServerManager.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CMSServerManager = void 0;
+const CMSServer_1 = require("../structures/CMSServer");
+const CacheManager_1 = require("./CacheManager");
+class CMSServerManager extends CacheManager_1.CacheManager {
+    constructor(instance, manager) {
+        super(instance, CMSServer_1.CMSServer, []);
+        (async () => {
+            var _a;
+            try {
+                const serversRes = await ((_a = manager.rest) === null || _a === void 0 ? void 0 : _a.request('GET_GAME_SERVERS'));
+                const servers = serversRes.servers;
+                servers.forEach((server) => {
+                    const serverStruct = {
+                        id: server.id,
+                        config: server
+                    };
+                    this._add(serverStruct, true, server.id);
+                });
+            }
+            catch (err) {
+                throw new Error(String(err));
+            }
+        })();
+    }
+}
+exports.CMSServerManager = CMSServerManager;

package/dist/managers/CacheManager.d.ts

@@ -0,0 +1,10 @@
+import Collection from '@discordjs/collection';
+import { Instance } from '../instance/Instance';
+import { Constructable } from '../constants';
+import { DataManager } from './DataManager';
+export declare class CacheManager<K, Holds, R> extends DataManager<K, Holds, R> {
+    _cache: Collection<any, any> | never;
+    protected constructor(instance: Instance, holds: Constructable<Holds>, iterable: Iterable<any>);
+    get cache(): Collection<any, any>;
+    _add(data: any, cache?: boolean, id?: K): any;
+}

package/dist/managers/CacheManager.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = void 0;
+const collection_1 = __importDefault(require("@discordjs/collection"));
+const DataManager_1 = require("./DataManager");
+class CacheManager extends DataManager_1.DataManager {
+    constructor(instance, holds, iterable) {
+        super(instance, holds);
+        this._cache = new collection_1.default();
+        if (iterable) {
+            for (const item of iterable) {
+                this._add(item);
+            }
+        }
+    }
+    get cache() {
+        return this._cache;
+    }
+    _add(data, cache = true, id) {
+        const existing = this.cache.get(id !== null && id !== void 0 ? id : data.id);
+        if (existing) {
+            if (cache) {
+                existing._patch(data);
+                return existing;
+            }
+            const clone = existing._clone();
+            clone._patch(data);
+            return clone;
+        }
+        const entry = data;
+        if (cache)
+            this.cache.set(id !== null && id !== void 0 ? id : entry.id, entry);
+        return entry;
+    }
+}
+exports.CacheManager = CacheManager;

package/dist/managers/DataManager.d.ts

@@ -0,0 +1,31 @@
+import { Instance } from '../instance/Instance';
+import { BaseManager } from './BaseManager';
+import { Constructable } from '../constants';
+import Collection from '@discordjs/collection';
+interface DataManagerInstanceObject {
+    id: string;
+}
+export declare class DataManager<_K, Holds, _R> extends BaseManager {
+    holds: Constructable<Holds>;
+    constructor(instance: Instance, holds: any);
+    /**
+     * The cache of items for this manager.
+     * @type {Collection}
+     * @abstract
+     */
+    get cache(): Collection<any, any>;
+    /**
+     * Resolves a data entry to a data Object.
+     * @param idOrInstance The id or instance of something in this Manager
+     * @returns {?Object} An instance from this Manager
+     */
+    resolve(idOrInstance: string | object): object | null;
+    /**
+     * Resolves a data entry to an instance id.
+     * @param {string|Object} idOrInstance The id or instance of something in this Manager
+     * @returns {?Snowflake}
+     */
+    resolveId(idOrInstance: string | DataManagerInstanceObject): string | null;
+    valueOf(): Collection<any, any>;
+}
+export {};

package/dist/managers/DataManager.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataManager = void 0;
+const BaseManager_1 = require("./BaseManager");
+const errors_1 = require("../errors");
+const collection_1 = __importDefault(require("@discordjs/collection"));
+class DataManager extends BaseManager_1.BaseManager {
+    constructor(instance, holds) {
+        super(instance);
+        /**
+         * The data structure belonging to this manager.
+         * @name DataManager#holds
+         * @type {Function}
+         * @private
+         * @readonly
+         */
+        this.holds = holds;
+    }
+    /**
+     * The cache of items for this manager.
+     * @type {Collection}
+     * @abstract
+     */
+    get cache() {
+        throw new errors_1.GenericError('NOT_IMPLEMENTED', 'get cache', this.constructor.name);
+    }
+    /**
+     * Resolves a data entry to a data Object.
+     * @param idOrInstance The id or instance of something in this Manager
+     * @returns {?Object} An instance from this Manager
+     */
+    resolve(idOrInstance) {
+        var _a;
+        if (this.cache instanceof collection_1.default) {
+            if (typeof idOrInstance === 'object')
+                return idOrInstance;
+            if (typeof idOrInstance === 'string')
+                return (_a = this.cache.get(idOrInstance)) !== null && _a !== void 0 ? _a : null;
+        }
+        return null;
+    }
+    /**
+     * Resolves a data entry to an instance id.
+     * @param {string|Object} idOrInstance The id or instance of something in this Manager
+     * @returns {?Snowflake}
+     */
+    resolveId(idOrInstance) {
+        if (typeof idOrInstance === 'object')
+            return idOrInstance.id;
+        if (typeof idOrInstance === 'string')
+            return idOrInstance;
+        return null;
+    }
+    valueOf() {
+        return this.cache;
+    }
+}
+exports.DataManager = DataManager;

package/dist/structures/Base.d.ts

@@ -0,0 +1,9 @@
+import { Instance } from '../instance/Instance';
+export declare abstract class Base {
+    instance: Instance;
+    constructor(instance: Instance);
+    _clone(): any;
+    _patch(data: any): any;
+    _update(data: any): any;
+    toJSON(...props: Record<string, boolean | string>[]): unknown;
+}

package/dist/structures/Base.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const utils_1 = require("../utils");
+class Base {
+    constructor(instance) {
+        this.instance = instance;
+    }
+    _clone() {
+        return Object.assign(Object.create(this), this);
+    }
+    _patch(data) {
+        return data;
+    }
+    _update(data) {
+        const clone = this._clone();
+        this._patch(data);
+        return clone;
+    }
+    toJSON(...props) {
+        return (0, utils_1.flatten)(this, ...props);
+    }
+}
+exports.Base = Base;

package/dist/structures/CADActiveUnit.d.ts

@@ -0,0 +1,47 @@
+import { Instance } from '../instance/Instance';
+import { Base } from './Base';
+export interface CADActiveUnitStruct {
+    id: number;
+    accId: string;
+    status: number;
+    isPanic: boolean;
+    location: string;
+    aop: string;
+    isDispatch: boolean;
+    data: CADActiveUnitDataStruct;
+}
+interface CADActiveUnitStructPartial {
+    id: number;
+    accId: string;
+    status: number;
+    isPanic: boolean;
+    location: string;
+    aop: string;
+    isDispatch: boolean;
+    data: Partial<CADActiveUnitDataStruct>;
+}
+export interface CADActiveUnitDataStruct {
+    apiId1: string;
+    apiId2: string;
+    unitNum: string;
+    name: string;
+    district: string;
+    department: string;
+    subdivision: string;
+    rank: string;
+    group: string;
+}
+export declare type CADActiveUnitResolvable = CADActiveUnit | number;
+export declare class CADActiveUnit extends Base {
+    id: number;
+    accId: string;
+    status: number;
+    isPanic: boolean;
+    location: string;
+    aop: string;
+    isDispatch: boolean;
+    data: CADActiveUnitDataStruct;
+    constructor(instance: Instance, data: any);
+    _patch(data: Partial<CADActiveUnitStructPartial>): void;
+}
+export {};

package/dist/structures/CADActiveUnit.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CADActiveUnit = void 0;
+const Base_1 = require("./Base");
+class CADActiveUnit extends Base_1.Base {
+    constructor(instance, data) {
+        super(instance);
+        this.id = -1;
+        this.accId = '';
+        this.status = 0;
+        this.isPanic = false;
+        this.location = '';
+        this.aop = '';
+        this.isDispatch = false;
+        this.data = {
+            apiId1: '',
+            apiId2: '',
+            unitNum: '',
+            name: '',
+            district: '',
+            department: '',
+            subdivision: '',
+            rank: '',
+            group: ''
+        };
+        if (data)
+            this._patch(data);
+    }
+    _patch(data) {
+        if (data.id !== undefined)
+            this.id = data.id;
+        if (data.accId !== undefined)
+            this.accId = data.accId;
+        if (data.status !== undefined)
+            this.status = data.status;
+        if (data.isPanic !== undefined)
+            this.isPanic = data.isPanic;
+        if (data.location !== undefined)
+            this.location = data.location;
+        if (data.aop !== undefined)
+            this.aop = data.aop;
+        if (data.isDispatch !== undefined)
+            this.isDispatch = data.isDispatch;
+        if (data.data !== undefined) {
+            if (data.data.apiId1 !== undefined)
+                this.data.apiId1 = data.data.apiId1;
+            if (data.data.apiId2 !== undefined)
+                this.data.apiId2 = data.data.apiId2;
+            if (data.data.unitNum !== undefined)
+                this.data.unitNum = data.data.unitNum;
+            if (data.data.name !== undefined)
+                this.data.name = data.data.name;
+            if (data.data.district !== undefined)
+                this.data.district = data.data.district;
+            if (data.data.department !== undefined)
+                this.data.department = data.data.department;
+            if (data.data.subdivision !== undefined)
+                this.data.subdivision = data.data.subdivision;
+            if (data.data.rank !== undefined)
+                this.data.rank = data.data.rank;
+            if (data.data.group !== undefined)
+                this.data.group = data.data.group;
+        }
+    }
+}
+exports.CADActiveUnit = CADActiveUnit;

package/dist/structures/CADServer.d.ts

@@ -0,0 +1,26 @@
+import { Instance } from '../instance/Instance';
+import { Base } from './Base';
+export interface CADServerData {
+    id: number;
+    config: CADServerConfig;
+}
+export interface CADServerConfig {
+    id: number;
+    name: string;
+    description: string;
+    signal: null;
+    mapUrl: string;
+    mapIp: string;
+    mapPort: string;
+    differingOutbound: boolean;
+    outboundIp: string;
+    listenerPort: string;
+    enableMap: boolean;
+    mapType: string;
+    isStatic: boolean;
+}
+export declare class CADServer extends Base {
+    id: number;
+    config: CADServerConfig;
+    constructor(instance: Instance, data: CADServerData);
+}

package/dist/structures/CADServer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CADServer = void 0;
+// import { CADActiveUnitsManager } from '../managers/CADActiveUnitsManager';
+const Base_1 = require("./Base");
+class CADServer extends Base_1.Base {
+    // public units!: CADActiveUnitsManager; 
+    constructor(instance, data) {
+        super(instance);
+        this.id = data.id;
+        this.config = data.config;
+        // this.units = new CADActiveUnitsManager(instance, [], this.id);
+    }
+}
+exports.CADServer = CADServer;