var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
import { Arg, Ctx, Field, InputType, Int, ObjectType, Query, Resolver, Float } from 'type-graphql';
import { TelemetryManager } from '@memberjunction/core';
let MemorySnapshotGQL = class MemorySnapshotGQL {
    heapUsed;
    heapTotal;
    timestamp;
};
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], MemorySnapshotGQL.prototype, "heapUsed", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], MemorySnapshotGQL.prototype, "heapTotal", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], MemorySnapshotGQL.prototype, "timestamp", void 0);
MemorySnapshotGQL = __decorate([
    ObjectType()
], MemorySnapshotGQL);
export { MemorySnapshotGQL };
let TelemetryEventGQL = class TelemetryEventGQL {
    id;
    category;
    operation;
    fingerprint;
    startTime;
    endTime;
    elapsedMs;
    userId;
    params;
    tags;
    stackTrace;
    memoryBefore;
    memoryAfter;
    parentEventId;
};
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "id", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "category", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "operation", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "fingerprint", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryEventGQL.prototype, "startTime", void 0);
__decorate([
    Field(() => Float, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryEventGQL.prototype, "endTime", void 0);
__decorate([
    Field(() => Float, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryEventGQL.prototype, "elapsedMs", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "userId", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "params", void 0);
__decorate([
    Field(() => [String], { nullable: true }),
    __metadata("design:type", Array)
], TelemetryEventGQL.prototype, "tags", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "stackTrace", void 0);
__decorate([
    Field(() => MemorySnapshotGQL, { nullable: true }),
    __metadata("design:type", MemorySnapshotGQL)
], TelemetryEventGQL.prototype, "memoryBefore", void 0);
__decorate([
    Field(() => MemorySnapshotGQL, { nullable: true }),
    __metadata("design:type", MemorySnapshotGQL)
], TelemetryEventGQL.prototype, "memoryAfter", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryEventGQL.prototype, "parentEventId", void 0);
TelemetryEventGQL = __decorate([
    ObjectType()
], TelemetryEventGQL);
export { TelemetryEventGQL };
let CallerLocationGQL = class CallerLocationGQL {
    location;
    count;
};
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], CallerLocationGQL.prototype, "location", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], CallerLocationGQL.prototype, "count", void 0);
CallerLocationGQL = __decorate([
    ObjectType()
], CallerLocationGQL);
export { CallerLocationGQL };
let TelemetryPatternGQL = class TelemetryPatternGQL {
    fingerprint;
    category;
    operation;
    sampleParams;
    count;
    totalElapsedMs;
    avgElapsedMs;
    minElapsedMs;
    maxElapsedMs;
    callerLocations;
    firstSeen;
    lastSeen;
    windowStartTime;
};
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryPatternGQL.prototype, "fingerprint", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryPatternGQL.prototype, "category", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryPatternGQL.prototype, "operation", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryPatternGQL.prototype, "sampleParams", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "count", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "totalElapsedMs", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "avgElapsedMs", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "minElapsedMs", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "maxElapsedMs", void 0);
__decorate([
    Field(() => [CallerLocationGQL]),
    __metadata("design:type", Array)
], TelemetryPatternGQL.prototype, "callerLocations", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "firstSeen", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "lastSeen", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryPatternGQL.prototype, "windowStartTime", void 0);
TelemetryPatternGQL = __decorate([
    ObjectType()
], TelemetryPatternGQL);
export { TelemetryPatternGQL };
let TelemetryInsightGQL = class TelemetryInsightGQL {
    id;
    severity;
    analyzerName;
    category;
    title;
    message;
    suggestion;
    relatedEventIds;
    entityName;
    metadata;
    timestamp;
};
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "id", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "severity", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "analyzerName", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "category", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "title", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "message", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "suggestion", void 0);
__decorate([
    Field(() => [String]),
    __metadata("design:type", Array)
], TelemetryInsightGQL.prototype, "relatedEventIds", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "entityName", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryInsightGQL.prototype, "metadata", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], TelemetryInsightGQL.prototype, "timestamp", void 0);
TelemetryInsightGQL = __decorate([
    ObjectType()
], TelemetryInsightGQL);
export { TelemetryInsightGQL };
let CategoryStatsGQL = class CategoryStatsGQL {
    category;
    events;
    avgMs;
};
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], CategoryStatsGQL.prototype, "category", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], CategoryStatsGQL.prototype, "events", void 0);
__decorate([
    Field(() => Float),
    __metadata("design:type", Number)
], CategoryStatsGQL.prototype, "avgMs", void 0);
CategoryStatsGQL = __decorate([
    ObjectType()
], CategoryStatsGQL);
export { CategoryStatsGQL };
let TelemetryStatsGQL = class TelemetryStatsGQL {
    totalEvents;
    totalPatterns;
    totalInsights;
    activeEvents;
    byCategory;
};
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], TelemetryStatsGQL.prototype, "totalEvents", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], TelemetryStatsGQL.prototype, "totalPatterns", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], TelemetryStatsGQL.prototype, "totalInsights", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], TelemetryStatsGQL.prototype, "activeEvents", void 0);
__decorate([
    Field(() => [CategoryStatsGQL]),
    __metadata("design:type", Array)
], TelemetryStatsGQL.prototype, "byCategory", void 0);
TelemetryStatsGQL = __decorate([
    ObjectType()
], TelemetryStatsGQL);
export { TelemetryStatsGQL };
let CategoryOverrideGQL = class CategoryOverrideGQL {
    category;
    enabled;
    level;
};
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], CategoryOverrideGQL.prototype, "category", void 0);
__decorate([
    Field(() => Boolean),
    __metadata("design:type", Boolean)
], CategoryOverrideGQL.prototype, "enabled", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], CategoryOverrideGQL.prototype, "level", void 0);
CategoryOverrideGQL = __decorate([
    ObjectType()
], CategoryOverrideGQL);
export { CategoryOverrideGQL };
let AutoTrimSettingsGQL = class AutoTrimSettingsGQL {
    enabled;
    maxEvents;
    maxAgeMs;
};
__decorate([
    Field(() => Boolean),
    __metadata("design:type", Boolean)
], AutoTrimSettingsGQL.prototype, "enabled", void 0);
__decorate([
    Field(() => Int, { nullable: true }),
    __metadata("design:type", Number)
], AutoTrimSettingsGQL.prototype, "maxEvents", void 0);
__decorate([
    Field(() => Int, { nullable: true }),
    __metadata("design:type", Number)
], AutoTrimSettingsGQL.prototype, "maxAgeMs", void 0);
AutoTrimSettingsGQL = __decorate([
    ObjectType()
], AutoTrimSettingsGQL);
export { AutoTrimSettingsGQL };
let DuplicateDetectionSettingsGQL = class DuplicateDetectionSettingsGQL {
    enabled;
    windowMs;
};
__decorate([
    Field(() => Boolean),
    __metadata("design:type", Boolean)
], DuplicateDetectionSettingsGQL.prototype, "enabled", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], DuplicateDetectionSettingsGQL.prototype, "windowMs", void 0);
DuplicateDetectionSettingsGQL = __decorate([
    ObjectType()
], DuplicateDetectionSettingsGQL);
export { DuplicateDetectionSettingsGQL };
let AnalyzerSettingsGQL = class AnalyzerSettingsGQL {
    enabled;
    dedupeWindowMs;
};
__decorate([
    Field(() => Boolean),
    __metadata("design:type", Boolean)
], AnalyzerSettingsGQL.prototype, "enabled", void 0);
__decorate([
    Field(() => Int),
    __metadata("design:type", Number)
], AnalyzerSettingsGQL.prototype, "dedupeWindowMs", void 0);
AnalyzerSettingsGQL = __decorate([
    ObjectType()
], AnalyzerSettingsGQL);
export { AnalyzerSettingsGQL };
let TelemetrySettingsGQL = class TelemetrySettingsGQL {
    enabled;
    level;
    categoryOverrides;
    autoTrim;
    duplicateDetection;
    analyzers;
};
__decorate([
    Field(() => Boolean),
    __metadata("design:type", Boolean)
], TelemetrySettingsGQL.prototype, "enabled", void 0);
__decorate([
    Field(() => String),
    __metadata("design:type", String)
], TelemetrySettingsGQL.prototype, "level", void 0);
__decorate([
    Field(() => [CategoryOverrideGQL]),
    __metadata("design:type", Array)
], TelemetrySettingsGQL.prototype, "categoryOverrides", void 0);
__decorate([
    Field(() => AutoTrimSettingsGQL),
    __metadata("design:type", AutoTrimSettingsGQL)
], TelemetrySettingsGQL.prototype, "autoTrim", void 0);
__decorate([
    Field(() => DuplicateDetectionSettingsGQL),
    __metadata("design:type", DuplicateDetectionSettingsGQL)
], TelemetrySettingsGQL.prototype, "duplicateDetection", void 0);
__decorate([
    Field(() => AnalyzerSettingsGQL),
    __metadata("design:type", AnalyzerSettingsGQL)
], TelemetrySettingsGQL.prototype, "analyzers", void 0);
TelemetrySettingsGQL = __decorate([
    ObjectType()
], TelemetrySettingsGQL);
export { TelemetrySettingsGQL };
let TelemetryEventFilterInput = class TelemetryEventFilterInput {
    category;
    operation;
    minElapsedMs;
    since;
    limit;
};
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryEventFilterInput.prototype, "category", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryEventFilterInput.prototype, "operation", void 0);
__decorate([
    Field(() => Float, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryEventFilterInput.prototype, "minElapsedMs", void 0);
__decorate([
    Field(() => Float, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryEventFilterInput.prototype, "since", void 0);
__decorate([
    Field(() => Int, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryEventFilterInput.prototype, "limit", void 0);
TelemetryEventFilterInput = __decorate([
    InputType()
], TelemetryEventFilterInput);
export { TelemetryEventFilterInput };
let TelemetryPatternFilterInput = class TelemetryPatternFilterInput {
    category;
    minCount;
    sortBy;
};
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryPatternFilterInput.prototype, "category", void 0);
__decorate([
    Field(() => Int, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryPatternFilterInput.prototype, "minCount", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryPatternFilterInput.prototype, "sortBy", void 0);
TelemetryPatternFilterInput = __decorate([
    InputType()
], TelemetryPatternFilterInput);
export { TelemetryPatternFilterInput };
let TelemetryInsightFilterInput = class TelemetryInsightFilterInput {
    severity;
    category;
    entityName;
    limit;
};
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryInsightFilterInput.prototype, "severity", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryInsightFilterInput.prototype, "category", void 0);
__decorate([
    Field(() => String, { nullable: true }),
    __metadata("design:type", String)
], TelemetryInsightFilterInput.prototype, "entityName", void 0);
__decorate([
    Field(() => Int, { nullable: true }),
    __metadata("design:type", Number)
], TelemetryInsightFilterInput.prototype, "limit", void 0);
TelemetryInsightFilterInput = __decorate([
    InputType()
], TelemetryInsightFilterInput);
export { TelemetryInsightFilterInput };
let TelemetryResolver = class TelemetryResolver {
    GetServerTelemetrySettings(_context) {
        const tm = TelemetryManager.Instance;
        const settings = tm.Settings;
        const categoryOverrides = [];
        if (settings.categoryOverrides) {
            for (const [category, override] of Object.entries(settings.categoryOverrides)) {
                if (override) {
                    categoryOverrides.push({
                        category,
                        enabled: override.enabled,
                        level: override.level
                    });
                }
            }
        }
        return {
            enabled: settings.enabled,
            level: settings.level,
            categoryOverrides,
            autoTrim: {
                enabled: settings.autoTrim.enabled,
                maxEvents: settings.autoTrim.maxEvents,
                maxAgeMs: settings.autoTrim.maxAgeMs
            },
            duplicateDetection: {
                enabled: settings.duplicateDetection.enabled,
                windowMs: settings.duplicateDetection.windowMs
            },
            analyzers: {
                enabled: settings.analyzers.enabled,
                dedupeWindowMs: settings.analyzers.dedupeWindowMs
            }
        };
    }
    GetServerTelemetryStats(_context) {
        const tm = TelemetryManager.Instance;
        const stats = tm.GetStats();
        const byCategory = Object.entries(stats.byCategory).map(([category, data]) => ({
            category,
            events: data.events,
            avgMs: data.avgMs
        }));
        return {
            totalEvents: stats.totalEvents,
            totalPatterns: stats.totalPatterns,
            totalInsights: stats.totalInsights,
            activeEvents: stats.activeEvents,
            byCategory
        };
    }
    GetServerTelemetryEvents(_context, filter) {
        const tm = TelemetryManager.Instance;
        const events = tm.GetEvents({
            category: filter?.category,
            operation: filter?.operation,
            minElapsedMs: filter?.minElapsedMs ?? undefined,
            since: filter?.since ?? undefined,
            limit: filter?.limit ?? undefined
        });
        return events.map(e => ({
            id: e.id,
            category: e.category,
            operation: e.operation,
            fingerprint: e.fingerprint,
            startTime: e.startTime,
            endTime: e.endTime,
            elapsedMs: e.elapsedMs,
            userId: e.userId,
            params: JSON.stringify(e.params),
            tags: e.tags,
            stackTrace: e.stackTrace,
            memoryBefore: e.memoryBefore,
            memoryAfter: e.memoryAfter,
            parentEventId: e.parentEventId
        }));
    }
    GetServerTelemetryPatterns(_context, filter) {
        const tm = TelemetryManager.Instance;
        const patterns = tm.GetPatterns({
            category: filter?.category,
            minCount: filter?.minCount ?? undefined,
            sortBy: filter?.sortBy
        });
        return patterns.map(p => {
            const callerLocations = [];
            p.callerLocations.forEach((count, location) => {
                callerLocations.push({ location, count });
            });
            return {
                fingerprint: p.fingerprint,
                category: p.category,
                operation: p.operation,
                sampleParams: JSON.stringify(p.sampleParams),
                count: p.count,
                totalElapsedMs: p.totalElapsedMs,
                avgElapsedMs: p.avgElapsedMs,
                minElapsedMs: p.minElapsedMs === Infinity ? 0 : p.minElapsedMs,
                maxElapsedMs: p.maxElapsedMs,
                callerLocations,
                firstSeen: p.firstSeen,
                lastSeen: p.lastSeen,
                windowStartTime: p.windowStartTime
            };
        });
    }
    GetServerTelemetryInsights(_context, filter) {
        const tm = TelemetryManager.Instance;
        const insights = tm.GetInsights({
            severity: filter?.severity,
            category: filter?.category,
            entityName: filter?.entityName,
            limit: filter?.limit ?? undefined
        });
        return insights.map(i => ({
            id: i.id,
            severity: i.severity,
            analyzerName: i.analyzerName,
            category: i.category,
            title: i.title,
            message: i.message,
            suggestion: i.suggestion,
            relatedEventIds: i.relatedEventIds,
            entityName: i.entityName,
            metadata: i.metadata ? JSON.stringify(i.metadata) : undefined,
            timestamp: i.timestamp
        }));
    }
    GetServerTelemetryDuplicates(_context, minCount) {
        const tm = TelemetryManager.Instance;
        const patterns = tm.GetDuplicates(minCount);
        return patterns.map(p => {
            const callerLocations = [];
            p.callerLocations.forEach((count, location) => {
                callerLocations.push({ location, count });
            });
            return {
                fingerprint: p.fingerprint,
                category: p.category,
                operation: p.operation,
                sampleParams: JSON.stringify(p.sampleParams),
                count: p.count,
                totalElapsedMs: p.totalElapsedMs,
                avgElapsedMs: p.avgElapsedMs,
                minElapsedMs: p.minElapsedMs === Infinity ? 0 : p.minElapsedMs,
                maxElapsedMs: p.maxElapsedMs,
                callerLocations,
                firstSeen: p.firstSeen,
                lastSeen: p.lastSeen,
                windowStartTime: p.windowStartTime
            };
        });
    }
    GetServerTelemetryActiveEvents(_context) {
        const tm = TelemetryManager.Instance;
        const events = tm.GetActiveEvents();
        return events.map(e => ({
            id: e.id,
            category: e.category,
            operation: e.operation,
            fingerprint: e.fingerprint,
            startTime: e.startTime,
            endTime: e.endTime,
            elapsedMs: e.elapsedMs,
            userId: e.userId,
            params: JSON.stringify(e.params),
            tags: e.tags,
            stackTrace: e.stackTrace,
            memoryBefore: e.memoryBefore,
            memoryAfter: e.memoryAfter,
            parentEventId: e.parentEventId
        }));
    }
};
__decorate([
    Query(() => TelemetrySettingsGQL),
    __param(0, Ctx()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", TelemetrySettingsGQL)
], TelemetryResolver.prototype, "GetServerTelemetrySettings", null);
__decorate([
    Query(() => TelemetryStatsGQL),
    __param(0, Ctx()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", TelemetryStatsGQL)
], TelemetryResolver.prototype, "GetServerTelemetryStats", null);
__decorate([
    Query(() => [TelemetryEventGQL]),
    __param(0, Ctx()),
    __param(1, Arg('filter', () => TelemetryEventFilterInput, { nullable: true })),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object, TelemetryEventFilterInput]),
    __metadata("design:returntype", Array)
], TelemetryResolver.prototype, "GetServerTelemetryEvents", null);
__decorate([
    Query(() => [TelemetryPatternGQL]),
    __param(0, Ctx()),
    __param(1, Arg('filter', () => TelemetryPatternFilterInput, { nullable: true })),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object, TelemetryPatternFilterInput]),
    __metadata("design:returntype", Array)
], TelemetryResolver.prototype, "GetServerTelemetryPatterns", null);
__decorate([
    Query(() => [TelemetryInsightGQL]),
    __param(0, Ctx()),
    __param(1, Arg('filter', () => TelemetryInsightFilterInput, { nullable: true })),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object, TelemetryInsightFilterInput]),
    __metadata("design:returntype", Array)
], TelemetryResolver.prototype, "GetServerTelemetryInsights", null);
__decorate([
    Query(() => [TelemetryPatternGQL]),
    __param(0, Ctx()),
    __param(1, Arg('minCount', () => Int, { defaultValue: 2 })),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object, Number]),
    __metadata("design:returntype", Array)
], TelemetryResolver.prototype, "GetServerTelemetryDuplicates", null);
__decorate([
    Query(() => [TelemetryEventGQL]),
    __param(0, Ctx()),
    __metadata("design:type", Function),
    __metadata("design:paramtypes", [Object]),
    __metadata("design:returntype", Array)
], TelemetryResolver.prototype, "GetServerTelemetryActiveEvents", null);
TelemetryResolver = __decorate([
    Resolver()
], TelemetryResolver);
export { TelemetryResolver };
//# sourceMappingURL=TelemetryResolver.js.map