@tomgiee/tsdp 1.0.1 → 1.1.0

package/dist/src/validator/validator.js

@@ -0,0 +1,573 @@
+"use strict";
+/**
+ * Validators for SDP (RFC 8866)
+ *
+ * This module consolidates:
+ * - Session-level validation
+ * - Media description validation
+ * - Cross-field semantic validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validResult = validResult;
+exports.invalidResult = invalidResult;
+exports.validateSdp = validateSdp;
+exports.validateSessionDescription = validateSessionDescription;
+exports.validateMediaDescription = validateMediaDescription;
+exports.validateAllMediaDescriptions = validateAllMediaDescriptions;
+exports.validateSemanticConstraints = validateSemanticConstraints;
+const errors_1 = require("../types/errors");
+const primitives_1 = require("../types/primitives");
+const attributes_1 = require("../types/attributes");
+const format_validators_1 = require("../utils/format-validators");
+/**
+ * Create a valid result
+ */
+function validResult() {
+    return { valid: true, errors: [] };
+}
+/**
+ * Create an invalid result with errors
+ */
+function invalidResult(errors) {
+    return { valid: false, errors };
+}
+// ============================================================================
+// Main Validation Entry Point
+// ============================================================================
+/**
+ * Perform complete semantic validation of a session description
+ *
+ * This is the main validation entry point that checks:
+ * 1. Session-level validation
+ * 2. Media-level validation
+ * 3. Cross-field semantic constraints
+ *
+ * @param session - Session description to validate
+ * @param options - Optional validation options
+ * @returns ValidationResult with all errors found
+ */
+function validateSdp(session, options = {}) {
+    const allErrors = [];
+    // 1. Session-level validation
+    const sessionResult = validateSessionDescription(session);
+    allErrors.push(...sessionResult.errors);
+    // 2. Check for deprecated key field
+    if (!options.allowDeprecatedKeyField && session.key !== undefined) {
+        allErrors.push(errors_1.ValidationError.constraintViolation('The k= field is deprecated per RFC 8866', 'RFC8866:5.12'));
+    }
+    // 3. Require session-level connection if specified
+    if (options.requireSessionConnection && session.connection === undefined) {
+        allErrors.push(errors_1.ValidationError.constraintViolation('Session-level connection information is required', 'RFC8866:5.7'));
+    }
+    // 4. Media-level validation
+    const hasSessionConnection = session.connection !== undefined;
+    const mediaResult = validateAllMediaDescriptions(session.mediaDescriptions, hasSessionConnection);
+    allErrors.push(...mediaResult.errors);
+    // 5. Cross-field semantic validation (if not skipped)
+    if (!options.skipSemanticValidation) {
+        const semanticResult = validateSemanticConstraints(session);
+        allErrors.push(...semanticResult.errors);
+    }
+    return allErrors.length === 0 ? validResult() : invalidResult(allErrors);
+}
+// ============================================================================
+// Session Validator
+// ============================================================================
+/**
+ * Validate a complete session description
+ *
+ * Checks RFC 8866 Section 5 requirements:
+ * - Required fields are present (v, o, s, t)
+ * - Version is 0
+ * - At least one time description
+ * - Connection coverage (session or all media)
+ *
+ * @param session - Session description to validate
+ * @returns ValidationResult with any errors found
+ */
+function validateSessionDescription(session) {
+    const errors = [];
+    // 1. Validate version (RFC 8866 Section 5.1)
+    validateVersion(session.version, errors);
+    // 2. Validate origin (RFC 8866 Section 5.2)
+    validateOrigin(session, errors);
+    // 3. Validate session name (RFC 8866 Section 5.3)
+    validateSessionName(session, errors);
+    // 4. Validate time descriptions (RFC 8866 Section 5.9)
+    validateTimeDescriptions(session, errors);
+    // 5. Validate connection coverage (RFC 8866 Section 5.7)
+    validateConnectionCoverage(session, errors);
+    // 6. Validate bandwidths (RFC 8866 Section 5.8)
+    validateBandwidths(session, errors);
+    // 7. Validate attributes (RFC 8866 Section 6)
+    validateSessionAttributes(session, errors);
+    // 8. Validate email format (RFC 8866 Section 5.6)
+    validateEmails(session, errors);
+    // 9. Validate phone format (RFC 8866 Section 5.6)
+    validatePhones(session, errors);
+    // 10. Validate URI format (RFC 8866 Section 5.5)
+    validateUri(session, errors);
+    return errors.length === 0 ? validResult() : invalidResult(errors);
+}
+/**
+ * Validate version field
+ */
+function validateVersion(version, errors) {
+    if (version !== 0) {
+        errors.push(errors_1.ValidationError.invalidValue('version', version, 'SDP version must be 0', 'RFC8866:5.1'));
+    }
+}
+/**
+ * Validate origin field
+ */
+function validateOrigin(session, errors) {
+    if (!session.origin) {
+        errors.push(errors_1.ValidationError.missingField('origin', 'RFC8866:5.2'));
+        return;
+    }
+    if (!session.origin.username || session.origin.username.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.username', session.origin.username, 'Username cannot be empty', 'RFC8866:5.2'));
+    }
+    if (!session.origin.sessId || session.origin.sessId.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessId', session.origin.sessId, 'Session ID cannot be empty', 'RFC8866:5.2'));
+    }
+    else if (!(0, primitives_1.isNumericString)(session.origin.sessId)) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessId', session.origin.sessId, 'Session ID must contain only digits (0-9)', 'RFC8866:5.2'));
+    }
+    if (!session.origin.sessVersion || session.origin.sessVersion.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessVersion', session.origin.sessVersion, 'Session version cannot be empty', 'RFC8866:5.2'));
+    }
+    else if (!(0, primitives_1.isNumericString)(session.origin.sessVersion)) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.sessVersion', session.origin.sessVersion, 'Session version must contain only digits (0-9)', 'RFC8866:5.2'));
+    }
+    if (!session.origin.netType || session.origin.netType.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.netType', session.origin.netType, 'Network type cannot be empty', 'RFC8866:5.2'));
+    }
+    if (!session.origin.addrType || session.origin.addrType.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.addrType', session.origin.addrType, 'Address type cannot be empty', 'RFC8866:5.2'));
+    }
+    if (!session.origin.unicastAddress || session.origin.unicastAddress.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('origin.unicastAddress', session.origin.unicastAddress, 'Unicast address cannot be empty', 'RFC8866:5.2'));
+    }
+}
+/**
+ * Validate session name field
+ */
+function validateSessionName(session, errors) {
+    if (session.sessionName === undefined || session.sessionName === null) {
+        errors.push(errors_1.ValidationError.missingField('sessionName', 'RFC8866:5.3'));
+    }
+    else if (session.sessionName.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue('sessionName', session.sessionName, 'Session name cannot be empty (use " " if no meaningful name)', 'RFC8866:5.3'));
+    }
+}
+/**
+ * Validate time descriptions
+ */
+function validateTimeDescriptions(session, errors) {
+    if (!session.timeDescriptions || session.timeDescriptions.length === 0) {
+        errors.push(errors_1.ValidationError.constraintViolation('At least one time description (t=) is required', 'RFC8866:5.9'));
+        return;
+    }
+    for (let i = 0; i < session.timeDescriptions.length; i++) {
+        const td = session.timeDescriptions[i];
+        if (!td.timing) {
+            errors.push(errors_1.ValidationError.missingField(`timeDescriptions[${i}].timing`, 'RFC8866:5.9'));
+            continue;
+        }
+        const { startTime, stopTime } = td.timing;
+        if (startTime !== 0 && stopTime !== 0 && startTime > stopTime) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}: start time (${startTime}) must be before or equal to stop time (${stopTime})`, 'RFC8866:5.9'));
+        }
+        for (let j = 0; j < td.repeats.length; j++) {
+            const repeat = td.repeats[j];
+            if (!repeat.offsets || repeat.offsets.length === 0) {
+                errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}, repeat ${j}: at least one offset is required`, 'RFC8866:5.10'));
+            }
+        }
+        if (td.timezone) {
+            if (!td.timezone.adjustments || td.timezone.adjustments.length === 0) {
+                errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}: timezone field requires at least one adjustment`, 'RFC8866:5.11'));
+            }
+        }
+    }
+}
+/**
+ * Validate connection coverage
+ */
+function validateConnectionCoverage(session, errors) {
+    var _a;
+    const hasSessionConnection = session.connection !== undefined;
+    const mediaDescriptions = (_a = session.mediaDescriptions) !== null && _a !== void 0 ? _a : [];
+    if (mediaDescriptions.length === 0) {
+        return;
+    }
+    if (hasSessionConnection) {
+        return;
+    }
+    for (let i = 0; i < mediaDescriptions.length; i++) {
+        const md = mediaDescriptions[i];
+        if (!md.connections || md.connections.length === 0) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Media description ${i} (${md.media.type}): connection information required when no session-level connection is present`, 'RFC8866:5.7'));
+        }
+    }
+}
+/**
+ * Validate bandwidth fields
+ */
+function validateBandwidths(session, errors) {
+    for (let i = 0; i < session.bandwidths.length; i++) {
+        const bw = session.bandwidths[i];
+        if (bw.value < 0) {
+            errors.push(errors_1.ValidationError.invalidValue(`bandwidths[${i}].value`, bw.value, 'Bandwidth value must be non-negative', 'RFC8866:5.8'));
+        }
+    }
+}
+/**
+ * Validate session-level attributes
+ */
+function validateSessionAttributes(session, errors) {
+    const directionAttrs = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+    let directionCount = 0;
+    for (const attr of session.attributes) {
+        if (attr.kind === 'property' && directionAttrs.includes(attr.name)) {
+            directionCount++;
+        }
+        if (attributes_1.MEDIA_ONLY_ATTRIBUTES.includes(attr.name)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Attribute '${attr.name}' is only valid at media level, not session level`, 'RFC8866:6'));
+        }
+    }
+    if (directionCount > 1) {
+        errors.push(errors_1.ValidationError.constraintViolation('Only one direction attribute (sendrecv/sendonly/recvonly/inactive) allowed at session level', 'RFC8866:6.7'));
+    }
+}
+/**
+ * Validate email addresses
+ */
+function validateEmails(session, errors) {
+    if (!session.emails || session.emails.length === 0) {
+        return;
+    }
+    for (let i = 0; i < session.emails.length; i++) {
+        const email = session.emails[i];
+        if (!(0, format_validators_1.isValidEmailFormat)(email)) {
+            errors.push(errors_1.ValidationError.invalidValue(`emails[${i}]`, email, 'Invalid email format. Expected: addr-spec, addr-spec (comment), or Display Name <addr-spec>', 'RFC8866:5.6'));
+        }
+    }
+}
+/**
+ * Validate phone numbers
+ */
+function validatePhones(session, errors) {
+    if (!session.phones || session.phones.length === 0) {
+        return;
+    }
+    for (let i = 0; i < session.phones.length; i++) {
+        const phone = session.phones[i];
+        if (!(0, format_validators_1.isValidPhoneFormat)(phone)) {
+            errors.push(errors_1.ValidationError.invalidValue(`phones[${i}]`, phone, 'Invalid phone format. Expected: phone, phone (comment), or Display Name <phone>', 'RFC8866:5.6'));
+        }
+    }
+}
+/**
+ * Validate URI
+ */
+function validateUri(session, errors) {
+    if (!session.uri) {
+        return;
+    }
+    if (!(0, format_validators_1.isValidURIReference)(session.uri)) {
+        errors.push(errors_1.ValidationError.invalidValue('uri', session.uri, 'Invalid URI format per RFC 3986', 'RFC8866:5.5'));
+    }
+}
+// ============================================================================
+// Media Description Validator
+// ============================================================================
+/**
+ * Validate a media description
+ *
+ * @param media - Media description to validate
+ * @param index - Index of media description (for error messages)
+ * @param hasSessionConnection - Whether session-level connection exists
+ * @returns ValidationResult with any errors found
+ */
+function validateMediaDescription(media, index, hasSessionConnection) {
+    const errors = [];
+    const prefix = `mediaDescriptions[${index}]`;
+    validateMediaField(media, prefix, errors);
+    validatePort(media, prefix, errors);
+    validateFormats(media, prefix, errors);
+    if (!hasSessionConnection) {
+        validateMediaConnection(media, prefix, errors);
+    }
+    validateMediaBandwidths(media, prefix, errors);
+    validateMediaAttributes(media, prefix, errors);
+    return errors.length === 0 ? validResult() : invalidResult(errors);
+}
+/**
+ * Validate media field
+ */
+function validateMediaField(media, prefix, errors) {
+    if (!media.media.type || media.media.type.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.type`, media.media.type, 'Media type cannot be empty', 'RFC8866:5.14'));
+    }
+    if (!media.media.proto || media.media.proto.length === 0) {
+        errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.proto`, media.media.proto, 'Protocol cannot be empty', 'RFC8866:5.14'));
+    }
+}
+/**
+ * Validate port
+ */
+function validatePort(media, prefix, errors) {
+    const port = media.media.port;
+    if (port.kind === 'simple') {
+        if (port.value < 0 || port.value > 65535) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.port`, port.value, 'Port must be 0-65535', 'RFC8866:5.14'));
+        }
+    }
+    else if (port.kind === 'range') {
+        if (port.base < 0 || port.base > 65535) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.port.base`, port.base, 'Port must be 0-65535', 'RFC8866:5.14'));
+        }
+        if (port.count < 1) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.media.port.count`, port.count, 'Port count must be at least 1', 'RFC8866:5.14'));
+        }
+        if (port.base + port.count - 1 > 65535) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: port range ${port.base}/${port.count} exceeds 65535`, 'RFC8866:5.14'));
+        }
+    }
+}
+/**
+ * Validate formats
+ */
+function validateFormats(media, prefix, errors) {
+    if (!media.media.formats || media.media.formats.length === 0) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: at least one media format is required`, 'RFC8866:5.14'));
+    }
+}
+/**
+ * Validate media-level connection
+ */
+function validateMediaConnection(media, prefix, errors) {
+    if (!media.connections || media.connections.length === 0) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: connection information required when no session-level connection`, 'RFC8866:5.7'));
+    }
+}
+/**
+ * Validate media-level bandwidths
+ */
+function validateMediaBandwidths(media, prefix, errors) {
+    for (let i = 0; i < media.bandwidths.length; i++) {
+        const bw = media.bandwidths[i];
+        if (bw.value < 0) {
+            errors.push(errors_1.ValidationError.invalidValue(`${prefix}.bandwidths[${i}].value`, bw.value, 'Bandwidth value must be non-negative', 'RFC8866:5.8'));
+        }
+    }
+}
+/**
+ * Validate media-level attributes
+ */
+function validateMediaAttributes(media, prefix, errors) {
+    const directionAttrs = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+    let directionCount = 0;
+    const rtpmapPayloadTypes = new Set();
+    const rtpmapPayloadTypeDuplicates = new Set();
+    const fmtpFormats = new Set();
+    const fmtpFormatDuplicates = new Set();
+    for (const attr of media.attributes) {
+        if (attr.kind === 'property' && directionAttrs.includes(attr.name)) {
+            directionCount++;
+        }
+        if (attributes_1.SESSION_ONLY_ATTRIBUTES.includes(attr.name)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: attribute '${attr.name}' is only valid at session level, not media level`, 'RFC8866:6'));
+        }
+        if (attr.kind === 'value' && attr.name === 'rtpmap') {
+            const match = attr.value.match(/^(\d+)\s/);
+            if (match) {
+                const payloadType = match[1];
+                if (rtpmapPayloadTypes.has(payloadType)) {
+                    rtpmapPayloadTypeDuplicates.add(payloadType);
+                }
+                else {
+                    rtpmapPayloadTypes.add(payloadType);
+                }
+            }
+        }
+        if (attr.kind === 'value' && attr.name === 'fmtp') {
+            const match = attr.value.match(/^(\S+)\s/);
+            if (match) {
+                const format = match[1];
+                if (fmtpFormats.has(format)) {
+                    fmtpFormatDuplicates.add(format);
+                }
+                else {
+                    fmtpFormats.add(format);
+                }
+            }
+        }
+        if (attr.kind === 'value' && attr.name === 'ptime') {
+            const ptime = parseFloat(attr.value);
+            if (isNaN(ptime) || ptime <= 0) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.ptime`, attr.value, 'ptime must be a positive number', 'RFC8866:6.4'));
+            }
+        }
+        if (attr.kind === 'value' && attr.name === 'maxptime') {
+            const maxptime = parseFloat(attr.value);
+            if (isNaN(maxptime) || maxptime <= 0) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.maxptime`, attr.value, 'maxptime must be a positive number', 'RFC8866:6.5'));
+            }
+        }
+        if (attr.kind === 'value' && attr.name === 'quality') {
+            const quality = parseInt(attr.value, 10);
+            if (isNaN(quality) || quality < 0 || quality > 10) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.quality`, attr.value, 'quality must be 0-10', 'RFC8866:6.14'));
+            }
+        }
+        if (attr.kind === 'value' && attr.name === 'framerate') {
+            const framerate = parseFloat(attr.value);
+            if (isNaN(framerate) || framerate <= 0) {
+                errors.push(errors_1.ValidationError.invalidValue(`${prefix}.attributes.framerate`, attr.value, 'framerate must be a positive number', 'RFC8866:6.13'));
+            }
+        }
+    }
+    if (directionCount > 1) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: only one direction attribute (sendrecv/sendonly/recvonly/inactive) allowed`, 'RFC8866:6.7'));
+    }
+    for (const pt of rtpmapPayloadTypeDuplicates) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: duplicate rtpmap for payload type ${pt} (at most one rtpmap per format allowed)`, 'RFC8866:6.6'));
+    }
+    for (const fmt of fmtpFormatDuplicates) {
+        errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: duplicate fmtp for format ${fmt} (at most one fmtp per format allowed)`, 'RFC8866:6.15'));
+    }
+    const formatStrings = media.media.formats.map((f) => f);
+    for (const pt of rtpmapPayloadTypes) {
+        if (!formatStrings.includes(pt)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: rtpmap payload type ${pt} not in format list`, 'RFC8866:6.6'));
+        }
+    }
+    for (const fmt of fmtpFormats) {
+        if (!formatStrings.includes(fmt) && !rtpmapPayloadTypes.has(fmt)) {
+            errors.push(errors_1.ValidationError.constraintViolation(`${prefix}: fmtp format ${fmt} not in format list`, 'RFC8866:6.15'));
+        }
+    }
+}
+/**
+ * Validate all media descriptions in a session
+ *
+ * @param mediaDescriptions - Array of media descriptions
+ * @param hasSessionConnection - Whether session-level connection exists
+ * @returns ValidationResult with any errors found
+ */
+function validateAllMediaDescriptions(mediaDescriptions, hasSessionConnection) {
+    const allErrors = [];
+    for (let i = 0; i < mediaDescriptions.length; i++) {
+        const result = validateMediaDescription(mediaDescriptions[i], i, hasSessionConnection);
+        allErrors.push(...result.errors);
+    }
+    return allErrors.length === 0 ? validResult() : invalidResult(allErrors);
+}
+// ============================================================================
+// Semantic Validation
+// ============================================================================
+/**
+ * Validate cross-field semantic constraints
+ *
+ * @param session - Session description to validate
+ * @returns ValidationResult with any errors found
+ */
+function validateSemanticConstraints(session) {
+    const errors = [];
+    validateDirectionConsistency(session, errors);
+    validateBandwidthConsistency(session, errors);
+    validateAddressTypeConsistency(session, errors);
+    validatePtimeConsistency(session, errors);
+    validateTimeConsistency(session, errors);
+    return errors.length === 0 ? validResult() : invalidResult(errors);
+}
+/**
+ * Validate direction attribute consistency
+ */
+function validateDirectionConsistency(session, errors) {
+    const directionAttrs = ['sendrecv', 'sendonly', 'recvonly', 'inactive'];
+    let sessionDirection;
+    for (const attr of session.attributes) {
+        if (attr.kind === 'property' && directionAttrs.includes(attr.name)) {
+            sessionDirection = attr.name;
+            break;
+        }
+    }
+    // If session is inactive, we could warn if any media has active direction
+    // but RFC allows media to override session-level direction
+}
+/**
+ * Validate bandwidth consistency
+ */
+function validateBandwidthConsistency(session, errors) {
+    let sessionCT;
+    for (const bw of session.bandwidths) {
+        if (bw.type === 'CT') {
+            sessionCT = bw.value;
+            break;
+        }
+    }
+    if (sessionCT === undefined) {
+        return;
+    }
+    let totalAS = 0;
+    for (const md of session.mediaDescriptions) {
+        for (const bw of md.bandwidths) {
+            if (bw.type === 'AS') {
+                totalAS += bw.value;
+            }
+        }
+    }
+    for (const bw of session.bandwidths) {
+        if (bw.type === 'AS') {
+            totalAS += bw.value;
+        }
+    }
+    if (totalAS > sessionCT) {
+        errors.push(errors_1.ValidationError.constraintViolation(`Sum of AS bandwidths (${totalAS}) exceeds CT bandwidth (${sessionCT})`, 'RFC8866:5.8'));
+    }
+}
+/**
+ * Validate address type consistency
+ */
+function validateAddressTypeConsistency(session, errors) {
+    // Different address types are allowed per RFC
+    // This function is a placeholder for additional consistency checks if needed
+}
+/**
+ * Validate ptime/maxptime relationship
+ */
+function validatePtimeConsistency(session, errors) {
+    for (let i = 0; i < session.mediaDescriptions.length; i++) {
+        const md = session.mediaDescriptions[i];
+        let ptime;
+        let maxptime;
+        for (const attr of md.attributes) {
+            if (attr.kind === 'value') {
+                if (attr.name === 'ptime') {
+                    ptime = parseFloat(attr.value);
+                }
+                else if (attr.name === 'maxptime') {
+                    maxptime = parseFloat(attr.value);
+                }
+            }
+        }
+        if (ptime !== undefined && maxptime !== undefined && ptime > maxptime) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Media ${i}: ptime (${ptime}) exceeds maxptime (${maxptime})`, 'RFC8866:6.4-6.5'));
+        }
+    }
+}
+/**
+ * Validate time description constraints
+ */
+function validateTimeConsistency(session, errors) {
+    for (let i = 0; i < session.timeDescriptions.length; i++) {
+        const td = session.timeDescriptions[i];
+        if (td.timezone && td.repeats.length === 0) {
+            errors.push(errors_1.ValidationError.constraintViolation(`Time description ${i}: timezone adjustment specified without repeat times`, 'RFC8866:5.11'));
+        }
+    }
+}