@statoss/sdk 0.2.0 → 0.4.0

package/dist/esm/logs.d.ts

@@ -0,0 +1,133 @@
+import type { Logger } from "./logger.js";
+import type { LevelOf, SchemaSpec } from "./schema.js";
+import type { SentryLevel } from "./types.js";
+/**
+ * Log lines, as Sentry's logger sends them: `log` items in envelopes, each
+ * line with a level, a body and typed attributes
+ * (https://develop.sentry.dev/sdk/telemetry/logs/).
+ */
+/** The levels of a log line: OpenTelemetry's six ranges, as Sentry's logger names them. */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+export declare const LOG_LEVELS: readonly LogLevel[];
+/** What intake keeps of a line (docs/logs.md, In), in UTF-8 bytes: a body, and an attribute's value. */
+export declare const MAX_BODY_BYTES: number;
+export declare const MAX_ATTRIBUTE_BYTES: number;
+/** A cut body's size in bytes before the cut, as intake records it. */
+export declare const TRUNCATED = "statoss.truncated";
+/** Each level's severity number: the start of its OpenTelemetry range. */
+export declare const LOG_SEVERITY: Readonly<Record<LogLevel, number>>;
+export declare function isLogLevel(value: unknown): value is LogLevel;
+/** The level a range (a schema's `like`) or a Sentry level is logged at. */
+export declare function logLevelOf(range: string): LogLevel | undefined;
+/** The range a severity number falls in. */
+export declare function rangeOfSeverity(severity: number): LogLevel;
+/** A message made by `logger.fmt`: the text, and the template and values it came from. */
+export interface LogMessage {
+    /** The message, its values filled in. */
+    readonly text: string;
+    /** The template, each value written %s, as Sentry's logger writes it. */
+    readonly template: string;
+    readonly values: readonly unknown[];
+    toString(): string;
+}
+/**
+ * A message with parameters: logger.info(logger.fmt`Paid ${amount} for ${order}`).
+ * The line's body is the text; the template and each value go along as
+ * the attributes sentry.message.template and sentry.message.parameter.<n>.
+ */
+export declare function fmt(strings: TemplateStringsArray, ...values: unknown[]): LogMessage;
+export declare function isLogMessage(value: unknown): value is LogMessage;
+/** A line's attributes: strings, numbers and booleans are sent as they are, anything else as JSON. */
+export type LogAttributes = Record<string, unknown>;
+/** A log line before it is sent, as beforeSendLog sees it. */
+export interface Log {
+    level: LogLevel;
+    /** The message, with its values filled in. */
+    message: string;
+    attributes: LogAttributes;
+    /** 1 to 24, inside the level's range. */
+    severityNumber: number;
+    /** Seconds since the epoch, with fractions. */
+    timestamp: number;
+}
+export type LogAttributeValue = {
+    value: string;
+    type: "string";
+} | {
+    value: number;
+    type: "integer";
+} | {
+    value: number;
+    type: "double";
+} | {
+    value: boolean;
+    type: "boolean";
+};
+/** A log line as an envelope's log item holds it. */
+export interface SerializedLog {
+    timestamp: number;
+    level: LogLevel;
+    body: string;
+    /** 32 lower-case hex digits; Sentry's Relay drops a line without one. */
+    trace_id: string;
+    severity_number: number;
+    attributes: Record<string, LogAttributeValue>;
+}
+/** An attribute's value as Sentry types it; undefined and null are left out. */
+export declare function serializeAttribute(value: unknown): LogAttributeValue | undefined;
+/** A string's length in UTF-8 bytes. */
+export declare function utf8Length(s: string): number;
+/**
+ * A string cut to at most `max` UTF-8 bytes, the cut marked "...", as
+ * intake's cut writes it (intake/normalize.ts), never inside a character.
+ */
+export declare function cutBytes(s: string, max: number): string;
+/**
+ * A body past 64 KiB is cut there, with its size in bytes as
+ * statoss.truncated, as intake cuts it and records it: one huge line must
+ * not take the batch it is sent in down with it.
+ */
+export declare function cutBody(body: string, attributes: Record<string, LogAttributeValue>): string;
+/** The message, or a value in it, as text: objects as JSON. */
+export declare function bodyOf(message: unknown): string;
+/** A level of the app's own, as a line is logged at it. */
+export interface OwnLogLevel {
+    level: LogLevel;
+    severity: number;
+}
+export interface LogLevelChoice {
+    level: LogLevel;
+    severity: number;
+    /** The app's own level, when the line names one. */
+    custom?: string;
+}
+/**
+ * The level a line is logged at. One of the six (or a Sentry level) is
+ * itself; an app's own level is its range's, with its severity and its
+ * name for statoss.level; a name nobody declared ranks as error, as an
+ * event's does. Anything else is logged as info.
+ */
+export declare function chooseLogLevel(level: unknown, own: Record<string, OwnLogLevel>, logger: Logger): LogLevelChoice;
+/** The ranges of init's `levels`: a Sentry level each. */
+export declare function ownLevelsFromSentry(levels: Record<string, SentryLevel>): Record<string, OwnLogLevel>;
+/** What `logger` and the handle's `logger` take as a level, typed by the schema. */
+export type LogLevelOf<S = SchemaSpec> = LogLevel | LevelOf<S>;
+/** The logger: one method per level, any level by name, and templates. */
+export interface AppLogger<S = SchemaSpec> {
+    trace(message: string | LogMessage, attributes?: LogAttributes): void;
+    debug(message: string | LogMessage, attributes?: LogAttributes): void;
+    info(message: string | LogMessage, attributes?: LogAttributes): void;
+    warn(message: string | LogMessage, attributes?: LogAttributes): void;
+    error(message: string | LogMessage, attributes?: LogAttributes): void;
+    fatal(message: string | LogMessage, attributes?: LogAttributes): void;
+    /**
+     * A line at a level by name: one of the six, a Sentry level, or one of
+     * the app's own (with a schema, only its names). An own level is sent at
+     * its range's level with the attribute statoss.level.
+     */
+    log(level: LogLevelOf<S>, message: string | LogMessage, attributes?: LogAttributes): void;
+    /** A message with parameters: logger.fmt`Paid ${amount}`. */
+    fmt(strings: TemplateStringsArray, ...values: unknown[]): LogMessage;
+}
+/** A logger that hands each line to `capture`. */
+export declare function makeAppLogger(capture: (level: unknown, message: unknown, attributes: LogAttributes | undefined) => void): AppLogger;

package/dist/esm/logs.js

@@ -0,0 +1,219 @@
+import { isLevelName, isSentryLevel, LEVEL_RULE } from "./levels.js";
+import { isObject, normalize, safely, safeString } from "./utils.js";
+export const LOG_LEVELS = [
+    "trace",
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "fatal",
+];
+/** What intake keeps of a line (docs/logs.md, In), in UTF-8 bytes: a body, and an attribute's value. */
+export const MAX_BODY_BYTES = 64 * 1024;
+export const MAX_ATTRIBUTE_BYTES = 8 * 1024;
+/** A cut body's size in bytes before the cut, as intake records it. */
+export const TRUNCATED = "statoss.truncated";
+/** Each level's severity number: the start of its OpenTelemetry range. */
+export const LOG_SEVERITY = {
+    trace: 1,
+    debug: 5,
+    info: 9,
+    warn: 13,
+    error: 17,
+    fatal: 21,
+};
+export function isLogLevel(value) {
+    return (typeof value === "string" &&
+        LOG_LEVELS.includes(value));
+}
+/** The level a range (a schema's `like`) or a Sentry level is logged at. */
+export function logLevelOf(range) {
+    if (range === "warning")
+        return "warn";
+    return isLogLevel(range) ? range : undefined;
+}
+/** The range a severity number falls in. */
+export function rangeOfSeverity(severity) {
+    if (severity >= 21)
+        return "fatal";
+    if (severity >= 17)
+        return "error";
+    if (severity >= 13)
+        return "warn";
+    if (severity >= 9)
+        return "info";
+    if (severity >= 5)
+        return "debug";
+    return "trace";
+}
+/**
+ * A message with parameters: logger.info(logger.fmt`Paid ${amount} for ${order}`).
+ * The line's body is the text; the template and each value go along as
+ * the attributes sentry.message.template and sentry.message.parameter.<n>.
+ */
+export function fmt(strings, ...values) {
+    const parts = Array.from(strings, (s, i) => s ?? strings.raw[i]);
+    let text = parts[0];
+    for (let i = 1; i < parts.length; i++)
+        text += `${bodyOf(values[i - 1])}${parts[i]}`;
+    return Object.freeze({
+        text,
+        template: parts.map((s) => s.replace(/%/g, "%%")).join("%s"),
+        values: Object.freeze([...values]),
+        toString: () => text,
+    });
+}
+export function isLogMessage(value) {
+    return (isObject(value) &&
+        typeof value.text === "string" &&
+        typeof value.template === "string" &&
+        Array.isArray(value.values));
+}
+/** An attribute's value as Sentry types it; undefined and null are left out. */
+export function serializeAttribute(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return { value: cutBytes(value, MAX_ATTRIBUTE_BYTES), type: "string" };
+    if (typeof value === "boolean")
+        return { value, type: "boolean" };
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return { value: safeString(value), type: "string" };
+        return Number.isInteger(value)
+            ? { value, type: "integer" }
+            : { value, type: "double" };
+    }
+    if (typeof value === "bigint") {
+        const n = Number(value);
+        return Number.isSafeInteger(n)
+            ? { value: n, type: "integer" }
+            : { value: value.toString(), type: "string" };
+    }
+    const text = value instanceof String
+        ? String(value)
+        : (safely(() => JSON.stringify(normalize(value, 4, 1024, 100))) ??
+            safeString(value));
+    return { value: cutBytes(text, MAX_ATTRIBUTE_BYTES), type: "string" };
+}
+/** UTF-8 bytes of one UTF-16 unit at i, and how many units it takes. */
+function utf8At(s, i) {
+    const c = s.charCodeAt(i);
+    if (c < 0x80)
+        return [1, 1];
+    if (c < 0x800)
+        return [2, 1];
+    if (c >= 0xd800 &&
+        c <= 0xdbff &&
+        i + 1 < s.length &&
+        (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00)
+        return [4, 2];
+    // A lone surrogate is written as U+FFFD, three bytes.
+    return [3, 1];
+}
+/** A string's length in UTF-8 bytes. */
+export function utf8Length(s) {
+    let n = 0;
+    for (let i = 0; i < s.length;) {
+        const [bytes, units] = utf8At(s, i);
+        n += bytes;
+        i += units;
+    }
+    return n;
+}
+/**
+ * A string cut to at most `max` UTF-8 bytes, the cut marked "...", as
+ * intake's cut writes it (intake/normalize.ts), never inside a character.
+ */
+export function cutBytes(s, max) {
+    if (s.length * 3 <= max || utf8Length(s) <= max)
+        return s;
+    let n = 0;
+    let i = 0;
+    while (i < s.length) {
+        const [bytes, units] = utf8At(s, i);
+        if (n + bytes > max - 3)
+            break;
+        n += bytes;
+        i += units;
+    }
+    // As intake: a lone high surrogate does not end a cut.
+    if (i > 0 && /[\ud800-\udbff]/.test(s[i - 1]))
+        i--;
+    return `${s.slice(0, i)}...`;
+}
+/**
+ * A body past 64 KiB is cut there, with its size in bytes as
+ * statoss.truncated, as intake cuts it and records it: one huge line must
+ * not take the batch it is sent in down with it.
+ */
+export function cutBody(body, attributes) {
+    if (body.length * 3 <= MAX_BODY_BYTES)
+        return body;
+    const size = utf8Length(body);
+    if (size <= MAX_BODY_BYTES)
+        return body;
+    attributes[TRUNCATED] = { value: size, type: "integer" };
+    return cutBytes(body, MAX_BODY_BYTES);
+}
+/** The message, or a value in it, as text: objects as JSON. */
+export function bodyOf(message) {
+    if (typeof message === "string")
+        return message;
+    if (isLogMessage(message))
+        return message.text;
+    if (message instanceof String)
+        return String(message);
+    if (isObject(message) && !(message instanceof Error)) {
+        const json = safely(() => JSON.stringify(normalize(message, 4)));
+        if (json !== undefined)
+            return json;
+    }
+    return safeString(message);
+}
+/**
+ * The level a line is logged at. One of the six (or a Sentry level) is
+ * itself; an app's own level is its range's, with its severity and its
+ * name for statoss.level; a name nobody declared ranks as error, as an
+ * event's does. Anything else is logged as info.
+ */
+export function chooseLogLevel(level, own, logger) {
+    if (isLogLevel(level))
+        return { level, severity: LOG_SEVERITY[level] };
+    if (isSentryLevel(level)) {
+        const as = logLevelOf(level) ?? "error";
+        return { level: as, severity: LOG_SEVERITY[as] };
+    }
+    if (isLevelName(level)) {
+        const found = own[level];
+        if (found)
+            return { ...found, custom: level };
+        logger.warn(`Level "${level}" is not in the schema or \`levels\`, so the line is logged as error.`);
+        return { level: "error", severity: LOG_SEVERITY.error, custom: level };
+    }
+    logger.warn(`Logged "${safeString(level)}" as info: use trace, debug, info, warn, error, fatal or a level name (${LEVEL_RULE}).`);
+    return { level: "info", severity: LOG_SEVERITY.info };
+}
+/** The ranges of init's `levels`: a Sentry level each. */
+export function ownLevelsFromSentry(levels) {
+    const out = {};
+    for (const [name, sentAs] of Object.entries(levels)) {
+        const level = logLevelOf(sentAs) ?? "error";
+        out[name] = { level, severity: LOG_SEVERITY[level] };
+    }
+    return out;
+}
+/** A logger that hands each line to `capture`. */
+export function makeAppLogger(capture) {
+    const at = (level) => (message, attributes) => capture(level, message, attributes);
+    return Object.freeze({
+        trace: at("trace"),
+        debug: at("debug"),
+        info: at("info"),
+        warn: at("warn"),
+        error: at("error"),
+        fatal: at("fatal"),
+        log: (level, message, attributes) => capture(level, message, attributes),
+        fmt,
+    });
+}

package/dist/esm/schema.d.ts

@@ -0,0 +1,211 @@
+import type { Logger } from "./logger.js";
+import { type AppLogger, type OwnLogLevel } from "./logs.js";
+import type { CaptureContext, Event, Level, SentryLevel } from "./types.js";
+/** The ranges a level ranks in: Sentry's five and OpenTelemetry's trace. */
+export declare const LIKES: readonly ["fatal", "error", "warning", "info", "debug", "trace"];
+export type Like = (typeof LIKES)[number];
+/** The colours a level or a category takes, by name. */
+export declare const SCHEMA_COLORS: readonly ["crimson", "red", "orange", "amber", "yellow", "green", "aqua", "teal", "blue", "violet", "indigo", "magenta", "plum", "grey"];
+export type SchemaColor = (typeof SCHEMA_COLORS)[number];
+/** What a rule tests: a tag by key, the logger, or one of the event's own fields. */
+export declare const RULE_SUBJECTS: readonly ["tag", "logger", "exception", "culprit", "title", "message"];
+export type RuleSubject = (typeof RULE_SUBJECTS)[number];
+export declare const RULE_MATCHES: readonly ["is", "starts", "contains"];
+export type RuleMatch = (typeof RULE_MATCHES)[number];
+export declare const FIELD_TYPES: readonly ["text", "number"];
+export type FieldType = (typeof FIELD_TYPES)[number];
+/** Each range's severities, as OpenTelemetry numbers them. */
+interface Severities {
+    fatal: 21 | 22 | 23 | 24;
+    error: 17 | 18 | 19 | 20;
+    warning: 13 | 14 | 15 | 16;
+    info: 9 | 10 | 11 | 12;
+    debug: 5 | 6 | 7 | 8;
+    trace: 1 | 2 | 3 | 4;
+}
+export type Severity = Severities[Like];
+/** A level of your own. Null clears a setting. */
+export interface LevelSettings {
+    /** The range it ranks in. Without it (and without severity) it ranks as error. */
+    like?: Like;
+    /** 1 to 24, inside the range of `like`. */
+    severity?: Severity;
+    label?: string | null;
+    color?: SchemaColor | null;
+}
+/** A category. Null clears a setting. */
+export interface CategorySettings {
+    label?: string | null;
+    color?: SchemaColor | null;
+    /** Left out of filters and lists; its events still carry it. */
+    hidden?: boolean;
+    /** A team member's email. */
+    owner?: string | null;
+}
+/** A field: a tag key. Null clears a setting. */
+export interface FieldSettings {
+    label?: string | null;
+    type?: FieldType;
+    unit?: string | null;
+    /** Gets a picker in Explore's filters. */
+    filterable?: boolean;
+}
+type RuleTests = {
+    subject: "tag";
+    tagKey: string;
+} | {
+    subject: Exclude<RuleSubject, "tag">;
+    tagKey?: undefined;
+};
+type RuleSets<L extends string, C extends string> = {
+    level: L;
+    category?: C;
+} | {
+    level?: L;
+    category: C;
+};
+/**
+ * Sets a level, a category or both for events that match: the first rule
+ * that matches wins. `match` defaults to "is".
+ */
+export type SchemaRule<L extends string = string, C extends string = string> = RuleTests & {
+    match?: RuleMatch;
+    value: string;
+} & RuleSets<L, C>;
+/** An app's levels, categories, fields and rules, as the server takes them. */
+export interface SchemaSpec {
+    /** Each name with the range it ranks in, or with its settings. */
+    levels?: {
+        readonly [name: string]: Like | LevelSettings;
+    };
+    categories?: readonly string[] | {
+        readonly [name: string]: CategorySettings;
+    };
+    fields?: readonly string[] | {
+        readonly [name: string]: FieldSettings;
+    };
+    rules?: readonly SchemaRule[];
+}
+type NamesIn<T> = T extends readonly (infer N)[] ? N & string : T extends object ? keyof T & string : never;
+type LevelNames<S> = S extends {
+    levels?: infer L;
+} ? NamesIn<NonNullable<L>> : never;
+type CategoryNames<S> = S extends {
+    categories?: infer C;
+} ? NamesIn<NonNullable<C>> : never;
+type FieldNames<S> = S extends {
+    fields?: infer F;
+} ? NamesIn<NonNullable<F>> : never;
+/** A Sentry level or a level of the schema. */
+export type LevelOf<S> = string extends LevelNames<S> ? Level : SentryLevel | LevelNames<S>;
+/** A category of the schema. */
+export type CategoryOf<S> = CategoryNames<S>;
+/** A field of the schema. */
+export type FieldOf<S> = FieldNames<S>;
+type NameChar = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "." | "-" | "_";
+/** True for 1 to Max of NameChar. A name only known as string passes. */
+type IsName<S extends string, Max extends number, Seen extends 0[] = []> = string extends S ? true : S extends `${infer C}${infer Rest}` ? C extends NameChar ? Seen["length"] extends Max ? false : IsName<Rest, Max, [...Seen, 0]> : false : Seen extends [] ? false : true;
+type LevelRule = "Level names are 1 to 32 lowercase letters, digits, dots, dashes or underscores";
+type CategoryRule = "Category names are 1 to 64 lowercase letters, digits, dots, dashes or underscores";
+type FieldRule = "Field names are not empty and do not start statoss.";
+type Only<V, Keys extends PropertyKey, Message extends string> = {
+    [P in Exclude<keyof V, Keys>]: {
+        [M in Message]: true;
+    };
+};
+type LevelCheck<V> = V extends string ? Like : {
+    like?: Like;
+    severity?: V extends {
+        like: infer K extends Like;
+    } ? Severities[K] : Severity;
+    label?: string | null;
+    color?: SchemaColor | null;
+} & Only<V, keyof LevelSettings, "A level takes like, severity, label and color">;
+/** Sentry's own levels rank as themselves: a label and a colour only. */
+type BuiltinLevelCheck<K extends SentryLevel, V> = V extends string ? K : {
+    like?: K;
+    label?: string | null;
+    color?: SchemaColor | null;
+} & Only<V, "like" | "label" | "color", "A built-in level takes label and color, and ranks as itself">;
+type CheckLevels<T> = {
+    [K in keyof T]: K extends SentryLevel ? BuiltinLevelCheck<K, T[K]> : K extends string ? IsName<K, 32> extends true ? LevelCheck<T[K]> : {
+        [M in LevelRule]: true;
+    } : never;
+};
+type CheckCategories<T> = T extends readonly unknown[] ? {
+    [I in keyof T]: T[I] extends string ? IsName<T[I], 64> extends true ? T[I] : {
+        [M in CategoryRule]: true;
+    } : string;
+} : {
+    [K in keyof T]: K extends string ? IsName<K, 64> extends true ? CategorySettings & Only<T[K], keyof CategorySettings, "A category takes label, color, hidden and owner"> : {
+        [M in CategoryRule]: true;
+    } : never;
+};
+type IsField<K extends string> = K extends "" | `statoss.${string}` ? false : true;
+type CheckFields<T> = T extends readonly unknown[] ? {
+    [I in keyof T]: T[I] extends string ? IsField<T[I]> extends true ? T[I] : {
+        [M in FieldRule]: true;
+    } : string;
+} : {
+    [K in keyof T]: K extends string ? IsField<K> extends true ? FieldSettings & Only<T[K], keyof FieldSettings, "A field takes label, type, unit and filterable"> : {
+        [M in FieldRule]: true;
+    } : never;
+};
+type CheckRules<T, L extends string, C extends string> = {
+    [I in keyof T]: SchemaRule<L, C> & Only<T[I], "subject" | "tagKey" | "match" | "value" | "level" | "category", "A rule takes subject, tagKey, match, value, level and category">;
+};
+/** What defineSchema holds a schema to, read from the schema itself. */
+export type CheckSchema<S> = {
+    [K in keyof S]: K extends "levels" ? CheckLevels<S[K]> : K extends "categories" ? CheckCategories<S[K]> : K extends "fields" ? CheckFields<S[K]> : K extends "rules" ? CheckRules<S[K], SentryLevel | LevelNames<S>, CategoryNames<S>> : {
+        "A schema takes levels, categories, fields and rules": true;
+    };
+};
+/**
+ * Declares an app's levels, categories, fields and rules. Returns the schema
+ * as given: plain data in the shape the server takes, so it can be sent as
+ * it is. Its names become types: pass it to init as `schema` and the capture
+ * functions init returns take only these names.
+ */
+export declare function defineSchema<const S extends SchemaSpec & CheckSchema<S>>(schema: S): S;
+/** A field's value; sent as a tag. */
+export type FieldValue = string | number | boolean;
+/** What the capture functions of init's handle take, typed by the schema. */
+export interface SchemaContext<S = SchemaSpec> extends Omit<CaptureContext, "level" | "category"> {
+    /** A Sentry level or a level of the schema. */
+    level?: LevelOf<S>;
+    /** A category of the schema, sent as the `statoss.category` tag. */
+    category?: CategoryOf<S>;
+    /**
+     * Fields of the schema, sent as tags; a schema that declares none takes
+     * none here.
+     */
+    fields?: [FieldOf<S>] extends [never] ? never : {
+        [K in FieldOf<S>]?: FieldValue;
+    };
+}
+/** The capture functions, typed by the schema given to init. */
+export interface Handle<S = SchemaSpec> {
+    /** Sends an error (or anything thrown). Returns the event id. */
+    captureException(error: unknown, context?: SchemaContext<S>): string;
+    /** Sends a message, with a level or a context. Returns the event id. */
+    captureMessage(message: string, levelOrContext?: LevelOf<S> | SchemaContext<S>): string;
+    /** Sends an event you built in Sentry's schema. Returns the event id. */
+    captureEvent(event: Event, context?: SchemaContext<S>): string;
+    /**
+     * Log lines, sent when init has `logs: true`; `log` takes the schema's
+     * own levels.
+     */
+    logger: AppLogger<S>;
+}
+/**
+ * How a line at each level of init's `schema` is logged: at its range's
+ * level (trace stays trace), with its severity when it gives one inside
+ * that range. Names readSchema refuses are left out.
+ */
+export declare function schemaLogLevels(schema: unknown): Record<string, OwnLogLevel>;
+/**
+ * The Sentry level each level of init's `schema` is sent as. Built-in
+ * levels are left out; names the SDK cannot send are logged in debug mode.
+ */
+export declare function readSchema(schema: unknown, logger: Logger): Record<string, SentryLevel>;
+export {};