@bilig/workbook 0.42.0

package/dist/guards.js

@@ -0,0 +1,659 @@
+import { isCellRangeRef, isLiteralInput } from '@bilig/protocol';
+const HORIZONTAL_ALIGNMENT_VALUES = new Set(['general', 'left', 'center', 'right', 'fill', 'justify', 'centerContinuous', 'distributed']);
+const VERTICAL_ALIGNMENT_VALUES = new Set(['top', 'middle', 'bottom', 'justify', 'distributed']);
+const BORDER_STYLE_VALUES = new Set(['solid', 'dashed', 'dotted', 'double']);
+const BORDER_WEIGHT_VALUES = new Set(['thin', 'medium', 'thick']);
+const NUMBER_FORMAT_KIND_VALUES = new Set(['general', 'number', 'currency', 'accounting', 'percent', 'date', 'time', 'datetime', 'text']);
+const COMPATIBILITY_MODE_VALUES = new Set(['excel-modern', 'odf-1.4']);
+const SORT_DIRECTION_VALUES = new Set(['asc', 'desc']);
+const PIVOT_AGGREGATION_VALUES = new Set(['sum', 'count', 'countNums', 'average', 'min', 'max', 'product']);
+const VALIDATION_COMPARISON_OPERATOR_VALUES = new Set([
+    'between',
+    'notBetween',
+    'equal',
+    'notEqual',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+]);
+const VALIDATION_ERROR_STYLE_VALUES = new Set(['stop', 'warning', 'information']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isSafeNonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function isSafePositiveInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isOptionalNumber(value) {
+    return value === undefined || isFiniteNumber(value);
+}
+function isOptionalSafePositiveInteger(value) {
+    return value === undefined || isSafePositiveInteger(value);
+}
+function isOptionalSafeNonNegativeInteger(value) {
+    return value === undefined || isSafeNonNegativeInteger(value);
+}
+function isOptionalNullableNumber(value) {
+    return value === undefined || value === null || isFiniteNumber(value);
+}
+function isOptionalNullableSafePositiveInteger(value) {
+    return value === undefined || value === null || isSafePositiveInteger(value);
+}
+function isOptionalBoolean(value) {
+    return value === undefined || typeof value === 'boolean';
+}
+function isOptionalLiteralInput(value) {
+    return value === undefined || isLiteralInput(value);
+}
+function isOptionalNullableBoolean(value) {
+    return value === undefined || value === null || typeof value === 'boolean';
+}
+function hasString(value, key) {
+    return typeof value[key] === 'string';
+}
+function hasFiniteNumber(value, key) {
+    return isFiniteNumber(value[key]);
+}
+function hasSafeNonNegativeInteger(value, key) {
+    return isSafeNonNegativeInteger(value[key]);
+}
+function hasSafePositiveInteger(value, key) {
+    return isSafePositiveInteger(value[key]);
+}
+function isWorkbookAxisEntry(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasSafeNonNegativeInteger(value, 'index') &&
+        isOptionalNullableSafePositiveInteger(value['size']) &&
+        isOptionalNullableBoolean(value['hidden']));
+}
+function isCellBorderSide(value) {
+    return (isRecord(value) &&
+        hasString(value, 'color') &&
+        typeof value['style'] === 'string' &&
+        BORDER_STYLE_VALUES.has(value['style']) &&
+        typeof value['weight'] === 'string' &&
+        BORDER_WEIGHT_VALUES.has(value['weight']));
+}
+function isCellStyleRecord(value) {
+    if (!isRecord(value) || !hasString(value, 'id')) {
+        return false;
+    }
+    const fill = value['fill'];
+    if (fill !== undefined && (!isRecord(fill) || typeof fill['backgroundColor'] !== 'string')) {
+        return false;
+    }
+    const font = value['font'];
+    if (font !== undefined &&
+        (!isRecord(font) ||
+            !isOptionalString(font['family']) ||
+            !isOptionalNumber(font['size']) ||
+            !isOptionalBoolean(font['bold']) ||
+            !isOptionalBoolean(font['italic']) ||
+            !isOptionalBoolean(font['underline']) ||
+            !isOptionalString(font['color']))) {
+        return false;
+    }
+    const alignment = value['alignment'];
+    if (alignment !== undefined &&
+        (!isRecord(alignment) ||
+            !(alignment['horizontal'] === undefined ||
+                (typeof alignment['horizontal'] === 'string' && HORIZONTAL_ALIGNMENT_VALUES.has(alignment['horizontal']))) ||
+            !(alignment['vertical'] === undefined ||
+                (typeof alignment['vertical'] === 'string' && VERTICAL_ALIGNMENT_VALUES.has(alignment['vertical']))) ||
+            !isOptionalBoolean(alignment['wrap']) ||
+            !isOptionalNumber(alignment['indent']) ||
+            !isOptionalBoolean(alignment['shrinkToFit']) ||
+            !isOptionalNumber(alignment['readingOrder']) ||
+            !isOptionalNumber(alignment['textRotation']) ||
+            !isOptionalBoolean(alignment['justifyLastLine']))) {
+        return false;
+    }
+    const borders = value['borders'];
+    if (borders !== undefined &&
+        (!isRecord(borders) ||
+            !(borders['top'] === undefined || isCellBorderSide(borders['top'])) ||
+            !(borders['right'] === undefined || isCellBorderSide(borders['right'])) ||
+            !(borders['bottom'] === undefined || isCellBorderSide(borders['bottom'])) ||
+            !(borders['left'] === undefined || isCellBorderSide(borders['left'])))) {
+        return false;
+    }
+    const protection = value['protection'];
+    if (protection !== undefined &&
+        (!isRecord(protection) || !isOptionalBoolean(protection['locked']) || !isOptionalBoolean(protection['hidden']))) {
+        return false;
+    }
+    return true;
+}
+function isCellNumberFormatRecord(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'code') &&
+        typeof value['kind'] === 'string' &&
+        NUMBER_FORMAT_KIND_VALUES.has(value['kind']));
+}
+function isWorkbookCalculationSettings(value) {
+    return (isRecord(value) &&
+        (value['mode'] === 'automatic' || value['mode'] === 'manual') &&
+        (value['compatibilityMode'] === undefined ||
+            (typeof value['compatibilityMode'] === 'string' && COMPATIBILITY_MODE_VALUES.has(value['compatibilityMode']))));
+}
+function isWorkbookVolatileContext(value) {
+    return isRecord(value) && hasFiniteNumber(value, 'recalcEpoch');
+}
+function isWorkbookSortKey(value) {
+    return (isRecord(value) &&
+        hasString(value, 'keyAddress') &&
+        typeof value['direction'] === 'string' &&
+        SORT_DIRECTION_VALUES.has(value['direction']));
+}
+function isWorkbookValidationListSource(value) {
+    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+        return false;
+    }
+    switch (value['kind']) {
+        case 'named-range':
+            return hasString(value, 'name');
+        case 'cell-ref':
+            return hasString(value, 'sheetName') && hasString(value, 'address');
+        case 'range-ref':
+            return isCellRangeRef(value);
+        case 'structured-ref':
+            return hasString(value, 'tableName') && hasString(value, 'columnName');
+        default:
+            return false;
+    }
+}
+function isWorkbookDataValidationRule(value) {
+    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+        return false;
+    }
+    switch (value['kind']) {
+        case 'list': {
+            const hasValues = Array.isArray(value['values']) && value['values'].every((entry) => isLiteralInput(entry));
+            const hasSource = value['source'] !== undefined && isWorkbookValidationListSource(value['source']);
+            return (hasValues ? 1 : 0) + (hasSource ? 1 : 0) === 1;
+        }
+        case 'checkbox':
+            return isOptionalLiteralInput(value['checkedValue']) && isOptionalLiteralInput(value['uncheckedValue']);
+        case 'any':
+            return true;
+        case 'whole':
+        case 'decimal':
+        case 'date':
+        case 'time':
+        case 'textLength':
+            return (typeof value['operator'] === 'string' &&
+                VALIDATION_COMPARISON_OPERATOR_VALUES.has(value['operator']) &&
+                Array.isArray(value['values']) &&
+                value['values'].every((entry) => isLiteralInput(entry)) &&
+                (value['operator'] === 'between' || value['operator'] === 'notBetween'
+                    ? value['values'].length === 2
+                    : value['values'].length === 1));
+        default:
+            return false;
+    }
+}
+function isWorkbookDataValidation(value) {
+    return (isRecord(value) &&
+        isCellRangeRef(value['range']) &&
+        isWorkbookDataValidationRule(value['rule']) &&
+        isOptionalBoolean(value['allowBlank']) &&
+        isOptionalBoolean(value['showDropdown']) &&
+        isOptionalString(value['promptTitle']) &&
+        isOptionalString(value['promptMessage']) &&
+        (value['errorStyle'] === undefined ||
+            (typeof value['errorStyle'] === 'string' && VALIDATION_ERROR_STYLE_VALUES.has(value['errorStyle']))) &&
+        isOptionalString(value['errorTitle']) &&
+        isOptionalString(value['errorMessage']));
+}
+function isCellStylePatch(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const fill = value['fill'];
+    if (fill !== undefined &&
+        fill !== null &&
+        (!isRecord(fill) || !(fill['backgroundColor'] === undefined || fill['backgroundColor'] === null || hasString(fill, 'backgroundColor')))) {
+        return false;
+    }
+    const font = value['font'];
+    if (font !== undefined &&
+        font !== null &&
+        (!isRecord(font) ||
+            !(font['family'] === undefined || font['family'] === null || hasString(font, 'family')) ||
+            !isOptionalNullableNumber(font['size']) ||
+            !isOptionalNullableBoolean(font['bold']) ||
+            !isOptionalNullableBoolean(font['italic']) ||
+            !isOptionalNullableBoolean(font['underline']) ||
+            !(font['color'] === undefined || font['color'] === null || hasString(font, 'color')))) {
+        return false;
+    }
+    const alignment = value['alignment'];
+    if (alignment !== undefined &&
+        alignment !== null &&
+        (!isRecord(alignment) ||
+            !(alignment['horizontal'] === undefined ||
+                alignment['horizontal'] === null ||
+                (typeof alignment['horizontal'] === 'string' && HORIZONTAL_ALIGNMENT_VALUES.has(alignment['horizontal']))) ||
+            !(alignment['vertical'] === undefined ||
+                alignment['vertical'] === null ||
+                (typeof alignment['vertical'] === 'string' && VERTICAL_ALIGNMENT_VALUES.has(alignment['vertical']))) ||
+            !isOptionalNullableBoolean(alignment['wrap']) ||
+            !isOptionalNullableNumber(alignment['indent']) ||
+            !isOptionalNullableBoolean(alignment['shrinkToFit']) ||
+            !isOptionalNullableNumber(alignment['readingOrder']) ||
+            !isOptionalNullableNumber(alignment['textRotation']) ||
+            !isOptionalNullableBoolean(alignment['justifyLastLine']))) {
+        return false;
+    }
+    const borders = value['borders'];
+    if (borders !== undefined && borders !== null) {
+        if (!isRecord(borders)) {
+            return false;
+        }
+        for (const side of ['top', 'right', 'bottom', 'left']) {
+            const sideValue = borders[side];
+            if (sideValue === undefined || sideValue === null) {
+                continue;
+            }
+            if (!isRecord(sideValue) ||
+                !(sideValue['style'] === undefined ||
+                    sideValue['style'] === null ||
+                    (typeof sideValue['style'] === 'string' && BORDER_STYLE_VALUES.has(sideValue['style']))) ||
+                !(sideValue['weight'] === undefined ||
+                    sideValue['weight'] === null ||
+                    (typeof sideValue['weight'] === 'string' && BORDER_WEIGHT_VALUES.has(sideValue['weight']))) ||
+                !(sideValue['color'] === undefined || sideValue['color'] === null || hasString(sideValue, 'color'))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function isWorkbookConditionalFormatRule(value) {
+    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+        return false;
+    }
+    switch (value['kind']) {
+        case 'cellIs':
+            return (typeof value['operator'] === 'string' &&
+                VALIDATION_COMPARISON_OPERATOR_VALUES.has(value['operator']) &&
+                Array.isArray(value['values']) &&
+                value['values'].every((entry) => isLiteralInput(entry)) &&
+                (value['operator'] === 'between' || value['operator'] === 'notBetween'
+                    ? value['values'].length === 2
+                    : value['values'].length === 1));
+        case 'textContains':
+            return hasString(value, 'text') && isOptionalBoolean(value['caseSensitive']);
+        case 'formula':
+            return hasString(value, 'formula');
+        case 'blanks':
+        case 'notBlanks':
+            return true;
+        default:
+            return false;
+    }
+}
+function isWorkbookConditionalFormat(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        isCellRangeRef(value['range']) &&
+        isWorkbookConditionalFormatRule(value['rule']) &&
+        isCellStylePatch(value['style']) &&
+        isOptionalBoolean(value['stopIfTrue']) &&
+        isOptionalSafeNonNegativeInteger(value['priority']));
+}
+function isWorkbookSheetProtection(value) {
+    return isRecord(value) && hasString(value, 'sheetName') && isOptionalBoolean(value['hideFormulas']);
+}
+function isWorkbookRangeProtection(value) {
+    return isRecord(value) && hasString(value, 'id') && isCellRangeRef(value['range']) && isOptionalBoolean(value['hideFormulas']);
+}
+function isWorkbookCommentEntry(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'body') &&
+        isOptionalString(value['authorUserId']) &&
+        isOptionalString(value['authorDisplayName']) &&
+        isOptionalSafeNonNegativeInteger(value['createdAtUnixMs']));
+}
+function isWorkbookCommentThread(value) {
+    return (isRecord(value) &&
+        hasString(value, 'threadId') &&
+        hasString(value, 'sheetName') &&
+        hasString(value, 'address') &&
+        Array.isArray(value['comments']) &&
+        value['comments'].length > 0 &&
+        value['comments'].every((entry) => isWorkbookCommentEntry(entry)) &&
+        isOptionalBoolean(value['resolved']) &&
+        isOptionalString(value['resolvedByUserId']) &&
+        isOptionalSafeNonNegativeInteger(value['resolvedAtUnixMs']));
+}
+function isWorkbookNote(value) {
+    return isRecord(value) && hasString(value, 'sheetName') && hasString(value, 'address') && hasString(value, 'text');
+}
+function isWorkbookDefinedNameValue(value) {
+    if (isLiteralInput(value)) {
+        return true;
+    }
+    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+        return false;
+    }
+    switch (value['kind']) {
+        case 'scalar':
+            return isLiteralInput(value['value']);
+        case 'cell-ref':
+            return hasString(value, 'sheetName') && hasString(value, 'address');
+        case 'range-ref':
+            return isCellRangeRef(value);
+        case 'structured-ref':
+            return hasString(value, 'tableName') && hasString(value, 'columnName');
+        case 'formula':
+            return hasString(value, 'formula');
+        default:
+            return false;
+    }
+}
+function isWorkbookTableOp(value) {
+    return (isRecord(value) &&
+        hasString(value, 'name') &&
+        hasString(value, 'sheetName') &&
+        hasString(value, 'startAddress') &&
+        hasString(value, 'endAddress') &&
+        isStringArray(value['columnNames']) &&
+        typeof value['headerRow'] === 'boolean' &&
+        typeof value['totalsRow'] === 'boolean' &&
+        (value['columns'] === undefined || isWorkbookTableColumns(value['columns'])) &&
+        (value['style'] === undefined || isWorkbookTableStyle(value['style'])) &&
+        isOptionalString(value['sortState']));
+}
+function isWorkbookTableColumns(value) {
+    return (Array.isArray(value) &&
+        value.every((entry) => isRecord(entry) &&
+            hasString(entry, 'name') &&
+            isOptionalString(entry['totalsRowLabel']) &&
+            isOptionalString(entry['totalsRowFunction'])));
+}
+function isWorkbookTableStyle(value) {
+    return (isRecord(value) &&
+        isOptionalString(value['name']) &&
+        isOptionalBoolean(value['showFirstColumn']) &&
+        isOptionalBoolean(value['showLastColumn']) &&
+        isOptionalBoolean(value['showRowStripes']) &&
+        isOptionalBoolean(value['showColumnStripes']));
+}
+function isWorkbookPivotValue(value) {
+    return (isRecord(value) &&
+        hasString(value, 'sourceColumn') &&
+        typeof value['summarizeBy'] === 'string' &&
+        PIVOT_AGGREGATION_VALUES.has(value['summarizeBy']) &&
+        isOptionalString(value['outputLabel']));
+}
+function isOptionalLiteralInputArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every((entry) => isLiteralInput(entry)));
+}
+function isWorkbookPivotFilter(value) {
+    return (isRecord(value) &&
+        hasString(value, 'sourceColumn') &&
+        isOptionalLiteralInputArray(value['includedValues']) &&
+        isOptionalLiteralInputArray(value['hiddenValues']));
+}
+function isWorkbookPivotPageField(value) {
+    return isRecord(value) && hasString(value, 'sourceColumn') && isOptionalLiteralInput(value['selectedValue']);
+}
+function isWorkbookPivotHiddenItems(value) {
+    return isRecord(value) && hasString(value, 'sourceColumn') && Array.isArray(value['values']) && value['values'].every(isLiteralInput);
+}
+function isWorkbookPivotCalculatedFormula(value) {
+    return (isRecord(value) &&
+        hasString(value, 'name') &&
+        hasString(value, 'formula') &&
+        (value['clause'] === '18.10' || value['clause'] === '3.2.3.1'));
+}
+function isOptionalStringArray(value) {
+    return value === undefined || isStringArray(value);
+}
+function isOptionalPivotFilterArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(isWorkbookPivotFilter));
+}
+function isOptionalPivotPageFieldArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(isWorkbookPivotPageField));
+}
+function isOptionalPivotHiddenItemsArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(isWorkbookPivotHiddenItems));
+}
+function isOptionalPivotCalculatedFormulaArray(value) {
+    return value === undefined || (Array.isArray(value) && value.every(isWorkbookPivotCalculatedFormula));
+}
+function isOptionalCachedRecords(value) {
+    return value === undefined || (Array.isArray(value) && value.every((row) => Array.isArray(row) && row.every(isLiteralInput)));
+}
+const CHART_TYPE_VALUES = new Set(['column', 'bar', 'line', 'area', 'pie', 'scatter']);
+const CHART_SERIES_ORIENTATION_VALUES = new Set(['rows', 'columns']);
+const CHART_LEGEND_POSITION_VALUES = new Set(['top', 'right', 'bottom', 'left', 'hidden']);
+const SHAPE_TYPE_VALUES = new Set(['rectangle', 'roundedRectangle', 'ellipse', 'line', 'arrow', 'textBox']);
+function isWorkbookChart(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'sheetName') &&
+        hasString(value, 'address') &&
+        isCellRangeRef(value['source']) &&
+        typeof value['chartType'] === 'string' &&
+        CHART_TYPE_VALUES.has(value['chartType']) &&
+        (value['seriesOrientation'] === undefined ||
+            (typeof value['seriesOrientation'] === 'string' && CHART_SERIES_ORIENTATION_VALUES.has(value['seriesOrientation']))) &&
+        isOptionalBoolean(value['firstRowAsHeaders']) &&
+        isOptionalBoolean(value['firstColumnAsLabels']) &&
+        isOptionalString(value['title']) &&
+        (value['legendPosition'] === undefined ||
+            (typeof value['legendPosition'] === 'string' && CHART_LEGEND_POSITION_VALUES.has(value['legendPosition']))) &&
+        hasSafePositiveInteger(value, 'rows') &&
+        hasSafePositiveInteger(value, 'cols'));
+}
+function isWorkbookImage(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'sheetName') &&
+        hasString(value, 'address') &&
+        hasString(value, 'sourceUrl') &&
+        hasSafePositiveInteger(value, 'rows') &&
+        hasSafePositiveInteger(value, 'cols') &&
+        isOptionalString(value['altText']));
+}
+function isWorkbookShape(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'sheetName') &&
+        hasString(value, 'address') &&
+        typeof value['shapeType'] === 'string' &&
+        SHAPE_TYPE_VALUES.has(value['shapeType']) &&
+        hasSafePositiveInteger(value, 'rows') &&
+        hasSafePositiveInteger(value, 'cols') &&
+        isOptionalString(value['text']) &&
+        isOptionalString(value['fillColor']) &&
+        isOptionalString(value['strokeColor']));
+}
+export function isWorkbookOp(value) {
+    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+        return false;
+    }
+    switch (value['kind']) {
+        case 'upsertWorkbook':
+            return hasString(value, 'name');
+        case 'setWorkbookMetadata':
+            return hasString(value, 'key') && isLiteralInput(value['value']);
+        case 'setCalculationSettings':
+            return isWorkbookCalculationSettings(value['settings']);
+        case 'setVolatileContext':
+            return isWorkbookVolatileContext(value['context']);
+        case 'upsertSheet':
+            return hasString(value, 'name') && hasSafeNonNegativeInteger(value, 'order') && isOptionalSafePositiveInteger(value['id']);
+        case 'renameSheet':
+            return hasString(value, 'oldName') && hasString(value, 'newName');
+        case 'deleteSheet':
+            return hasString(value, 'name');
+        case 'insertRows':
+        case 'insertColumns':
+            return (hasString(value, 'sheetName') &&
+                hasSafeNonNegativeInteger(value, 'start') &&
+                hasSafePositiveInteger(value, 'count') &&
+                (value['entries'] === undefined ||
+                    (Array.isArray(value['entries']) && value['entries'].every((entry) => isWorkbookAxisEntry(entry)))));
+        case 'deleteRows':
+        case 'deleteColumns':
+            return hasString(value, 'sheetName') && hasSafeNonNegativeInteger(value, 'start') && hasSafePositiveInteger(value, 'count');
+        case 'moveRows':
+        case 'moveColumns':
+            return (hasString(value, 'sheetName') &&
+                hasSafeNonNegativeInteger(value, 'start') &&
+                hasSafePositiveInteger(value, 'count') &&
+                hasSafeNonNegativeInteger(value, 'target'));
+        case 'updateRowMetadata':
+        case 'updateColumnMetadata':
+            return (hasString(value, 'sheetName') &&
+                hasSafeNonNegativeInteger(value, 'start') &&
+                hasSafePositiveInteger(value, 'count') &&
+                isOptionalNullableSafePositiveInteger(value['size']) &&
+                isOptionalNullableBoolean(value['hidden']));
+        case 'setFreezePane':
+            return hasString(value, 'sheetName') && hasSafeNonNegativeInteger(value, 'rows') && hasSafeNonNegativeInteger(value, 'cols');
+        case 'clearFreezePane':
+            return hasString(value, 'sheetName');
+        case 'mergeCells':
+        case 'unmergeCells':
+            return isCellRangeRef(value['range']);
+        case 'setSheetProtection':
+            return isWorkbookSheetProtection(value['protection']);
+        case 'clearSheetProtection':
+            return hasString(value, 'sheetName');
+        case 'setFilter':
+        case 'clearFilter':
+        case 'clearSort':
+            return hasString(value, 'sheetName') && isCellRangeRef(value['range']);
+        case 'setSort':
+            return (hasString(value, 'sheetName') &&
+                isCellRangeRef(value['range']) &&
+                Array.isArray(value['keys']) &&
+                value['keys'].every((entry) => isWorkbookSortKey(entry)));
+        case 'setDataValidation':
+            return isWorkbookDataValidation(value['validation']);
+        case 'clearDataValidation':
+            return hasString(value, 'sheetName') && isCellRangeRef(value['range']);
+        case 'upsertConditionalFormat':
+            return isWorkbookConditionalFormat(value['format']);
+        case 'deleteConditionalFormat':
+            return hasString(value, 'id') && hasString(value, 'sheetName');
+        case 'upsertRangeProtection':
+            return isWorkbookRangeProtection(value['protection']);
+        case 'deleteRangeProtection':
+            return hasString(value, 'id') && hasString(value, 'sheetName');
+        case 'upsertCommentThread':
+            return isWorkbookCommentThread(value['thread']);
+        case 'deleteCommentThread':
+        case 'deleteNote':
+            return hasString(value, 'sheetName') && hasString(value, 'address');
+        case 'upsertNote':
+            return isWorkbookNote(value['note']);
+        case 'setCellValue':
+            return (hasString(value, 'sheetName') &&
+                hasString(value, 'address') &&
+                isLiteralInput(value['value']) &&
+                (value['authoredBlank'] === undefined || typeof value['authoredBlank'] === 'boolean'));
+        case 'setCellFormula':
+            return hasString(value, 'sheetName') && hasString(value, 'address') && hasString(value, 'formula');
+        case 'setCellFormat':
+            return (hasString(value, 'sheetName') && hasString(value, 'address') && (value['format'] === null || typeof value['format'] === 'string'));
+        case 'upsertCellStyle':
+            return isCellStyleRecord(value['style']);
+        case 'upsertCellNumberFormat':
+            return isCellNumberFormatRecord(value['format']);
+        case 'setStyleRange':
+            return isCellRangeRef(value['range']) && hasString(value, 'styleId');
+        case 'setFormatRange':
+            return isCellRangeRef(value['range']) && hasString(value, 'formatId');
+        case 'clearCell':
+            return hasString(value, 'sheetName') && hasString(value, 'address');
+        case 'upsertDefinedName':
+            return hasString(value, 'name') && isWorkbookDefinedNameValue(value['value']);
+        case 'deleteDefinedName':
+        case 'deleteTable':
+            return hasString(value, 'name');
+        case 'upsertTable':
+            return isWorkbookTableOp(value['table']);
+        case 'upsertSpillRange':
+            return (hasString(value, 'sheetName') &&
+                hasString(value, 'address') &&
+                hasSafePositiveInteger(value, 'rows') &&
+                hasSafePositiveInteger(value, 'cols'));
+        case 'deleteSpillRange':
+        case 'deletePivotTable':
+            return hasString(value, 'sheetName') && hasString(value, 'address');
+        case 'upsertPivotTable':
+            return (hasString(value, 'name') &&
+                hasString(value, 'sheetName') &&
+                hasString(value, 'address') &&
+                isCellRangeRef(value['source']) &&
+                isStringArray(value['groupBy']) &&
+                isOptionalStringArray(value['columnFields']) &&
+                isOptionalPivotPageFieldArray(value['pageFields']) &&
+                isOptionalPivotFilterArray(value['filters']) &&
+                isOptionalPivotHiddenItemsArray(value['hiddenItems']) &&
+                isOptionalPivotCalculatedFormulaArray(value['calculatedFields']) &&
+                isOptionalPivotCalculatedFormulaArray(value['calculatedItems']) &&
+                (value['sourceKind'] === undefined ||
+                    value['sourceKind'] === 'worksheet' ||
+                    value['sourceKind'] === 'table' ||
+                    value['sourceKind'] === 'named-range' ||
+                    value['sourceKind'] === 'external-cache-only') &&
+                (value['cacheOnly'] === undefined || typeof value['cacheOnly'] === 'boolean') &&
+                (value['cacheId'] === undefined || isSafeNonNegativeInteger(value['cacheId'])) &&
+                isOptionalStringArray(value['cacheFields']) &&
+                isOptionalCachedRecords(value['cachedRecords']) &&
+                Array.isArray(value['values']) &&
+                value['values'].every((entry) => isWorkbookPivotValue(entry)) &&
+                hasSafePositiveInteger(value, 'rows') &&
+                hasSafePositiveInteger(value, 'cols'));
+        case 'upsertChart':
+            return isWorkbookChart(value['chart']);
+        case 'deleteChart':
+            return hasString(value, 'id');
+        case 'upsertImage':
+            return isWorkbookImage(value['image']);
+        case 'deleteImage':
+            return hasString(value, 'id');
+        case 'upsertShape':
+            return isWorkbookShape(value['shape']);
+        case 'deleteShape':
+            return hasString(value, 'id');
+        default:
+            return false;
+    }
+}
+export function isEngineOp(value) {
+    return isWorkbookOp(value);
+}
+export function isEngineOps(value) {
+    return Array.isArray(value) && value.every((entry) => isEngineOp(entry));
+}
+export function isEngineOpBatch(value) {
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'replicaId') &&
+        isRecord(value['clock']) &&
+        hasSafeNonNegativeInteger(value['clock'], 'counter') &&
+        isEngineOps(value['ops']));
+}
+//# sourceMappingURL=guards.js.map