palbase 0.0.0-stage → 0.1.0

package/types/internal/src/modules/analytics.d.ts

@@ -0,0 +1,1414 @@
+import { type Reply, type Transport } from '../transport.js';
+export type AliasRequest = {
+    /**
+     * One id.
+     */
+    from: string;
+    /**
+     * When the device sent it, unix milliseconds on its clock: the difference to the server's is the clock's error, taken off timestamp.
+     */
+    sent_at?: number;
+    /**
+     * Unix milliseconds on the device's clock.
+     */
+    timestamp?: number;
+    /**
+     * The other: the event is under it.
+     */
+    to: string;
+};
+export type BatchAnswer = {
+    /**
+     * Events kept.
+     */
+    accepted: number;
+    /**
+     * Events refused.
+     */
+    rejected: BatchRejection[];
+};
+export type BatchRejection = {
+    /**
+     * Why: the code.
+     */
+    error: string;
+    /**
+     * Why, in words.
+     */
+    error_description: string;
+    /**
+     * Its place in the batch.
+     */
+    index: number;
+};
+export type BatchRequest = {
+    /**
+     * 1 to 100 events.
+     */
+    events: CaptureRequest[];
+};
+export type Breakdown = {
+    /**
+     * What the events are split by, as asked.
+     */
+    by: string;
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * The most frequent value first.
+     */
+    rows: BreakdownRow[];
+};
+export type BreakdownRow = {
+    /**
+     * Events with this value.
+     */
+    events: number;
+    /**
+     * Distinct ids among them.
+     */
+    users: number;
+    /**
+     * The value ("" when absent or empty).
+     */
+    value: string;
+};
+export type CaptureRequest = {
+    /**
+     * The app's version.
+     */
+    app_version?: string;
+    /**
+     * Who did it (256 characters at most). With a user's token, the user's id instead.
+     */
+    distinct_id: string;
+    /**
+     * The event's name: a letter or $, then letters, digits and _.:-$; 64 at most.
+     */
+    event: string;
+    /**
+     * Free-form properties: 100 at most, 8 KiB each as JSON.
+     */
+    properties?: {
+        [key: string]: unknown;
+    };
+    /**
+     * When the device sent it, unix milliseconds on its clock: the difference to the server's is the clock's error, taken off timestamp.
+     */
+    sent_at?: number;
+    /**
+     * The session it happened in.
+     */
+    session_id?: string;
+    /**
+     * Unix milliseconds on the device's clock.
+     */
+    timestamp?: number;
+};
+export type ConsoleAnswer = {
+    /**
+     * Records that passed.
+     */
+    accepted: number;
+    /**
+     * Always false: nothing samples a history away.
+     */
+    sampled: boolean;
+    /**
+     * Records kept.
+     */
+    stored: number;
+};
+export type ConsoleBatch = {
+    /**
+     * 500 at most.
+     */
+    records: ConsoleStoredRecord[];
+    /**
+     * The launch: app version and build, OS version, device model, SDK version.
+     */
+    session?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The app session the history is from.
+     */
+    session_id: string;
+    /**
+     * What made the device send it.
+     */
+    trigger: "error" | "crash" | "user_report";
+};
+export type ConsoleConfig = {
+    /**
+     * Bodies are kept now.
+     */
+    bodies_enabled: boolean;
+    /**
+     * enabled or disabled: the project's setting; unavailable: it could not be read, and bodies are not kept.
+     */
+    bodies_reason: "enabled" | "disabled" | "unavailable";
+    /**
+     * An upload's limit.
+     */
+    max_batch_bytes: number;
+    /**
+     * A record's limit.
+     */
+    max_record_bytes: number;
+};
+export type ConsolePage = {
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * Newest first.
+     */
+    records: ConsoleRecord[];
+    /**
+     * How long records are kept.
+     */
+    retention_days: number;
+};
+export type ConsoleRecord = {
+    /**
+     * Whose.
+     */
+    distinct_id: string;
+    /**
+     * The record as the SDK wrote it (JSON).
+     */
+    record: string;
+    /**
+     * The record.
+     */
+    record_id: string;
+    /**
+     * Its schema's version.
+     */
+    schema_version: number;
+    /**
+     * The session.
+     */
+    session_id: string;
+    /**
+     * When, on the device's clock.
+     */
+    timestamp: string;
+};
+/**
+ * One record, in the SDK's own versioned shape (schemaVersion 1): a log message (message) or a network exchange (network), each with its id and createdAt. The rest is kept as sent.
+ */
+export type ConsoleStoredRecord = {
+    [key: string]: unknown;
+};
+export type ErrorResponse = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Correlation ID
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying, when the refusal ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code
+     */
+    status: number;
+};
+export type Event = {
+    /**
+     * Whose.
+     */
+    distinct_id: string;
+    /**
+     * The event.
+     */
+    event_id: string;
+    /**
+     * Its name.
+     */
+    name: string;
+    /**
+     * Its properties.
+     */
+    properties: {
+        [key: string]: unknown;
+    };
+    /**
+     * The session.
+     */
+    session_id: string;
+    /**
+     * When it happened (corrected for the device's clock).
+     */
+    timestamp: string;
+};
+export type EventBucket = {
+    /**
+     * The bucket's start, unix milliseconds, UTC.
+     */
+    bucket_ms: number;
+    /**
+     * Events.
+     */
+    events: number;
+    /**
+     * Distinct ids.
+     */
+    users: number;
+};
+export type EventNames = {
+    /**
+     * In order.
+     */
+    names: string[];
+};
+export type EventPage = {
+    /**
+     * Newest first.
+     */
+    events: Event[];
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+};
+export type EventTimeline = {
+    /**
+     * What a row spans: hour or day.
+     */
+    bucket: "hour" | "day";
+    /**
+     * Bucket by bucket, oldest first.
+     */
+    rows: EventBucket[];
+};
+export type FunnelAnswer = {
+    /**
+     * The steps.
+     */
+    steps: FunnelStep[];
+};
+export type FunnelRequest = {
+    /**
+     * How long after the first step the last may be (an hour unless said).
+     */
+    conversion_window_seconds?: number;
+    /**
+     * 2 to 10 event names, in order.
+     */
+    steps: string[];
+    /**
+     * Any other funnel event between steps breaks the chain.
+     */
+    strict_order?: boolean;
+    /**
+     * How far back (an hour unless said).
+     */
+    window_seconds?: number;
+};
+export type FunnelStep = {
+    /**
+     * Their share of the first step's.
+     */
+    conversion_rate: number;
+    /**
+     * The event.
+     */
+    name: string;
+    /**
+     * Its place, from 1.
+     */
+    step: number;
+    /**
+     * People who reached it.
+     */
+    users: number;
+};
+export type IdentifyRequest = {
+    /**
+     * The anonymous id they had.
+     */
+    anonymous_id?: string;
+    /**
+     * The user's id.
+     */
+    distinct_id: string;
+    /**
+     * When the device sent it, unix milliseconds on its clock: the difference to the server's is the clock's error, taken off timestamp.
+     */
+    sent_at?: number;
+    /**
+     * Unix milliseconds on the device's clock.
+     */
+    timestamp?: number;
+    /**
+     * Free-form properties: 100 at most, 8 KiB each as JSON.
+     */
+    traits?: {
+        [key: string]: unknown;
+    };
+};
+export type MachineTraffic = {
+    /**
+     * What a row spans: hour or day.
+     */
+    bucket: "hour" | "day";
+    /**
+     * Bucket by bucket, oldest first.
+     */
+    rows: TraceHour[];
+};
+export type NameCount = {
+    /**
+     * How often.
+     */
+    count: number;
+    /**
+     * The name.
+     */
+    name: string;
+};
+export type PageRequest = {
+    /**
+     * Who saw it.
+     */
+    distinct_id: string;
+    /**
+     * Free-form properties: 100 at most, 8 KiB each as JSON.
+     */
+    properties?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Where from.
+     */
+    referrer?: string;
+    /**
+     * When the device sent it, unix milliseconds on its clock: the difference to the server's is the clock's error, taken off timestamp.
+     */
+    sent_at?: number;
+    /**
+     * The session.
+     */
+    session_id?: string;
+    /**
+     * Unix milliseconds on the device's clock.
+     */
+    timestamp?: number;
+    /**
+     * Its title.
+     */
+    title?: string;
+    /**
+     * The page.
+     */
+    url: string;
+};
+export type PerfAnswer = {
+    /**
+     * Samples kept.
+     */
+    accepted: number;
+    /**
+     * Samples dropped.
+     */
+    dropped: number;
+};
+export type PerfBucket = {
+    /**
+     * The bucket's start, unix milliseconds, UTC.
+     */
+    bucket_ms: number;
+    /**
+     * Median.
+     */
+    p50: number;
+    /**
+     * 75th percentile.
+     */
+    p75: number;
+    /**
+     * 95th percentile.
+     */
+    p95: number;
+    /**
+     * Samples.
+     */
+    sample_count: number;
+};
+export type PerfConfig = {
+    /**
+     * Samples the SDK batches.
+     */
+    flush_at: number;
+    /**
+     * How often the SDK sends at least.
+     */
+    flush_interval_ms: number;
+    /**
+     * The share kept, 0 to 100.
+     */
+    sample_pct: number;
+};
+export type PerfGroup = {
+    /**
+     * The dimension's value (the name, when grouped by name).
+     */
+    key: string;
+    /**
+     * The measure.
+     */
+    name: string;
+    /**
+     * Median.
+     */
+    p50: number;
+    /**
+     * 75th percentile.
+     */
+    p75: number;
+    /**
+     * 95th percentile.
+     */
+    p95: number;
+    /**
+     * 99th percentile.
+     */
+    p99: number;
+    /**
+     * Samples.
+     */
+    sample_count: number;
+    /**
+     * The type.
+     */
+    trace_type: string;
+};
+export type PerfItem = {
+    /**
+     * Not read.
+     */
+    app_id?: string;
+    /**
+     * 5 at most.
+     */
+    attrs?: {
+        [key: string]: string;
+    };
+    /**
+     * 32 at most.
+     */
+    counters?: {
+        [key: string]: number;
+    };
+    /**
+     * Not read: who measured is the caller.
+     */
+    distinct_id?: string;
+    /**
+     * The measure: a network sample's "<METHOD> <url>" (kept as its route: the query dropped, ids as :id).
+     */
+    name: string;
+    /**
+     * The request a network sample measured.
+     */
+    request_id?: string;
+    /**
+     * The sample's id: it decides its sampling.
+     */
+    row_id: string;
+    /**
+     * Unix milliseconds.
+     */
+    timestamp: number;
+    /**
+     * What was measured: network, app_start, custom, screen or web_vital (another is dropped).
+     */
+    trace_type: string;
+    /**
+     * The measurement.
+     */
+    value: number;
+};
+export type PerfPage = {
+    /**
+     * The dimension.
+     */
+    group_by: string;
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * The most sampled first.
+     */
+    rows: PerfGroup[];
+};
+export type PerfRequest = {
+    /**
+     * 100 at most; more are dropped.
+     */
+    items: PerfItem[];
+};
+export type PerfTimeline = {
+    /**
+     * What a row spans: hour or day.
+     */
+    bucket: "hour" | "day";
+    /**
+     * Bucket by bucket, oldest first.
+     */
+    rows: PerfBucket[];
+};
+export type RequestLine = {
+    /**
+     * The address it came from.
+     */
+    client_ip: string;
+    /**
+     * How long it took.
+     */
+    duration_ms: number;
+    /**
+     * How it ended when it did not reach a module's answer (Envoy's response flags: UAEX the check refused it, NR no module answers its path, UF the module could not be reached, UT it did not answer in time, DC the client went away).
+     */
+    flags?: string;
+    /**
+     * Its HTTP method.
+     */
+    method: string;
+    /**
+     * The module it went to; other for a path none answers.
+     */
+    module: string;
+    /**
+     * Its path, without its query.
+     */
+    path: string;
+    /**
+     * The id the edge gave the request.
+     */
+    request_id: string;
+    /**
+     * The status it was answered; 0 for none.
+     */
+    status: number;
+    /**
+     * When it arrived.
+     */
+    ts: string;
+    /**
+     * The client's user agent.
+     */
+    user_agent: string;
+};
+export type RequestLinePage = {
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * The request lines.
+     */
+    requests: RequestLine[];
+};
+export type RetentionAnswer = {
+    /**
+     * The period.
+     */
+    period: string;
+    /**
+     * Periods read: as many as the window holds.
+     */
+    periods: number;
+    /**
+     * Newest first.
+     */
+    rows: RetentionRow[];
+};
+export type RetentionRequest = {
+    /**
+     * The event that puts a person in a cohort.
+     */
+    first_event: string;
+    /**
+     * A cohort's period (week unless said).
+     */
+    period?: "day" | "week" | "month";
+    /**
+     * Periods after the cohort (8 unless said; 31 at most).
+     */
+    periods?: number;
+    /**
+     * The event that counts as returning.
+     */
+    return_event: string;
+    /**
+     * How far back (30 days unless said).
+     */
+    window_seconds?: number;
+};
+export type RetentionRow = {
+    /**
+     * People in it.
+     */
+    cohort_size: number;
+    /**
+     * The cohort's period.
+     */
+    cohort_start: string;
+    /**
+     * How many of the periods after have fully passed.
+     */
+    observable: number;
+    /**
+     * returns[0] is the cohort's size, returns[k] the people back k periods later.
+     */
+    returns: number[];
+};
+export type ScreenRequest = {
+    /**
+     * Who saw it.
+     */
+    distinct_id: string;
+    /**
+     * Free-form properties: 100 at most, 8 KiB each as JSON.
+     */
+    properties?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The screen.
+     */
+    screen_name: string;
+    /**
+     * When the device sent it, unix milliseconds on its clock: the difference to the server's is the clock's error, taken off timestamp.
+     */
+    sent_at?: number;
+    /**
+     * The session.
+     */
+    session_id?: string;
+    /**
+     * Unix milliseconds on the device's clock.
+     */
+    timestamp?: number;
+};
+export type Settings = {
+    /**
+     * Console records keep request and response bodies.
+     */
+    console_bodies: boolean;
+    /**
+     * How long console records are kept, in days.
+     */
+    console_retention_days: number;
+    /**
+     * The share of performance samples kept.
+     */
+    perf_sample_pct: number;
+    /**
+     * How long events, samples and traces are kept, in days.
+     */
+    retention_days: number;
+};
+export type Summary = {
+    /**
+     * The 50 most frequent names.
+     */
+    events: NameCount[];
+    /**
+     * Events.
+     */
+    total: number;
+    /**
+     * Distinct ids.
+     */
+    unique_users: number;
+    /**
+     * The window read, after the retention bound it.
+     */
+    window_seconds: number;
+};
+export type Trace = {
+    /**
+     * Whose.
+     */
+    distinct_id: string;
+    /**
+     * How long.
+     */
+    duration_ms: number;
+    /**
+     * The path.
+     */
+    endpoint: string;
+    /**
+     * The error's code.
+     */
+    error_code: string;
+    /**
+     * The error.
+     */
+    error_message: string;
+    /**
+     * The method.
+     */
+    method: string;
+    /**
+     * The request.
+     */
+    request_id: string;
+    /**
+     * The session.
+     */
+    session_id: string;
+    /**
+     * client or backend.
+     */
+    source: string;
+    /**
+     * The status.
+     */
+    status: number;
+    /**
+     * When.
+     */
+    timestamp: string;
+    /**
+     * Its trace.
+     */
+    trace_id: string;
+};
+export type TraceBatchRequest = {
+    /**
+     * 1 to 100 traces.
+     */
+    traces: TraceRequest[];
+};
+export type TraceHour = {
+    /**
+     * 2xx.
+     */
+    count_2xx: number;
+    /**
+     * 3xx.
+     */
+    count_3xx: number;
+    /**
+     * 4xx.
+     */
+    count_4xx: number;
+    /**
+     * 5xx.
+     */
+    count_5xx: number;
+    /**
+     * 4xx and 5xx.
+     */
+    error_count: number;
+    /**
+     * The bucket's start (an hour, or a day), unix milliseconds, UTC.
+     */
+    hour_ms: number;
+    /**
+     * Median duration.
+     */
+    p50_duration_ms: number;
+    /**
+     * 95th percentile.
+     */
+    p95_duration_ms: number;
+    /**
+     * Requests.
+     */
+    requests: number;
+};
+export type TraceList = {
+    /**
+     * In order.
+     */
+    traces: Trace[];
+};
+export type TracePage = {
+    /**
+     * Reads the next page; absent on the last.
+     */
+    next_cursor?: string;
+    /**
+     * The requests.
+     */
+    traces: Trace[];
+};
+export type TraceRequest = {
+    /**
+     * What the client says of itself (4 KiB at most).
+     */
+    client_meta?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Whose (the signed-in user's when absent).
+     */
+    distinct_id?: string;
+    /**
+     * How long it took.
+     */
+    duration_ms?: number;
+    /**
+     * The path (512 at most).
+     */
+    endpoint: string;
+    /**
+     * The error's code.
+     */
+    error_code?: string;
+    /**
+     * The error (4 KiB at most).
+     */
+    error_message?: string;
+    /**
+     * The HTTP method.
+     */
+    method?: string;
+    /**
+     * The request's id: letters, digits, _ and -; 64 at most.
+     */
+    request_id: string;
+    /**
+     * When the device sent it, unix milliseconds on its clock: the difference to the server's is the clock's error, taken off timestamp.
+     */
+    sent_at?: number;
+    /**
+     * The session.
+     */
+    session_id?: string;
+    /**
+     * Who saw it.
+     */
+    source: "client" | "backend";
+    /**
+     * The status (0, or 100 to 599).
+     */
+    status?: number;
+    /**
+     * Unix milliseconds on the device's clock.
+     */
+    timestamp?: number;
+    /**
+     * The trace it is part of.
+     */
+    trace_id?: string;
+};
+export type TraceSummary = {
+    /**
+     * 4xx.
+     */
+    client_error_count: number;
+    /**
+     * 2xx.
+     */
+    count_2xx: number;
+    /**
+     * 3xx.
+     */
+    count_3xx: number;
+    /**
+     * 4xx.
+     */
+    count_4xx: number;
+    /**
+     * 5xx.
+     */
+    count_5xx: number;
+    /**
+     * 4xx and 5xx.
+     */
+    error_count: number;
+    /**
+     * Errors' share.
+     */
+    error_rate: number;
+    /**
+     * Median duration.
+     */
+    p50_duration_ms: number;
+    /**
+     * 95th percentile.
+     */
+    p95_duration_ms: number;
+    /**
+     * 99th percentile.
+     */
+    p99_duration_ms: number;
+    /**
+     * 5xx.
+     */
+    server_error_count: number;
+    /**
+     * Requests.
+     */
+    total: number;
+};
+export type TraceTimeline = {
+    /**
+     * What a row spans: hour or day.
+     */
+    bucket: "hour" | "day";
+    /**
+     * Bucket by bucket, oldest first.
+     */
+    rows: TraceHour[];
+};
+/** Palbase Analytics */
+export declare function client(t: Transport): {
+    /**
+     * Join two ids
+     *
+     * An $alias event: from and to are one user. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    alias(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: AliasRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, undefined>>;
+    /**
+     * Send events in a batch
+     *
+     * Up to 100 events (3 MiB). Each is kept or refused on its own: 202 when all were kept, 207 naming the refused by their place, and the first refusal's own answer when none was. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    batch(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: BatchRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, BatchAnswer> | Reply<207, BatchAnswer>>;
+    /**
+     * Break the events down
+     *
+     * The window's events split by one dimension — the platform, the app version, the OS version, the country, the event's name, or one of its properties — the most frequent value first: how many events had each value, by how many distinct ids. An absent or empty value is ""; a property that is not a string is its JSON (a number, true, an array).
+     */
+    getEventBreakdown(input: {
+        query: {
+            window_seconds?: number; /** What to split by: platform, app_version, os_version, country, event (the event's name), or property:<key> — a key of the events' properties (letters, digits and _ . $ -, 64 at most). */
+            by: string; /** Only this event (every event unless said). */
+            event?: string; /** Values per page (10 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Breakdown>>;
+    /**
+     * Send an event
+     *
+     * One event: a name, who did it (distinct_id), its properties (100 at most, 8 KiB each, 32 KiB in all), when on the device's clock (corrected by sent_at). The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    capture(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: CaptureRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, undefined>>;
+    /**
+     * Upload console history
+     *
+     * An app's console history — its log messages and network exchanges — sent when something went wrong (an error, a crash, a user's report): 500 records at most, 64 KiB each, 2 MiB in all, kept whole or not at all. Request and response bodies are kept only if the project said so; otherwise they are removed before anything is kept, and each record says so. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    sendConsoleHistory(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: ConsoleBatch; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, ConsoleAnswer>>;
+    /**
+     * Read what console uploads keep
+     *
+     * Whether bodies are kept now — and why: the project's setting, or a setting that could not be read (then they are not) — and the upload limits.
+     */
+    getConsoleConfig(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ConsoleConfig>>;
+    /**
+     * List console records
+     *
+     * A page of the window's console records, newest first, each as the SDK wrote it (its bodies removed if the project keeps none), and how long records are kept.
+     */
+    listConsoleRecords(input?: {
+        query?: {
+            window_seconds?: number; /** Only this distinct id's. */
+            user?: string; /** Only this session's. */
+            session?: string; /** Rows per page (100 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ConsolePage>>;
+    /**
+     * List event names
+     *
+     * Every name the window's events had (1000 at most), in order.
+     */
+    listEventNames(input?: {
+        query?: {
+            window_seconds?: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, EventNames>>;
+    /**
+     * List events
+     *
+     * A page of the window's events, newest first.
+     */
+    listEvents(input?: {
+        query?: {
+            window_seconds?: number; /** Only events of this name. */
+            name?: string; /** Only this distinct id's. */
+            distinct_id?: string; /** Only this session's. */
+            session_id?: string; /** Rows per page (100 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, EventPage>>;
+    /**
+     * Read events over time
+     *
+     * The window's events bucket by bucket, oldest first: how many, and by how many distinct ids. A bucket with no event is not a row; its start is unix milliseconds, UTC.
+     */
+    getEventTimeline(input?: {
+        query?: {
+            window_seconds?: number; /** hour or day: what a row spans (hours for a window of two days or less, days beyond, unless said). */
+            bucket?: "hour" | "day"; /** Only this event. */
+            name?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, EventTimeline>>;
+    /**
+     * Run a funnel
+     *
+     * How many people took each step — event names, in order — each within the conversion window of their first; in strict order, any other event between breaks the chain. A step's conversion rate is its share of the first step's.
+     */
+    runFunnel(input: {
+        body: FunnelRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, FunnelAnswer>>;
+    /**
+     * Say who the user is
+     *
+     * An $identify event: the user's id, their traits, and the anonymous id they had — their anonymous history goes with them if they are deleted. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    identify(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: IdentifyRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, undefined>>;
+    /**
+     * Send a page view
+     *
+     * A $pageview event; url, title and referrer are kept among its properties. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    page(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: PageRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, undefined>>;
+    /**
+     * Send performance samples
+     *
+     * Up to 100 samples (512 KiB): app starts, screens, network calls, web vitals, custom measures. Each is kept or dropped on its own — a bad shape, a time more than 7 days off, or not sampled in at the project's rate — and the answer counts both: dropping is the server's call, not an error. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    sendPerf(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: PerfRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, PerfAnswer>>;
+    /**
+     * Read performance percentiles
+     *
+     * The window's samples, grouped by their type and name and by one more dimension (the name alone, the app version, the platform, the OS version): p50, p75, p95, p99 and how many samples, the most sampled first.
+     */
+    listPerfGroups(input?: {
+        query?: {
+            window_seconds?: number; /** Only this type. */
+            trace_type?: "network" | "app_start" | "custom" | "screen" | "web_vital"; /** Only this measure. */
+            name?: string; /** The dimension (name unless said). */
+            group_by?: "name" | "app_version" | "platform" | "os_version"; /** Rows per page (100 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PerfPage>>;
+    /**
+     * Read the sampling
+     *
+     * The share of samples the project keeps, for the SDK to sample at before it sends (the server samples again), and how the SDK batches them. An unchanged configuration is 304 against If-None-Match.
+     */
+    getPerfConfig(input?: {
+        headers?: {
+            "If-None-Match"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PerfConfig> | Reply<304, undefined>>;
+    /**
+     * Read performance percentiles over time
+     *
+     * One type's samples bucket by bucket, oldest first: p50, p75, p95 and how many samples. A bucket with no sample is not a row; its start is unix milliseconds, UTC.
+     */
+    getPerfTimeline(input: {
+        query: {
+            window_seconds?: number; /** hour or day: what a row spans (hours for a window of two days or less, days beyond, unless said). */
+            bucket?: "hour" | "day"; /** The type: a percentile is of one type's samples (an app start's milliseconds and a CLS's score are never one). */
+            trace_type: "network" | "app_start" | "custom" | "screen" | "web_vital"; /** Only this measure. */
+            name?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, PerfTimeline>>;
+    /**
+     * List request lines
+     *
+     * A page of the project's requests as the edge saw them — every module's, newest first: what Studio's Logs show. A line keeps its path without its query, its status and duration, and the client's address and user agent; lines are kept a week.
+     */
+    listRequestLines(input?: {
+        query?: {
+            window_seconds?: number; /** Only this module's requests. */
+            module?: "auth" | "storage" | "realtime" | "flags" | "notify" | "analytics" | "secrets" | "machines" | "stores" | "ai" | "other"; /** Only these levels, comma-separated: info (answered below 400), warn (4xx), error (5xx, or no answer). */
+            level?: string; /** Only lines whose path or user agent holds this, or whose request id or client address is this. */
+            q?: string; /** Rows per page (100 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, RequestLinePage>>;
+    /**
+     * Read a machine's requests over time
+     *
+     * The requests the edge took to one of the project's machines, bucket by bucket, oldest first — every request to the machine's address, whatever program answers it: by status class, with their median and p95 duration, as the machine's page shows them. A bucket with no request is not a row. Kept 30 days; nothing of who sent a request or what it asked is kept.
+     */
+    getMachineTraffic(input: {
+        path: {
+            name: string;
+        };
+        query?: {
+            window_seconds?: number; /** hour or day: what a row spans (hours up to two days, days beyond, unless said). */
+            bucket?: "hour" | "day";
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MachineTraffic>>;
+    /**
+     * Run a retention table
+     *
+     * The people whose first first_event fell in each period (day, week, month), and how many of them did return_event in each period after — as many periods as the window holds, 31 at most. A period that has not fully passed is not counted as observable.
+     */
+    runRetention(input: {
+        body: RetentionRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, RetentionAnswer>>;
+    /**
+     * Send a screen view
+     *
+     * A $screen event; screen_name is kept among its properties. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    screen(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: ScreenRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, undefined>>;
+    /**
+     * Read the settings
+     *
+     * The project's analytics settings.
+     */
+    getSettings(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Settings>>;
+    /**
+     * Change the settings
+     *
+     * How long rows are kept (a shorter retention removes what is older within minutes; a longer one keeps what is still there longer), the share of performance samples kept, and whether console records keep bodies.
+     */
+    putSettings(input: {
+        body: Settings; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Settings>>;
+    /**
+     * Summarize the events
+     *
+     * The window's events: how many, by how many distinct ids, and the 50 most frequent names.
+     */
+    getSummary(input?: {
+        query?: {
+            window_seconds?: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Summary>>;
+    /**
+     * List requests
+     *
+     * A page of the window's requests, newest first: the traces sent, and the clients' network samples (GET /analytics/perf/client), in one shape.
+     */
+    listTraces(input?: {
+        query?: {
+            window_seconds?: number; /** Only this path. */
+            endpoint?: string; /** client or backend. */
+            source?: "client" | "backend"; /** Only this HTTP method. */
+            method?: string; /** Only this status. */
+            status?: number; /** Only this class of status. */
+            status_class?: "2xx" | "3xx" | "4xx" | "5xx"; /** At least this long. */
+            duration_min_ms?: number; /** At most this long. */
+            duration_max_ms?: number; /** Only this user's (their distinct id). */
+            distinct_id?: string; /** Only this request. */
+            request_id?: string; /** Rows per page (100 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TracePage>>;
+    /**
+     * Send a request trace
+     *
+     * One request, as the client (or a backend) saw it: its path, method, status, duration and error, by the request id the platform gave it. The request is answered once what it sends is kept — on the platform's stream, written to the store within seconds, even while the store is restarting. A signed-in user's token (with the publishable key) makes it theirs: their user id is the distinct id, whatever the body says.
+     */
+    sendTrace(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: TraceRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, undefined>>;
+    /**
+     * Send request traces in a batch
+     *
+     * Up to 100 requests at once, each kept or refused on its own as a batch of events is: 202 when all were kept, 207 with the refused ones named by place, the first refusal's own answer when none was. What a backend sends of the requests it answered. The request is answered once what it keeps is on the platform's stream, written to the store within seconds.
+     */
+    sendTraceBatch(input: {
+        headers?: {
+            "Idempotency-Key"?: string; /** The app's version: kept with what it sends. */
+            "X-Palbase-Client-Version"?: string; /** The app's platform (ios, android, web). */
+            "X-Platform"?: string; /** The operating system's version. */
+            "X-OS-Version"?: string;
+        };
+        body: TraceBatchRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, BatchAnswer> | Reply<207, BatchAnswer>>;
+    /**
+     * Read one request's hops
+     *
+     * Every report of one request — the client's and the backend's — by trace id, or by request id (a client sample carries no trace id); 500 at most, in order.
+     */
+    getTraceHops(input: {
+        query: {
+            window_seconds?: number; /** The trace id, or the request id. */
+            trace_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TraceList>>;
+    /**
+     * List a session's requests
+     *
+     * A page of one session's requests, in the order they happened.
+     */
+    listSessionTraces(input: {
+        query: {
+            window_seconds?: number; /** The session. */
+            session_id: string; /** Rows per page (100 unless said). */
+            limit?: number; /** The next_cursor of the page before: reads the page after it. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TracePage>>;
+    /**
+     * Summarize requests
+     *
+     * The whole window's requests — not a page's — with the filters: counts by status class, error rate, duration percentiles.
+     */
+    getTraceSummary(input?: {
+        query?: {
+            window_seconds?: number; /** Only this path. */
+            endpoint?: string; /** client or backend. */
+            source?: "client" | "backend"; /** Only this HTTP method. */
+            method?: string; /** Only this status. */
+            status?: number; /** Only this class of status. */
+            status_class?: "2xx" | "3xx" | "4xx" | "5xx"; /** At least this long. */
+            duration_min_ms?: number; /** At most this long. */
+            duration_max_ms?: number; /** Only this user's (their distinct id). */
+            distinct_id?: string; /** Only this request. */
+            request_id?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TraceSummary>>;
+    /**
+     * Read requests over time
+     *
+     * The summary, bucket by bucket — hour by hour unless said, or day by day — oldest first; a bucket with no request is not a row. A row's hour_ms is its bucket's start, an hour's or a day's (unix milliseconds, UTC).
+     */
+    getTraceTimeline(input?: {
+        query?: {
+            window_seconds?: number; /** hour or day: what a row spans (hour unless said). */
+            bucket?: "hour" | "day"; /** Only this path. */
+            endpoint?: string; /** client or backend. */
+            source?: "client" | "backend"; /** Only this HTTP method. */
+            method?: string; /** Only this status. */
+            status?: number; /** Only this class of status. */
+            status_class?: "2xx" | "3xx" | "4xx" | "5xx"; /** At least this long. */
+            duration_min_ms?: number; /** At most this long. */
+            duration_max_ms?: number; /** Only this user's (their distinct id). */
+            distinct_id?: string; /** Only this request. */
+            request_id?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, TraceTimeline>>;
+};
+export type Client = ReturnType<typeof client>;