sermon-js 0.0.0-stage → 0.2.0

package/dist/presets/index.d.ts

@@ -0,0 +1,516 @@
+export { G as GenericHttpOptions, g as generic } from '../generic-BJmlgtUM.js';
+import { b as PresetOptions, S as ServiceDefinition } from '../config-w1tm1bdu.js';
+import { P as ProbeHelpers, h as CommonOptions } from '../types-CctvUAs2.js';
+
+type FlyAppOptions = PresetOptions & {
+    /** The Fly app name, e.g. "my-api" */
+    app: string;
+    secrets: {
+        /** A Fly API token. A read-only one is enough: `fly tokens create readonly` */
+        token: string | undefined;
+    };
+    track?: {
+        /**
+         * Health path probed on each machine that is already running (default "/").
+         * Pass `false` to only read machine states. `anyStatus` accepts any HTTP answer,
+         * e.g. for servers that answer 404 on their root.
+         */
+        health?: string | false | {
+            path?: string;
+            anyStatus?: boolean;
+        };
+        /** Report every machine individually (default true) */
+        machines?: boolean;
+    };
+};
+type FlyMachineEvent = {
+    type?: string;
+    timestamp?: number;
+    request?: {
+        exit_event?: {
+            exit_code?: number;
+            oom_killed?: boolean;
+            requested_stop?: boolean;
+        };
+    };
+};
+/** Last exit of a stopped machine, if it was a crash rather than a scale-to-zero stop */
+declare function crashReason(machine: {
+    events?: FlyMachineEvent[];
+}): string | undefined;
+/** Presets for Fly.io */
+declare const fly: {
+    app: (options: FlyAppOptions) => ServiceDefinition;
+};
+
+type GoogleServiceAccount = {
+    client_email: string;
+    private_key: string;
+    project_id?: string;
+};
+/** Parse a service-account JSON key; undefined when it isn't one */
+declare function parseServiceAccount(json: string | undefined): GoogleServiceAccount | undefined;
+/** A signed JWT assertion for Google's OAuth token endpoint (RS256, Web Crypto) */
+declare function signGoogleAssertion({ account, scope, now, }: {
+    account: GoogleServiceAccount;
+    scope: string;
+    now?: number;
+}): Promise<string>;
+/** Forget cached tokens (for tests) */
+declare function clearGoogleTokens(): void;
+/**
+ * An OAuth access token for a Google service account, without any Google library: it only
+ * needs `fetch` and Web Crypto, so it works on edge runtimes. Tokens are kept in memory until
+ * shortly before they expire.
+ */
+declare function googleServiceAccountToken({ account, scope, http, now, }: {
+    account: GoogleServiceAccount;
+    scope: string;
+    http: ProbeHelpers["http"];
+    now?: number;
+}): Promise<string>;
+
+type GcpInstanceOptions = PresetOptions & {
+    /** The Compute Engine instance name */
+    instance: string | undefined;
+    /** Its zone, e.g. "europe-west1-b" */
+    zone: string | undefined;
+    /** The project ID (default: the one in the service-account key) */
+    project?: string;
+    secrets: {
+        /** Service-account JSON key allowed to read instances (e.g. Compute Viewer) */
+        serviceAccount: string | undefined;
+    };
+    track?: {
+        /** URL probed only while the VM is RUNNING. Any HTTP answer counts as healthy. */
+        health?: string | false;
+    };
+};
+/** Presets for Google Cloud */
+declare const gcp: {
+    instance: (options: GcpInstanceOptions) => ServiceDefinition;
+};
+
+type AwsSecrets = {
+    accessKeyId: string | undefined;
+    secretAccessKey: string | undefined;
+};
+type AwsCredentialsOptions = PresetOptions & {
+    /** How to call it: these credentials usually belong to one AWS service you use */
+    name: string;
+    secrets: AwsSecrets;
+};
+type S3BucketOptions = PresetOptions & {
+    bucket: string | undefined;
+    /** S3-compatible endpoint (Tigris, R2, MinIO…). Default: AWS S3 in `region`. */
+    endpoint?: string;
+    /** Region (default "us-east-1"; S3-compatible services often use "auto") */
+    region?: string;
+    secrets: AwsSecrets;
+};
+/** Presets for AWS and S3-compatible storage */
+declare const aws: {
+    credentials: (options: AwsCredentialsOptions) => ServiceDefinition;
+    s3Bucket: (options: S3BucketOptions) => ServiceDefinition;
+};
+
+type MongoDatabase = {
+    command(command: Record<string, unknown>): Promise<unknown>;
+};
+type MongoLike = MongoDatabase | {
+    db(name?: string): MongoDatabase;
+};
+type MongoPingOptions = PresetOptions & {
+    /**
+     * Your `MongoClient` (or a `Db`). The driver connects on first use, so there is nothing to
+     * await. When undefined the service is "not configured".
+     */
+    client: MongoLike | undefined;
+    /** Optional: the connection string, only so it is redacted from public errors */
+    secrets?: {
+        url?: string;
+    };
+};
+/** Presets for MongoDB */
+declare const mongodb: {
+    ping: (options: MongoPingOptions) => ServiceDefinition;
+};
+type RedisLike = {
+    ping: () => Promise<unknown>;
+} | {
+    call: (command: string, ...args: string[]) => Promise<unknown>;
+} | {
+    sendCommand: (args: string[]) => Promise<unknown>;
+};
+type RedisPingOptions = PresetOptions & {
+    /** A connected ioredis or node-redis client. When undefined the service is "not configured". */
+    client: RedisLike | undefined;
+};
+/** Presets for Redis servers reached with a client library */
+declare const redis: {
+    ping: (options: RedisPingOptions) => ServiceDefinition;
+};
+type PostgresPingOptions = PresetOptions & {
+    /**
+     * Runs one statement with the driver you already use (pg, postgres.js, Neon…). When
+     * undefined the service is "not configured".
+     */
+    query: ((sql: string) => Promise<unknown>) | undefined;
+    /** Optional: the connection string, only so it is redacted from public errors */
+    secrets?: {
+        url?: string;
+    };
+};
+/** Presets for PostgreSQL servers reached with a client library */
+declare const postgres: {
+    ping: (options: PostgresPingOptions) => ServiceDefinition;
+};
+
+type ApiKey = {
+    secrets: {
+        apiKey: string | undefined;
+    };
+};
+type DeepgramOptions = PresetOptions & ApiKey & {
+    track?: {
+        /** Warn when the prepaid balance drops below this amount (default 20). `false` skips the balance. */
+        balance?: {
+            warnBelow?: number;
+        } | false;
+    };
+};
+/**
+ * Deepgram. Lists projects, then reads the balance of the first one.
+ * - up: the key works
+ * - degraded: balance below `track.balance.warnBelow`, or the key sees no project
+ * - down: the API rejects the key or errors
+ *
+ * Reports `metrics.balance`. Keys without billing scope still count as up.
+ */
+declare const deepgram: (options: DeepgramOptions) => ServiceDefinition;
+/** Gladia. Lists live sessions (limit 1). up when the key works; down when rejected. */
+declare const gladia: (options: CommonOptions & ApiKey) => ServiceDefinition;
+type SpeechmaticsOptions = PresetOptions & ApiKey & {
+    /** API base URL, e.g. the EU endpoint (default "https://asr.api.speechmatics.com") */
+    baseUrl?: string;
+};
+/** Speechmatics. Lists batch jobs (limit 1), which validates the API key. */
+declare const speechmatics: (options: SpeechmaticsOptions) => ServiceDefinition;
+type OpenAIOptions = PresetOptions & ApiKey & {
+    /** Sent as the `OpenAI-Organization` header */
+    organization?: string;
+    track?: {
+        /** Also check that the key can use this model (`GET /v1/models/{model}`) */
+        model?: string;
+    };
+};
+/**
+ * OpenAI. Lists models, or reads one model when `track.model` is set (both free).
+ * It proves the key works; it can't see billing problems, which only show on real requests.
+ */
+declare const openai: (options: OpenAIOptions) => ServiceDefinition;
+/** Anthropic. Lists models (limit 1). up when the key works; down when rejected. */
+declare const anthropic: (options: CommonOptions & ApiKey) => ServiceDefinition;
+/** Google Gemini. Lists models (page size 1). */
+declare const gemini: (options: CommonOptions & ApiKey) => ServiceDefinition;
+/** CAMB.AI. Lists source languages. */
+declare const cambai: (options: CommonOptions & ApiKey) => ServiceDefinition;
+type ElevenLabsOptions = PresetOptions & ApiKey & {
+    track?: {
+        /** Warn when less than this share of the period's credits is left (default 10) */
+        quota?: {
+            warnBelowPct?: number;
+        };
+    };
+};
+/**
+ * ElevenLabs. Reads the subscription, which validates the API key.
+ * - up: the key works. A key without the user scope is refused with `missing_permissions`,
+ *   which still proves it is valid.
+ * - degraded: less than `track.quota.warnBelowPct` of the credits left
+ * - down: the API rejects the key or errors
+ *
+ * Reports a `usage` bar (credits used this period, with the reset time) and `metrics.tier`.
+ */
+declare const elevenlabs: (options: ElevenLabsOptions) => ServiceDefinition;
+
+type DeepLOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+    track?: {
+        /** Warn when this share of the character quota is used (default 90) */
+        quota?: {
+            warnAbovePct?: number;
+        };
+    };
+};
+/**
+ * DeepL. Reads `/v2/usage` (free and paid keys are detected from the key).
+ * - up: quota available
+ * - degraded: usage at or above `track.quota.warnAbovePct`
+ * - down: the API rejects the key or errors
+ *
+ * Reports a `usage` bar: characters used of the limit.
+ */
+declare const deepl: (options: DeepLOptions) => ServiceDefinition;
+type AzureTranslatorOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+    /** Region of the Translator resource (default "westeurope") */
+    region?: string;
+};
+/** Azure Translator. Translates a single character, which proves the key and region work. */
+declare const azureTranslator: (options: AzureTranslatorOptions) => ServiceDefinition;
+type GoogleTranslateOptions = PresetOptions & {
+    secrets: {
+        /** The service-account JSON key (the whole file content), not an API key */
+        serviceAccount: string | undefined;
+    };
+    /** Translation location (default "global") */
+    location?: string;
+};
+/**
+ * Google Cloud Translation v3, with a service account. Gets a token, then lists supported
+ * languages (free: Google bills by characters translated).
+ * - up: languages returned
+ * - down: the key isn't valid JSON, or auth or the API fails
+ *
+ * Reports `metrics.languages`.
+ */
+declare const googleTranslate: (options: GoogleTranslateOptions) => ServiceDefinition;
+
+type MuxOptions = PresetOptions & {
+    secrets: {
+        tokenId: string | undefined;
+        tokenSecret: string | undefined;
+    };
+};
+/** Mux Video. Lists live streams (limit 1). up when the token works; down when rejected. */
+declare const mux: (options: MuxOptions) => ServiceDefinition;
+type CloudflareStreamOptions = PresetOptions & {
+    /** The Cloudflare account ID */
+    accountId: string | undefined;
+    secrets: {
+        token: string | undefined;
+    };
+    track?: {
+        /** Warn when this share of the storage plan is used (default 90). `false` skips storage. */
+        storage?: {
+            warnAbovePct?: number;
+        } | false;
+    };
+};
+/**
+ * Cloudflare Stream. Lists videos (limit 1) and reads storage usage, in parallel.
+ * - up: both calls work
+ * - degraded: storage at or above `track.storage.warnAbovePct`
+ * - down: either call fails
+ *
+ * Reports a `usage` bar (storage minutes) and `metrics.videos`.
+ */
+declare const cloudflareStream: (options: CloudflareStreamOptions) => ServiceDefinition;
+
+type MailerSendOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+    track?: {
+        /** Warn when less than this share of the API quota is left (default 10) */
+        quota?: {
+            warnBelowPct?: number;
+        };
+    };
+};
+/**
+ * MailerSend. Reads `/v1/api-quota`.
+ * - up: quota available
+ * - degraded: less than `track.quota.warnBelowPct` of the requests left
+ * - down: the API rejects the key or errors
+ *
+ * Reports a `usage` bar: API requests used, with the reset time.
+ */
+declare const mailersend: (options: MailerSendOptions) => ServiceDefinition;
+type GitHubOptions = PresetOptions & {
+    secrets: {
+        token: string | undefined;
+    };
+    track?: {
+        /** Also check that the token can read this repository's releases, e.g. "owner/name" */
+        repo?: string;
+        /** Warn when less than this share of the hourly rate limit is left (default 10) */
+        rateLimit?: {
+            warnBelowPct?: number;
+        };
+    };
+};
+/**
+ * GitHub. Reads `/rate_limit` (free: it doesn't count against the limit), and optionally
+ * checks access to a repository's releases.
+ * - up: the token works (and can read the repository)
+ * - degraded: less than `track.rateLimit.warnBelowPct` of the hourly requests left
+ * - down: bad credentials, or the repository can't be read
+ *
+ * Reports a `usage` bar: requests this hour, with the reset time.
+ */
+declare const github: (options: GitHubOptions) => ServiceDefinition;
+type RevolutOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+    /** Which Merchant API to call (default "production") */
+    environment?: "production" | "sandbox";
+};
+/** Revolut Merchant. Lists orders (limit 1). up when the secret key works; down when rejected. */
+declare const revolut: (options: RevolutOptions) => ServiceDefinition;
+type AttendeeOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+    /** API base URL (default "https://app.attendee.dev") */
+    baseUrl?: string;
+};
+/** Attendee (meeting bots). Lists bots (page size 1). */
+declare const attendee: (options: AttendeeOptions) => ServiceDefinition;
+type AxiomOptions = PresetOptions & {
+    /** The dataset logs are sent to */
+    dataset: string | undefined;
+    /** Regional edge domain for ingestion, e.g. "eu-central-1.aws.edge.axiom.co" */
+    edge?: string;
+    secrets: {
+        token: string | undefined;
+    };
+};
+/** Axiom. Ingests an empty batch into the dataset: it writes nothing and proves token and dataset. */
+declare const axiom: (options: AxiomOptions) => ServiceDefinition;
+type UpstashRedisOptions = PresetOptions & {
+    /** REST URL of the database */
+    url: string | undefined;
+    secrets: {
+        token: string | undefined;
+    };
+};
+/**
+ * Upstash Redis / Vercel KV, over REST. Sends `PING` as a regular command (which compatible
+ * servers such as serverless-redis-http also accept). up on PONG.
+ */
+declare const upstashRedis: (options: UpstashRedisOptions) => ServiceDefinition;
+type StatuspageOptions = PresetOptions & {
+    /** The status page, e.g. "https://status.flyio.net" */
+    url: string;
+};
+/**
+ * Any provider that publishes an Atlassian Statuspage (Fly.io, Vercel, Cloudflare, GitHub…).
+ * Reads `/api/v2/status.json`.
+ * - up: the provider reports no incident
+ * - degraded: a minor incident
+ * - down: a major or critical incident
+ *
+ * The provider's own description becomes the error text.
+ */
+declare const statuspage: (options: StatuspageOptions) => ServiceDefinition;
+type ResendOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+};
+/**
+ * Resend. Lists domains, which validates the API key.
+ * - up: the key works. A sending-only key is refused with `restricted_api_key`, which still
+ *   proves it is valid.
+ * - degraded: domains exist, but none is verified
+ * - down: the API rejects the key or errors
+ *
+ * Reports `metrics.domains` and `metrics.verified` for full-access keys.
+ */
+declare const resend: (options: ResendOptions) => ServiceDefinition;
+type MeilisearchOptions = PresetOptions & {
+    /** The server, e.g. "https://search.example.com" */
+    host: string | undefined;
+    /** Also require this index, and report its document count */
+    index?: string;
+    secrets: {
+        apiKey: string | undefined;
+    };
+};
+/**
+ * Meilisearch. Reads `/health`, then the index (or the list of indexes), which validates the key.
+ * - up: the server is available and the key works
+ * - degraded: the index does not exist
+ * - down: the server is unavailable, or rejects the key
+ *
+ * Reports `metrics.documents`, and `metrics.indexing` while a batch is running, when the key
+ * may read statistics; scoped keys often may not, and that is not held against them.
+ */
+declare const meilisearch: (options: MeilisearchOptions) => ServiceDefinition;
+
+type PusherOptions = PresetOptions & {
+    appId: string | undefined;
+    /** Pusher cluster, e.g. "eu" (default "mt1"). Ignored when `host` is set. */
+    cluster?: string;
+    /** Custom host, for Pusher-compatible servers such as Soketi */
+    host?: string;
+    port?: string | number;
+    /** Use HTTPS (default: true unless a non-443 port is given) */
+    tls?: boolean;
+    secrets: {
+        key: string | undefined;
+        secret: string | undefined;
+    };
+    track?: {
+        connections?: {
+            /** Your plan's maximum concurrent connections: turns the counts into usage bars */
+            max?: number;
+            /** Warn when today's peak reaches this share of `max` (default 90) */
+            warnAbovePct?: number;
+        };
+    };
+};
+/** Path and signed query of a GET to the Pusher HTTP API */
+declare function signPusherRequest({ appId, key, secret, path, params, timestamp, }: {
+    appId: string;
+    key: string;
+    secret: string;
+    path: string;
+    params?: Record<string, string>;
+    timestamp?: number;
+}): Promise<string>;
+/**
+ * Pusher Channels (and compatible servers). Lists occupied channels, then reads each one's
+ * `subscription_count` to estimate concurrent connections. Pusher has no usage API, so this is
+ * an estimate: clients subscribed to several channels make it run slightly high.
+ * Requires "subscription counting" enabled in the app settings.
+ * - up: the API answers
+ * - degraded: today's peak at or above `warnAbovePct` of `track.connections.max`, or subscription counting is off
+ * - down: the API rejects the credentials or errors
+ *
+ * Reports `metrics.channels` and `metrics.signedInUsers`; with `max`, two `usage` bars
+ * (connections now, peak today), otherwise the counts as metrics. The daily peak (UTC) is kept
+ * in the store's cache.
+ */
+declare const pusher: (options: PusherOptions) => ServiceDefinition;
+
+type VercelAiGatewayOptions = PresetOptions & {
+    secrets: {
+        apiKey: string | undefined;
+    };
+    track?: {
+        /** Warn when the credit balance drops below this amount in USD (default 5). `false` skips the balance. */
+        credits?: {
+            warnBelow?: number;
+        } | false;
+    };
+};
+type VercelBlobOptions = PresetOptions & {
+    secrets: {
+        token: string | undefined;
+    };
+};
+/** Presets for Vercel products */
+declare const vercel: {
+    aiGateway: (options: VercelAiGatewayOptions) => ServiceDefinition;
+    blob: (options: VercelBlobOptions) => ServiceDefinition;
+};
+
+export { type AttendeeOptions, type AwsCredentialsOptions, type AxiomOptions, type AzureTranslatorOptions, type CloudflareStreamOptions, type DeepLOptions, type DeepgramOptions, type ElevenLabsOptions, type FlyAppOptions, type GcpInstanceOptions, type GitHubOptions, type GoogleServiceAccount, type GoogleTranslateOptions, type MailerSendOptions, type MeilisearchOptions, type MongoPingOptions, type MuxOptions, type OpenAIOptions, type PostgresPingOptions, type PusherOptions, type RedisPingOptions, type ResendOptions, type RevolutOptions, type S3BucketOptions, type SpeechmaticsOptions, type StatuspageOptions, type UpstashRedisOptions, type VercelAiGatewayOptions, type VercelBlobOptions, anthropic, attendee, aws, axiom, azureTranslator, cambai, clearGoogleTokens, cloudflareStream, crashReason, deepgram, deepl, elevenlabs, fly, gcp, gemini, github, gladia, googleServiceAccountToken, googleTranslate, mailersend, meilisearch, mongodb, mux, openai, parseServiceAccount, postgres, pusher, redis, resend, revolut, signGoogleAssertion, signPusherRequest, speechmatics, statuspage, upstashRedis, vercel };