@every-app/sdk 0.2.0 → 0.3.0-rc.10

package/dist/cloudflare/worker.d.ts

@@ -0,0 +1,805 @@
+import { DEV_GATEWAY_KEYS } from "./catalogSettings.generated.js";
+import { type AiGatewayValue } from "./sentinel.js";
+export { helperWorkerName, workflowNameFor } from "./sentinel.js";
+/** A Durable Object or Workflow class, and the helper Worker defining it. */
+interface ClassResource {
+    readonly name: string;
+    readonly className: string;
+    /** A helper Worker (`workers`) that defines the class; the app's own when unset. */
+    readonly worker?: string;
+}
+/** A Hyperdrive config, and the helper Worker that alone binds it. */
+interface HyperdriveResource {
+    readonly name: string;
+    /** A helper Worker (`workers`) that alone binds it; every Worker when unset. */
+    readonly worker?: string;
+    /** Whether Hyperdrive caches its reads (the deploy's concern; "off" by default). */
+    readonly caching?: "off" | "default";
+}
+/**
+ * How a queue's consumer takes its messages (`@cloudflare/config`'s
+ * `QueueConsumerTriggerOptions` but the name), and the helper Worker that
+ * consumes, when not the app's own.
+ */
+interface QueueConsumerSettings {
+    /** A helper Worker (`workers`) that consumes; the app's own when unset. */
+    readonly worker?: string;
+    readonly maxBatchSize?: number;
+    readonly maxBatchTimeout?: number;
+    readonly maxRetries?: number;
+    readonly maxConcurrency?: number | null;
+    readonly retryDelay?: number;
+    readonly visibilityTimeoutMs?: number;
+    /** Another of the manifest's queue bindings, which takes the messages that ran out of retries. */
+    readonly deadLetterQueue?: string;
+}
+/** A queue every Worker of the app produces to, and the Worker that consumes it. */
+interface QueueResource {
+    readonly name: string;
+    /** `true`: the app's own Worker consumes; settings, maybe naming a helper Worker. */
+    readonly consumer?: true | QueueConsumerSettings;
+}
+/**
+ * A Vectorize index: `dimensions` and `metric`, or a `preset` (the
+ * deploy's concern; the Worker only binds it by name).
+ */
+interface VectorizeResource {
+    readonly name: string;
+    readonly dimensions?: number;
+    readonly metric?: string;
+    readonly preset?: string;
+}
+/** An AI Gateway of the app's own, which every one of its Workers binds. */
+interface AiGatewayResource {
+    readonly name: string;
+    /** Whether the gateway logs each request (the deploy's concern; on by default). */
+    readonly collectLogs?: boolean;
+    /** How long the gateway caches a response, in seconds (the deploy's concern; 0 by default). */
+    readonly cacheTtl?: number;
+}
+/**
+ * A Cloudflare `send_email` binding and the addresses it may use: the
+ * senders, and one destination or a list of them (never both).
+ */
+interface SendEmailResource {
+    readonly name: string;
+    readonly allowedSenderAddresses?: readonly string[];
+    readonly destinationAddress?: string;
+    readonly allowedDestinationAddresses?: readonly string[];
+}
+/** An Analytics Engine dataset, by binding, and its name when not the default. */
+interface AnalyticsEngineResource {
+    readonly name: string;
+    readonly dataset?: string;
+}
+/** Cloudflare's limits for one of the app's Workers. */
+interface WorkerLimits {
+    readonly cpuMs?: number;
+}
+/** The fields of `everyapp.config.ts` the Worker definition is built from. */
+export interface EveryAppWorkerManifest {
+    id: string;
+    compatibilityDate?: string;
+    resources?: {
+        d1?: readonly string[];
+        kv?: readonly string[];
+        /**
+         * R2 buckets every one of the app's Workers binds: `R2` named after the
+         * app's Worker, any other binding `<app worker>--<binding>`.
+         */
+        r2?: readonly string[];
+        durableObjects?: readonly ClassResource[];
+        workflows?: readonly ClassResource[];
+        /** Hyperdrive configs, named `<app worker>--<binding>` by the deploy. */
+        hyperdrive?: readonly HyperdriveResource[];
+        /**
+         * Cloudflare Queues, named `<app worker>--<binding>`: every Worker of
+         * the app binds each one to produce, and the consumer's Worker gets
+         * its trigger.
+         */
+        queues?: readonly QueueResource[];
+        /**
+         * Workers AI, by binding (`["AI"]`), which every one of the app's
+         * Workers binds: nothing to create, billed to the account. In
+         * development it reaches the account only once the app's Vite config
+         * turns `remoteBindings` on (see {@link AiBinding}).
+         */
+        ai?: readonly string[];
+        /**
+         * Browser Rendering, by binding (`["BROWSER"]`), which every one of the
+         * app's Workers binds: nothing to create (Workers Paid). Local in
+         * development (see {@link BrowserBinding}).
+         */
+        browser?: readonly string[];
+        /**
+         * Cloudflare Images, by binding (`["IMAGES"]`), which every one of the
+         * app's Workers binds: nothing to create. Local in development (see
+         * {@link ImagesBinding}).
+         */
+        images?: readonly string[];
+        /**
+         * Vectorize indexes every one of the app's Workers binds, named
+         * `<app worker>--<binding>`. Cloudflare has no local Vectorize: in
+         * development each binding reaches the account's index (`dev.remote`),
+         * once the Vite plugin's `remoteBindings` is on and `cf auth login` ran.
+         */
+        vectorize?: readonly VectorizeResource[];
+        /**
+         * AI Gateways of the app's own, each `<app worker>-<binding>` in the
+         * account, bound on every Worker as `{ id, accountId, url }`.
+         */
+        aiGateway?: readonly AiGatewayResource[];
+        /**
+         * Cloudflare `send_email` bindings every one of the app's Workers
+         * gets, with their addresses; nothing is made in the account.
+         */
+        sendEmail?: readonly SendEmailResource[];
+        /**
+         * Secrets Store secrets, by binding (`[{ name: "STRIPE_KEY" }]`), which
+         * every one of the app's Workers binds: each a secret in the account's
+         * store named `<app worker>--<binding>`, made by the deploy (see
+         * {@link SecretsStoreSecretBinding}).
+         */
+        secretsStore?: readonly {
+            readonly name: string;
+        }[];
+        /**
+         * Analytics Engine datasets every one of the app's Workers writes to, by
+         * binding: `dataset` as written, else `<app worker>--<binding>`.
+         * Nothing to create; `writeDataPoint()` does nothing in development.
+         */
+        analyticsEngine?: readonly AnalyticsEngineResource[];
+    };
+    /**
+     * Helper Workers deployed beside the app's Worker as
+     * `<app worker>--<name>`, built with {@link everyAppAuxiliaryWorker}.
+     * `binding` names the app Worker's service binding to one.
+     */
+    workers?: readonly {
+        readonly name: string;
+        readonly binding?: string;
+        readonly limits?: WorkerLimits;
+    }[];
+    /**
+     * The database the app's code talks to, which its Workers read as
+     * DATABASE_PROVIDER; deployed Workers run near `region`.
+     */
+    database?: {
+        readonly provider: "d1" | "postgres";
+        readonly region?: string;
+    };
+    /** Cloudflare's limits for the app's own Worker. */
+    limits?: WorkerLimits;
+    /**
+     * AI providers the app calls through the gateway (`createGatewayFetch()`):
+     * each by id, or as `{ id, optional, anyOf, why, docs }` (the manifest's
+     * settings model, `@every-app/sdk/internal` appSettings).
+     */
+    providers?: ReadonlyArray<string | {
+        readonly id: string;
+    }>;
+    /** Capabilities the app calls through the gateway (`integrationFetch()`). */
+    capabilities?: {
+        readonly [id: string]: unknown;
+    };
+    /**
+     * The app's own secrets, e.g. an API key it calls out with. A deployed
+     * Worker gets them from `everyapp secret set <NAME>`, and later deploys
+     * keep them, so production builds don't declare them. In development each
+     * one that is set locally is declared, read as the Vite plugin reads
+     * secrets (`.dev.vars[.<mode>]` alone when present, otherwise the `.env`
+     * files and the environment), so the plugin passes it through. Type them
+     * as optional in `src/env.d.ts`.
+     *
+     * The keys of `providers` and `capabilities` need no listing: there's no
+     * gateway in development, so each one set locally under the gateway
+     * secret's name (OPENAI_API_KEY, DATAFORSEO_API_KEY, …) is declared for
+     * the SDK's direct fallback.
+     *
+     * Each by name, or as `{ name, optional, anyOf, why, docs }`: whether the
+     * app opens without it, and why it is needed.
+     */
+    secrets?: ReadonlyArray<string | {
+        readonly name: string;
+    }>;
+    /**
+     * The app's plain settings: values that aren't secrets and differ per
+     * install (a PostHog host, a region), as `{ name, why, type, values,
+     * default, optional }`. A deployed Worker holds them like its secrets
+     * (`everyapp configure <app>` sets them; the deploy writes each
+     * default nobody has set), so production builds don't declare them. In
+     * development each one set locally (`.dev.vars`, `.env`, as for
+     * secrets) is declared as a secret, and one that isn't, but has a
+     * default, as text with its default.
+     */
+    settings?: ReadonlyArray<{
+        readonly name: string;
+        readonly default?: string;
+    }>;
+}
+/** The context cf passes to a `defineConfig((ctx) => …)` factory. */
+export interface EveryAppConfigContext {
+    mode: string | undefined;
+    isPreview?: boolean;
+}
+export interface EveryAppWorkerOptions<TManifest extends EveryAppWorkerManifest, TEntrypoint> {
+    /** The default export of `everyapp.config.ts`, declared `as const`. */
+    manifest: TManifest;
+    /** The Worker entry, usually a `cf-worker` namespace import of `src/entry.worker.ts`. */
+    entrypoint: TEntrypoint;
+    ctx: EveryAppConfigContext;
+    /** App root holding `.dev.vars` and `.env` files. Defaults to the working directory. */
+    root?: string;
+    /**
+     * Cron schedules (UTC) that run the Worker's `scheduled` handler, e.g.
+     * `"0 6 * * *"` (daily at 06:00). Deploys keep them; an app can't declare
+     * routes.
+     */
+    crons?: readonly string[];
+    /**
+     * Compatibility flags beyond `nodejs_compat`, which every Every App Worker
+     * has, e.g. `["global_fetch_strictly_public"]` so the Worker's `fetch()`
+     * reaches only the public internet. Appended to `nodejs_compat`, without
+     * duplicates. The compatibility date is the manifest's.
+     */
+    compatibilityFlags?: readonly string[];
+}
+export interface TextBinding {
+    type: "text";
+    value: string;
+}
+export interface SecretBinding {
+    type: "secret";
+}
+export interface D1Binding {
+    type: "d1";
+    name: string;
+    id?: string;
+}
+export interface KvBinding {
+    type: "kv";
+    id?: string;
+}
+export interface R2Binding {
+    type: "r2";
+    name: string;
+}
+export interface HyperdriveBinding {
+    type: "hyperdrive";
+    id: string;
+    dev?: {
+        connectionString?: string;
+    };
+}
+/** A producer binding to one of the app's queues. */
+export interface QueueBinding {
+    type: "queue";
+    name: string;
+}
+/** A JSON value the Worker reads as it is: `env.<NAME>` is `value`. */
+export interface JsonBinding<T = unknown> {
+    type: "json";
+    value: T;
+}
+/**
+ * An AI Gateway of the app's own (`resources.aiGateway`): its id, account
+ * and URL, which the Worker reads as `env.<NAME>.id` and `env.<NAME>.url`.
+ */
+export type AiGatewayBinding = JsonBinding<AiGatewayValue>;
+/**
+ * Workers AI (`env.AI.run()`), which cf types as `Ai`. Deployed, it calls
+ * the account's Workers AI. Miniflare has none locally: in development the
+ * binding is marked remote, so it reaches the account once the app's Vite
+ * config sets `remoteBindings: true` (the starter sets it false) and
+ * `cf auth login` has run; until then every call throws `Binding AI needs
+ * to be run remotely`.
+ */
+export interface AiBinding {
+    type: "ai";
+    dev?: {
+        remote?: boolean;
+    };
+}
+/**
+ * Browser Rendering (`env.BROWSER`, for `@cloudflare/puppeteer` or
+ * `@cloudflare/playwright`), which cf types as `BrowserRun`. Deployed, it
+ * drives a headless Chrome on Cloudflare (Workers Paid). In development
+ * the same binding reaches Miniflare's local stand-in: the first session
+ * downloads a Chrome into the global `.wrangler` cache and starts it.
+ */
+export interface BrowserBinding {
+    type: "browser";
+}
+/**
+ * Cloudflare Images (`env.IMAGES.input(stream).transform(…).output(…)`,
+ * `env.IMAGES.info(stream)`), which cf types as the runtime's
+ * `ImagesBinding`. Deployed, it runs on Cloudflare and bills the account's
+ * Images transformations. In development Miniflare answers it locally with
+ * sharp, which ships with it.
+ */
+export interface ImagesBinding {
+    type: "images";
+}
+/**
+ * A Vectorize index, by name. `dev.remote` sends development calls to the
+ * account's index: Cloudflare has no local Vectorize.
+ */
+export interface VectorizeBinding {
+    type: "vectorize";
+    name: string;
+    dev?: {
+        remote?: boolean;
+    };
+}
+/**
+ * A `send_email` binding (cf's `SendEmailBindingOptions`): one destination,
+ * a list of them, or neither, and the senders it may use.
+ */
+type SendEmailDestination = {
+    destinationAddress: string;
+    allowedDestinationAddresses?: never;
+} | {
+    destinationAddress?: never;
+    allowedDestinationAddresses: string[];
+} | {
+    destinationAddress?: never;
+    allowedDestinationAddresses?: never;
+};
+export type SendEmailBinding = SendEmailDestination & {
+    type: "send-email";
+    allowedSenderAddresses?: string[];
+};
+/**
+ * A Secrets Store secret (`await env.STRIPE_KEY.get()`), which cf types as
+ * `SecretsStoreSecret`. Deployed, the secret the deploy made in the
+ * account's store; in development, the local store `local` that Miniflare
+ * keeps under `.cloudflare/state`, where `get()` throws `Secret "<name>"
+ * not found` until the secret is seeded there (`.dev.vars` doesn't reach
+ * this binding).
+ */
+export interface SecretsStoreSecretBinding {
+    type: "secrets-store-secret";
+    storeId: string;
+    secretName: string;
+}
+/**
+ * An Analytics Engine dataset (`env.EVENTS.writeDataPoint({ blobs,
+ * doubles, indexes })`), which cf types as `AnalyticsEngineDataset`.
+ * Deployed, the dataset exists once written to. In development Miniflare
+ * accepts every write and keeps none. cf's shape takes no `dev` options.
+ */
+export interface AnalyticsEngineDatasetBinding {
+    type: "analytics-engine-dataset";
+    name: string;
+}
+/**
+ * The app's own Worker, as the bindings of the Durable Objects it defines
+ * name it when its entrypoint is a `cf-worker` module import. cf reads each
+ * class from that module, so the `Env` it generates types the namespace
+ * with it (`DurableObjectNamespace<UserSyncDO>`) and RPC calls on a stub
+ * type-check, and it resolves the reference to the Worker's name.
+ */
+export interface EveryAppWorkerReference<TEntrypoint extends object> {
+    name: string;
+    compatibilityDate: string;
+    entrypoint: TEntrypoint;
+}
+/**
+ * A Durable Object binding. `worker` names the Worker defining the class:
+ * the app's own Worker by its definition (see
+ * {@link EveryAppWorkerReference}), or a Worker by name, which cf types as
+ * an untyped `DurableObjectNamespace`.
+ */
+export interface DurableObjectBinding<TWorker extends string | EveryAppWorkerReference<object> = string, TClassName extends string = string> {
+    type: "durable-object";
+    worker: TWorker;
+    exportName: TClassName;
+}
+export interface WorkflowBinding {
+    type: "workflow";
+    name: string;
+    worker: string;
+    exportName: string;
+}
+export interface GatewayBinding {
+    type: "worker";
+    worker: string;
+    exportName: string;
+    props: Record<string, string>;
+}
+/** The app's service binding to one of its helper Workers. */
+export interface ServiceBinding {
+    type: "worker";
+    worker: string;
+}
+export interface VersionMetadataBinding {
+    type: "version-metadata";
+}
+/**
+ * A binding of any Worker these helpers build, each one `InputWorkerConfig`
+ * accepts, so a helper Worker's definition passes as the Vite plugin's
+ * `auxiliaryWorkers` config. A Durable Object binding names its Worker by
+ * name; only the app's own Worker names itself by definition (see
+ * {@link EveryAppWorkerReference}), in its typed `env`, which
+ * `defineConfig()` takes.
+ */
+export type EveryAppBinding = TextBinding | SecretBinding | D1Binding | KvBinding | R2Binding | HyperdriveBinding | QueueBinding | AiBinding | BrowserBinding | ImagesBinding | VectorizeBinding | AiGatewayBinding | JsonBinding<JsonValue> | SendEmailBinding | SecretsStoreSecretBinding | AnalyticsEngineDatasetBinding | DurableObjectBinding | WorkflowBinding | GatewayBinding | ServiceBinding | VersionMetadataBinding;
+export interface DurableObjectExport {
+    type: "durable-object";
+    storage: "sqlite";
+}
+export interface WorkflowExport {
+    type: "workflow";
+    name: string;
+}
+type D1Names<M> = M extends {
+    resources: {
+        d1: readonly (infer B)[];
+    };
+} ? B & string : never;
+type KvNames<M> = M extends {
+    resources: {
+        kv: readonly (infer B)[];
+    };
+} ? B & string : never;
+type R2Names<M> = M extends {
+    resources: {
+        r2: readonly (infer B)[];
+    };
+} ? B & string : never;
+type AiNames<M> = M extends {
+    resources: {
+        ai: readonly (infer B)[];
+    };
+} ? B & string : never;
+type BrowserNames<M> = M extends {
+    resources: {
+        browser: readonly (infer B)[];
+    };
+} ? B & string : never;
+type ImagesNames<M> = M extends {
+    resources: {
+        images: readonly (infer B)[];
+    };
+} ? B & string : never;
+type VectorizeNames<M> = M extends {
+    resources: {
+        vectorize: readonly (infer V)[];
+    };
+} ? V extends {
+    name: infer N extends string;
+} ? N : never : never;
+type AiGatewayNames<M> = M extends {
+    resources: {
+        aiGateway: readonly (infer G)[];
+    };
+} ? G extends {
+    name: infer N extends string;
+} ? N : never : never;
+type AnalyticsEngineNames<M> = M extends {
+    resources: {
+        analyticsEngine: readonly (infer A)[];
+    };
+} ? A extends {
+    name: infer N extends string;
+} ? N : never : never;
+type DurableObjects<M> = M extends {
+    resources: {
+        durableObjects: readonly (infer D)[];
+    };
+} ? D : never;
+type Workflows<M> = M extends {
+    resources: {
+        workflows: readonly (infer W)[];
+    };
+} ? W : never;
+type QueueNames<M> = M extends {
+    resources: {
+        queues: readonly (infer Q)[];
+    };
+} ? Q extends {
+    name: infer N extends string;
+} ? N : never : never;
+type SendEmailNames<M> = M extends {
+    resources: {
+        sendEmail: readonly (infer S)[];
+    };
+} ? S extends {
+    name: infer N extends string;
+} ? N : never : never;
+type SecretsStoreNames<M> = M extends {
+    resources: {
+        secretsStore: readonly (infer S)[];
+    };
+} ? S extends {
+    name: infer N extends string;
+} ? N : never : never;
+type HelperWorkers<M> = M extends {
+    workers: readonly (infer H)[];
+} ? H : never;
+/** The Hyperdrive bindings the app's own Worker has: those no helper alone takes. */
+type AppHyperdriveNames<M> = M extends {
+    resources: {
+        hyperdrive: readonly (infer H)[];
+    };
+} ? H extends {
+    worker: string;
+} ? never : H extends {
+    name: infer N extends string;
+} ? N : never : never;
+type DatabaseEnv<M> = M extends {
+    database: object;
+} ? {
+    DATABASE_PROVIDER: TextBinding;
+} : unknown;
+type DevProviderKeys = typeof DEV_GATEWAY_KEYS.providers;
+type DevCapabilityKeys = typeof DEV_GATEWAY_KEYS.capabilities;
+/** The gateway keys a developer may set locally for the manifest's providers and capabilities. */
+type DevGatewayKeys<M> = (M extends {
+    providers: readonly (infer P)[];
+} ? P extends keyof DevProviderKeys ? DevProviderKeys[P][number] : never : never) | (M extends {
+    capabilities: infer C;
+} ? keyof C extends infer K ? K extends keyof DevCapabilityKeys ? DevCapabilityKeys[K][number] : never : never : never);
+/**
+ * A manifest Durable Object's binding: named after the app's own Worker by
+ * its definition when that Worker defines the class and its entrypoint is a
+ * module import, so cf types the namespace with the class; a helper
+ * Worker's class, or any class behind a path entrypoint, by name.
+ */
+type DurableObjectBindingFor<D, TEntrypoint> = D extends {
+    worker: string;
+} ? DurableObjectBinding : TEntrypoint extends object ? D extends {
+    className: infer C extends string;
+} ? DurableObjectBinding<EveryAppWorkerReference<TEntrypoint>, C> : DurableObjectBinding : DurableObjectBinding;
+type ResourceEnv<M, TEntrypoint> = {
+    [B in D1Names<M>]: D1Binding;
+} & {
+    [B in KvNames<M>]: KvBinding;
+} & {
+    [B in R2Names<M>]: R2Binding;
+} & {
+    [B in QueueNames<M>]: QueueBinding;
+} & {
+    [B in AiNames<M>]: AiBinding;
+} & {
+    [B in BrowserNames<M>]: BrowserBinding;
+} & {
+    [B in ImagesNames<M>]: ImagesBinding;
+} & {
+    [B in VectorizeNames<M>]: VectorizeBinding;
+} & {
+    [B in AiGatewayNames<M>]: AiGatewayBinding;
+} & {
+    [B in SendEmailNames<M>]: SendEmailBinding;
+} & {
+    [B in SecretsStoreNames<M>]: SecretsStoreSecretBinding;
+} & {
+    [B in AnalyticsEngineNames<M>]: AnalyticsEngineDatasetBinding;
+} & {
+    [D in DurableObjects<M> as D extends {
+        name: infer N extends string;
+    } ? N : never]: DurableObjectBindingFor<D, TEntrypoint>;
+} & {
+    [W in Workflows<M> as W extends {
+        name: infer N extends string;
+    } ? N : never]: WorkflowBinding;
+} & {
+    [H in HelperWorkers<M> as H extends {
+        binding: infer B extends string;
+    } ? B : never]: ServiceBinding;
+};
+/** A JSON value, as cf's JSON bindings take one. */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** `M` without `readonly`, as cf's JSON bindings take their value. */
+type JsonValueOf<M> = M extends readonly (infer E)[] ? JsonValueOf<E>[] : M extends object ? {
+    -readonly [K in keyof M]: JsonValueOf<M[K]>;
+} : M;
+type SharedEnv<M> = {
+    EVERYAPP_APP_ID: TextBinding;
+    EVERYAPP_MANIFEST: JsonBinding<JsonValueOf<M>>;
+    CF_VERSION_METADATA: VersionMetadataBinding;
+    GATEWAY_URL: TextBinding | SecretBinding;
+};
+/**
+ * Hyperdrive in production; in development only where a local connection
+ * string is set, so `Env` marks each optional.
+ */
+type HyperdriveEnv<M> = {
+    [B in AppHyperdriveNames<M>]: HyperdriveBinding;
+};
+/** In dev, an app that lists `email` may get the installation's stand-in senders from .dev.vars. */
+type DevEmailEnv<M> = M extends {
+    capabilities: {
+        email: unknown;
+    };
+} ? {
+    EVERYAPP_EMAIL_SENDERS?: SecretBinding;
+} : unknown;
+/**
+ * Bindings in development: the well-known dev identity, as plain text, and
+ * the developer's own gateway keys (when set).
+ */
+export type EveryAppDevEnv<M, TEntrypoint = string> = ResourceEnv<M, TEntrypoint> & SharedEnv<M> & DatabaseEnv<M> & DevEmailEnv<M> & {
+    EVERYAPP_DEV: TextBinding;
+    EVERYAPP_DEV_CAPABILITIES: TextBinding;
+    /** The specs in `.everyapp/providers/*.json`, when the app has any: providers registered on a gateway, for integrationFetch()'s dev fallback. */
+    EVERYAPP_DEV_PROVIDERS?: TextBinding;
+    /** Under `everyapp dev --gateway` (linked dev): the gateway-lite's forwarder and the run's nonce, which the SDK's services call the real Gateway through. */
+    EVERYAPP_LINKED_DEV_URL?: TextBinding;
+    EVERYAPP_LINKED_DEV_NONCE?: TextBinding;
+    EVERYAPP_IDENTITY_PUBLIC_KEYS: TextBinding;
+    EVERYAPP_IDENTITY_ISSUER: TextBinding;
+    /** The stub dev gateway's organization (`dev-org`), so `withOrganization(env.EVERY_APP_ORG_ID, …)` works in development as deployed. */
+    EVERY_APP_ORG_ID: TextBinding;
+} & {
+    [K in DevGatewayKeys<M>]: SecretBinding;
+};
+/** Bindings in production: the deployed identity and the gateway binding. */
+export type EveryAppDeployEnv<M, TEntrypoint = string> = ResourceEnv<M, TEntrypoint> & SharedEnv<M> & DatabaseEnv<M> & HyperdriveEnv<M> & {
+    EVERYAPP_AUDIENCE: TextBinding;
+    EVERYAPP_IDENTITY_PUBLIC_KEYS: TextBinding;
+    EVERYAPP_IDENTITY_ISSUER: TextBinding;
+    EVERY_APP_GATEWAY: GatewayBinding;
+    /**
+     * The owning organization. The build always declares it; installing a
+     * shared app, which serves every organization, drops it.
+     */
+    EVERY_APP_ORG_ID?: SecretBinding;
+    /**
+     * `1` on a shared app's Workers, added when it is installed: gateway
+     * calls say whom they are for.
+     */
+    EVERYAPP_SHARED?: TextBinding;
+};
+/** The classes the app's own Worker defines: none a helper Worker does. */
+export type EveryAppExports<M> = {
+    [E in DurableObjects<M> | Workflows<M> as E extends {
+        worker: string;
+    } ? never : E extends {
+        className: infer C extends string;
+    } ? C : never]: E extends Workflows<M> ? WorkflowExport : DurableObjectExport;
+};
+export interface EveryAppObservability {
+    enabled: boolean;
+    headSamplingRate: number;
+    redactQueryString: boolean;
+    logs: {
+        enabled: boolean;
+        invocationLogs: boolean;
+        persist: boolean;
+        headSamplingRate: number;
+    };
+    traces: {
+        enabled: boolean;
+        persist: boolean;
+        headSamplingRate: number;
+    };
+    issues: {
+        enabled: boolean;
+    };
+}
+/** Structural copy of cf's targeted placement: run near a cloud region. */
+export interface EveryAppPlacement {
+    region: string;
+}
+/** Structural copy of cf's scheduled (cron) trigger. */
+export interface ScheduledTrigger {
+    type: "scheduled";
+    schedule: string;
+}
+/**
+ * Structural copy of cf's queue consumer trigger: the Worker consumes the
+ * named queue (its `queue(batch, env)` handler), with these settings.
+ */
+export interface QueueConsumerTrigger {
+    type: "queue";
+    name: string;
+    deadLetterQueue?: string;
+    maxBatchSize?: number;
+    maxBatchTimeout?: number;
+    maxConcurrency?: number | null;
+    maxRetries?: number;
+    retryDelay?: number;
+    visibilityTimeoutMs?: number;
+}
+/** A trigger one of the app's Workers may have: its crons, the queues it consumes. */
+export type EveryAppTrigger = ScheduledTrigger | QueueConsumerTrigger;
+export interface EveryAppWorkerConfig<M, TEntrypoint> {
+    name: string;
+    entrypoint: TEntrypoint;
+    compatibilityDate: string;
+    compatibilityFlags: string[];
+    workersDev: false;
+    previewUrls: false;
+    /** The `crons` option's schedules and the queues it consumes; absent without any. */
+    triggers?: EveryAppTrigger[];
+    /** Near the manifest's `database.region`, once deployed. */
+    placement?: EveryAppPlacement;
+    /** The manifest's `limits`. */
+    limits?: {
+        cpuMs?: number;
+    };
+    observability: EveryAppObservability;
+    /** Either branch, so `Env` marks dev-only and deploy-only bindings optional. */
+    env: EveryAppDevEnv<M, TEntrypoint> | EveryAppDeployEnv<M, TEntrypoint>;
+    exports: EveryAppExports<M>;
+}
+/**
+ * Observability every Every App Worker ships with: logs (with invocation
+ * logs), sampled traces and Workers Issues, with query strings redacted so
+ * tokens and invitation ids in URLs stay out of logs.
+ */
+export declare const EVERYAPP_OBSERVABILITY: Readonly<EveryAppObservability>;
+/**
+ * Build the Worker definition for an Every App app from its manifest.
+ *
+ * - `development` (cf dev) and no mode (cf API commands, `cf workers types`):
+ *   EVERYAPP_DEV is on, the identity keys and issuer are the well-known dev
+ *   ones (`@every-app/sdk/dev`) as plain text, so nothing needs writing to
+ *   `.dev.vars`, and each D1 database gets a fixed local id (see
+ *   {@link localD1Id}) that `cf d1 … --local` can address.
+ * - `production`: tenant-neutral. Everything install-specific (the Worker
+ *   name, organization, gateway URL, identity keys, resource names and ids)
+ *   is a placeholder from {@link sentinelDeployTarget}, which the installer
+ *   rewrites (`everyapp deploy`, or a hosted gateway's deployer), so every
+ *   build of an app is the same. Only with EVERYAPP_BUILD=1, which
+ *   `everyapp deploy` sets: a bare `cf deploy` would upload the
+ *   placeholders.
+ */
+export declare function everyAppWorker<const M extends EveryAppWorkerManifest, TEntrypoint extends string | object>(options: EveryAppWorkerOptions<M, TEntrypoint>): EveryAppWorkerConfig<M, TEntrypoint>;
+export interface EveryAppAuxiliaryWorkerOptions<TManifest extends EveryAppWorkerManifest, TEntrypoint> extends EveryAppWorkerOptions<TManifest, TEntrypoint> {
+    /** The helper Worker's name in the manifest's `workers`. */
+    worker: string;
+}
+/** A helper Worker's definition, for the Vite plugin's `auxiliaryWorkers`. */
+export interface EveryAppAuxiliaryWorkerConfig<TEntrypoint> {
+    name: string;
+    entrypoint: TEntrypoint;
+    compatibilityDate: string;
+    compatibilityFlags: string[];
+    workersDev: false;
+    previewUrls: false;
+    triggers?: EveryAppTrigger[];
+    placement?: EveryAppPlacement;
+    limits?: {
+        cpuMs?: number;
+    };
+    observability: EveryAppObservability;
+    env: Record<string, EveryAppBinding>;
+    exports: Record<string, DurableObjectExport | WorkflowExport>;
+}
+/**
+ * Build the definition of one of the app's helper Workers (the manifest's
+ * `workers`), e.g. one that runs a memory-hungry job away from the app's
+ * Worker. It is named `<app worker>--<worker>`, is private like the app, and
+ * binds the app's  and Analytics Engine datasets, the classes it defines, and
+ * binds the app's D1 databases, KV namespaces, R2 buckets, Workers AI,
+ * Browser Rendering, Images, Vectorize indexes, AI Gateways, `send_email`
+ * bindings and Secrets Store secrets, the classes it defines, and
+ * the gateway (with the app's identity, for capabilities). Only the app's
+ * Worker reaches it. Pass it to the Vite plugin:
+ *
+ *   cloudflare({
+ *     auxiliaryWorkers: [
+ *       { config: everyAppAuxiliaryWorker({ manifest, worker: "audit", entrypoint: "./src/audit.ts", ctx: { mode } }) },
+ *     ],
+ *   })
+ */
+export declare function everyAppAuxiliaryWorker<const M extends EveryAppWorkerManifest, TEntrypoint extends string | object>(options: EveryAppAuxiliaryWorkerOptions<M, TEntrypoint>): EveryAppAuxiliaryWorkerConfig<TEntrypoint>;
+/**
+ * The local D1 database id for a binding: a 32-hex string, because
+ * `cf d1 … --local` rejects names. The everyapp CLI computes the same id to
+ * apply local migrations to the database `cf dev` serves.
+ */
+export declare function localD1Id(workerName: string, binding: string): string;
+/**
+ * The sqlite file `cf dev` (and `cf d1 … --local`) keeps the local D1
+ * database `databaseId` in, under the app at `root`, for tools such as
+ * drizzle-kit studio: `.cloudflare/state/v3/d1/miniflare-D1DatabaseObject/
+ * <hash>.sqlite`. The database is a Durable Object named after its id, and
+ * the file after that object's id. `databaseId` is the {@link localD1Id}.
+ */
+export declare function localD1Path(root: string, databaseId: string): string;
+//# sourceMappingURL=worker.d.ts.map