import { I as InstaQLQuery, t as tx$1, Q as QueryResult$1, e as QueryTotals, T as TxInput$1, d as AggregateSpec, b as QueryOpts$1, A as AggregateResult$1, g as AggregateRequest, E as Entity$1, W as WhereClause$1, h as WhereOp$1, i as WhereValue$1, c as TxChain } from './tx.d-DzXSvnTg.cjs';
export { j as AggregateResults, N as NamespaceDiff, k as NodeQuery, O as OdlaError, f as flattenTx } from './tx.d-DzXSvnTg.cjs';
import { V as ValueType$1, T as TxId, J as Json$1, A as AppId$1, E as EntityId$1, a as EntityRef$1, b as ErrShape$1, M as MutationId$1, O as Op$1, S as Scalar$1, c as Value$1 } from './ops.d-D9oT7Y5m.cjs';
export { L as Lookup, P as PROTOCOL_VERSION } from './ops.d-D9oT7Y5m.cjs';
export { u as uuidv7 } from './helpers.d-DX9il_Du.cjs';
export { FEDERATION_HEADERS, FEDERATION_VERSION, FederationVerification, FederationVerificationFailure, RejectedFederatedRequest, SignFederatedRequestOptions, VerifiedFederatedRequest, VerifyFederatedRequestOptions, signFederatedRequest, verifyFederatedRequest } from './federation.cjs';

interface SerializedAttr$1 {
    type: Exclude<ValueType$1, "ref">;
    unique: boolean;
    indexed: boolean;
    optional: boolean;
}
interface SerializedEntity$1 {
    attrs: Record<string, SerializedAttr$1>;
}
type Cardinality$1 = "one" | "many";
interface SerializedLinkEnd$1 {
    on: string;
    has: Cardinality$1;
    label: string;
}
interface SerializedLink$1 {
    forward: SerializedLinkEnd$1;
    reverse: SerializedLinkEnd$1;
}
interface SerializedSchema$1 {
    entities: Record<string, SerializedEntity$1>;
    links: Record<string, SerializedLink$1>;
}

/**
 * A server-issued position in one app's transaction stream.
 *
 * Both fields are opaque outside that stream. In particular, a cursor from one
 * app must never be compared with or supplied to another app.
 */
interface ChangeCursor$1 {
    epoch: number;
    txId: TxId;
}
/** Content-free change metadata for one committed transaction. */
interface ChangeTransaction$1 {
    txId: TxId;
    createdAt: number;
    /** Namespace names touched by the transaction. */
    namespaces: string[];
    /** Stable `namespace:entityId` keys touched by the transaction. */
    entities: string[];
    /** Stable `namespace:entityId` keys first created by the transaction. */
    created: string[];
}
/** Options accepted by the trusted Admin SDK change feed. */
interface ChangesOptions$1 {
    /** Omit to establish a fresh checkpoint without replaying history. */
    cursor?: ChangeCursor$1;
    /** Maximum committed transactions returned in one page. */
    limit?: number;
}
/**
 * One page from an app's trusted, content-free transaction feed.
 *
 * `checkpointRequired` is explicit: restore, copy, truncation, or a cursor from
 * another epoch never masquerades as an empty page. The replacement `cursor`
 * is a new baseline and `transactions` is empty in that case.
 */
interface ChangePage$1 {
    cursor: ChangeCursor$1;
    currentTx: TxId;
    earliestTx: TxId;
    checkpointRequired: boolean;
    hasMore: boolean;
    transactions: ChangeTransaction$1[];
}

/**
 * Per-handshake restrictions for a trusted backend realtime proxy.
 *
 * These restrictions are enforced before the app credential leaves the
 * backend. They do not replace the host application's own authentication and
 * authorization of the incoming browser request.
 */
interface RealtimeProxyOptions$1 {
    /** Exact HTTP(S) browser origins allowed to use this proxy. Wildcards are rejected. */
    allowedOrigins: readonly string[];
    /** Exact live queries the proxied connection may execute (1–16, 4 KiB serialized total). */
    queries: readonly InstaQLQuery[];
    /** Lifetime and maximum session/key revocation window in seconds (1–300, default 300). */
    expiresInSeconds?: number;
}
/** Trusted, Worker/server-only realtime WebSocket proxy surface. */
interface RealtimeProxy$1 {
    /**
     * Validate a downstream WebSocket handshake and open a query-scoped upstream
     * connection without exposing or accepting a browser credential.
     *
     * Authenticate and authorize the browser request before calling this method,
     * then return its response directly from the Worker. Cloudflare couples the
     * upstream upgrade to the downstream client; the Worker never intercepts or
     * relays database frames.
     */
    proxy(request: Request, options: RealtimeProxyOptions$1): Promise<Response>;
}

/**
 * @odla/admin — server-side SDK for a customer's own backend. An app API key
 * (`odla_sk_…`) receives its configured app authority. App API keys may project
 * a human app user via `asUser`. Managed-agent developer tokens (`odla_dev_…`)
 * are control-plane identities and are rejected on this direct app-data client;
 * agents use a human-minted rules-scoped app key or a platform-mediated route.
 * HTTP/fetch based; runs in Node or Workers.
 */

interface AdminOptions$1 {
    appId: string;
    /** App API key (`odla_sk_…`) or the platform machine credential. A managed
     * agent's `odla_dev_…` token is not a direct app-data credential. */
    adminToken: string;
    endpoint: string;
    /** Custom fetch implementation (defaults to the global `fetch`). Useful for
     *  tests (inject a worker's `SELF.fetch`), proxies, or non-standard runtimes. */
    fetch?: typeof globalThis.fetch;
    /** Assertion-only precondition for a server-bound managed-agent key. The
     * server compares it with the stored key binding and never uses it to select
     * or project an identity. */
    expectedPrincipal?: {
        kind: "agent";
        id: string;
    };
}
interface AsUser$1 {
    asUser?: string;
    /** Verified email for the impersonated user (projects them into $users). */
    asEmail?: string;
    /**
     * Kind for a projected `asUser`. Customer app API keys may project only a
     * human. `"agent"` and `"service"` are reserved for the platform's internal
     * machine-authenticated bridge after it has verified the source principal;
     * attempting either with an app API key is rejected.
     */
    asPrincipalKind?: "human" | "agent" | "service";
}
interface FileRecord$1 {
    id: string;
    path: string;
    /** Root-relative app path for this file (`/app/<tenant>/files/<path>`), not
     * an absolute URL. It is deliberately origin-independent: this value is
     * stored on the `$files` entity and rewritten prefix-wise when a tenant is
     * copied, so baking a host into it would travel with the snapshot. Resolve
     * it against your endpoint to fetch it — `new URL(record.url, endpoint)` —
     * or use `storage.sign` for a private file, which returns an absolute URL. */
    url: string;
    size: number;
    contentType: string;
    private?: boolean;
}
interface TransactResult$1 {
    txId: number;
    /** True when this mutationId was already applied and the ops were NOT
     *  re-run. With a stable mutationId this is the `ON CONFLICT DO NOTHING`
     *  rowCount check: `!duplicate` means "this call did the write". */
    duplicate: boolean;
}
interface BrandProposalRequest {
    bookId: string;
    jobId: string;
    mutationId: string;
    kind: "palette" | "typography" | "voice" | "logo" | "imagery";
    payload: Record<string, unknown>;
    rationale: string;
    sourceAssetId?: string;
}
interface BrandAnalysisRequest {
    bookId: string;
    assetId: string;
    jobId: string;
    mutationId: string;
    expectedAnalysisRevision: number;
    analysis: {
        description: string;
        dominantColors: string[];
        tags: string[];
    };
}
interface BrandCapabilityAuthority {
    capability: "brand.read" | "brand.edit";
    authorityRef: string;
    /** Server-resolved identifier for the exact app key used by this client. */
    credentialRef: string;
}
/**
 * One entity-state precondition evaluated atomically with a transaction.
 *
 * Use guards for compare-and-swap edits: the write commits only when the row
 * still exists (or does not exist) and every declared field still has the value
 * the caller reviewed. `absent` makes a legacy-field upgrade atomic without
 * encoding JavaScript `undefined` on the wire. A failed guard rejects the whole
 * transaction.
 */
interface TransactGuard$1 {
    ns: string;
    id: string;
    exists: boolean;
    /** Fields that must still deeply equal these values when `exists` is true. */
    equals?: Record<string, unknown>;
    /** Top-level fields that must not exist when `exists` is true. */
    absent?: string[];
}
/** Exact immutable Registry lifetime of a project in a shared tenant. */
interface ExactProjectScope$1 {
    appId: string;
    appIncarnation: string;
    projectScope: string;
}
/**
 * Internal platform bridge for one explicit agent-to-agent turn.
 *
 * Customer app keys cannot assert this envelope: the data-plane edge accepts
 * it only with the platform machine credential, binds it to a verified agent
 * projection, and the AppDO compares it with the final source row. It is
 * exposed structurally so platform packages can preserve atomic source-write
 * plus durable-dispatch semantics through the normal transaction client.
 */
interface AgentDelegationEnvelope {
    v: 1;
    triggerId: string;
    targetAgentId: string;
    depth: 1;
    sourceNamespace: string;
    sourceMessageId: string;
    sourcePrincipalId: string;
    sourceCredentialId: string;
    /** `runtime` denotes one exact platform-hosted durable agent dispatch. */
    sourceCredentialKind: "device" | "runtime";
    delegatedByPrincipalId: string;
    grantId: string;
    grantVersion: number;
    project: ExactProjectScope$1;
}
/**
 * Internal platform bridge for one required human-to-agent Discussion turn.
 *
 * The AppDO consumes the complete array atomically with the source write:
 * every exact target must match a current trigger and be durably enqueued, or
 * the transaction rolls back.
 */
interface RequiredDiscussionDispatch$1 {
    v: 1;
    triggerId: string;
    targetAgentId: string;
    /** Exact Registry-installed trigger JSON matched inside the transaction. */
    triggerSpec: string;
    sourceNamespace: string;
    sourceMessageId: string;
    project: ExactProjectScope$1;
}
/** Attribution, idempotency, and atomic preconditions for one transaction. */
interface TransactOptions$1 extends AsUser$1 {
    mutationId?: string;
    guards?: TransactGuard$1[];
    /** @internal Platform-machine-only explicit agent delegation metadata. */
    agentDelegation?: AgentDelegationEnvelope;
    /** @internal Platform-machine-only required Discussion dispatch batch. */
    requiredDiscussionDispatches?: RequiredDiscussionDispatch$1[];
}
interface AdminDb$1 {
    tx: typeof tx$1;
    query(query: InstaQLQuery, opts?: AsUser$1): Promise<QueryResult$1>;
    /**
     * One query result plus exact totals for top-level nodes that opt into
     * `count:true`. Rows and totals are computed in the same data-plane request.
     */
    queryWithTotals(query: InstaQLQuery, opts?: AsUser$1): Promise<{
        result: QueryResult$1;
        totals: QueryTotals;
    }>;
    transact(input: TxInput$1, opts?: TransactOptions$1): Promise<TransactResult$1>;
    /** One-shot aggregate (count/sum/avg/min/max) over a namespace's matching rows. */
    aggregate(ns: string, spec: AggregateSpec, queryOpts?: QueryOpts$1, opts?: AsUser$1): Promise<AggregateResult$1>;
    /** Several independent aggregates computed in one bounded data-plane request. */
    aggregateBatch(requests: AggregateRequest[], opts?: AsUser$1): Promise<AggregateResult$1[]>;
    /**
     * Read the content-free committed-transaction feed. Omit `cursor` to obtain a
     * fresh checkpoint; pass the returned cursor to resume without a timestamp
     * race. A restore or truncated position returns `checkpointRequired`.
     */
    changes(opts?: ChangesOptions$1): Promise<ChangePage$1>;
    /**
     * Worker/server-only WebSocket proxy. The app credential remains on the
     * backend while the upstream connection is restricted to exact queries.
     */
    realtime: RealtimeProxy$1;
    storage: {
        upload(path: string, data: BodyInit, contentType?: string, opts?: {
            private?: boolean;
        }): Promise<FileRecord$1>;
        /** Mint a short-lived absolute URL for a private file, ready to hand to
         * `fetch`. Call only after the host route has authorized the requesting
         * member; persist the stable `path`/`url` from the record, never this
         * expiring result. */
        sign(path: string, ttlSeconds?: number): Promise<string>;
        delete(path: string): Promise<void>;
    };
    /** Host-mediated Brand effects for a managed-agent key. The server reloads
     * the active job, current roster, and linked asset and supplies provenance. */
    brand: {
        /** Revalidate this key's live project grant, active job, current book
         * roster, and channel binding without exposing a generic registry key. */
        authorize(bookId: string, jobId: string, capability: "brand.read" | "brand.edit"): Promise<BrandCapabilityAuthority>;
        propose(input: BrandProposalRequest): Promise<{
            proposal: Record<string, unknown>;
            duplicate: boolean;
        }>;
        analyze(input: BrandAnalysisRequest): Promise<{
            asset: Record<string, unknown>;
            duplicate: boolean;
        }>;
        readAssetContent(bookId: string, assetId: string, jobId: string): Promise<{
            bytes: Uint8Array;
            contentType: string;
        }>;
    };
    secrets: {
        /** Read one of this app's (non-reserved) secrets by name. */
        get(name: string): Promise<string>;
    };
}

/**
 * @odla/schema — the `i.schema()` builder. Defines an app's entities, typed
 * attributes, and links in code. Produces a `SerializedSchema` (the wire shape
 * in @odla/protocol) that the CLI pushes to the app DO, and TypeScript types
 * the client uses for `useQuery`/`db.tx`.
 */

type ScalarType = SerializedAttr$1["type"];
/** A typed attribute definition. `T` carries the inferred TS value type. */
declare class Attr<T, Req extends boolean = true> {
    readonly type: ScalarType;
    readonly _unique: boolean;
    readonly _indexed: boolean;
    readonly _optional: boolean;
    readonly __type: T;
    readonly __req: Req;
    constructor(type: ScalarType, _unique?: boolean, _indexed?: boolean, _optional?: boolean);
    unique(): Attr<T, Req>;
    indexed(): Attr<T, Req>;
    optional(): Attr<T | undefined, false>;
    serialize(): SerializedAttr$1;
}
interface EntityDef$1<A extends Record<string, Attr<unknown, boolean>>> {
    attrs: A;
}
/**
 * A compiled schema: the app's entity definitions (`entities`) and links
 * (`links`), produced by `i.schema({ entities, links })`. Its type parameters
 * carry the entity/link shapes so the client can infer query and `tx` types;
 * `serialize()` lowers it to the `SerializedSchema` wire form the CLI pushes to
 * the app DO and that codegen reads.
 */
declare class OdlaSchema<E extends Record<string, EntityDef$1<Record<string, Attr<unknown, boolean>>>>, L extends Record<string, SerializedLink$1>> {
    readonly entities: E;
    readonly links: L;
    constructor(entities: E, links: L);
    serialize(): SerializedSchema$1;
}
/** The schema builder entrypoint. */
declare const i: {
    string: () => Attr<string, true>;
    number: () => Attr<number, true>;
    boolean: () => Attr<boolean, true>;
    date: () => Attr<string | number, true>;
    json: <T extends Json$1 = Json$1>() => Attr<T, true>;
    entity<A extends Record<string, Attr<unknown, boolean>>>(attrs: A): EntityDef$1<A>;
    schema<E extends Record<string, EntityDef$1<Record<string, Attr<unknown, boolean>>>>, L extends Record<string, SerializedLink$1> = Record<string, never>>(def: {
        entities: E;
        links?: L;
    }): OdlaSchema<E, L>;
};
type EntityName$1<S> = S extends OdlaSchema<infer E, infer _L> ? keyof E : never;
type InferEntity$1<S, NS extends keyof InferEntities<S>> = {
    id: string;
} & {
    [K in keyof InferEntities<S>[NS]]: InferEntities<S>[NS][K];
};
type InferEntities<S> = S extends OdlaSchema<infer E, infer _L> ? {
    [NS in keyof E]: {
        [K in keyof E[NS]["attrs"]]: E[NS]["attrs"][K] extends Attr<infer T, boolean> ? T : never;
    };
} : never;

/**
 * Owner-reviewed exact-project authority that is excluded from ordinary agent
 * handshakes.
 *
 * This union is duplicated from OPTIONAL_AGENT_PROJECT_CAPABILITIES in the
 * registry, because @odla-ai/db cannot depend on it — and it has already
 * drifted once: `code.session` shipped registry-side while this list still said
 * two entries, which made it impossible for the CLI to request the very
 * capability the registry had just started accepting. Add here whenever you add
 * there.
 */
type OptionalAgentProjectCapability = "app.manage" | "crm.read" | "code.session";
/** The same list as a value, so a caller asking for everything an owner can
 * approve does not have to keep its own copy of what "everything" is. */
declare const OPTIONAL_AGENT_PROJECT_CAPABILITIES: readonly OptionalAgentProjectCapability[];
/**
 * Every app the approving human owns, now and later — the one `projectIds`
 * value that is not an exact id.
 *
 * Not platform-wide authority and cannot become it: the registry resolves it at
 * each action boundary against that human's LIVE owned apps, so an app
 * transferred away stops being reachable without anyone re-approving anything.
 */
declare const ALL_OWNED_APPS = "*";
/**
 * Scopes an app owner may put on a machine in a single approval.
 *
 * Duplicated from OWNER_DEVICE_SCOPES in the registry for the same reason the
 * capability union above is — @odla-ai/db cannot depend on it — and guarded the
 * same way, by a source-comparison test. The registry clamps whatever arrives,
 * so drift here costs a refused enrollment with an exact message, never
 * authority nobody approved.
 */
declare const OWNER_DEVICE_SCOPES: readonly string[];
/** Scopes only an administrator's approval can put on a machine: the whole
 * requestable vocabulary, which is what "all of odla" has to mean. */
declare const ADMIN_DEVICE_SCOPES: readonly string[];
/** Inputs for the human-approved, scoped developer-token device handshake. */
interface RequestTokenOptions {
    /** odla platform origin hosting the device handshake, normally https://odla.ai. */
    endpoint: string;
    /** Email of the existing odla account that will claim the request. This is
     * an identity hint, not a password or bearer credential; the matching human
     * must still sign in to Studio and explicitly review the exact code. */
    email: string;
    /** Called with the short code and signed-in Studio URL. Opening the URL does
     * not claim access; the human must choose Review, then Approve. The
     * `deviceCode` is the opaque poll credential — persist it privately (never
     * display it) to make the handshake collectable by a later `collectToken`
     * call if this process dies before approval. */
    onCode: (info: {
        userCode: string;
        deviceCode: string;
        expiresIn: number;
        interval: number;
        verificationUri?: string;
        verificationUriComplete?: string;
    }) => void | Promise<void>;
    /** Required-for-recognition agent name shown to the human approver and used
     * to register this handshake's new principal. The server supplies "Agent"
     * only when older callers omit it. */
    label?: string;
    /** Optional stable single-segment agent handle. It is frozen into the exact
     * request and reconnects a later approved handshake to the same principal. */
    agentHandle?: string;
    /** Optional supported platform scopes shown verbatim to an admin approver.
     * System AI policy, credential, and usage capabilities are separate;
     * ordinary provisioning omits scopes entirely. */
    scopes?: string[];
    /** Exact project ids the agent is asking the human to grant. Studio shows
     * these verbatim; approval cannot add, remove, or replace them. */
    projectIds?: string[];
    /** Closed optional project capabilities requested for every selected
     * project. Approval accepts or declines this exact set. */
    optionalProjectCapabilities?: OptionalAgentProjectCapability[];
    /** Cap this call's wait for approval. When it elapses while the handshake is
     * still approvable, throws `OdlaError("handshake_pending")`; the handshake
     * stays claimable and `collectToken` can keep waiting. */
    waitMs?: number;
    fetch?: typeof globalThis.fetch;
    signal?: AbortSignal;
}
/** Scoped, revocable developer token returned by a successful device handshake. */
interface DeviceToken {
    /** An `odla_dev_…` token bound to the newly registered agent principal.
     * Ordinary credentials last ~24h and can act only in exact projects selected
     * by the approver; explicitly scoped platform grants last ~15m. Neither form
     * inherits the approver's ownership or admin role. */
    token: string;
    expiresAt: number;
}
/** Inputs for resuming a previously started handshake by its poll credential. */
interface CollectTokenOptions {
    /** odla platform origin hosting the device handshake, normally https://odla.ai. */
    endpoint: string;
    /** Opaque poll credential returned when the handshake started. */
    deviceCode: string;
    /** Epoch milliseconds when the handshake itself lapses server-side. */
    expiresAt: number;
    /** Seconds between polls, as announced when the handshake started. */
    interval?: number;
    /** Cap this call's wait; see {@link RequestTokenOptions.waitMs}. */
    waitMs?: number;
    fetch?: typeof globalThis.fetch;
    signal?: AbortSignal;
}
/**
 * Obtain a scoped developer token from odla-db via a device-authorization
 * handshake — no pre-shared secret. Starts a handshake, calls `onCode` with the
 * short user code to show the named account owner, then polls until that same
 * user signs in, explicitly claims it, reviews the requested exact projects,
 * and approves it at odla.ai. Requested projects and capabilities are immutable;
 * a different grant requires a declined request and a fresh submission. Resolves
 * with a revocable token (~24h for ordinary project
 * grants, ~15m for a visible admin-approved platform scope). Each new handshake
 * without `agentHandle` registers a new principal. Reuse the same reviewed
 * handle to preserve identity and authorship across credential rotation.
 *
 *   const { token } = await requestToken({
 *     endpoint: "https://odla.ai",
 *     email: "owner@example.com",
 *     projectIds: ["customer-app"],
 *     onCode: ({ userCode, verificationUriComplete }) =>
 *       console.log(`Review "${userCode}" at ${verificationUriComplete ?? "https://odla.ai/studio"}.`),
 *   });
 */
declare function requestToken(opts: RequestTokenOptions): Promise<DeviceToken>;
/**
 * Wait for the human's decision on an already-started handshake and collect
 * the approved token. The poll is idempotent while the handshake is pending,
 * and an approval stays claimable (exactly once) until the handshake's own
 * expiry — so a caller that persisted the `deviceCode` can crash, be killed by
 * a shell timeout, and still collect on a later run. Throws
 * `OdlaError("handshake_pending")` when `waitMs` elapses first (retry later),
 * `handshake_denied`/`handshake_expired` on a terminal decision, and
 * `handshake_timeout` once the handshake itself has lapsed unapproved.
 */
declare function collectToken(opts: CollectTokenOptions): Promise<DeviceToken>;

/**
 * Create the trusted backend client. The default transport calls fetch through
 * `globalThis`, preserving the receiver required by Cloudflare Workers.
 */
declare function init(options: AdminOptions$1): AdminDb$1;

/** Connection options for the trusted backend client, including its full app key. */
type AdminOptions = AdminOptions$1;
/** Privileged HTTP database facade returned by root `init`; never expose it to a browser. */
type AdminDb = AdminDb$1;
/** Optional verified user identity used to evaluate a privileged call as that user. */
type AsUser = AsUser$1;
/** Metadata returned after uploading a file through the trusted backend client. */
type FileRecord = FileRecord$1;
/** Transaction acknowledgement, including whether a stable mutation id was already applied. */
type TransactResult = TransactResult$1;
/** One entity-state precondition evaluated atomically with a transaction. */
type TransactGuard = TransactGuard$1;
/** Exact immutable Registry project lifetime used by trusted dispatch metadata. */
type ExactProjectScope = ExactProjectScope$1;
/** One required trusted Discussion target committed with its source write. */
type RequiredDiscussionDispatch = RequiredDiscussionDispatch$1;
/** Attribution, idempotency, and atomic preconditions for one transaction. */
type TransactOptions = TransactOptions$1;
/** Server-issued position in one app's trusted transaction stream. */
type ChangeCursor = ChangeCursor$1;
/** Content-free metadata for one committed transaction. */
type ChangeTransaction = ChangeTransaction$1;
/** Options for {@link AdminDb.changes}. */
type ChangesOptions = ChangesOptions$1;
/** One resumable page returned by {@link AdminDb.changes}. */
type ChangePage = ChangePage$1;
/** Exact origin, query scope, and lifetime restrictions for a trusted realtime proxy. */
type RealtimeProxyOptions = RealtimeProxyOptions$1;
/** Worker/server-only realtime proxy surface exposed by {@link AdminDb.realtime}. */
type RealtimeProxy = RealtimeProxy$1;
/** Namespace/id transaction proxy for building update, delete, link, and unlink operations. */
declare const tx: Record<string, {
    [x: string]: TxChain;
}>;

/** A transaction chain, raw operation, or arbitrarily nested array of either. */
type TxInput = TxInput$1;

/** UUIDv7 entity identifier carried over the wire. */
type EntityId = EntityId$1;
/** Public application identifier used to select an odla tenant. */
type AppId = AppId$1;
/** Client-supplied stable transaction idempotency key. */
type MutationId = MutationId$1;
/** Serialized schema value-kind discriminator. */
type ValueType = ValueType$1;
/** JSON scalar accepted in attributes and query predicates. */
type Scalar = Scalar$1;
/** Recursively JSON-compatible value. */
type Json = Json$1;
/** Attribute value accepted by transaction operations. */
type Value = Value$1;
/** Comparison-operator object accepted for one query field. */
type WhereOp = WhereOp$1;
/** Scalar equality value or comparison-operator object for one query field. */
type WhereValue = WhereValue$1;
/** Recursive boolean filter tree for query rows. */
type WhereClause = WhereClause$1;
/** Per-query-node filtering, ordering, pagination, and text-search options. */
type QueryOpts = QueryOpts$1;
/** Count/sum/average/min/max values returned by one aggregate request. */
type AggregateResult = AggregateResult$1;
/** One query-result entity with an id and selected attributes or relations. */
type Entity = Entity$1;
/** Namespace-keyed entity arrays returned by an InstaQL query. */
type QueryResult = QueryResult$1;
/** Direct id, unique-attribute lookup, or graph-qualified entity reference. */
type EntityRef = EntityRef$1;
/** Closed transaction-operation union for updates, merges, deletes, links, and unlinks. */
type Op = Op$1;
/** Stable wire error payload with a machine-readable code and optional JSON detail. */
type ErrShape = ErrShape$1;
/** Serialized scalar attribute definition sent with an application schema. */
type SerializedAttr = SerializedAttr$1;
/** Serialized namespace definition containing its attributes. */
type SerializedEntity = SerializedEntity$1;
/** Link cardinality for one end of a schema relation. */
type Cardinality = Cardinality$1;
/** Namespace, cardinality, and label for one end of a serialized relation. */
type SerializedLinkEnd = SerializedLinkEnd$1;
/** Forward and reverse ends of a serialized schema relation. */
type SerializedLink = SerializedLink$1;
/** Complete entity/link schema accepted by odla provisioning. */
type SerializedSchema = SerializedSchema$1;

/** Typed attribute map used by the schema builder for one entity namespace. */
type EntityDef<A extends Record<string, Attr<unknown, boolean>>> = EntityDef$1<A>;
/** Namespace-name union inferred from an `OdlaSchema`. */
type EntityName<S> = EntityName$1<S>;
/** Runtime entity shape inferred from one namespace in an `OdlaSchema`. */
type InferEntity<S, NS extends EntityName$1<S>> = InferEntity$1<S, NS>;

export { ADMIN_DEVICE_SCOPES, ALL_OWNED_APPS, type AdminDb, type AdminOptions, AggregateRequest, type AggregateResult, AggregateSpec, type AppId, type AsUser, Attr, type Cardinality, type ChangeCursor, type ChangePage, type ChangeTransaction, type ChangesOptions, type CollectTokenOptions, type DeviceToken, type Entity, type EntityDef, type EntityId, type EntityName, type EntityRef, type ErrShape, type ExactProjectScope, type FileRecord, type InferEntity, InstaQLQuery, type Json, type MutationId, OPTIONAL_AGENT_PROJECT_CAPABILITIES, OWNER_DEVICE_SCOPES, OdlaSchema, type Op, type OptionalAgentProjectCapability, type QueryOpts, type QueryResult, type RealtimeProxy, type RealtimeProxyOptions, type RequestTokenOptions, type RequiredDiscussionDispatch, type Scalar, type SerializedAttr, type SerializedEntity, type SerializedLink, type SerializedLinkEnd, type SerializedSchema, type TransactGuard, type TransactOptions, type TransactResult, TxChain, TxId, type TxInput, type Value, type ValueType, type WhereClause, type WhereOp, type WhereValue, collectToken, i, init, init as initAdmin, requestToken, tx };