import { z } from "zod";
/** Page size cap for GET /workspaces/:workspaceId/calls. History is unbounded
 * in principle, so the read is paged rather than windowed by date the way the
 * calendar's is — a call has one instant, not a range to overlap. */
export declare const MAX_CALL_PAGE_SIZE = 100;
/**
 * How many peers one call may hold.
 *
 * Phase 6 moved media onto LiveKit (an SFU), so the old mesh bandwidth
 * argument no longer caps this. Twelve is the Phase 6 exit criterion
 * (ARCHITECTURE.md §8) and is still enforced server-side so a client cannot
 * bypass it.
 */
export declare const MAX_CALL_PARTICIPANTS = 12;
export declare const StartCallRequest: z.ZodEffects<z.ZodObject<{
    kind: z.ZodDefault<z.ZodEnum<["audio", "video", "connect"]>>;
    /** Who to ring. The caller is added as a joined participant implicitly and
     * does not need to be listed. */
    inviteeUserIds: z.ZodArray<z.ZodNumber, "many">;
    /** Optional origin context — the DM or room the call was started from. */
    channelId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    /** Set when this call is the realisation of a scheduled calendar event. */
    eventId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    kind: "audio" | "video" | "connect";
    inviteeUserIds: number[];
    title?: string | null | undefined;
    channelId?: number | null | undefined;
    eventId?: number | null | undefined;
}, {
    inviteeUserIds: number[];
    title?: string | null | undefined;
    channelId?: number | null | undefined;
    kind?: "audio" | "video" | "connect" | undefined;
    eventId?: number | null | undefined;
}>, {
    kind: "audio" | "video" | "connect";
    inviteeUserIds: number[];
    title?: string | null | undefined;
    channelId?: number | null | undefined;
    eventId?: number | null | undefined;
}, {
    inviteeUserIds: number[];
    title?: string | null | undefined;
    channelId?: number | null | undefined;
    kind?: "audio" | "video" | "connect" | undefined;
    eventId?: number | null | undefined;
}>;
export type StartCallRequest = z.infer<typeof StartCallRequest>;
/** Join-or-start the persistent audio room for a channel (feature 8.1). */
export declare const StartConnectRequest: z.ZodObject<{
    channelId: z.ZodNumber;
    /** Connect is audio by default; video is opt-in once you are in the room. */
    video: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    channelId: number;
    video?: boolean | undefined;
}, {
    channelId: number;
    video?: boolean | undefined;
}>;
export type StartConnectRequest = z.infer<typeof StartConnectRequest>;
export declare const CallMediaTokenResponse: z.ZodObject<{
    /** False when LiveKit is not configured — the client falls back to mesh. */
    configured: z.ZodBoolean;
    url: z.ZodNullable<z.ZodString>;
    token: z.ZodNullable<z.ZodString>;
    roomName: z.ZodNullable<z.ZodString>;
    identity: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    token: string | null;
    configured: boolean;
    url: string | null;
    roomName: string | null;
    identity: string | null;
}, {
    token: string | null;
    configured: boolean;
    url: string | null;
    roomName: string | null;
    identity: string | null;
}>;
export type CallMediaTokenResponse = z.infer<typeof CallMediaTokenResponse>;
export declare const DialPstnRequest: z.ZodObject<{
    e164: z.ZodString;
}, "strip", z.ZodTypeAny, {
    e164: string;
}, {
    e164: string;
}>;
export type DialPstnRequest = z.infer<typeof DialPstnRequest>;
/** Which side of the call the caller was on. Not stored — derived per-reader
 * from `startedBy`, since one row is outgoing for the caller and incoming for
 * everyone else. */
export declare const CallDirection: z.ZodEnum<["incoming", "outgoing"]>;
export type CallDirection = z.infer<typeof CallDirection>;
export declare const ListCallsQuery: z.ZodObject<{
    /** Only calls that are still live — the active-calls strip's read. */
    active: z.ZodOptional<z.ZodEffects<z.ZodEnum<["true", "false", "1", "0"]>, boolean, "0" | "1" | "true" | "false">>;
    /** Only calls this user never answered. */
    missed: z.ZodOptional<z.ZodEffects<z.ZodEnum<["true", "false", "1", "0"]>, boolean, "0" | "1" | "true" | "false">>;
    direction: z.ZodOptional<z.ZodEnum<["incoming", "outgoing"]>>;
    /** Restrict to calls involving this person, for a per-contact history. */
    withUserId: z.ZodOptional<z.ZodNumber>;
    /** Restrict to calls started from this room or DM. */
    channelId: z.ZodOptional<z.ZodNumber>;
    limit: z.ZodDefault<z.ZodNumber>;
    /** Keyset cursor: return calls started strictly before this instant. Chosen
     * over an offset because history grows at the head, where an offset would
     * silently skip or repeat rows between pages. */
    before: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    limit: number;
    channelId?: number | undefined;
    active?: boolean | undefined;
    missed?: boolean | undefined;
    direction?: "incoming" | "outgoing" | undefined;
    withUserId?: number | undefined;
    before?: string | undefined;
}, {
    channelId?: number | undefined;
    active?: "0" | "1" | "true" | "false" | undefined;
    missed?: "0" | "1" | "true" | "false" | undefined;
    direction?: "incoming" | "outgoing" | undefined;
    withUserId?: number | undefined;
    limit?: number | undefined;
    before?: string | undefined;
}>;
export type ListCallsQuery = z.infer<typeof ListCallsQuery>;
/** Adds people to a call already in progress. Replace-wholesale would be
 * wrong here (unlike event invites): the existing participants are *on* the
 * call, so their rows are not the caller's to rewrite. */
export declare const InviteToCallRequest: z.ZodObject<{
    inviteeUserIds: z.ZodArray<z.ZodNumber, "many">;
}, "strip", z.ZodTypeAny, {
    inviteeUserIds: number[];
}, {
    inviteeUserIds: number[];
}>;
export type InviteToCallRequest = z.infer<typeof InviteToCallRequest>;
/** Marks calls as acknowledged in the caller's own history, clearing the
 * missed badge. Omitting `callIds` acknowledges every unseen call — the
 * "opened the calls page" case. */
export declare const MarkCallsSeenRequest: z.ZodObject<{
    callIds: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
}, "strip", z.ZodTypeAny, {
    callIds?: number[] | undefined;
}, {
    callIds?: number[] | undefined;
}>;
export type MarkCallsSeenRequest = z.infer<typeof MarkCallsSeenRequest>;
/**
 * WebRTC signalling relay, carried over the socket rather than HTTP — offers,
 * answers and ICE candidates are a fast back-and-forth between two specific
 * clients and there is nothing to persist.
 *
 * `data` is deliberately opaque: it is an SDP blob or an ICE candidate whose
 * shape belongs to the browser's WebRTC implementation, not to this protocol.
 * The gateway authorises the relay (both ends must be participants of the
 * named call) and forwards the payload without inspecting it.
 */
export declare const CallSignalKind: z.ZodEnum<["offer", "answer", "ice", "ready"]>;
export type CallSignalKind = z.infer<typeof CallSignalKind>;
export declare const CallSignalRequest: z.ZodObject<{
    /** Carried because the gateway has no ambient workspace scope — every
     * tenant-scoped read needs it, and it is checked against the call's own
     * workspace rather than trusted. */
    workspaceId: z.ZodNumber;
    callId: z.ZodNumber;
    toUserId: z.ZodNumber;
    signal: z.ZodEnum<["offer", "answer", "ice", "ready"]>;
    data: z.ZodUnknown;
}, "strip", z.ZodTypeAny, {
    workspaceId: number;
    callId: number;
    toUserId: number;
    signal: "ready" | "offer" | "answer" | "ice";
    data?: unknown;
}, {
    workspaceId: number;
    callId: number;
    toUserId: number;
    signal: "ready" | "offer" | "answer" | "ice";
    data?: unknown;
}>;
export type CallSignalRequest = z.infer<typeof CallSignalRequest>;
//# sourceMappingURL=calls-http.d.ts.map