@jrojaspin/security-map-api-cli 9.5.0 → 9.7.0

package/dist/index.cjs

@@ -1283,19 +1283,19 @@ function ComputeRouteInputToJSONTyped(value, ignoreDiscriminator = false) {
     };
 }
 
-function instanceOfDef197(value) {
+function instanceOfDef223(value) {
     return true;
 }
-function Def197FromJSON(json) {
-    return Def197FromJSONTyped(json);
+function Def223FromJSON(json) {
+    return Def223FromJSONTyped(json);
 }
-function Def197FromJSONTyped(json, ignoreDiscriminator) {
+function Def223FromJSONTyped(json, ignoreDiscriminator) {
     return json;
 }
-function Def197ToJSON(json) {
-    return Def197ToJSONTyped(json, false);
+function Def223ToJSON(json) {
+    return Def223ToJSONTyped(json, false);
 }
-function Def197ToJSONTyped(value, ignoreDiscriminator = false) {
+function Def223ToJSONTyped(value, ignoreDiscriminator = false) {
     return value;
 }
 
@@ -4582,6 +4582,124 @@ function MapItemTypeSingleOutputToJSONTyped(value, ignoreDiscriminator = false)
     };
 }
 
+function instanceOfMapZonePointInput(value) {
+    if (!('lat' in value) || value['lat'] === undefined)
+        return false;
+    if (!('lon' in value) || value['lon'] === undefined)
+        return false;
+    return true;
+}
+function MapZonePointInputFromJSON(json) {
+    return MapZonePointInputFromJSONTyped(json);
+}
+function MapZonePointInputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'lat': json['lat'],
+        'lon': json['lon'],
+    };
+}
+function MapZonePointInputToJSON(json) {
+    return MapZonePointInputToJSONTyped(json, false);
+}
+function MapZonePointInputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'lat': value['lat'],
+        'lon': value['lon'],
+    };
+}
+
+function instanceOfMapZoneWithPointsInput(value) {
+    if (!('title' in value) || value['title'] === undefined)
+        return false;
+    if (!('isCloseZone' in value) || value['isCloseZone'] === undefined)
+        return false;
+    if (!('points' in value) || value['points'] === undefined)
+        return false;
+    return true;
+}
+function MapZoneWithPointsInputFromJSON(json) {
+    return MapZoneWithPointsInputFromJSONTyped(json);
+}
+function MapZoneWithPointsInputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'title': json['title'],
+        'isCloseZone': json['isCloseZone'],
+        'points': (json['points'].map(MapZonePointInputFromJSON)),
+    };
+}
+function MapZoneWithPointsInputToJSON(json) {
+    return MapZoneWithPointsInputToJSONTyped(json, false);
+}
+function MapZoneWithPointsInputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'title': value['title'],
+        'isCloseZone': value['isCloseZone'],
+        'points': (value['points'].map(MapZonePointInputToJSON)),
+    };
+}
+
+function instanceOfMapItemWithPointsInput(value) {
+    if (!('articles' in value) || value['articles'] === undefined)
+        return false;
+    if (!('mapZoneInput' in value) || value['mapZoneInput'] === undefined)
+        return false;
+    if (!('dynamicFields' in value) || value['dynamicFields'] === undefined)
+        return false;
+    if (!('stateId' in value) || value['stateId'] === undefined)
+        return false;
+    if (!('mapItemTypeId' in value) || value['mapItemTypeId'] === undefined)
+        return false;
+    return true;
+}
+function MapItemWithPointsInputFromJSON(json) {
+    return MapItemWithPointsInputFromJSONTyped(json);
+}
+function MapItemWithPointsInputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'articles': (json['articles'].map(MapItemArticleInputDtoFromJSON)),
+        'mapZoneInput': MapZoneWithPointsInputFromJSON(json['mapZoneInput']),
+        'dynamicFields': (json['dynamicFields'].map(MapItemDynamicFieldInputDtoFromJSON)),
+        'stateId': json['stateId'],
+        'title': json['title'] == null ? undefined : json['title'],
+        'description': json['description'] == null ? undefined : json['description'],
+        'mapItemTypeId': json['mapItemTypeId'],
+        'createDate': json['createDate'] == null ? undefined : json['createDate'],
+    };
+}
+function MapItemWithPointsInputToJSON(json) {
+    return MapItemWithPointsInputToJSONTyped(json, false);
+}
+function MapItemWithPointsInputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'articles': (value['articles'].map(MapItemArticleInputDtoToJSON)),
+        'mapZoneInput': MapZoneWithPointsInputToJSON(value['mapZoneInput']),
+        'dynamicFields': (value['dynamicFields'].map(MapItemDynamicFieldInputDtoToJSON)),
+        'stateId': value['stateId'],
+        'title': value['title'],
+        'description': value['description'],
+        'mapItemTypeId': value['mapItemTypeId'],
+        'createDate': value['createDate'],
+    };
+}
+
 function instanceOfMapLayerContourCoordORM(value) {
     if (!('layerId' in value) || value['layerId'] === undefined)
         return false;
@@ -5813,7 +5931,7 @@ function ReportAllItemsListOutputFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
-        'data': (json['data'].map(Def197FromJSON)),
+        'data': (json['data'].map(Def223FromJSON)),
         'pageInfo': PageInfoFromJSON(json['pageInfo']),
     };
 }
@@ -5825,7 +5943,7 @@ function ReportAllItemsListOutputToJSONTyped(value, ignoreDiscriminator = false)
         return value;
     }
     return {
-        'data': (value['data'].map(Def197ToJSON)),
+        'data': (value['data'].map(Def223ToJSON)),
         'pageInfo': PageInfoToJSON(value['pageInfo']),
     };
 }
@@ -6300,162 +6418,1030 @@ function ReportDataORMToJSONTyped(value, ignoreDiscriminator = false) {
     };
 }
 
-function instanceOfReportDataOutput(value) {
-    if (!('data' in value) || value['data'] === undefined)
+function instanceOfReportDataOutput(value) {
+    if (!('data' in value) || value['data'] === undefined)
+        return false;
+    return true;
+}
+function ReportDataOutputFromJSON(json) {
+    return ReportDataOutputFromJSONTyped(json);
+}
+function ReportDataOutputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'data': ReportDataJSONDtoFromJSON(json['data']),
+    };
+}
+function ReportDataOutputToJSON(json) {
+    return ReportDataOutputToJSONTyped(json, false);
+}
+function ReportDataOutputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'data': ReportDataJSONDtoToJSON(value['data']),
+    };
+}
+
+function instanceOfReportDto(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('name' in value) || value['name'] === undefined)
+        return false;
+    if (!('reportType' in value) || value['reportType'] === undefined)
+        return false;
+    return true;
+}
+function ReportDtoFromJSON(json) {
+    return ReportDtoFromJSONTyped(json);
+}
+function ReportDtoFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'name': json['name'],
+        'reportType': json['reportType'],
+    };
+}
+function ReportDtoToJSON(json) {
+    return ReportDtoToJSONTyped(json, false);
+}
+function ReportDtoToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'name': value['name'],
+        'reportType': value['reportType'],
+    };
+}
+
+function instanceOfReportListOutput(value) {
+    if (!('data' in value) || value['data'] === undefined)
+        return false;
+    return true;
+}
+function ReportListOutputFromJSON(json) {
+    return ReportListOutputFromJSONTyped(json);
+}
+function ReportListOutputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'data': (json['data'].map(ReportDtoFromJSON)),
+    };
+}
+function ReportListOutputToJSON(json) {
+    return ReportListOutputToJSONTyped(json, false);
+}
+function ReportListOutputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'data': (value['data'].map(ReportDtoToJSON)),
+    };
+}
+
+function instanceOfReportORM(value) {
+    if (!('title' in value) || value['title'] === undefined)
+        return false;
+    if (!('reportType' in value) || value['reportType'] === undefined)
+        return false;
+    return true;
+}
+function ReportORMFromJSON(json) {
+    return ReportORMFromJSONTyped(json);
+}
+function ReportORMFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'title': json['title'],
+        'reportType': json['reportType'],
+        'id': json['id'] == null ? undefined : json['id'],
+        'createDate': json['createDate'] == null ? undefined : json['createDate'],
+        'deleteDate': json['deleteDate'] == null ? undefined : json['deleteDate'],
+    };
+}
+function ReportORMToJSON(json) {
+    return ReportORMToJSONTyped(json, false);
+}
+function ReportORMToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'title': value['title'],
+        'reportType': value['reportType'],
+        'id': value['id'],
+        'createDate': value['createDate'],
+        'deleteDate': value['deleteDate'],
+    };
+}
+
+function instanceOfReportOutput(value) {
+    if (!('data' in value) || value['data'] === undefined)
+        return false;
+    return true;
+}
+function ReportOutputFromJSON(json) {
+    return ReportOutputFromJSONTyped(json);
+}
+function ReportOutputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'data': ReportDtoFromJSON(json['data']),
+    };
+}
+function ReportOutputToJSON(json) {
+    return ReportOutputToJSONTyped(json, false);
+}
+function ReportOutputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'data': ReportDtoToJSON(value['data']),
+    };
+}
+
+const ReportQueryCatalogFieldTypeEnum = {
+    Number: 'number',
+    Boolean: 'boolean',
+    Category: 'category',
+    Text: 'text',
+    Date: 'date'
+};
+const ReportQueryCatalogFieldSourcesEnum = {
+    Items: 'items',
+    Articles: 'articles',
+    StateHistory: 'state_history'
+};
+const ReportQueryCatalogFieldMetricOperationsEnum = {
+    Count: 'count',
+    CountDistinct: 'count_distinct',
+    Sum: 'sum',
+    Avg: 'avg',
+    Min: 'min',
+    Max: 'max'
+};
+const ReportQueryCatalogFieldFilterOperatorsEnum = {
+    Contains: 'contains',
+    NotContains: 'not_contains',
+    Eq: 'eq',
+    Neq: 'neq',
+    In: 'in',
+    NotIn: 'not_in',
+    Gt: 'gt',
+    Gte: 'gte',
+    Lt: 'lt',
+    Lte: 'lte',
+    IsEmpty: 'is_empty',
+    IsNotEmpty: 'is_not_empty'
+};
+const ReportQueryCatalogFieldBucketsEnum = {
+    Day: 'day',
+    Week: 'week',
+    Month: 'month',
+    Quarter: 'quarter',
+    Year: 'year'
+};
+const ReportQueryCatalogFieldSuggestedNormalizeEnum = {
+    None: 'none',
+    TrimCase: 'trim_case',
+    Ipp: 'ipp'
+};
+function instanceOfReportQueryCatalogField(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('label' in value) || value['label'] === undefined)
+        return false;
+    if (!('type' in value) || value['type'] === undefined)
+        return false;
+    if (!('group' in value) || value['group'] === undefined)
+        return false;
+    if (!('sources' in value) || value['sources'] === undefined)
+        return false;
+    if (!('canBeDimension' in value) || value['canBeDimension'] === undefined)
+        return false;
+    if (!('metricOperations' in value) || value['metricOperations'] === undefined)
+        return false;
+    if (!('filterOperators' in value) || value['filterOperators'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryCatalogFieldFromJSON(json) {
+    return ReportQueryCatalogFieldFromJSONTyped(json);
+}
+function ReportQueryCatalogFieldFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'label': json['label'],
+        'type': json['type'],
+        'group': json['group'],
+        'itemTypeId': json['itemTypeId'] == null ? undefined : json['itemTypeId'],
+        'sources': json['sources'],
+        'canBeDimension': json['canBeDimension'],
+        'metricOperations': json['metricOperations'],
+        'filterOperators': json['filterOperators'],
+        'buckets': json['buckets'] == null ? undefined : json['buckets'],
+        'suggestedNormalize': json['suggestedNormalize'] == null ? undefined : json['suggestedNormalize'],
+    };
+}
+function ReportQueryCatalogFieldToJSON(json) {
+    return ReportQueryCatalogFieldToJSONTyped(json, false);
+}
+function ReportQueryCatalogFieldToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'label': value['label'],
+        'type': value['type'],
+        'group': value['group'],
+        'itemTypeId': value['itemTypeId'],
+        'sources': value['sources'],
+        'canBeDimension': value['canBeDimension'],
+        'metricOperations': value['metricOperations'],
+        'filterOperators': value['filterOperators'],
+        'buckets': value['buckets'],
+        'suggestedNormalize': value['suggestedNormalize'],
+    };
+}
+
+function instanceOfReportQueryCatalogOutput(value) {
+    if (!('data' in value) || value['data'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryCatalogOutputFromJSON(json) {
+    return ReportQueryCatalogOutputFromJSONTyped(json);
+}
+function ReportQueryCatalogOutputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'data': (json['data'].map(ReportQueryCatalogFieldFromJSON)),
+    };
+}
+function ReportQueryCatalogOutputToJSON(json) {
+    return ReportQueryCatalogOutputToJSONTyped(json, false);
+}
+function ReportQueryCatalogOutputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'data': (value['data'].map(ReportQueryCatalogFieldToJSON)),
+    };
+}
+
+const ReportQueryChart = {
+    Bar: 'bar',
+    Line: 'line',
+    Pie: 'pie',
+    StackedBar: 'stacked_bar',
+    Table: 'table'
+};
+function instanceOfReportQueryChart(value) {
+    for (const key in ReportQueryChart) {
+        if (Object.prototype.hasOwnProperty.call(ReportQueryChart, key)) {
+            if (ReportQueryChart[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function ReportQueryChartFromJSON(json) {
+    return ReportQueryChartFromJSONTyped(json);
+}
+function ReportQueryChartFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+function ReportQueryChartToJSON(value) {
+    return value;
+}
+function ReportQueryChartToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}
+
+function instanceOfReportQueryResultRow(value) {
+    if (!('keys' in value) || value['keys'] === undefined)
+        return false;
+    if (!('labels' in value) || value['labels'] === undefined)
+        return false;
+    if (!('values' in value) || value['values'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryResultRowFromJSON(json) {
+    return ReportQueryResultRowFromJSONTyped(json);
+}
+function ReportQueryResultRowFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'keys': json['keys'],
+        'labels': json['labels'],
+        'values': json['values'],
+    };
+}
+function ReportQueryResultRowToJSON(json) {
+    return ReportQueryResultRowToJSONTyped(json, false);
+}
+function ReportQueryResultRowToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'keys': value['keys'],
+        'labels': value['labels'],
+        'values': value['values'],
+    };
+}
+
+function instanceOfReportQueryResultColumn(value) {
+    if (!('label' in value) || value['label'] === undefined)
+        return false;
+    if (!('kind' in value) || value['kind'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryResultColumnFromJSON(json) {
+    return ReportQueryResultColumnFromJSONTyped(json);
+}
+function ReportQueryResultColumnFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'label': json['label'],
+        'kind': json['kind'],
+    };
+}
+function ReportQueryResultColumnToJSON(json) {
+    return ReportQueryResultColumnToJSONTyped(json, false);
+}
+function ReportQueryResultColumnToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'label': value['label'],
+        'kind': value['kind'],
+    };
+}
+
+function instanceOfReportQueryResult(value) {
+    if (!('columns' in value) || value['columns'] === undefined)
+        return false;
+    if (!('rows' in value) || value['rows'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryResultFromJSON(json) {
+    return ReportQueryResultFromJSONTyped(json);
+}
+function ReportQueryResultFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'columns': (json['columns'].map(ReportQueryResultColumnFromJSON)),
+        'rows': (json['rows'].map(ReportQueryResultRowFromJSON)),
+    };
+}
+function ReportQueryResultToJSON(json) {
+    return ReportQueryResultToJSONTyped(json, false);
+}
+function ReportQueryResultToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'columns': (value['columns'].map(ReportQueryResultColumnToJSON)),
+        'rows': (value['rows'].map(ReportQueryResultRowToJSON)),
+    };
+}
+
+function instanceOfReportQueryDataDto(value) {
+    if (!('table' in value) || value['table'] === undefined)
+        return false;
+    if (!('chart' in value) || value['chart'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryDataDtoFromJSON(json) {
+    return ReportQueryDataDtoFromJSONTyped(json);
+}
+function ReportQueryDataDtoFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'table': ReportQueryResultFromJSON(json['table']),
+        'chart': ReportDataJSONDtoFromJSON(json['chart']),
+    };
+}
+function ReportQueryDataDtoToJSON(json) {
+    return ReportQueryDataDtoToJSONTyped(json, false);
+}
+function ReportQueryDataDtoToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'table': ReportQueryResultToJSON(value['table']),
+        'chart': ReportDataJSONDtoToJSON(value['chart']),
+    };
+}
+
+function instanceOfReportQueryDataOutput(value) {
+    if (!('data' in value) || value['data'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryDataOutputFromJSON(json) {
+    return ReportQueryDataOutputFromJSONTyped(json);
+}
+function ReportQueryDataOutputFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'data': ReportQueryDataDtoFromJSON(json['data']),
+    };
+}
+function ReportQueryDataOutputToJSON(json) {
+    return ReportQueryDataOutputToJSONTyped(json, false);
+}
+function ReportQueryDataOutputToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'data': ReportQueryDataDtoToJSON(value['data']),
+    };
+}
+
+const ReportQueryDateBucket = {
+    Day: 'day',
+    Week: 'week',
+    Month: 'month',
+    Quarter: 'quarter',
+    Year: 'year'
+};
+function instanceOfReportQueryDateBucket(value) {
+    for (const key in ReportQueryDateBucket) {
+        if (Object.prototype.hasOwnProperty.call(ReportQueryDateBucket, key)) {
+            if (ReportQueryDateBucket[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function ReportQueryDateBucketFromJSON(json) {
+    return ReportQueryDateBucketFromJSONTyped(json);
+}
+function ReportQueryDateBucketFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+function ReportQueryDateBucketToJSON(value) {
+    return value;
+}
+function ReportQueryDateBucketToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}
+
+const ReportQueryMetricOpEnum = {
+    Count: 'count',
+    CountDistinct: 'count_distinct',
+    Sum: 'sum',
+    Avg: 'avg',
+    Min: 'min',
+    Max: 'max'
+};
+function instanceOfReportQueryMetric(value) {
+    if (!('op' in value) || value['op'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryMetricFromJSON(json) {
+    return ReportQueryMetricFromJSONTyped(json);
+}
+function ReportQueryMetricFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'op': json['op'],
+        'field': json['field'] == null ? undefined : json['field'],
+        'label': json['label'] == null ? undefined : json['label'],
+    };
+}
+function ReportQueryMetricToJSON(json) {
+    return ReportQueryMetricToJSONTyped(json, false);
+}
+function ReportQueryMetricToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'op': value['op'],
+        'field': value['field'],
+        'label': value['label'],
+    };
+}
+
+const ReportQueryFilterOpEnum = {
+    Contains: 'contains',
+    NotContains: 'not_contains',
+    Eq: 'eq',
+    Neq: 'neq',
+    In: 'in',
+    NotIn: 'not_in',
+    Gt: 'gt',
+    Gte: 'gte',
+    Lt: 'lt',
+    Lte: 'lte',
+    IsEmpty: 'is_empty',
+    IsNotEmpty: 'is_not_empty'
+};
+function instanceOfReportQueryFilter(value) {
+    if (!('field' in value) || value['field'] === undefined)
+        return false;
+    if (!('op' in value) || value['op'] === undefined)
+        return false;
+    if (!('values' in value) || value['values'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryFilterFromJSON(json) {
+    return ReportQueryFilterFromJSONTyped(json);
+}
+function ReportQueryFilterFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'field': json['field'],
+        'op': json['op'],
+        'values': json['values'],
+    };
+}
+function ReportQueryFilterToJSON(json) {
+    return ReportQueryFilterToJSONTyped(json, false);
+}
+function ReportQueryFilterToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'field': value['field'],
+        'op': value['op'],
+        'values': value['values'],
+    };
+}
+
+const ReportQueryDimensionBucketEnum = {
+    Day: 'day',
+    Week: 'week',
+    Month: 'month',
+    Quarter: 'quarter',
+    Year: 'year'
+};
+const ReportQueryDimensionNormalizeEnum = {
+    None: 'none',
+    TrimCase: 'trim_case',
+    Ipp: 'ipp'
+};
+function instanceOfReportQueryDimension(value) {
+    if (!('field' in value) || value['field'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryDimensionFromJSON(json) {
+    return ReportQueryDimensionFromJSONTyped(json);
+}
+function ReportQueryDimensionFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'field': json['field'],
+        'bucket': json['bucket'] == null ? undefined : json['bucket'],
+        'normalize': json['normalize'] == null ? undefined : json['normalize'],
+        'includeEmpty': json['includeEmpty'] == null ? undefined : json['includeEmpty'],
+    };
+}
+function ReportQueryDimensionToJSON(json) {
+    return ReportQueryDimensionToJSONTyped(json, false);
+}
+function ReportQueryDimensionToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'field': value['field'],
+        'bucket': value['bucket'],
+        'normalize': value['normalize'],
+        'includeEmpty': value['includeEmpty'],
+    };
+}
+
+const ReportQueryDefinitionSourceEnum = {
+    Items: 'items',
+    Articles: 'articles',
+    StateHistory: 'state_history'
+};
+const ReportQueryDefinitionChartEnum = {
+    Bar: 'bar',
+    Line: 'line',
+    Pie: 'pie',
+    StackedBar: 'stacked_bar',
+    Table: 'table'
+};
+function instanceOfReportQueryDefinition(value) {
+    if (!('source' in value) || value['source'] === undefined)
+        return false;
+    if (!('itemTypeIds' in value) || value['itemTypeIds'] === undefined)
+        return false;
+    if (!('dimensions' in value) || value['dimensions'] === undefined)
+        return false;
+    if (!('metrics' in value) || value['metrics'] === undefined)
+        return false;
+    if (!('filters' in value) || value['filters'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryDefinitionFromJSON(json) {
+    return ReportQueryDefinitionFromJSONTyped(json);
+}
+function ReportQueryDefinitionFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'version': json['version'] == null ? undefined : json['version'],
+        'source': json['source'],
+        'itemTypeIds': json['itemTypeIds'],
+        'dimensions': (json['dimensions'].map(ReportQueryDimensionFromJSON)),
+        'metrics': (json['metrics'].map(ReportQueryMetricFromJSON)),
+        'filters': (json['filters'].map(ReportQueryFilterFromJSON)),
+        'chart': json['chart'] == null ? undefined : json['chart'],
+        'labelX': json['labelX'] == null ? undefined : json['labelX'],
+        'labelY': json['labelY'] == null ? undefined : json['labelY'],
+    };
+}
+function ReportQueryDefinitionToJSON(json) {
+    return ReportQueryDefinitionToJSONTyped(json, false);
+}
+function ReportQueryDefinitionToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'version': value['version'],
+        'source': value['source'],
+        'itemTypeIds': value['itemTypeIds'],
+        'dimensions': (value['dimensions'].map(ReportQueryDimensionToJSON)),
+        'metrics': (value['metrics'].map(ReportQueryMetricToJSON)),
+        'filters': (value['filters'].map(ReportQueryFilterToJSON)),
+        'chart': value['chart'],
+        'labelX': value['labelX'],
+        'labelY': value['labelY'],
+    };
+}
+
+function instanceOfReportQueryDto(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('title' in value) || value['title'] === undefined)
+        return false;
+    return true;
+}
+function ReportQueryDtoFromJSON(json) {
+    return ReportQueryDtoFromJSONTyped(json);
+}
+function ReportQueryDtoFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'title': json['title'],
+        'definition': json['definition'] == null ? undefined : ReportQueryDefinitionFromJSON(json['definition']),
+    };
+}
+function ReportQueryDtoToJSON(json) {
+    return ReportQueryDtoToJSONTyped(json, false);
+}
+function ReportQueryDtoToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'title': value['title'],
+        'definition': ReportQueryDefinitionToJSON(value['definition']),
+    };
+}
+
+const ReportQueryFieldType = {
+    Number: 'number',
+    Boolean: 'boolean',
+    Category: 'category',
+    Text: 'text',
+    Date: 'date'
+};
+function instanceOfReportQueryFieldType(value) {
+    for (const key in ReportQueryFieldType) {
+        if (Object.prototype.hasOwnProperty.call(ReportQueryFieldType, key)) {
+            if (ReportQueryFieldType[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function ReportQueryFieldTypeFromJSON(json) {
+    return ReportQueryFieldTypeFromJSONTyped(json);
+}
+function ReportQueryFieldTypeFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+function ReportQueryFieldTypeToJSON(value) {
+    return value;
+}
+function ReportQueryFieldTypeToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}
+
+const ReportQueryFilterOperator = {
+    Contains: 'contains',
+    NotContains: 'not_contains',
+    Eq: 'eq',
+    Neq: 'neq',
+    In: 'in',
+    NotIn: 'not_in',
+    Gt: 'gt',
+    Gte: 'gte',
+    Lt: 'lt',
+    Lte: 'lte',
+    IsEmpty: 'is_empty',
+    IsNotEmpty: 'is_not_empty'
+};
+function instanceOfReportQueryFilterOperator(value) {
+    for (const key in ReportQueryFilterOperator) {
+        if (Object.prototype.hasOwnProperty.call(ReportQueryFilterOperator, key)) {
+            if (ReportQueryFilterOperator[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function ReportQueryFilterOperatorFromJSON(json) {
+    return ReportQueryFilterOperatorFromJSONTyped(json);
+}
+function ReportQueryFilterOperatorFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+function ReportQueryFilterOperatorToJSON(value) {
+    return value;
+}
+function ReportQueryFilterOperatorToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}
+
+function instanceOfReportQueryInput(value) {
+    if (!('title' in value) || value['title'] === undefined)
+        return false;
+    if (!('definition' in value) || value['definition'] === undefined)
         return false;
     return true;
 }
-function ReportDataOutputFromJSON(json) {
-    return ReportDataOutputFromJSONTyped(json);
+function ReportQueryInputFromJSON(json) {
+    return ReportQueryInputFromJSONTyped(json);
 }
-function ReportDataOutputFromJSONTyped(json, ignoreDiscriminator) {
+function ReportQueryInputFromJSONTyped(json, ignoreDiscriminator) {
     if (json == null) {
         return json;
     }
     return {
-        'data': ReportDataJSONDtoFromJSON(json['data']),
+        'title': json['title'],
+        'definition': ReportQueryDefinitionFromJSON(json['definition']),
     };
 }
-function ReportDataOutputToJSON(json) {
-    return ReportDataOutputToJSONTyped(json, false);
+function ReportQueryInputToJSON(json) {
+    return ReportQueryInputToJSONTyped(json, false);
 }
-function ReportDataOutputToJSONTyped(value, ignoreDiscriminator = false) {
+function ReportQueryInputToJSONTyped(value, ignoreDiscriminator = false) {
     if (value == null) {
         return value;
     }
     return {
-        'data': ReportDataJSONDtoToJSON(value['data']),
+        'title': value['title'],
+        'definition': ReportQueryDefinitionToJSON(value['definition']),
     };
 }
 
-function instanceOfReportDto(value) {
-    if (!('id' in value) || value['id'] === undefined)
-        return false;
-    if (!('name' in value) || value['name'] === undefined)
-        return false;
-    if (!('reportType' in value) || value['reportType'] === undefined)
+function instanceOfReportQueryListOutput(value) {
+    if (!('data' in value) || value['data'] === undefined)
         return false;
     return true;
 }
-function ReportDtoFromJSON(json) {
-    return ReportDtoFromJSONTyped(json);
+function ReportQueryListOutputFromJSON(json) {
+    return ReportQueryListOutputFromJSONTyped(json);
 }
-function ReportDtoFromJSONTyped(json, ignoreDiscriminator) {
+function ReportQueryListOutputFromJSONTyped(json, ignoreDiscriminator) {
     if (json == null) {
         return json;
     }
     return {
-        'id': json['id'],
-        'name': json['name'],
-        'reportType': json['reportType'],
+        'data': (json['data'].map(ReportQueryDtoFromJSON)),
     };
 }
-function ReportDtoToJSON(json) {
-    return ReportDtoToJSONTyped(json, false);
+function ReportQueryListOutputToJSON(json) {
+    return ReportQueryListOutputToJSONTyped(json, false);
 }
-function ReportDtoToJSONTyped(value, ignoreDiscriminator = false) {
+function ReportQueryListOutputToJSONTyped(value, ignoreDiscriminator = false) {
     if (value == null) {
         return value;
     }
     return {
-        'id': value['id'],
-        'name': value['name'],
-        'reportType': value['reportType'],
+        'data': (value['data'].map(ReportQueryDtoToJSON)),
     };
 }
 
-function instanceOfReportListOutput(value) {
+const ReportQueryMetricOperation = {
+    Count: 'count',
+    CountDistinct: 'count_distinct',
+    Sum: 'sum',
+    Avg: 'avg',
+    Min: 'min',
+    Max: 'max'
+};
+function instanceOfReportQueryMetricOperation(value) {
+    for (const key in ReportQueryMetricOperation) {
+        if (Object.prototype.hasOwnProperty.call(ReportQueryMetricOperation, key)) {
+            if (ReportQueryMetricOperation[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function ReportQueryMetricOperationFromJSON(json) {
+    return ReportQueryMetricOperationFromJSONTyped(json);
+}
+function ReportQueryMetricOperationFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+function ReportQueryMetricOperationToJSON(value) {
+    return value;
+}
+function ReportQueryMetricOperationToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}
+
+const ReportQueryNormalize = {
+    None: 'none',
+    TrimCase: 'trim_case',
+    Ipp: 'ipp'
+};
+function instanceOfReportQueryNormalize(value) {
+    for (const key in ReportQueryNormalize) {
+        if (Object.prototype.hasOwnProperty.call(ReportQueryNormalize, key)) {
+            if (ReportQueryNormalize[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function ReportQueryNormalizeFromJSON(json) {
+    return ReportQueryNormalizeFromJSONTyped(json);
+}
+function ReportQueryNormalizeFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+function ReportQueryNormalizeToJSON(value) {
+    return value;
+}
+function ReportQueryNormalizeToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}
+
+function instanceOfReportQueryOutput(value) {
     if (!('data' in value) || value['data'] === undefined)
         return false;
     return true;
 }
-function ReportListOutputFromJSON(json) {
-    return ReportListOutputFromJSONTyped(json);
+function ReportQueryOutputFromJSON(json) {
+    return ReportQueryOutputFromJSONTyped(json);
 }
-function ReportListOutputFromJSONTyped(json, ignoreDiscriminator) {
+function ReportQueryOutputFromJSONTyped(json, ignoreDiscriminator) {
     if (json == null) {
         return json;
     }
     return {
-        'data': (json['data'].map(ReportDtoFromJSON)),
+        'data': ReportQueryDtoFromJSON(json['data']),
     };
 }
-function ReportListOutputToJSON(json) {
-    return ReportListOutputToJSONTyped(json, false);
+function ReportQueryOutputToJSON(json) {
+    return ReportQueryOutputToJSONTyped(json, false);
 }
-function ReportListOutputToJSONTyped(value, ignoreDiscriminator = false) {
+function ReportQueryOutputToJSONTyped(value, ignoreDiscriminator = false) {
     if (value == null) {
         return value;
     }
     return {
-        'data': (value['data'].map(ReportDtoToJSON)),
+        'data': ReportQueryDtoToJSON(value['data']),
     };
 }
 
-function instanceOfReportORM(value) {
-    if (!('title' in value) || value['title'] === undefined)
+function instanceOfReportQueryPreviewInput(value) {
+    if (!('definition' in value) || value['definition'] === undefined)
         return false;
-    if (!('reportType' in value) || value['reportType'] === undefined)
+    if (!('startDate' in value) || value['startDate'] === undefined)
+        return false;
+    if (!('endDate' in value) || value['endDate'] === undefined)
         return false;
     return true;
 }
-function ReportORMFromJSON(json) {
-    return ReportORMFromJSONTyped(json);
+function ReportQueryPreviewInputFromJSON(json) {
+    return ReportQueryPreviewInputFromJSONTyped(json);
 }
-function ReportORMFromJSONTyped(json, ignoreDiscriminator) {
+function ReportQueryPreviewInputFromJSONTyped(json, ignoreDiscriminator) {
     if (json == null) {
         return json;
     }
     return {
-        'title': json['title'],
-        'reportType': json['reportType'],
-        'id': json['id'] == null ? undefined : json['id'],
-        'createDate': json['createDate'] == null ? undefined : json['createDate'],
-        'deleteDate': json['deleteDate'] == null ? undefined : json['deleteDate'],
+        'definition': ReportQueryDefinitionFromJSON(json['definition']),
+        'startDate': json['startDate'],
+        'endDate': json['endDate'],
     };
 }
-function ReportORMToJSON(json) {
-    return ReportORMToJSONTyped(json, false);
+function ReportQueryPreviewInputToJSON(json) {
+    return ReportQueryPreviewInputToJSONTyped(json, false);
 }
-function ReportORMToJSONTyped(value, ignoreDiscriminator = false) {
+function ReportQueryPreviewInputToJSONTyped(value, ignoreDiscriminator = false) {
     if (value == null) {
         return value;
     }
     return {
-        'title': value['title'],
-        'reportType': value['reportType'],
-        'id': value['id'],
-        'createDate': value['createDate'],
-        'deleteDate': value['deleteDate'],
+        'definition': ReportQueryDefinitionToJSON(value['definition']),
+        'startDate': value['startDate'],
+        'endDate': value['endDate'],
     };
 }
 
-function instanceOfReportOutput(value) {
-    if (!('data' in value) || value['data'] === undefined)
-        return false;
-    return true;
+const ReportQuerySource = {
+    Items: 'items',
+    Articles: 'articles',
+    StateHistory: 'state_history'
+};
+function instanceOfReportQuerySource(value) {
+    for (const key in ReportQuerySource) {
+        if (Object.prototype.hasOwnProperty.call(ReportQuerySource, key)) {
+            if (ReportQuerySource[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
-function ReportOutputFromJSON(json) {
-    return ReportOutputFromJSONTyped(json);
+function ReportQuerySourceFromJSON(json) {
+    return ReportQuerySourceFromJSONTyped(json);
 }
-function ReportOutputFromJSONTyped(json, ignoreDiscriminator) {
-    if (json == null) {
-        return json;
-    }
-    return {
-        'data': ReportDtoFromJSON(json['data']),
-    };
+function ReportQuerySourceFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
 }
-function ReportOutputToJSON(json) {
-    return ReportOutputToJSONTyped(json, false);
+function ReportQuerySourceToJSON(value) {
+    return value;
 }
-function ReportOutputToJSONTyped(value, ignoreDiscriminator = false) {
-    if (value == null) {
-        return value;
-    }
-    return {
-        'data': ReportDtoToJSON(value['data']),
-    };
+function ReportQuerySourceToJSONTyped(value, ignoreDiscriminator) {
+    return value;
 }
 
 function instanceOfReverseGeoCodingOutput(value) {
@@ -7975,6 +8961,29 @@ class ItemApi extends BaseAPI {
         const response = await this.apiV1ItemWithinGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    async apiV2ItemPostRaw(requestParameters, initOverrides) {
+        if (requestParameters['mapItemWithPointsInput'] == null) {
+            throw new RequiredError('mapItemWithPointsInput', 'Required parameter "mapItemWithPointsInput" was null or undefined when calling apiV2ItemPost().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/item`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: MapItemWithPointsInputToJSON(requestParameters['mapItemWithPointsInput']),
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => MapItemOutputFromJSON(jsonValue));
+    }
+    async apiV2ItemPost(requestParameters, initOverrides) {
+        const response = await this.apiV2ItemPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 }
 
 class ItemTypeApi extends BaseAPI {
@@ -9966,6 +10975,161 @@ class ReportApi extends BaseAPI {
         const response = await this.apiV1ReportReportIdGetRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    async apiV2ReportCatalogGetRaw(initOverrides) {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report/catalog`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryCatalogOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportCatalogGet(initOverrides) {
+        const response = await this.apiV2ReportCatalogGetRaw(initOverrides);
+        return await response.value();
+    }
+    async apiV2ReportGetRaw(initOverrides) {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryListOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportGet(initOverrides) {
+        const response = await this.apiV2ReportGetRaw(initOverrides);
+        return await response.value();
+    }
+    async apiV2ReportPostRaw(requestParameters, initOverrides) {
+        if (requestParameters['reportQueryInput'] == null) {
+            throw new RequiredError('reportQueryInput', 'Required parameter "reportQueryInput" was null or undefined when calling apiV2ReportPost().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ReportQueryInputToJSON(requestParameters['reportQueryInput']),
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportPost(requestParameters, initOverrides) {
+        const response = await this.apiV2ReportPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    async apiV2ReportPreviewPostRaw(requestParameters, initOverrides) {
+        if (requestParameters['reportQueryPreviewInput'] == null) {
+            throw new RequiredError('reportQueryPreviewInput', 'Required parameter "reportQueryPreviewInput" was null or undefined when calling apiV2ReportPreviewPost().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report/preview`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ReportQueryPreviewInputToJSON(requestParameters['reportQueryPreviewInput']),
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryDataOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportPreviewPost(requestParameters, initOverrides) {
+        const response = await this.apiV2ReportPreviewPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    async apiV2ReportReportIdDataPostRaw(requestParameters, initOverrides) {
+        if (requestParameters['reportId'] == null) {
+            throw new RequiredError('reportId', 'Required parameter "reportId" was null or undefined when calling apiV2ReportReportIdDataPost().');
+        }
+        if (requestParameters['reportConfigurationDto'] == null) {
+            throw new RequiredError('reportConfigurationDto', 'Required parameter "reportConfigurationDto" was null or undefined when calling apiV2ReportReportIdDataPost().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report/{reportId}/data`.replace(`{${"reportId"}}`, encodeURIComponent(String(requestParameters['reportId']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ReportConfigurationDtoToJSON(requestParameters['reportConfigurationDto']),
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryDataOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportReportIdDataPost(requestParameters, initOverrides) {
+        const response = await this.apiV2ReportReportIdDataPostRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    async apiV2ReportReportIdGetRaw(requestParameters, initOverrides) {
+        if (requestParameters['reportId'] == null) {
+            throw new RequiredError('reportId', 'Required parameter "reportId" was null or undefined when calling apiV2ReportReportIdGet().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report/{reportId}`.replace(`{${"reportId"}}`, encodeURIComponent(String(requestParameters['reportId']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportReportIdGet(requestParameters, initOverrides) {
+        const response = await this.apiV2ReportReportIdGetRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    async apiV2ReportReportIdPutRaw(requestParameters, initOverrides) {
+        if (requestParameters['reportId'] == null) {
+            throw new RequiredError('reportId', 'Required parameter "reportId" was null or undefined when calling apiV2ReportReportIdPut().');
+        }
+        if (requestParameters['reportQueryInput'] == null) {
+            throw new RequiredError('reportQueryInput', 'Required parameter "reportQueryInput" was null or undefined when calling apiV2ReportReportIdPut().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apiKey"] = await this.configuration.apiKey("apiKey");
+        }
+        const response = await this.request({
+            path: `/api/v2/report/{reportId}`.replace(`{${"reportId"}}`, encodeURIComponent(String(requestParameters['reportId']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ReportQueryInputToJSON(requestParameters['reportQueryInput']),
+        }, initOverrides);
+        return new JSONApiResponse(response, (jsonValue) => ReportQueryOutputFromJSON(jsonValue));
+    }
+    async apiV2ReportReportIdPut(requestParameters, initOverrides) {
+        const response = await this.apiV2ReportReportIdPutRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
 }
 const ApiV1ReportItemGetQOperatorEnum = {
     And: 'and',
@@ -10352,10 +11516,10 @@ exports.DataPointFromJSON = DataPointFromJSON;
 exports.DataPointFromJSONTyped = DataPointFromJSONTyped;
 exports.DataPointToJSON = DataPointToJSON;
 exports.DataPointToJSONTyped = DataPointToJSONTyped;
-exports.Def197FromJSON = Def197FromJSON;
-exports.Def197FromJSONTyped = Def197FromJSONTyped;
-exports.Def197ToJSON = Def197ToJSON;
-exports.Def197ToJSONTyped = Def197ToJSONTyped;
+exports.Def223FromJSON = Def223FromJSON;
+exports.Def223FromJSONTyped = Def223FromJSONTyped;
+exports.Def223ToJSON = Def223ToJSON;
+exports.Def223ToJSONTyped = Def223ToJSONTyped;
 exports.DefaultApi = DefaultApi;
 exports.DefaultConfig = DefaultConfig;
 exports.FetchError = FetchError;
@@ -10712,6 +11876,10 @@ exports.MapItemTypeSingleOutputFromJSON = MapItemTypeSingleOutputFromJSON;
 exports.MapItemTypeSingleOutputFromJSONTyped = MapItemTypeSingleOutputFromJSONTyped;
 exports.MapItemTypeSingleOutputToJSON = MapItemTypeSingleOutputToJSON;
 exports.MapItemTypeSingleOutputToJSONTyped = MapItemTypeSingleOutputToJSONTyped;
+exports.MapItemWithPointsInputFromJSON = MapItemWithPointsInputFromJSON;
+exports.MapItemWithPointsInputFromJSONTyped = MapItemWithPointsInputFromJSONTyped;
+exports.MapItemWithPointsInputToJSON = MapItemWithPointsInputToJSON;
+exports.MapItemWithPointsInputToJSONTyped = MapItemWithPointsInputToJSONTyped;
 exports.MapLayerContourCoordORMFromJSON = MapLayerContourCoordORMFromJSON;
 exports.MapLayerContourCoordORMFromJSONTyped = MapLayerContourCoordORMFromJSONTyped;
 exports.MapLayerContourCoordORMToJSON = MapLayerContourCoordORMToJSON;
@@ -10777,10 +11945,18 @@ exports.MapZoneOutputFromJSON = MapZoneOutputFromJSON;
 exports.MapZoneOutputFromJSONTyped = MapZoneOutputFromJSONTyped;
 exports.MapZoneOutputToJSON = MapZoneOutputToJSON;
 exports.MapZoneOutputToJSONTyped = MapZoneOutputToJSONTyped;
+exports.MapZonePointInputFromJSON = MapZonePointInputFromJSON;
+exports.MapZonePointInputFromJSONTyped = MapZonePointInputFromJSONTyped;
+exports.MapZonePointInputToJSON = MapZonePointInputToJSON;
+exports.MapZonePointInputToJSONTyped = MapZonePointInputToJSONTyped;
 exports.MapZonePointORMFromJSON = MapZonePointORMFromJSON;
 exports.MapZonePointORMFromJSONTyped = MapZonePointORMFromJSONTyped;
 exports.MapZonePointORMToJSON = MapZonePointORMToJSON;
 exports.MapZonePointORMToJSONTyped = MapZonePointORMToJSONTyped;
+exports.MapZoneWithPointsInputFromJSON = MapZoneWithPointsInputFromJSON;
+exports.MapZoneWithPointsInputFromJSONTyped = MapZoneWithPointsInputFromJSONTyped;
+exports.MapZoneWithPointsInputToJSON = MapZoneWithPointsInputToJSON;
+exports.MapZoneWithPointsInputToJSONTyped = MapZoneWithPointsInputToJSONTyped;
 exports.McpApi = McpApi;
 exports.MeasureUnitORMFromJSON = MeasureUnitORMFromJSON;
 exports.MeasureUnitORMFromJSONTyped = MeasureUnitORMFromJSONTyped;
@@ -10928,6 +12104,117 @@ exports.ReportOutputFromJSON = ReportOutputFromJSON;
 exports.ReportOutputFromJSONTyped = ReportOutputFromJSONTyped;
 exports.ReportOutputToJSON = ReportOutputToJSON;
 exports.ReportOutputToJSONTyped = ReportOutputToJSONTyped;
+exports.ReportQueryCatalogFieldBucketsEnum = ReportQueryCatalogFieldBucketsEnum;
+exports.ReportQueryCatalogFieldFilterOperatorsEnum = ReportQueryCatalogFieldFilterOperatorsEnum;
+exports.ReportQueryCatalogFieldFromJSON = ReportQueryCatalogFieldFromJSON;
+exports.ReportQueryCatalogFieldFromJSONTyped = ReportQueryCatalogFieldFromJSONTyped;
+exports.ReportQueryCatalogFieldMetricOperationsEnum = ReportQueryCatalogFieldMetricOperationsEnum;
+exports.ReportQueryCatalogFieldSourcesEnum = ReportQueryCatalogFieldSourcesEnum;
+exports.ReportQueryCatalogFieldSuggestedNormalizeEnum = ReportQueryCatalogFieldSuggestedNormalizeEnum;
+exports.ReportQueryCatalogFieldToJSON = ReportQueryCatalogFieldToJSON;
+exports.ReportQueryCatalogFieldToJSONTyped = ReportQueryCatalogFieldToJSONTyped;
+exports.ReportQueryCatalogFieldTypeEnum = ReportQueryCatalogFieldTypeEnum;
+exports.ReportQueryCatalogOutputFromJSON = ReportQueryCatalogOutputFromJSON;
+exports.ReportQueryCatalogOutputFromJSONTyped = ReportQueryCatalogOutputFromJSONTyped;
+exports.ReportQueryCatalogOutputToJSON = ReportQueryCatalogOutputToJSON;
+exports.ReportQueryCatalogOutputToJSONTyped = ReportQueryCatalogOutputToJSONTyped;
+exports.ReportQueryChart = ReportQueryChart;
+exports.ReportQueryChartFromJSON = ReportQueryChartFromJSON;
+exports.ReportQueryChartFromJSONTyped = ReportQueryChartFromJSONTyped;
+exports.ReportQueryChartToJSON = ReportQueryChartToJSON;
+exports.ReportQueryChartToJSONTyped = ReportQueryChartToJSONTyped;
+exports.ReportQueryDataDtoFromJSON = ReportQueryDataDtoFromJSON;
+exports.ReportQueryDataDtoFromJSONTyped = ReportQueryDataDtoFromJSONTyped;
+exports.ReportQueryDataDtoToJSON = ReportQueryDataDtoToJSON;
+exports.ReportQueryDataDtoToJSONTyped = ReportQueryDataDtoToJSONTyped;
+exports.ReportQueryDataOutputFromJSON = ReportQueryDataOutputFromJSON;
+exports.ReportQueryDataOutputFromJSONTyped = ReportQueryDataOutputFromJSONTyped;
+exports.ReportQueryDataOutputToJSON = ReportQueryDataOutputToJSON;
+exports.ReportQueryDataOutputToJSONTyped = ReportQueryDataOutputToJSONTyped;
+exports.ReportQueryDateBucket = ReportQueryDateBucket;
+exports.ReportQueryDateBucketFromJSON = ReportQueryDateBucketFromJSON;
+exports.ReportQueryDateBucketFromJSONTyped = ReportQueryDateBucketFromJSONTyped;
+exports.ReportQueryDateBucketToJSON = ReportQueryDateBucketToJSON;
+exports.ReportQueryDateBucketToJSONTyped = ReportQueryDateBucketToJSONTyped;
+exports.ReportQueryDefinitionChartEnum = ReportQueryDefinitionChartEnum;
+exports.ReportQueryDefinitionFromJSON = ReportQueryDefinitionFromJSON;
+exports.ReportQueryDefinitionFromJSONTyped = ReportQueryDefinitionFromJSONTyped;
+exports.ReportQueryDefinitionSourceEnum = ReportQueryDefinitionSourceEnum;
+exports.ReportQueryDefinitionToJSON = ReportQueryDefinitionToJSON;
+exports.ReportQueryDefinitionToJSONTyped = ReportQueryDefinitionToJSONTyped;
+exports.ReportQueryDimensionBucketEnum = ReportQueryDimensionBucketEnum;
+exports.ReportQueryDimensionFromJSON = ReportQueryDimensionFromJSON;
+exports.ReportQueryDimensionFromJSONTyped = ReportQueryDimensionFromJSONTyped;
+exports.ReportQueryDimensionNormalizeEnum = ReportQueryDimensionNormalizeEnum;
+exports.ReportQueryDimensionToJSON = ReportQueryDimensionToJSON;
+exports.ReportQueryDimensionToJSONTyped = ReportQueryDimensionToJSONTyped;
+exports.ReportQueryDtoFromJSON = ReportQueryDtoFromJSON;
+exports.ReportQueryDtoFromJSONTyped = ReportQueryDtoFromJSONTyped;
+exports.ReportQueryDtoToJSON = ReportQueryDtoToJSON;
+exports.ReportQueryDtoToJSONTyped = ReportQueryDtoToJSONTyped;
+exports.ReportQueryFieldType = ReportQueryFieldType;
+exports.ReportQueryFieldTypeFromJSON = ReportQueryFieldTypeFromJSON;
+exports.ReportQueryFieldTypeFromJSONTyped = ReportQueryFieldTypeFromJSONTyped;
+exports.ReportQueryFieldTypeToJSON = ReportQueryFieldTypeToJSON;
+exports.ReportQueryFieldTypeToJSONTyped = ReportQueryFieldTypeToJSONTyped;
+exports.ReportQueryFilterFromJSON = ReportQueryFilterFromJSON;
+exports.ReportQueryFilterFromJSONTyped = ReportQueryFilterFromJSONTyped;
+exports.ReportQueryFilterOpEnum = ReportQueryFilterOpEnum;
+exports.ReportQueryFilterOperator = ReportQueryFilterOperator;
+exports.ReportQueryFilterOperatorFromJSON = ReportQueryFilterOperatorFromJSON;
+exports.ReportQueryFilterOperatorFromJSONTyped = ReportQueryFilterOperatorFromJSONTyped;
+exports.ReportQueryFilterOperatorToJSON = ReportQueryFilterOperatorToJSON;
+exports.ReportQueryFilterOperatorToJSONTyped = ReportQueryFilterOperatorToJSONTyped;
+exports.ReportQueryFilterToJSON = ReportQueryFilterToJSON;
+exports.ReportQueryFilterToJSONTyped = ReportQueryFilterToJSONTyped;
+exports.ReportQueryInputFromJSON = ReportQueryInputFromJSON;
+exports.ReportQueryInputFromJSONTyped = ReportQueryInputFromJSONTyped;
+exports.ReportQueryInputToJSON = ReportQueryInputToJSON;
+exports.ReportQueryInputToJSONTyped = ReportQueryInputToJSONTyped;
+exports.ReportQueryListOutputFromJSON = ReportQueryListOutputFromJSON;
+exports.ReportQueryListOutputFromJSONTyped = ReportQueryListOutputFromJSONTyped;
+exports.ReportQueryListOutputToJSON = ReportQueryListOutputToJSON;
+exports.ReportQueryListOutputToJSONTyped = ReportQueryListOutputToJSONTyped;
+exports.ReportQueryMetricFromJSON = ReportQueryMetricFromJSON;
+exports.ReportQueryMetricFromJSONTyped = ReportQueryMetricFromJSONTyped;
+exports.ReportQueryMetricOpEnum = ReportQueryMetricOpEnum;
+exports.ReportQueryMetricOperation = ReportQueryMetricOperation;
+exports.ReportQueryMetricOperationFromJSON = ReportQueryMetricOperationFromJSON;
+exports.ReportQueryMetricOperationFromJSONTyped = ReportQueryMetricOperationFromJSONTyped;
+exports.ReportQueryMetricOperationToJSON = ReportQueryMetricOperationToJSON;
+exports.ReportQueryMetricOperationToJSONTyped = ReportQueryMetricOperationToJSONTyped;
+exports.ReportQueryMetricToJSON = ReportQueryMetricToJSON;
+exports.ReportQueryMetricToJSONTyped = ReportQueryMetricToJSONTyped;
+exports.ReportQueryNormalize = ReportQueryNormalize;
+exports.ReportQueryNormalizeFromJSON = ReportQueryNormalizeFromJSON;
+exports.ReportQueryNormalizeFromJSONTyped = ReportQueryNormalizeFromJSONTyped;
+exports.ReportQueryNormalizeToJSON = ReportQueryNormalizeToJSON;
+exports.ReportQueryNormalizeToJSONTyped = ReportQueryNormalizeToJSONTyped;
+exports.ReportQueryOutputFromJSON = ReportQueryOutputFromJSON;
+exports.ReportQueryOutputFromJSONTyped = ReportQueryOutputFromJSONTyped;
+exports.ReportQueryOutputToJSON = ReportQueryOutputToJSON;
+exports.ReportQueryOutputToJSONTyped = ReportQueryOutputToJSONTyped;
+exports.ReportQueryPreviewInputFromJSON = ReportQueryPreviewInputFromJSON;
+exports.ReportQueryPreviewInputFromJSONTyped = ReportQueryPreviewInputFromJSONTyped;
+exports.ReportQueryPreviewInputToJSON = ReportQueryPreviewInputToJSON;
+exports.ReportQueryPreviewInputToJSONTyped = ReportQueryPreviewInputToJSONTyped;
+exports.ReportQueryResultColumnFromJSON = ReportQueryResultColumnFromJSON;
+exports.ReportQueryResultColumnFromJSONTyped = ReportQueryResultColumnFromJSONTyped;
+exports.ReportQueryResultColumnToJSON = ReportQueryResultColumnToJSON;
+exports.ReportQueryResultColumnToJSONTyped = ReportQueryResultColumnToJSONTyped;
+exports.ReportQueryResultFromJSON = ReportQueryResultFromJSON;
+exports.ReportQueryResultFromJSONTyped = ReportQueryResultFromJSONTyped;
+exports.ReportQueryResultRowFromJSON = ReportQueryResultRowFromJSON;
+exports.ReportQueryResultRowFromJSONTyped = ReportQueryResultRowFromJSONTyped;
+exports.ReportQueryResultRowToJSON = ReportQueryResultRowToJSON;
+exports.ReportQueryResultRowToJSONTyped = ReportQueryResultRowToJSONTyped;
+exports.ReportQueryResultToJSON = ReportQueryResultToJSON;
+exports.ReportQueryResultToJSONTyped = ReportQueryResultToJSONTyped;
+exports.ReportQuerySource = ReportQuerySource;
+exports.ReportQuerySourceFromJSON = ReportQuerySourceFromJSON;
+exports.ReportQuerySourceFromJSONTyped = ReportQuerySourceFromJSONTyped;
+exports.ReportQuerySourceToJSON = ReportQuerySourceToJSON;
+exports.ReportQuerySourceToJSONTyped = ReportQuerySourceToJSONTyped;
 exports.RequiredError = RequiredError;
 exports.ResponseError = ResponseError;
 exports.ReverseGeoCodingOutputFromJSON = ReverseGeoCodingOutputFromJSON;
@@ -11121,7 +12408,7 @@ exports.instanceOfChartTitle = instanceOfChartTitle;
 exports.instanceOfComputeRouteInput = instanceOfComputeRouteInput;
 exports.instanceOfCoordDto = instanceOfCoordDto;
 exports.instanceOfDataPoint = instanceOfDataPoint;
-exports.instanceOfDef197 = instanceOfDef197;
+exports.instanceOfDef223 = instanceOfDef223;
 exports.instanceOfHealthcheckStatusValue = instanceOfHealthcheckStatusValue;
 exports.instanceOfInternalMapItemSearchResultORM = instanceOfInternalMapItemSearchResultORM;
 exports.instanceOfItemDecorationDto = instanceOfItemDecorationDto;
@@ -11204,6 +12491,7 @@ exports.instanceOfMapItemTypeInitialValueORM = instanceOfMapItemTypeInitialValue
 exports.instanceOfMapItemTypeORM = instanceOfMapItemTypeORM;
 exports.instanceOfMapItemTypeOutput = instanceOfMapItemTypeOutput;
 exports.instanceOfMapItemTypeSingleOutput = instanceOfMapItemTypeSingleOutput;
+exports.instanceOfMapItemWithPointsInput = instanceOfMapItemWithPointsInput;
 exports.instanceOfMapLayerContourCoordORM = instanceOfMapLayerContourCoordORM;
 exports.instanceOfMapLayerInput = instanceOfMapLayerInput;
 exports.instanceOfMapLayerItemDecorationORM = instanceOfMapLayerItemDecorationORM;
@@ -11220,7 +12508,9 @@ exports.instanceOfMapZoneInput = instanceOfMapZoneInput;
 exports.instanceOfMapZoneORM = instanceOfMapZoneORM;
 exports.instanceOfMapZoneOutput = instanceOfMapZoneOutput;
 exports.instanceOfMapZoneOutputDto = instanceOfMapZoneOutputDto;
+exports.instanceOfMapZonePointInput = instanceOfMapZonePointInput;
 exports.instanceOfMapZonePointORM = instanceOfMapZonePointORM;
+exports.instanceOfMapZoneWithPointsInput = instanceOfMapZoneWithPointsInput;
 exports.instanceOfMeasureUnitORM = instanceOfMeasureUnitORM;
 exports.instanceOfModelRequestContext = instanceOfModelRequestContext;
 exports.instanceOfMultimediaORM = instanceOfMultimediaORM;
@@ -11256,6 +12546,29 @@ exports.instanceOfReportDto = instanceOfReportDto;
 exports.instanceOfReportListOutput = instanceOfReportListOutput;
 exports.instanceOfReportORM = instanceOfReportORM;
 exports.instanceOfReportOutput = instanceOfReportOutput;
+exports.instanceOfReportQueryCatalogField = instanceOfReportQueryCatalogField;
+exports.instanceOfReportQueryCatalogOutput = instanceOfReportQueryCatalogOutput;
+exports.instanceOfReportQueryChart = instanceOfReportQueryChart;
+exports.instanceOfReportQueryDataDto = instanceOfReportQueryDataDto;
+exports.instanceOfReportQueryDataOutput = instanceOfReportQueryDataOutput;
+exports.instanceOfReportQueryDateBucket = instanceOfReportQueryDateBucket;
+exports.instanceOfReportQueryDefinition = instanceOfReportQueryDefinition;
+exports.instanceOfReportQueryDimension = instanceOfReportQueryDimension;
+exports.instanceOfReportQueryDto = instanceOfReportQueryDto;
+exports.instanceOfReportQueryFieldType = instanceOfReportQueryFieldType;
+exports.instanceOfReportQueryFilter = instanceOfReportQueryFilter;
+exports.instanceOfReportQueryFilterOperator = instanceOfReportQueryFilterOperator;
+exports.instanceOfReportQueryInput = instanceOfReportQueryInput;
+exports.instanceOfReportQueryListOutput = instanceOfReportQueryListOutput;
+exports.instanceOfReportQueryMetric = instanceOfReportQueryMetric;
+exports.instanceOfReportQueryMetricOperation = instanceOfReportQueryMetricOperation;
+exports.instanceOfReportQueryNormalize = instanceOfReportQueryNormalize;
+exports.instanceOfReportQueryOutput = instanceOfReportQueryOutput;
+exports.instanceOfReportQueryPreviewInput = instanceOfReportQueryPreviewInput;
+exports.instanceOfReportQueryResult = instanceOfReportQueryResult;
+exports.instanceOfReportQueryResultColumn = instanceOfReportQueryResultColumn;
+exports.instanceOfReportQueryResultRow = instanceOfReportQueryResultRow;
+exports.instanceOfReportQuerySource = instanceOfReportQuerySource;
 exports.instanceOfReverseGeoCodingOutput = instanceOfReverseGeoCodingOutput;
 exports.instanceOfRouteDto = instanceOfRouteDto;
 exports.instanceOfRouteLegDto = instanceOfRouteLegDto;