rustplus-ts
Version:
Rust+ API Wrapper written in TypeScript for the game Rust.
1,138 lines (1,133 loc) • 76.9 kB
JavaScript
/*
Copyright (C) 2025 Alexander Emanuelsson (alexemanuelol)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
https://github.com/alexemanuelol/rustplus-ts
*/
'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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.isValidVector2 = isValidVector2;
exports.isValidVector3 = isValidVector3;
exports.isValidVector4 = isValidVector4;
exports.isValidHalf3 = isValidHalf3;
exports.isValidColor = isValidColor;
exports.isValidRay = isValidRay;
exports.isValidClanActionResult = isValidClanActionResult;
exports.isValidClanInfo = isValidClanInfo;
exports.isValidClanInfo_Role = isValidClanInfo_Role;
exports.isValidClanInfo_Member = isValidClanInfo_Member;
exports.isValidClanInfo_Invite = isValidClanInfo_Invite;
exports.isValidClanLog = isValidClanLog;
exports.isValidClanLog_Entry = isValidClanLog_Entry;
exports.isValidClanInvitations = isValidClanInvitations;
exports.isValidClanInvitations_Invitation = isValidClanInvitations_Invitation;
exports.isValidAppRequest = isValidAppRequest;
exports.isValidAppEmpty = isValidAppEmpty;
exports.isValidAppSendMessage = isValidAppSendMessage;
exports.isValidAppSetEntityValue = isValidAppSetEntityValue;
exports.isValidAppFlag = isValidAppFlag;
exports.isValidAppPromoteToLeader = isValidAppPromoteToLeader;
exports.isValidAppGetNexusAuth = isValidAppGetNexusAuth;
exports.isValidAppCameraSubscribe = isValidAppCameraSubscribe;
exports.isValidAppCameraInput = isValidAppCameraInput;
exports.isValidAppMessage = isValidAppMessage;
exports.isValidAppResponse = isValidAppResponse;
exports.isValidAppSuccess = isValidAppSuccess;
exports.isValidAppError = isValidAppError;
exports.isValidAppInfo = isValidAppInfo;
exports.isValidAppTime = isValidAppTime;
exports.isValidAppMap = isValidAppMap;
exports.isValidAppMap_Monument = isValidAppMap_Monument;
exports.isValidAppTeamInfo = isValidAppTeamInfo;
exports.isValidAppTeamInfo_Member = isValidAppTeamInfo_Member;
exports.isValidAppTeamInfo_Note = isValidAppTeamInfo_Note;
exports.isValidAppTeamInfo_Note_Type = isValidAppTeamInfo_Note_Type;
exports.isValidAppTeamInfo_Note_Icon = isValidAppTeamInfo_Note_Icon;
exports.isValidAppTeamInfo_Note_ColourIndex = isValidAppTeamInfo_Note_ColourIndex;
exports.isValidAppTeamChat = isValidAppTeamChat;
exports.isValidAppTeamMessage = isValidAppTeamMessage;
exports.isValidAppEntityInfo = isValidAppEntityInfo;
exports.isValidAppEntityType = isValidAppEntityType;
exports.isValidAppEntityPayload = isValidAppEntityPayload;
exports.isValidAppEntityPayload_Item = isValidAppEntityPayload_Item;
exports.isValidAppMapMarkers = isValidAppMapMarkers;
exports.isValidAppMarker = isValidAppMarker;
exports.isValidAppMarkerType = isValidAppMarkerType;
exports.isValidAppMarker_SellOrder = isValidAppMarker_SellOrder;
exports.isValidAppClanInfo = isValidAppClanInfo;
exports.isValidAppClanChat = isValidAppClanChat;
exports.isValidAppClanMessage = isValidAppClanMessage;
exports.isValidAppNexusAuth = isValidAppNexusAuth;
exports.isValidAppCameraInfo = isValidAppCameraInfo;
exports.isValidAppBroadcast = isValidAppBroadcast;
exports.isValidAppTeamChanged = isValidAppTeamChanged;
exports.isValidAppNewTeamMessage = isValidAppNewTeamMessage;
exports.isValidAppEntityChanged = isValidAppEntityChanged;
exports.isValidAppClanChanged = isValidAppClanChanged;
exports.isValidAppNewClanMessage = isValidAppNewClanMessage;
exports.isValidAppCameraRays = isValidAppCameraRays;
exports.isValidAppCameraRays_Entity = isValidAppCameraRays_Entity;
exports.isValidAppCameraRays_EntityType = isValidAppCameraRays_EntityType;
exports.isValidRustPlusRequestTokens = isValidRustPlusRequestTokens;
exports.isValidEmitErrorType = isValidEmitErrorType;
exports.isValidAppResponseError = isValidAppResponseError;
exports.isValidConsumeTokensError = isValidConsumeTokensError;
const rpi = __importStar(require("./interfaces/rustplus"));
const rp = __importStar(require("./rustplus"));
function getTypeOf(value) {
return value === null ? 'null' : typeof value;
}
function isType(value, ...types) {
return types.some(type => (type === null && value === null) || (type === undefined && value === undefined) || (typeof value === type));
}
function validateType(key, value, ...types) {
if (!isType(value, ...types)) {
return { key: key, value: getTypeOf(value), expected: types };
}
return null;
}
function validateInterface(key, value, logger = null, validationCallback) {
if (!validationCallback(value, logger)) {
return { key: key, value: value, expected: 'unknown' };
}
return null;
}
function validateArrayOfInterfaces(key, value, logger = null, validationCallback) {
if (!Array.isArray(value)) {
return { key: key, value: getTypeOf(value), expected: 'Array of interfaces' };
}
const errors = value.map((item, index) => {
const isValid = validationCallback(item, logger);
return isValid ? null : 'Invalid';
}).filter(error => error !== null);
if (errors.length > 0) {
return { key, value: 'unknown', expected: 'Array of interfaces' };
}
return null;
}
function validateArrayOfTypes(key, value, ...types) {
if (!Array.isArray(value)) {
return { key: key, value: getTypeOf(value), expected: `Array of types ${types.join(', ')}` };
}
/* Loop through each element in the array and check if its type is in the allowed types */
for (const item of value) {
let isValid = false;
for (const type of types) {
if (isType(item, type)) {
isValid = true;
break;
}
}
if (!isValid) {
/* If an invalid element is found, return the error */
return { key: key, value: getTypeOf(item), expected: `Array of types ${types.join(', ')}` };
}
}
return null;
}
function validateObjectOfInterfaces(key, value, logger = null, validationCallback) {
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
return { key: key, value: getTypeOf(value), expected: 'Object of interfaces' };
}
for (const [objKey, objValue] of Object.entries(value)) {
if (typeof objKey !== 'string' || typeof objValue !== 'object' || objValue === null || Array.isArray(objValue) || !validationCallback(objValue, logger)) {
return { key: key, value: 'unknown', expected: 'Object of interfaces' };
}
}
return null;
}
function validateNestedObjectOfInterfaces(key, value, logger = null, validationCallback) {
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
return { key: key, value: getTypeOf(value), expected: 'Nested object of interfaces' };
}
for (const [keyOuter, valueOuter] of Object.entries(value)) {
if (typeof keyOuter !== 'string' || typeof valueOuter !== 'object' || valueOuter === null ||
Array.isArray(valueOuter)) {
return { key: key, value: getTypeOf(valueOuter), expected: 'Outer nested object of interfaces' };
}
for (const [keyInner, valueInner] of Object.entries(valueOuter)) {
if (typeof keyInner !== 'string' || typeof valueInner !== 'object' || valueInner === null ||
Array.isArray(valueInner) || !validationCallback(valueInner, logger)) {
return { key: key, value: 'unknown', expected: 'Inner nested object of interfaces' };
}
}
}
return null;
}
function validateObjectOfTypes(key, value, ...types) {
if (typeof value !== 'object' || value === null || Array.isArray(value)) {
return { key: key, value: getTypeOf(value), expected: `Object of types ${types.join(', ')}` };
}
for (const [objKey, objValue] of Object.entries(value)) {
if (typeof objKey !== 'string') {
return { key: key, value: `objKey: ${typeof objKey}`, expected: `Object of types ${types.join(', ')}` };
}
let isValid = false;
for (const type of types) {
if (isType(objValue, type)) {
isValid = true;
break;
}
}
if (!isValid) {
return { key: key, value: `objValue: ${typeof objValue}`, expected: `Object of types ${types.join(', ')}` };
}
}
return null;
}
function validateUint8Array(key, value) {
if (!(value instanceof Uint8Array)) {
return { key, value: getTypeOf(value), expected: 'Uint8Array' };
}
return null;
}
function logValidations(interfaceName, errors, unknownKeys, logger = null) {
const functionName = `isValid${interfaceName}`;
const hasOnlyValidKeys = unknownKeys.length === 0;
const logError = logger ? logger.error.bind(logger) : console.error;
if (errors.length !== 0 || !hasOnlyValidKeys) {
logError(`[${functionName}] Invalid ${interfaceName} object.`);
if (errors.length !== 0) {
errors.forEach(error => {
logError(`[${functionName}] Key: ${error.key}, Value: ${error.value}, ` +
`Expected: ${error.expected}.`);
});
}
if (!hasOnlyValidKeys) {
logError(`[${functionName}] Unknown keys: ${unknownKeys.join(', ')}.`);
}
}
}
/**
* Validation checks for the rustplus.proto file interfaces and enums.
*/
function isValidVector2(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'Vector2';
const validKeys = [
'x',
'y'
];
const errors = [];
errors.push(validateType('x', obj.x, 'number'));
errors.push(validateType('y', obj.y, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidVector3(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'Vector3';
const validKeys = [
'x',
'y',
'z'
];
const errors = [];
errors.push(validateType('x', obj.x, 'number'));
errors.push(validateType('y', obj.y, 'number'));
errors.push(validateType('z', obj.z, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidVector4(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'Vector4';
const validKeys = [
'x',
'y',
'z',
'w'
];
const errors = [];
errors.push(validateType('x', obj.x, 'number'));
errors.push(validateType('y', obj.y, 'number'));
errors.push(validateType('z', obj.z, 'number'));
errors.push(validateType('w', obj.w, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidHalf3(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'Half3';
const validKeys = [
'x',
'y',
'z'
];
const errors = [];
errors.push(validateType('x', obj.x, 'number'));
errors.push(validateType('y', obj.y, 'number'));
errors.push(validateType('z', obj.z, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidColor(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'Color';
const validKeys = [
'r',
'g',
'b',
'a'
];
const errors = [];
errors.push(validateType('r', obj.r, 'number'));
errors.push(validateType('g', obj.g, 'number'));
errors.push(validateType('b', obj.b, 'number'));
errors.push(validateType('a', obj.a, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidRay(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'Ray';
const validKeys = [
'origin',
'direction'
];
const errors = [];
errors.push(Object.hasOwn(obj, 'origin') ?
validateInterface('origin', obj.origin, logger, isValidVector3) : null);
errors.push(Object.hasOwn(obj, 'direction') ?
validateInterface('direction', obj.direction, logger, isValidVector3) : null);
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanActionResult(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanActionResult';
const validKeys = [
'requestId',
'result',
'hasClanInfo',
'clanInfo'
];
const errors = [];
errors.push(validateType('requestId', obj.requestId, 'number'));
errors.push(validateType('result', obj.result, 'number'));
errors.push(validateType('hasClanInfo', obj.hasClanInfo, 'boolean'));
errors.push(Object.hasOwn(obj, 'clanInfo') ?
validateInterface('clanInfo', obj.clanInfo, logger, isValidClanInfo) : null);
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanInfo(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanInfo';
const validKeys = [
'clanId',
'name',
'created',
'creator',
'motd',
'motdTimestamp',
'motdAuthor',
'logo',
'color',
'roles',
'members',
'invites',
'maxMemberCount',
'score'
];
const errors = [];
errors.push(validateType('clanId', obj.clanId, 'string'));
errors.push(validateType('name', obj.name, 'string'));
errors.push(validateType('created', obj.created, 'string'));
errors.push(validateType('creator', obj.creator, 'string'));
errors.push(validateType('motd', obj.motd, 'string', undefined));
errors.push(validateType('motdTimestamp', obj.motdTimestamp, 'string'));
errors.push(validateType('motdAuthor', obj.motdAuthor, 'string'));
errors.push(Object.hasOwn(obj, 'logo') ? validateUint8Array('logo', obj.logo) : null);
errors.push(validateType('color', obj.color, 'number'));
errors.push(validateArrayOfInterfaces('roles', obj.roles, logger, isValidClanInfo_Role));
errors.push(validateArrayOfInterfaces('members', obj.members, logger, isValidClanInfo_Member));
errors.push(validateArrayOfInterfaces('invites', obj.invites, logger, isValidClanInfo_Invite));
errors.push(validateType('maxMemberCount', obj.maxMemberCount, 'number', undefined));
errors.push(validateType('score', obj.score, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanInfo_Role(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanInfo_Role';
const validKeys = [
'roleId',
'rank',
'name',
'canSetMotd',
'canSetLogo',
'canInvite',
'canKick',
'canPromote',
'canDemote',
'canSetPlayerNotes',
'canAccessLogs',
'canAccessScoreEvents'
];
const errors = [];
errors.push(validateType('roleId', obj.roleId, 'number'));
errors.push(validateType('rank', obj.rank, 'number'));
errors.push(validateType('name', obj.name, 'string'));
errors.push(validateType('canSetMotd', obj.canSetMotd, 'boolean'));
errors.push(validateType('canSetLogo', obj.canSetLogo, 'boolean'));
errors.push(validateType('canInvite', obj.canInvite, 'boolean'));
errors.push(validateType('canKick', obj.canKick, 'boolean'));
errors.push(validateType('canPromote', obj.canPromote, 'boolean'));
errors.push(validateType('canDemote', obj.canDemote, 'boolean'));
errors.push(validateType('canSetPlayerNotes', obj.canSetPlayerNotes, 'boolean'));
errors.push(validateType('canAccessLogs', obj.canAccessLogs, 'boolean'));
errors.push(validateType('canAccessScoreEvents', obj.canAccessScoreEvents, 'boolean'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanInfo_Member(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanInfo_Member';
const validKeys = [
'steamId',
'roleId',
'joined',
'lastSeen',
'notes',
'online'
];
const errors = [];
errors.push(validateType('steamId', obj.steamId, 'string'));
errors.push(validateType('roleId', obj.roleId, 'number'));
errors.push(validateType('joined', obj.joined, 'string'));
errors.push(validateType('lastSeen', obj.lastSeen, 'string'));
errors.push(validateType('notes', obj.notes, 'string', undefined));
errors.push(validateType('online', obj.online, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanInfo_Invite(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanInfo_Invite';
const validKeys = [
'steamId',
'recruiter',
'timestamp'
];
const errors = [];
errors.push(validateType('steamId', obj.steamId, 'string'));
errors.push(validateType('recruiter', obj.recruiter, 'string'));
errors.push(validateType('timestamp', obj.timestamp, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanLog(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanLog';
const validKeys = [
'clanId',
'logEntries'
];
const errors = [];
errors.push(validateType('clanId', obj.clanId, 'string'));
errors.push(validateArrayOfInterfaces('logEntries', obj.logEntries, logger, isValidClanLog_Entry));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanLog_Entry(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanLog_Entry';
const validKeys = [
'timestamp',
'eventKey',
'arg1',
'arg2',
'arg3',
'arg4'
];
const errors = [];
errors.push(validateType('timestamp', obj.timestamp, 'string'));
errors.push(validateType('eventKey', obj.eventKey, 'string'));
errors.push(validateType('arg1', obj.arg1, 'string', undefined));
errors.push(validateType('arg2', obj.arg2, 'string', undefined));
errors.push(validateType('arg3', obj.arg3, 'string', undefined));
errors.push(validateType('arg4', obj.arg4, 'string', undefined));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanInvitations(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanInvitations';
const validKeys = [
'invitations'
];
const errors = [];
errors.push(validateArrayOfInterfaces('invitations', obj.invitations, logger, isValidClanInvitations_Invitation));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidClanInvitations_Invitation(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'ClanInvitations_Invitation';
const validKeys = [
'clanId',
'recruiter',
'timestamp'
];
const errors = [];
errors.push(validateType('clanId', obj.clanId, 'string'));
errors.push(validateType('recruiter', obj.recruiter, 'string'));
errors.push(validateType('timestamp', obj.timestamp, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppRequest(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppRequest';
const validKeys = [
'seq',
'playerId',
'playerToken',
'entityId',
'getInfo',
'getTime',
'getMap',
'getTeamInfo',
'getTeamChat',
'sendTeamMessage',
'getEntityInfo',
'setEntityValue',
'checkSubscription',
'setSubscription',
'getMapMarkers',
'promoteToLeader',
'getClanInfo',
'setClanMotd',
'getClanChat',
'sendClanMessage',
'getNexusAuth',
'cameraSubscribe',
'cameraUnsubscribe',
'cameraInput'
];
const errors = [];
errors.push(validateType('seq', obj.seq, 'number'));
errors.push(validateType('playerId', obj.playerId, 'string'));
errors.push(validateType('playerToken', obj.playerToken, 'number'));
errors.push(validateType('entityId', obj.entityId, 'number', undefined));
errors.push(Object.hasOwn(obj, 'getInfo') ?
validateInterface('getInfo', obj.getInfo, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'getTime') ?
validateInterface('getTime', obj.getTime, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'getMap') ?
validateInterface('getMap', obj.getMap, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'getTeamInfo') ?
validateInterface('getTeamInfo', obj.getTeamInfo, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'getTeamChat') ?
validateInterface('getTeamChat', obj.getTeamChat, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'sendTeamMessage') ?
validateInterface('sendTeamMessage', obj.sendTeamMessage, logger, isValidAppSendMessage) : null);
errors.push(Object.hasOwn(obj, 'getEntityInfo') ?
validateInterface('getEntityInfo', obj.getEntityInfo, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'setEntityValue') ?
validateInterface('setEntityValue', obj.setEntityValue, logger, isValidAppSetEntityValue) : null);
errors.push(Object.hasOwn(obj, 'checkSubscription') ?
validateInterface('checkSubscription', obj.checkSubscription, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'setSubscription') ?
validateInterface('setSubscription', obj.setSubscription, logger, isValidAppFlag) : null);
errors.push(Object.hasOwn(obj, 'getMapMarkers') ?
validateInterface('getMapMarkers', obj.getMapMarkers, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'promoteToLeader') ?
validateInterface('promoteToLeader', obj.promoteToLeader, logger, isValidAppPromoteToLeader) : null);
errors.push(Object.hasOwn(obj, 'getClanInfo') ?
validateInterface('getClanInfo', obj.getClanInfo, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'setClanMotd') ?
validateInterface('setClanMotd', obj.setClanMotd, logger, isValidAppSendMessage) : null);
errors.push(Object.hasOwn(obj, 'getClanChat') ?
validateInterface('getClanChat', obj.getClanChat, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'sendClanMessage') ?
validateInterface('sendClanMessage', obj.sendClanMessage, logger, isValidAppSendMessage) : null);
errors.push(Object.hasOwn(obj, 'getNexusAuth') ?
validateInterface('getNexusAuth', obj.getNexusAuth, logger, isValidAppGetNexusAuth) : null);
errors.push(Object.hasOwn(obj, 'cameraSubscribe') ?
validateInterface('cameraSubscribe', obj.cameraSubscribe, logger, isValidAppCameraSubscribe) : null);
errors.push(Object.hasOwn(obj, 'cameraUnsubscribe') ?
validateInterface('cameraUnsubscribe', obj.cameraUnsubscribe, logger, isValidAppEmpty) : null);
errors.push(Object.hasOwn(obj, 'cameraInput') ?
validateInterface('cameraInput', obj.cameraInput, logger, isValidAppCameraInput) : null);
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppEmpty(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const interfaceName = 'AppEmpty';
const validKeys = [];
const errors = [];
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppSendMessage(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppSendMessage';
const validKeys = [
'message'
];
const errors = [];
errors.push(validateType('message', obj.message, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppSetEntityValue(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppSetEntityValue';
const validKeys = [
'value'
];
const errors = [];
errors.push(validateType('value', obj.value, 'boolean'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppFlag(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppFlag';
const validKeys = [
'value'
];
const errors = [];
errors.push(validateType('value', obj.value, 'boolean', undefined));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppPromoteToLeader(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppPromoteToLeader';
const validKeys = [
'steamId'
];
const errors = [];
errors.push(validateType('steamId', obj.steamId, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppGetNexusAuth(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppGetNexusAuth';
const validKeys = [
'appKey'
];
const errors = [];
errors.push(validateType('appKey', obj.appKey, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppCameraSubscribe(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppCameraSubscribe';
const validKeys = [
'cameraId'
];
const errors = [];
errors.push(validateType('cameraId', obj.cameraId, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppCameraInput(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppCameraInput';
const validKeys = [
'buttons',
'mouseDelta'
];
const errors = [];
errors.push(validateType('buttons', obj.buttons, 'number'));
errors.push(Object.hasOwn(obj, 'mouseDelta') ?
validateInterface('mouseDelta', obj.mouseDelta, logger, isValidVector2) : null);
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppMessage(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppMessage';
const validKeys = [
'response',
'broadcast'
];
const errors = [];
errors.push(Object.hasOwn(obj, 'response') ?
validateInterface('response', obj.response, logger, isValidAppResponse) : null);
errors.push(Object.hasOwn(obj, 'broadcast') ?
validateInterface('broadcast', obj.broadcast, logger, isValidAppBroadcast) : null);
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppResponse(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppResponse';
const validKeys = [
'seq',
'success',
'error',
'info',
'time',
'map',
'teamInfo',
'teamChat',
'entityInfo',
'flag',
'mapMarkers',
'clanInfo',
'clanChat',
'nexusAuth',
'cameraSubscribeInfo'
];
const errors = [];
errors.push(validateType('seq', obj.seq, 'number'));
errors.push(Object.hasOwn(obj, 'success') ?
validateInterface('success', obj.success, logger, isValidAppSuccess) : null);
errors.push(Object.hasOwn(obj, 'error') ?
validateInterface('error', obj.error, logger, isValidAppError) : null);
errors.push(Object.hasOwn(obj, 'info') ?
validateInterface('info', obj.info, logger, isValidAppInfo) : null);
errors.push(Object.hasOwn(obj, 'time') ?
validateInterface('time', obj.time, logger, isValidAppTime) : null);
errors.push(Object.hasOwn(obj, 'map') ?
validateInterface('map', obj.map, logger, isValidAppMap) : null);
errors.push(Object.hasOwn(obj, 'teamInfo') ?
validateInterface('teamInfo', obj.teamInfo, logger, isValidAppTeamInfo) : null);
errors.push(Object.hasOwn(obj, 'teamChat') ?
validateInterface('teamChat', obj.teamChat, logger, isValidAppTeamChat) : null);
errors.push(Object.hasOwn(obj, 'entityInfo') ?
validateInterface('entityInfo', obj.entityInfo, logger, isValidAppEntityInfo) : null);
errors.push(Object.hasOwn(obj, 'flag') ?
validateInterface('flag', obj.flag, logger, isValidAppFlag) : null);
errors.push(Object.hasOwn(obj, 'mapMarkers') ?
validateInterface('mapMarkers', obj.mapMarkers, logger, isValidAppMapMarkers) : null);
errors.push(Object.hasOwn(obj, 'clanInfo') ?
validateInterface('clanInfo', obj.clanInfo, logger, isValidAppClanInfo) : null);
errors.push(Object.hasOwn(obj, 'clanChat') ?
validateInterface('clanChat', obj.clanChat, logger, isValidAppClanChat) : null);
errors.push(Object.hasOwn(obj, 'nexusAuth') ?
validateInterface('nexusAuth', obj.nexusAuth, logger, isValidAppNexusAuth) : null);
errors.push(Object.hasOwn(obj, 'cameraSubscribeInfo') ?
validateInterface('cameraSubscribeInfo', obj.cameraSubscribeInfo, logger, isValidAppCameraInfo) : null);
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppSuccess(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const interfaceName = 'AppSuccess';
const validKeys = [];
const errors = [];
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppError(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppError';
const validKeys = [
'error'
];
const errors = [];
errors.push(validateType('error', obj.error, 'string'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppInfo(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppInfo';
const validKeys = [
'name',
'headerImage',
'url',
'map',
'mapSize',
'wipeTime',
'players',
'maxPlayers',
'queuedPlayers',
'seed',
'salt',
'logoImage',
'nexus',
'nexusId',
'nexusZone',
'camerasEnabled'
];
const errors = [];
errors.push(validateType('name', obj.name, 'string'));
errors.push(validateType('headerImage', obj.headerImage, 'string'));
errors.push(validateType('url', obj.url, 'string'));
errors.push(validateType('map', obj.map, 'string'));
errors.push(validateType('mapSize', obj.mapSize, 'number'));
errors.push(validateType('wipeTime', obj.wipeTime, 'number'));
errors.push(validateType('players', obj.players, 'number'));
errors.push(validateType('maxPlayers', obj.maxPlayers, 'number'));
errors.push(validateType('queuedPlayers', obj.queuedPlayers, 'number'));
errors.push(validateType('seed', obj.seed, 'number'));
errors.push(validateType('salt', obj.salt, 'number'));
errors.push(validateType('logoImage', obj.logoImage, 'string', undefined));
errors.push(validateType('nexus', obj.nexus, 'string', undefined));
errors.push(validateType('nexusId', obj.nexusId, 'number'));
errors.push(validateType('nexusZone', obj.nexusZone, 'string', undefined));
errors.push(validateType('camerasEnabled', obj.camerasEnabled, 'boolean'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppTime(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppTime';
const validKeys = [
'dayLengthMinutes',
'timeScale',
'sunrise',
'sunset',
'time'
];
const errors = [];
errors.push(validateType('dayLengthMinutes', obj.dayLengthMinutes, 'number'));
errors.push(validateType('timeScale', obj.timeScale, 'number'));
errors.push(validateType('sunrise', obj.sunrise, 'number'));
errors.push(validateType('sunset', obj.sunset, 'number'));
errors.push(validateType('time', obj.time, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppMap(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppMap';
const validKeys = [
'width',
'height',
'jpgImage',
'oceanMargin',
'monuments',
'background'
];
const errors = [];
errors.push(validateType('width', obj.width, 'number'));
errors.push(validateType('height', obj.height, 'number'));
errors.push(validateUint8Array('jpgImage', obj.jpgImage));
errors.push(validateType('oceanMargin', obj.oceanMargin, 'number'));
errors.push(validateArrayOfInterfaces('monuments', obj.monuments, logger, isValidAppMap_Monument));
errors.push(validateType('background', obj.background, 'string', undefined));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppMap_Monument(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppMap_Monument';
const validKeys = [
'token',
'x',
'y'
];
const errors = [];
errors.push(validateType('token', obj.token, 'string'));
errors.push(validateType('x', obj.x, 'number'));
errors.push(validateType('y', obj.y, 'number'));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppTeamInfo(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppTeamInfo';
const validKeys = [
'leaderSteamId',
'members',
'mapNotes',
'leaderMapNotes'
];
const errors = [];
errors.push(validateType('leaderSteamId', obj.leaderSteamId, 'string'));
errors.push(validateArrayOfInterfaces('members', obj.members, logger, isValidAppTeamInfo_Member));
errors.push(validateArrayOfInterfaces('mapNotes', obj.mapNotes, logger, isValidAppTeamInfo_Note));
errors.push(validateArrayOfInterfaces('leaderMapNotes', obj.leaderMapNotes, logger, isValidAppTeamInfo_Note));
const filteredErrors = errors.filter((error) => error !== null);
const objectKeys = Object.keys(object);
const unknownKeys = objectKeys.filter(key => !validKeys.includes(key));
const hasOnlyValidKeys = unknownKeys.length === 0;
logValidations(interfaceName, filteredErrors, unknownKeys, logger);
return filteredErrors.length === 0 && hasOnlyValidKeys;
}
function isValidAppTeamInfo_Member(object, logger = null) {
if (typeof object !== 'object' || object === null || Array.isArray(object)) {
return false;
}
const obj = object;
const interfaceName = 'AppTeamInfo_Member';
const validKeys = [
'steamId',
'name',
'x',
'y',
'isOnline',
'spawnTime',
'isAlive',
'deathTime'
];
const errors = [];
errors.push(validateType('steamId', obj.steamId, 'string'));
errors.push(validateType('n