@babelforce/babelconnect-sdk 0.1.0

package/dist/gen/babelconnect/v1/babelconnect_pb.d.ts

@@ -0,0 +1,2362 @@
+import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
+import { Message, proto3 } from "@bufbuild/protobuf";
+/**
+ * @generated from enum babelconnect.v1.AgentState
+ */
+export declare enum AgentState {
+    /**
+     * @generated from enum value: AGENT_STATE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: AGENT_STATE_OFFLINE = 1;
+     */
+    OFFLINE = 1,
+    /**
+     * @generated from enum value: AGENT_STATE_AVAILABLE = 2;
+     */
+    AVAILABLE = 2,
+    /**
+     * @generated from enum value: AGENT_STATE_IN_CALL = 3;
+     */
+    IN_CALL = 3,
+    /**
+     * @generated from enum value: AGENT_STATE_WRAP_UP = 4;
+     */
+    WRAP_UP = 4,
+    /**
+     * @generated from enum value: AGENT_STATE_PAUSED = 5;
+     */
+    PAUSED = 5,
+    /**
+     * @generated from enum value: AGENT_STATE_RINGING = 6;
+     */
+    RINGING = 6,
+    /**
+     * @generated from enum value: AGENT_STATE_BUSY = 7;
+     */
+    BUSY = 7
+}
+/**
+ * @generated from enum babelconnect.v1.CallDirection
+ */
+export declare enum CallDirection {
+    /**
+     * @generated from enum value: CALL_DIRECTION_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: CALL_DIRECTION_INBOUND = 1;
+     */
+    INBOUND = 1,
+    /**
+     * @generated from enum value: CALL_DIRECTION_OUTBOUND = 2;
+     */
+    OUTBOUND = 2
+}
+/**
+ * @generated from enum babelconnect.v1.CallLifecycle
+ */
+export declare enum CallLifecycle {
+    /**
+     * @generated from enum value: CALL_LIFECYCLE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: CALL_LIFECYCLE_INIT = 1;
+     */
+    INIT = 1,
+    /**
+     * offer present; client should answer
+     *
+     * @generated from enum value: CALL_LIFECYCLE_RINGING = 2;
+     */
+    RINGING = 2,
+    /**
+     * @generated from enum value: CALL_LIFECYCLE_IN_PROGRESS = 3;
+     */
+    IN_PROGRESS = 3,
+    /**
+     * media flowing both ways
+     *
+     * @generated from enum value: CALL_LIFECYCLE_BRIDGED = 4;
+     */
+    BRIDGED = 4,
+    /**
+     * @generated from enum value: CALL_LIFECYCLE_COMPLETED = 5;
+     */
+    COMPLETED = 5,
+    /**
+     * @generated from enum value: CALL_LIFECYCLE_FAILED = 6;
+     */
+    FAILED = 6
+}
+/**
+ * @generated from enum babelconnect.v1.CallSource
+ */
+export declare enum CallSource {
+    /**
+     * @generated from enum value: CALL_SOURCE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: CALL_SOURCE_API = 1;
+     */
+    API = 1,
+    /**
+     * @generated from enum value: CALL_SOURCE_WEBRTC = 2;
+     */
+    WEBRTC = 2,
+    /**
+     * @generated from enum value: CALL_SOURCE_QUEUE = 3;
+     */
+    QUEUE = 3,
+    /**
+     * @generated from enum value: CALL_SOURCE_TRANSFER = 4;
+     */
+    TRANSFER = 4,
+    /**
+     * @generated from enum value: CALL_SOURCE_DIALER = 5;
+     */
+    DIALER = 5,
+    /**
+     * @generated from enum value: CALL_SOURCE_CONFERENCE = 6;
+     */
+    CONFERENCE = 6,
+    /**
+     * @generated from enum value: CALL_SOURCE_CALLBACK = 7;
+     */
+    CALLBACK = 7
+}
+/**
+ * @generated from message babelconnect.v1.AuthenticateRequest
+ */
+export declare class AuthenticateRequest extends Message<AuthenticateRequest> {
+    /**
+     * Optional: token may instead be supplied via "authorization" metadata.
+     *
+     * @generated from field: string token = 1;
+     */
+    token: string;
+    constructor(data?: PartialMessage<AuthenticateRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.AuthenticateRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AuthenticateRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AuthenticateRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AuthenticateRequest;
+    static equals(a: AuthenticateRequest | PlainMessage<AuthenticateRequest> | undefined, b: AuthenticateRequest | PlainMessage<AuthenticateRequest> | undefined): boolean;
+}
+/**
+ * SubscribeRequest opens the StateUpdate stream for the authenticated agent (the
+ * bearer token rides in "authorization" metadata, like every call). Empty today;
+ * reserved for future subscription filters.
+ *
+ * @generated from message babelconnect.v1.SubscribeRequest
+ */
+export declare class SubscribeRequest extends Message<SubscribeRequest> {
+    constructor(data?: PartialMessage<SubscribeRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SubscribeRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SubscribeRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SubscribeRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SubscribeRequest;
+    static equals(a: SubscribeRequest | PlainMessage<SubscribeRequest> | undefined, b: SubscribeRequest | PlainMessage<SubscribeRequest> | undefined): boolean;
+}
+/**
+ * Ack is the empty reply to Send. It only confirms the server accepted the
+ * command for processing — the resulting state (or an Error) is delivered on the
+ * Subscribe stream, the same way Session reports it.
+ *
+ * @generated from message babelconnect.v1.Ack
+ */
+export declare class Ack extends Message<Ack> {
+    constructor(data?: PartialMessage<Ack>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Ack";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Ack;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Ack;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Ack;
+    static equals(a: Ack | PlainMessage<Ack> | undefined, b: Ack | PlainMessage<Ack> | undefined): boolean;
+}
+/**
+ * GetStateRequest fetches the current AgentView (the unary "get current state").
+ * Empty; the bearer token rides in "authorization" metadata like every call.
+ *
+ * @generated from message babelconnect.v1.GetStateRequest
+ */
+export declare class GetStateRequest extends Message<GetStateRequest> {
+    constructor(data?: PartialMessage<GetStateRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.GetStateRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStateRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStateRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStateRequest;
+    static equals(a: GetStateRequest | PlainMessage<GetStateRequest> | undefined, b: GetStateRequest | PlainMessage<GetStateRequest> | undefined): boolean;
+}
+/**
+ * HistoryRequest pages the agent's call history (newest first).
+ *
+ * @generated from message babelconnect.v1.HistoryRequest
+ */
+export declare class HistoryRequest extends Message<HistoryRequest> {
+    /**
+     * page size (default 50)
+     *
+     * @generated from field: int32 max = 1;
+     */
+    max: number;
+    /**
+     * 1-based page (default 1)
+     *
+     * @generated from field: int32 page = 2;
+     */
+    page: number;
+    constructor(data?: PartialMessage<HistoryRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.HistoryRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HistoryRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HistoryRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HistoryRequest;
+    static equals(a: HistoryRequest | PlainMessage<HistoryRequest> | undefined, b: HistoryRequest | PlainMessage<HistoryRequest> | undefined): boolean;
+}
+/**
+ * HistoryResponse is one page of past calls.
+ *
+ * @generated from message babelconnect.v1.HistoryResponse
+ */
+export declare class HistoryResponse extends Message<HistoryResponse> {
+    /**
+     * @generated from field: repeated babelconnect.v1.CallRecord calls = 1;
+     */
+    calls: CallRecord[];
+    constructor(data?: PartialMessage<HistoryResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.HistoryResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HistoryResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HistoryResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HistoryResponse;
+    static equals(a: HistoryResponse | PlainMessage<HistoryResponse> | undefined, b: HistoryResponse | PlainMessage<HistoryResponse> | undefined): boolean;
+}
+/**
+ * CallRecord is one past call for the history list (a flattened conversation).
+ *
+ * @generated from message babelconnect.v1.CallRecord
+ */
+export declare class CallRecord extends Message<CallRecord> {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: babelconnect.v1.CallDirection direction = 2;
+     */
+    direction: CallDirection;
+    /**
+     * @generated from field: string from = 3;
+     */
+    from: string;
+    /**
+     * @generated from field: string to = 4;
+     */
+    to: string;
+    /**
+     * phonebook label for the other party, if known
+     *
+     * @generated from field: string contact = 5;
+     */
+    contact: string;
+    /**
+     * unix seconds of the call
+     *
+     * @generated from field: int64 time = 6;
+     */
+    time: bigint;
+    /**
+     * @generated from field: int32 duration_ms = 7;
+     */
+    durationMs: number;
+    /**
+     * @generated from field: bool has_recording = 8;
+     */
+    hasRecording: boolean;
+    /**
+     * playback URL when a recording exists
+     *
+     * @generated from field: string recording_url = 9;
+     */
+    recordingUrl: string;
+    constructor(data?: PartialMessage<CallRecord>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.CallRecord";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CallRecord;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CallRecord;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CallRecord;
+    static equals(a: CallRecord | PlainMessage<CallRecord> | undefined, b: CallRecord | PlainMessage<CallRecord> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Identity
+ */
+export declare class Identity extends Message<Identity> {
+    /**
+     * Agent UUID, hyphen-normalized
+     *
+     * @generated from field: string agent_id = 1;
+     */
+    agentId: string;
+    /**
+     * customer / account id
+     *
+     * @generated from field: string account = 2;
+     */
+    account: string;
+    /**
+     * agent's number, if any
+     *
+     * @generated from field: string number = 3;
+     */
+    number: string;
+    /**
+     * @generated from field: string username = 4;
+     */
+    username: string;
+    /**
+     * current presence
+     *
+     * @generated from field: babelconnect.v1.AgentState state = 5;
+     */
+    state: AgentState;
+    constructor(data?: PartialMessage<Identity>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Identity";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Identity;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Identity;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Identity;
+    static equals(a: Identity | PlainMessage<Identity> | undefined, b: Identity | PlainMessage<Identity> | undefined): boolean;
+}
+/**
+ * AgentView is the complete per-agent state the server owns and renders to. A
+ * snapshot carries the whole view; patches carry entity-level deltas.
+ *
+ * @generated from message babelconnect.v1.AgentView
+ */
+export declare class AgentView extends Message<AgentView> {
+    /**
+     * @generated from field: babelconnect.v1.AgentInfo agent = 1;
+     */
+    agent?: AgentInfo;
+    /**
+     * calls currently in flight for this agent
+     *
+     * @generated from field: repeated babelconnect.v1.CallState active_calls = 2;
+     */
+    activeCalls: CallState[];
+    /**
+     * @generated from field: babelconnect.v1.WrapUpStatus wrap_up = 3;
+     */
+    wrapUp?: WrapUpStatus;
+    /**
+     * SMS thread summaries (full history on demand)
+     *
+     * @generated from field: repeated babelconnect.v1.SmsConversation sms = 4;
+     */
+    sms: SmsConversation[];
+    /**
+     * active multi-party conferences (usually 0 or 1)
+     *
+     * @generated from field: repeated babelconnect.v1.Conference conferences = 5;
+     */
+    conferences: Conference[];
+    /**
+     * which surfaces this deployment/account shows
+     *
+     * @generated from field: babelconnect.v1.AppConfig config = 6;
+     */
+    config?: AppConfig;
+    constructor(data?: PartialMessage<AgentView>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.AgentView";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentView;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentView;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentView;
+    static equals(a: AgentView | PlainMessage<AgentView> | undefined, b: AgentView | PlainMessage<AgentView> | undefined): boolean;
+}
+/**
+ * AppConfig is the server-resolved, per-agent feature configuration the client
+ * renders against (UI = f(view)): which surfaces are shown and their per-feature
+ * settings. Resolved server-side per deployment + account, so the client is a
+ * pure renderer. Carried on the snapshot (no patch) — config applies on next connect.
+ *
+ * @generated from message babelconnect.v1.AppConfig
+ */
+export declare class AppConfig extends Message<AppConfig> {
+    /**
+     * @generated from field: babelconnect.v1.FeatureCalls calls = 1;
+     */
+    calls?: FeatureCalls;
+    /**
+     * @generated from field: babelconnect.v1.FeatureMessaging messaging = 2;
+     */
+    messaging?: FeatureMessaging;
+    /**
+     * @generated from field: babelconnect.v1.FeatureHistory history = 3;
+     */
+    history?: FeatureHistory;
+    /**
+     * @generated from field: babelconnect.v1.FeatureAccount account = 4;
+     */
+    account?: FeatureAccount;
+    /**
+     * @generated from field: babelconnect.v1.FeatureOutbound outbound = 5;
+     */
+    outbound?: FeatureOutbound;
+    /**
+     * @generated from field: babelconnect.v1.FeatureCti cti = 6;
+     */
+    cti?: FeatureCti;
+    /**
+     * Contacts (phonebook) tab
+     *
+     * @generated from field: babelconnect.v1.FeaturePhonebook phonebook = 7;
+     */
+    phonebook?: FeaturePhonebook;
+    /**
+     * build version for the Status/About surface; reserve 8–14
+     *
+     * @generated from field: string server_version = 15;
+     */
+    serverVersion: string;
+    constructor(data?: PartialMessage<AppConfig>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.AppConfig";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AppConfig;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AppConfig;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AppConfig;
+    static equals(a: AppConfig | PlainMessage<AppConfig> | undefined, b: AppConfig | PlainMessage<AppConfig> | undefined): boolean;
+}
+/**
+ * FeatureCalls gates the call surface (Phone tab) and its in-call actions.
+ * Recording stays gated by AgentInfo.can_record (not duplicated here); device
+ * (browser/telephone) by AgentInfo.webrtc_enabled.
+ *
+ * @generated from message babelconnect.v1.FeatureCalls
+ */
+export declare class FeatureCalls extends Message<FeatureCalls> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    /**
+     * cold transfer action
+     *
+     * @generated from field: bool allow_transfer = 2;
+     */
+    allowTransfer: boolean;
+    /**
+     * conference action (own bucket later when that surface lands)
+     *
+     * @generated from field: bool allow_conference = 3;
+     */
+    allowConference: boolean;
+    constructor(data?: PartialMessage<FeatureCalls>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeatureCalls";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureCalls;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureCalls;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureCalls;
+    static equals(a: FeatureCalls | PlainMessage<FeatureCalls> | undefined, b: FeatureCalls | PlainMessage<FeatureCalls> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.FeatureMessaging
+ */
+export declare class FeatureMessaging extends Message<FeatureMessaging> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    constructor(data?: PartialMessage<FeatureMessaging>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeatureMessaging";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureMessaging;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureMessaging;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureMessaging;
+    static equals(a: FeatureMessaging | PlainMessage<FeatureMessaging> | undefined, b: FeatureMessaging | PlainMessage<FeatureMessaging> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.FeatureHistory
+ */
+export declare class FeatureHistory extends Message<FeatureHistory> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    constructor(data?: PartialMessage<FeatureHistory>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeatureHistory";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureHistory;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureHistory;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureHistory;
+    static equals(a: FeatureHistory | PlainMessage<FeatureHistory> | undefined, b: FeatureHistory | PlainMessage<FeatureHistory> | undefined): boolean;
+}
+/**
+ * FeatureAccount gates the Account tab and its sections.
+ *
+ * @generated from message babelconnect.v1.FeatureAccount
+ */
+export declare class FeatureAccount extends Message<FeatureAccount> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    /**
+     * browser/telephone selector + agent-number field
+     *
+     * @generated from field: bool allow_device_switch = 2;
+     */
+    allowDeviceSwitch: boolean;
+    /**
+     * the Status/About section
+     *
+     * @generated from field: bool show_status = 3;
+     */
+    showStatus: boolean;
+    constructor(data?: PartialMessage<FeatureAccount>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeatureAccount";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureAccount;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureAccount;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureAccount;
+    static equals(a: FeatureAccount | PlainMessage<FeatureAccount> | undefined, b: FeatureAccount | PlainMessage<FeatureAccount> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.FeatureOutbound
+ */
+export declare class FeatureOutbound extends Message<FeatureOutbound> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    constructor(data?: PartialMessage<FeatureOutbound>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeatureOutbound";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureOutbound;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureOutbound;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureOutbound;
+    static equals(a: FeatureOutbound | PlainMessage<FeatureOutbound> | undefined, b: FeatureOutbound | PlainMessage<FeatureOutbound> | undefined): boolean;
+}
+/**
+ * FeatureCti gates CTI/integration behavior (screen-pop + app→host call events).
+ *
+ * @generated from message babelconnect.v1.FeatureCti
+ */
+export declare class FeatureCti extends Message<FeatureCti> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    /**
+     * emit cti.call to an embedding host on each transition
+     *
+     * @generated from field: bool emit_call_events = 2;
+     */
+    emitCallEvents: boolean;
+    /**
+     * surface screen-pop notifications
+     *
+     * @generated from field: bool screen_pop = 3;
+     */
+    screenPop: boolean;
+    constructor(data?: PartialMessage<FeatureCti>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeatureCti";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeatureCti;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeatureCti;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeatureCti;
+    static equals(a: FeatureCti | PlainMessage<FeatureCti> | undefined, b: FeatureCti | PlainMessage<FeatureCti> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.FeaturePhonebook
+ */
+export declare class FeaturePhonebook extends Message<FeaturePhonebook> {
+    /**
+     * @generated from field: bool enabled = 1;
+     */
+    enabled: boolean;
+    constructor(data?: PartialMessage<FeaturePhonebook>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FeaturePhonebook";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeaturePhonebook;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeaturePhonebook;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeaturePhonebook;
+    static equals(a: FeaturePhonebook | PlainMessage<FeaturePhonebook> | undefined, b: FeaturePhonebook | PlainMessage<FeaturePhonebook> | undefined): boolean;
+}
+/**
+ * AgentInfo is the agent block of the view (identity + live presence + caps).
+ *
+ * @generated from message babelconnect.v1.AgentInfo
+ */
+export declare class AgentInfo extends Message<AgentInfo> {
+    /**
+     * Agent UUID (hyphen-normalized)
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * @generated from field: string number = 3;
+     */
+    number: string;
+    /**
+     * @generated from field: babelconnect.v1.AgentState presence = 4;
+     */
+    presence: AgentState;
+    /**
+     * @generated from field: bool webrtc_enabled = 5;
+     */
+    webrtcEnabled: boolean;
+    /**
+     * currently selected outbound number
+     *
+     * @generated from field: string display_as = 6;
+     */
+    displayAs: string;
+    /**
+     * @generated from field: repeated string available_numbers = 7;
+     */
+    availableNumbers: string[];
+    /**
+     * @generated from field: bool can_record = 8;
+     */
+    canRecord: boolean;
+    /**
+     * Presence selector: the options the agent may switch to (AVAILABLE plus any
+     * configured pause reasons), and the current presence's exact name+label. The
+     * `presence` enum above stays the coarse bucket for icons/colors; these carry
+     * the precise presence name+label the client renders + selects.
+     *
+     * @generated from field: repeated babelconnect.v1.PresenceOption presence_options = 9;
+     */
+    presenceOptions: PresenceOption[];
+    /**
+     * current presence name, e.g. "available", "break"
+     *
+     * @generated from field: string presence_name = 10;
+     */
+    presenceName: string;
+    /**
+     * current presence label, e.g. "Available", "Break"
+     *
+     * @generated from field: string presence_label = 11;
+     */
+    presenceLabel: string;
+    /**
+     * recording tags the agent may apply
+     *
+     * @generated from field: repeated string available_tags = 12;
+     */
+    availableTags: string[];
+    /**
+     * dial-from contacts + recent numbers
+     *
+     * @generated from field: repeated babelconnect.v1.PhonebookEntry phonebook = 13;
+     */
+    phonebook: PhonebookEntry[];
+    /**
+     * account records every outbound automatically
+     *
+     * @generated from field: bool always_record_outbound = 14;
+     */
+    alwaysRecordOutbound: boolean;
+    /**
+     * Identity for the shell/Status surface (resolved at auth, no extra fetch).
+     *
+     * login / email
+     *
+     * @generated from field: string username = 15;
+     */
+    username: string;
+    /**
+     * customer / account id
+     *
+     * @generated from field: string account_id = 16;
+     */
+    accountId: string;
+    /**
+     * account / company display name, when known
+     *
+     * @generated from field: string account_name = 17;
+     */
+    accountName: string;
+    constructor(data?: PartialMessage<AgentInfo>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.AgentInfo";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AgentInfo;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AgentInfo;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentInfo;
+    static equals(a: AgentInfo | PlainMessage<AgentInfo> | undefined, b: AgentInfo | PlainMessage<AgentInfo> | undefined): boolean;
+}
+/**
+ * PhonebookEntry is one dialable contact (or a recent number) for the dialer's
+ * autocomplete.
+ *
+ * @generated from message babelconnect.v1.PhonebookEntry
+ */
+export declare class PhonebookEntry extends Message<PhonebookEntry> {
+    /**
+     * contact name, or "recent" for a recently dialed number
+     *
+     * @generated from field: string label = 1;
+     */
+    label: string;
+    /**
+     * @generated from field: string number = 2;
+     */
+    number: string;
+    constructor(data?: PartialMessage<PhonebookEntry>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.PhonebookEntry";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PhonebookEntry;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PhonebookEntry;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PhonebookEntry;
+    static equals(a: PhonebookEntry | PlainMessage<PhonebookEntry> | undefined, b: PhonebookEntry | PlainMessage<PhonebookEntry> | undefined): boolean;
+}
+/**
+ * PhonebookRequest / PhonebookResponse re-pull the agent's merged contacts +
+ * recent numbers on demand (refresh). `query` filters by label/number server-side.
+ *
+ * @generated from message babelconnect.v1.PhonebookRequest
+ */
+export declare class PhonebookRequest extends Message<PhonebookRequest> {
+    /**
+     * page size (default 200)
+     *
+     * @generated from field: int32 max = 1;
+     */
+    max: number;
+    /**
+     * 1-based page (default 1)
+     *
+     * @generated from field: int32 page = 2;
+     */
+    page: number;
+    /**
+     * optional label/number filter
+     *
+     * @generated from field: string query = 3;
+     */
+    query: string;
+    constructor(data?: PartialMessage<PhonebookRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.PhonebookRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PhonebookRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PhonebookRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PhonebookRequest;
+    static equals(a: PhonebookRequest | PlainMessage<PhonebookRequest> | undefined, b: PhonebookRequest | PlainMessage<PhonebookRequest> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.PhonebookResponse
+ */
+export declare class PhonebookResponse extends Message<PhonebookResponse> {
+    /**
+     * @generated from field: repeated babelconnect.v1.PhonebookEntry entries = 1;
+     */
+    entries: PhonebookEntry[];
+    constructor(data?: PartialMessage<PhonebookResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.PhonebookResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PhonebookResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PhonebookResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PhonebookResponse;
+    static equals(a: PhonebookResponse | PlainMessage<PhonebookResponse> | undefined, b: PhonebookResponse | PlainMessage<PhonebookResponse> | undefined): boolean;
+}
+/**
+ * PresenceOption is one selectable agent presence — "Available" or a configured
+ * pause reason. `available` is whether the agent can receive calls in it.
+ *
+ * @generated from message babelconnect.v1.PresenceOption
+ */
+export declare class PresenceOption extends Message<PresenceOption> {
+    /**
+     * e.g. "available", "break"
+     *
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    /**
+     * e.g. "Available", "Break"
+     *
+     * @generated from field: string label = 2;
+     */
+    label: string;
+    /**
+     * @generated from field: bool available = 3;
+     */
+    available: boolean;
+    constructor(data?: PartialMessage<PresenceOption>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.PresenceOption";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PresenceOption;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PresenceOption;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PresenceOption;
+    static equals(a: PresenceOption | PlainMessage<PresenceOption> | undefined, b: PresenceOption | PlainMessage<PresenceOption> | undefined): boolean;
+}
+/**
+ * CallState is one call as the server sees it. Replace-by-id on upsert.
+ *
+ * @generated from message babelconnect.v1.CallState
+ */
+export declare class CallState extends Message<CallState> {
+    /**
+     * server call id
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: babelconnect.v1.CallDirection direction = 2;
+     */
+    direction: CallDirection;
+    /**
+     * @generated from field: babelconnect.v1.CallLifecycle state = 3;
+     */
+    state: CallLifecycle;
+    /**
+     * @generated from field: babelconnect.v1.CallSource source = 4;
+     */
+    source: CallSource;
+    /**
+     * @generated from field: string from = 5;
+     */
+    from: string;
+    /**
+     * @generated from field: string to = 6;
+     */
+    to: string;
+    /**
+     * @generated from field: string queue_name = 7;
+     */
+    queueName: string;
+    /**
+     * unix seconds when the call bridged (0 until then)
+     *
+     * @generated from field: int64 established_at = 8;
+     */
+    establishedAt: bigint;
+    /**
+     * @generated from field: bool muted = 9;
+     */
+    muted: boolean;
+    /**
+     * @generated from field: bool on_hold = 10;
+     */
+    onHold: boolean;
+    /**
+     * @generated from field: bool recording = 11;
+     */
+    recording: boolean;
+    /**
+     * @generated from field: bool anonymous = 12;
+     */
+    anonymous: boolean;
+    /**
+     * SDP offer the client answers; set while RINGING
+     *
+     * @generated from field: string webrtc_offer = 13;
+     */
+    webrtcOffer: string;
+    /**
+     * active recording id (for stop/flag/tags)
+     *
+     * @generated from field: string recording_id = 14;
+     */
+    recordingId: string;
+    /**
+     * @generated from field: repeated string recording_tags = 15;
+     */
+    recordingTags: string[];
+    /**
+     * @generated from field: bool recording_flagged = 16;
+     */
+    recordingFlagged: boolean;
+    /**
+     * STUN/TURN servers the client applies; for off-host NAT traversal
+     *
+     * @generated from field: repeated babelconnect.v1.IceServer ice_servers = 17;
+     */
+    iceServers: IceServer[];
+    constructor(data?: PartialMessage<CallState>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.CallState";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CallState;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CallState;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CallState;
+    static equals(a: CallState | PlainMessage<CallState> | undefined, b: CallState | PlainMessage<CallState> | undefined): boolean;
+}
+/**
+ * IceServer is a STUN/TURN server the client applies to its WebRTC peer
+ * connection (RTCIceServer shape). Carried on CallState so an off-host client
+ * (e.g. a phone) can relay media through TURN when it can't reach the server's
+ * host ICE candidates. Empty in the in-cluster/LAN case.
+ *
+ * @generated from message babelconnect.v1.IceServer
+ */
+export declare class IceServer extends Message<IceServer> {
+    /**
+     * e.g. ["turn:host:3478?transport=tcp"]
+     *
+     * @generated from field: repeated string urls = 1;
+     */
+    urls: string[];
+    /**
+     * @generated from field: string username = 2;
+     */
+    username: string;
+    /**
+     * @generated from field: string credential = 3;
+     */
+    credential: string;
+    constructor(data?: PartialMessage<IceServer>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.IceServer";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): IceServer;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): IceServer;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): IceServer;
+    static equals(a: IceServer | PlainMessage<IceServer> | undefined, b: IceServer | PlainMessage<IceServer> | undefined): boolean;
+}
+/**
+ * WrapUpStatus is the after-call-work countdown.
+ *
+ * @generated from message babelconnect.v1.WrapUpStatus
+ */
+export declare class WrapUpStatus extends Message<WrapUpStatus> {
+    /**
+     * @generated from field: bool active = 1;
+     */
+    active: boolean;
+    /**
+     * @generated from field: int32 remaining_seconds = 2;
+     */
+    remainingSeconds: number;
+    /**
+     * @generated from field: string last_call_type = 3;
+     */
+    lastCallType: string;
+    /**
+     * @generated from field: bool can_cancel = 4;
+     */
+    canCancel: boolean;
+    /**
+     * @generated from field: bool can_extend = 5;
+     */
+    canExtend: boolean;
+    constructor(data?: PartialMessage<WrapUpStatus>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.WrapUpStatus";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WrapUpStatus;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WrapUpStatus;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WrapUpStatus;
+    static equals(a: WrapUpStatus | PlainMessage<WrapUpStatus> | undefined, b: WrapUpStatus | PlainMessage<WrapUpStatus> | undefined): boolean;
+}
+/**
+ * StateUpdate is the single server → client message on the Session stream. On
+ * open the client receives a snapshot; thereafter partial patches. `seq` is
+ * monotonic across snapshot+patch — a gap means the client should resubscribe
+ * for a fresh snapshot. `error` is an out-of-band notice (command rejection /
+ * server warning) and does NOT advance `seq`.
+ *
+ * @generated from message babelconnect.v1.StateUpdate
+ */
+export declare class StateUpdate extends Message<StateUpdate> {
+    /**
+     * @generated from field: uint64 seq = 1;
+     */
+    seq: bigint;
+    /**
+     * @generated from oneof babelconnect.v1.StateUpdate.update
+     */
+    update: {
+        /**
+         * @generated from field: babelconnect.v1.AgentView snapshot = 2;
+         */
+        value: AgentView;
+        case: "snapshot";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.Patch patch = 3;
+         */
+        value: Patch;
+        case: "patch";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.Error error = 4;
+         */
+        value: Error;
+        case: "error";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<StateUpdate>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.StateUpdate";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StateUpdate;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StateUpdate;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StateUpdate;
+    static equals(a: StateUpdate | PlainMessage<StateUpdate> | undefined, b: StateUpdate | PlainMessage<StateUpdate> | undefined): boolean;
+}
+/**
+ * Patch is an entity-level delta applied mechanically by the client cache:
+ * replace the agent block, upsert/remove a call by id, or set wrap-up.
+ *
+ * @generated from message babelconnect.v1.Patch
+ */
+export declare class Patch extends Message<Patch> {
+    /**
+     * @generated from oneof babelconnect.v1.Patch.change
+     */
+    change: {
+        /**
+         * @generated from field: babelconnect.v1.AgentInfo agent = 1;
+         */
+        value: AgentInfo;
+        case: "agent";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.CallState call_upsert = 2;
+         */
+        value: CallState;
+        case: "callUpsert";
+    } | {
+        /**
+         * call id to drop
+         *
+         * @generated from field: string call_remove = 3;
+         */
+        value: string;
+        case: "callRemove";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.WrapUpStatus wrap_up = 4;
+         */
+        value: WrapUpStatus;
+        case: "wrapUp";
+    } | {
+        /**
+         * transient CTI screen-pop (not part of the view)
+         *
+         * @generated from field: babelconnect.v1.Notification notification = 5;
+         */
+        value: Notification;
+        case: "notification";
+    } | {
+        /**
+         * upsert an SMS thread summary by id
+         *
+         * @generated from field: babelconnect.v1.SmsConversation sms_upsert = 6;
+         */
+        value: SmsConversation;
+        case: "smsUpsert";
+    } | {
+        /**
+         * SMS conversation id to drop
+         *
+         * @generated from field: string sms_remove = 7;
+         */
+        value: string;
+        case: "smsRemove";
+    } | {
+        /**
+         * upsert a conference by id
+         *
+         * @generated from field: babelconnect.v1.Conference conference_upsert = 8;
+         */
+        value: Conference;
+        case: "conferenceUpsert";
+    } | {
+        /**
+         * conference id to drop (finished/left)
+         *
+         * @generated from field: string conference_remove = 9;
+         */
+        value: string;
+        case: "conferenceRemove";
+    } | {
+        /**
+         * resolved feature config (emitted on register)
+         *
+         * @generated from field: babelconnect.v1.AppConfig config = 10;
+         */
+        value: AppConfig;
+        case: "config";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<Patch>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Patch";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Patch;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Patch;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Patch;
+    static equals(a: Patch | PlainMessage<Patch> | undefined, b: Patch | PlainMessage<Patch> | undefined): boolean;
+}
+/**
+ * Notification is a transient one-shot the client surfaces (a CTI screen-pop /
+ * pushed agent data). It is NOT stored in the AgentView snapshot — it fires once.
+ *
+ * @generated from message babelconnect.v1.Notification
+ */
+export declare class Notification extends Message<Notification> {
+    /**
+     * e.g. "cti.message"
+     *
+     * @generated from field: string kind = 1;
+     */
+    kind: string;
+    /**
+     * @generated from field: string title = 2;
+     */
+    title: string;
+    /**
+     * @generated from field: string body = 3;
+     */
+    body: string;
+    /**
+     * arbitrary pushed payload, JSON-encoded
+     *
+     * @generated from field: string data_json = 4;
+     */
+    dataJson: string;
+    /**
+     * @generated from field: int64 ts = 5;
+     */
+    ts: bigint;
+    constructor(data?: PartialMessage<Notification>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Notification";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Notification;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Notification;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Notification;
+    static equals(a: Notification | PlainMessage<Notification> | undefined, b: Notification | PlainMessage<Notification> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Error
+ */
+export declare class Error extends Message<Error> {
+    /**
+     * @generated from field: string code = 1;
+     */
+    code: string;
+    /**
+     * @generated from field: string message = 2;
+     */
+    message: string;
+    /**
+     * optional: the call the rejected command targeted
+     *
+     * @generated from field: string call_id = 3;
+     */
+    callId: string;
+    constructor(data?: PartialMessage<Error>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Error";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Error;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Error;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Error;
+    static equals(a: Error | PlainMessage<Error> | undefined, b: Error | PlainMessage<Error> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Command
+ */
+export declare class Command extends Message<Command> {
+    /**
+     * @generated from oneof babelconnect.v1.Command.command
+     */
+    command: {
+        /**
+         * announce reachability for this session
+         *
+         * @generated from field: babelconnect.v1.Register register = 1;
+         */
+        value: Register;
+        case: "register";
+    } | {
+        /**
+         * place an outbound call
+         *
+         * @generated from field: babelconnect.v1.PlaceCall place_call = 2;
+         */
+        value: PlaceCall;
+        case: "placeCall";
+    } | {
+        /**
+         * SDP answer to a RINGING CallState
+         *
+         * @generated from field: babelconnect.v1.AnswerCall answer = 3;
+         */
+        value: AnswerCall;
+        case: "answer";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.Hangup hangup = 4;
+         */
+        value: Hangup;
+        case: "hangup";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.Mute mute = 5;
+         */
+        value: Mute;
+        case: "mute";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.Hold hold = 6;
+         */
+        value: Hold;
+        case: "hold";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.SendDigits dtmf = 7;
+         */
+        value: SendDigits;
+        case: "dtmf";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.SetDisplayAs set_display_as = 8;
+         */
+        value: SetDisplayAs;
+        case: "setDisplayAs";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.Transfer transfer = 9;
+         */
+        value: Transfer;
+        case: "transfer";
+    } | {
+        /**
+         * switch the agent's presence (selector)
+         *
+         * @generated from field: babelconnect.v1.SetPresence set_presence = 10;
+         */
+        value: SetPresence;
+        case: "setPresence";
+    } | {
+        /**
+         * add time to the after-call-work countdown
+         *
+         * @generated from field: babelconnect.v1.WrapUpExtend wrap_up_extend = 11;
+         */
+        value: WrapUpExtend;
+        case: "wrapUpExtend";
+    } | {
+        /**
+         * end after-call-work early
+         *
+         * @generated from field: babelconnect.v1.WrapUpCancel wrap_up_cancel = 12;
+         */
+        value: WrapUpCancel;
+        case: "wrapUpCancel";
+    } | {
+        /**
+         * clear a blocked line (busy/unreachable)
+         *
+         * @generated from field: babelconnect.v1.ResetLineStatus reset_line_status = 13;
+         */
+        value: ResetLineStatus;
+        case: "resetLineStatus";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.StartRecording start_recording = 14;
+         */
+        value: StartRecording;
+        case: "startRecording";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.StopRecording stop_recording = 15;
+         */
+        value: StopRecording;
+        case: "stopRecording";
+    } | {
+        /**
+         * toggle the "flagged" tag on the recording
+         *
+         * @generated from field: babelconnect.v1.FlagRecording flag_recording = 16;
+         */
+        value: FlagRecording;
+        case: "flagRecording";
+    } | {
+        /**
+         * @generated from field: babelconnect.v1.SetRecordingTags set_recording_tags = 17;
+         */
+        value: SetRecordingTags;
+        case: "setRecordingTags";
+    } | {
+        /**
+         * browser phone (webrtc) on/off
+         *
+         * @generated from field: babelconnect.v1.SetWebrtc set_webrtc = 18;
+         */
+        value: SetWebrtc;
+        case: "setWebrtc";
+    } | {
+        /**
+         * the external-telephone number to bridge to
+         *
+         * @generated from field: babelconnect.v1.SetAgentNumber set_agent_number = 19;
+         */
+        value: SetAgentNumber;
+        case: "setAgentNumber";
+    } | {
+        /**
+         * send an SMS (same as the SendSms RPC)
+         *
+         * @generated from field: babelconnect.v1.SendSmsRequest send_sms = 20;
+         */
+        value: SendSmsRequest;
+        case: "sendSms";
+    } | {
+        /**
+         * open a conference around the current call
+         *
+         * @generated from field: babelconnect.v1.StartConference start_conference = 21;
+         */
+        value: StartConference;
+        case: "startConference";
+    } | {
+        /**
+         * invite an agent or number
+         *
+         * @generated from field: babelconnect.v1.AddConferenceMember add_conference_member = 22;
+         */
+        value: AddConferenceMember;
+        case: "addConferenceMember";
+    } | {
+        /**
+         * moderator removes a member
+         *
+         * @generated from field: babelconnect.v1.KickConferenceMember kick_conference_member = 23;
+         */
+        value: KickConferenceMember;
+        case: "kickConferenceMember";
+    } | {
+        /**
+         * moderator ends the whole conference
+         *
+         * @generated from field: babelconnect.v1.EndConference end_conference = 24;
+         */
+        value: EndConference;
+        case: "endConference";
+    } | {
+        /**
+         * hang up only my own leg
+         *
+         * @generated from field: babelconnect.v1.LeaveConference leave_conference = 25;
+         */
+        value: LeaveConference;
+        case: "leaveConference";
+    } | {
+        /**
+         * moderator holds/unholds a member
+         *
+         * @generated from field: babelconnect.v1.HoldConferenceMember hold_conference_member = 26;
+         */
+        value: HoldConferenceMember;
+        case: "holdConferenceMember";
+    } | {
+        /**
+         * moderator mutes/unmutes a member
+         *
+         * @generated from field: babelconnect.v1.MuteConferenceMember mute_conference_member = 27;
+         */
+        value: MuteConferenceMember;
+        case: "muteConferenceMember";
+    } | {
+        /**
+         * open/close (resolve) an SMS conversation
+         *
+         * @generated from field: babelconnect.v1.SetConversationOpen set_conversation_open = 28;
+         */
+        value: SetConversationOpen;
+        case: "setConversationOpen";
+    } | {
+        /**
+         * clear unread on an SMS conversation
+         *
+         * @generated from field: babelconnect.v1.MarkConversationRead mark_conversation_read = 29;
+         */
+        value: MarkConversationRead;
+        case: "markConversationRead";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<Command>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Command";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Command;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Command;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Command;
+    static equals(a: Command | PlainMessage<Command> | undefined, b: Command | PlainMessage<Command> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Register
+ */
+export declare class Register extends Message<Register> {
+    /**
+     * advisory, e.g. ["webrtc"]
+     *
+     * @generated from field: repeated string capabilities = 1;
+     */
+    capabilities: string[];
+    constructor(data?: PartialMessage<Register>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Register";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Register;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Register;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Register;
+    static equals(a: Register | PlainMessage<Register> | undefined, b: Register | PlainMessage<Register> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.PlaceCall
+ */
+export declare class PlaceCall extends Message<PlaceCall> {
+    /**
+     * @generated from field: string to = 1;
+     */
+    to: string;
+    /**
+     * service number shown to the consumer
+     *
+     * @generated from field: string display_as_to = 2;
+     */
+    displayAsTo: string;
+    /**
+     * number shown to the agent
+     *
+     * @generated from field: string display_as_from = 3;
+     */
+    displayAsFrom: string;
+    /**
+     * start recording the call from answer (recording.autostart)
+     *
+     * @generated from field: bool record = 4;
+     */
+    record: boolean;
+    /**
+     * opaque CTI/embedding correlation (from session.set)
+     *
+     * @generated from field: map<string, string> session = 5;
+     */
+    session: {
+        [key: string]: string;
+    };
+    constructor(data?: PartialMessage<PlaceCall>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.PlaceCall";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PlaceCall;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PlaceCall;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PlaceCall;
+    static equals(a: PlaceCall | PlainMessage<PlaceCall> | undefined, b: PlaceCall | PlainMessage<PlaceCall> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.AnswerCall
+ */
+export declare class AnswerCall extends Message<AnswerCall> {
+    /**
+     * the RINGING call's id
+     *
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    /**
+     * WebRTC SDP answer
+     *
+     * @generated from field: string sdp = 2;
+     */
+    sdp: string;
+    constructor(data?: PartialMessage<AnswerCall>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.AnswerCall";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AnswerCall;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AnswerCall;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AnswerCall;
+    static equals(a: AnswerCall | PlainMessage<AnswerCall> | undefined, b: AnswerCall | PlainMessage<AnswerCall> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Hangup
+ */
+export declare class Hangup extends Message<Hangup> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    constructor(data?: PartialMessage<Hangup>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Hangup";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Hangup;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Hangup;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Hangup;
+    static equals(a: Hangup | PlainMessage<Hangup> | undefined, b: Hangup | PlainMessage<Hangup> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Mute
+ */
+export declare class Mute extends Message<Mute> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    /**
+     * @generated from field: bool on = 2;
+     */
+    on: boolean;
+    constructor(data?: PartialMessage<Mute>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Mute";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Mute;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Mute;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Mute;
+    static equals(a: Mute | PlainMessage<Mute> | undefined, b: Mute | PlainMessage<Mute> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.Hold
+ */
+export declare class Hold extends Message<Hold> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    /**
+     * @generated from field: bool on = 2;
+     */
+    on: boolean;
+    constructor(data?: PartialMessage<Hold>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Hold";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Hold;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Hold;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Hold;
+    static equals(a: Hold | PlainMessage<Hold> | undefined, b: Hold | PlainMessage<Hold> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.SendDigits
+ */
+export declare class SendDigits extends Message<SendDigits> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    /**
+     * DTMF, e.g. "1", "#"
+     *
+     * @generated from field: string digits = 2;
+     */
+    digits: string;
+    constructor(data?: PartialMessage<SendDigits>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SendDigits";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendDigits;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendDigits;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendDigits;
+    static equals(a: SendDigits | PlainMessage<SendDigits> | undefined, b: SendDigits | PlainMessage<SendDigits> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.SetDisplayAs
+ */
+export declare class SetDisplayAs extends Message<SetDisplayAs> {
+    /**
+     * outbound number to present
+     *
+     * @generated from field: string number = 1;
+     */
+    number: string;
+    constructor(data?: PartialMessage<SetDisplayAs>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SetDisplayAs";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetDisplayAs;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetDisplayAs;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetDisplayAs;
+    static equals(a: SetDisplayAs | PlainMessage<SetDisplayAs> | undefined, b: SetDisplayAs | PlainMessage<SetDisplayAs> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.SetPresence
+ */
+export declare class SetPresence extends Message<SetPresence> {
+    /**
+     * presence to switch to, e.g. "available" or a pause reason
+     *
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    constructor(data?: PartialMessage<SetPresence>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SetPresence";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetPresence;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetPresence;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetPresence;
+    static equals(a: SetPresence | PlainMessage<SetPresence> | undefined, b: SetPresence | PlainMessage<SetPresence> | undefined): boolean;
+}
+/**
+ * Transfer hands the current call to a target. Exactly one target is set:
+ * `to` (external number), `agent_id` (another agent), or `application_id` (a
+ * queue/voice application). `warm` selects attended (consult-then-drop) vs
+ * blind/cold (single action).
+ *
+ * @generated from message babelconnect.v1.Transfer
+ */
+export declare class Transfer extends Message<Transfer> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    /**
+     * external number target
+     *
+     * @generated from field: string to = 2;
+     */
+    to: string;
+    /**
+     * true = attended/warm, false = blind/cold
+     *
+     * @generated from field: bool warm = 3;
+     */
+    warm: boolean;
+    /**
+     * transfer to another agent
+     *
+     * @generated from field: string agent_id = 4;
+     */
+    agentId: string;
+    /**
+     * transfer to a queue / voice application
+     *
+     * @generated from field: string application_id = 5;
+     */
+    applicationId: string;
+    constructor(data?: PartialMessage<Transfer>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Transfer";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Transfer;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Transfer;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Transfer;
+    static equals(a: Transfer | PlainMessage<Transfer> | undefined, b: Transfer | PlainMessage<Transfer> | undefined): boolean;
+}
+/**
+ * WrapUpExtend adds time to the agent's after-call-work countdown.
+ *
+ * @generated from message babelconnect.v1.WrapUpExtend
+ */
+export declare class WrapUpExtend extends Message<WrapUpExtend> {
+    /**
+     * extra wrap-up seconds to add (e.g. 30)
+     *
+     * @generated from field: int32 seconds = 1;
+     */
+    seconds: number;
+    constructor(data?: PartialMessage<WrapUpExtend>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.WrapUpExtend";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WrapUpExtend;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WrapUpExtend;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WrapUpExtend;
+    static equals(a: WrapUpExtend | PlainMessage<WrapUpExtend> | undefined, b: WrapUpExtend | PlainMessage<WrapUpExtend> | undefined): boolean;
+}
+/**
+ * WrapUpCancel ends the agent's after-call-work early.
+ *
+ * @generated from message babelconnect.v1.WrapUpCancel
+ */
+export declare class WrapUpCancel extends Message<WrapUpCancel> {
+    constructor(data?: PartialMessage<WrapUpCancel>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.WrapUpCancel";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WrapUpCancel;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WrapUpCancel;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WrapUpCancel;
+    static equals(a: WrapUpCancel | PlainMessage<WrapUpCancel> | undefined, b: WrapUpCancel | PlainMessage<WrapUpCancel> | undefined): boolean;
+}
+/**
+ * ResetLineStatus clears a blocked line state (busy/unreachable/declined) so the
+ * agent can receive calls again.
+ *
+ * @generated from message babelconnect.v1.ResetLineStatus
+ */
+export declare class ResetLineStatus extends Message<ResetLineStatus> {
+    constructor(data?: PartialMessage<ResetLineStatus>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.ResetLineStatus";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResetLineStatus;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResetLineStatus;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResetLineStatus;
+    static equals(a: ResetLineStatus | PlainMessage<ResetLineStatus> | undefined, b: ResetLineStatus | PlainMessage<ResetLineStatus> | undefined): boolean;
+}
+/**
+ * StartRecording begins recording the given call.
+ *
+ * @generated from message babelconnect.v1.StartRecording
+ */
+export declare class StartRecording extends Message<StartRecording> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    constructor(data?: PartialMessage<StartRecording>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.StartRecording";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StartRecording;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StartRecording;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StartRecording;
+    static equals(a: StartRecording | PlainMessage<StartRecording> | undefined, b: StartRecording | PlainMessage<StartRecording> | undefined): boolean;
+}
+/**
+ * StopRecording ends the call's active recording.
+ *
+ * @generated from message babelconnect.v1.StopRecording
+ */
+export declare class StopRecording extends Message<StopRecording> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    constructor(data?: PartialMessage<StopRecording>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.StopRecording";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StopRecording;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StopRecording;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StopRecording;
+    static equals(a: StopRecording | PlainMessage<StopRecording> | undefined, b: StopRecording | PlainMessage<StopRecording> | undefined): boolean;
+}
+/**
+ * FlagRecording toggles the "flagged" mark on the call's active recording.
+ *
+ * @generated from message babelconnect.v1.FlagRecording
+ */
+export declare class FlagRecording extends Message<FlagRecording> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    constructor(data?: PartialMessage<FlagRecording>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.FlagRecording";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FlagRecording;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FlagRecording;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FlagRecording;
+    static equals(a: FlagRecording | PlainMessage<FlagRecording> | undefined, b: FlagRecording | PlainMessage<FlagRecording> | undefined): boolean;
+}
+/**
+ * SetRecordingTags replaces the tags on the call's active recording.
+ *
+ * @generated from message babelconnect.v1.SetRecordingTags
+ */
+export declare class SetRecordingTags extends Message<SetRecordingTags> {
+    /**
+     * @generated from field: string call_id = 1;
+     */
+    callId: string;
+    /**
+     * @generated from field: repeated string tags = 2;
+     */
+    tags: string[];
+    constructor(data?: PartialMessage<SetRecordingTags>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SetRecordingTags";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetRecordingTags;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetRecordingTags;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetRecordingTags;
+    static equals(a: SetRecordingTags | PlainMessage<SetRecordingTags> | undefined, b: SetRecordingTags | PlainMessage<SetRecordingTags> | undefined): boolean;
+}
+/**
+ * SetWebrtc enables or disables the browser phone (WebRTC). Off = bridge calls to
+ * the external-telephone number instead.
+ *
+ * @generated from message babelconnect.v1.SetWebrtc
+ */
+export declare class SetWebrtc extends Message<SetWebrtc> {
+    /**
+     * @generated from field: bool on = 1;
+     */
+    on: boolean;
+    constructor(data?: PartialMessage<SetWebrtc>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SetWebrtc";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetWebrtc;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetWebrtc;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetWebrtc;
+    static equals(a: SetWebrtc | PlainMessage<SetWebrtc> | undefined, b: SetWebrtc | PlainMessage<SetWebrtc> | undefined): boolean;
+}
+/**
+ * SetAgentNumber sets the external phone number the agent's calls bridge to.
+ *
+ * @generated from message babelconnect.v1.SetAgentNumber
+ */
+export declare class SetAgentNumber extends Message<SetAgentNumber> {
+    /**
+     * @generated from field: string number = 1;
+     */
+    number: string;
+    constructor(data?: PartialMessage<SetAgentNumber>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SetAgentNumber";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetAgentNumber;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetAgentNumber;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetAgentNumber;
+    static equals(a: SetAgentNumber | PlainMessage<SetAgentNumber> | undefined, b: SetAgentNumber | PlainMessage<SetAgentNumber> | undefined): boolean;
+}
+/**
+ * SmsConversation is one SMS thread summary carried in the AgentView (the full
+ * thread history is fetched on demand, not held in the snapshot). Upsert-by-id;
+ * the reducer keeps the list sorted by last_ts descending.
+ *
+ * @generated from message babelconnect.v1.SmsConversation
+ */
+export declare class SmsConversation extends Message<SmsConversation> {
+    /**
+     * conversation id
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * the other party's number
+     *
+     * @generated from field: string peer = 2;
+     */
+    peer: string;
+    /**
+     * INBOUND = received, OUTBOUND = sent
+     *
+     * @generated from field: babelconnect.v1.CallDirection last_direction = 3;
+     */
+    lastDirection: CallDirection;
+    /**
+     * latest message preview
+     *
+     * @generated from field: string last_text = 4;
+     */
+    lastText: string;
+    /**
+     * unix seconds of the latest message
+     *
+     * @generated from field: int64 last_ts = 5;
+     */
+    lastTs: bigint;
+    /**
+     * unread message count
+     *
+     * @generated from field: uint32 unread = 6;
+     */
+    unread: number;
+    /**
+     * phonebook label for the peer, if known
+     *
+     * @generated from field: string contact_label = 7;
+     */
+    contactLabel: string;
+    /**
+     * conversation open (unresolved) vs closed
+     *
+     * @generated from field: bool open = 8;
+     */
+    open: boolean;
+    constructor(data?: PartialMessage<SmsConversation>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SmsConversation";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmsConversation;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmsConversation;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmsConversation;
+    static equals(a: SmsConversation | PlainMessage<SmsConversation> | undefined, b: SmsConversation | PlainMessage<SmsConversation> | undefined): boolean;
+}
+/**
+ * SendSmsRequest sends an SMS. `from` defaults to the agent's SMS-capable number
+ * when empty. `session` carries opaque
+ * CTI/embedding correlation keys (e.g. from session.set), like PlaceCall.
+ *
+ * @generated from message babelconnect.v1.SendSmsRequest
+ */
+export declare class SendSmsRequest extends Message<SendSmsRequest> {
+    /**
+     * @generated from field: string to = 1;
+     */
+    to: string;
+    /**
+     * @generated from field: string text = 2;
+     */
+    text: string;
+    /**
+     * @generated from field: string from = 3;
+     */
+    from: string;
+    /**
+     * @generated from field: map<string, string> session = 4;
+     */
+    session: {
+        [key: string]: string;
+    };
+    constructor(data?: PartialMessage<SendSmsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SendSmsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SendSmsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SendSmsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SendSmsRequest;
+    static equals(a: SendSmsRequest | PlainMessage<SendSmsRequest> | undefined, b: SendSmsRequest | PlainMessage<SendSmsRequest> | undefined): boolean;
+}
+/**
+ * SmsMessage is one message inside a conversation thread, fetched on demand via
+ * GetSmsThread (the AgentView only carries the lightweight SmsConversation
+ * summary, not the full history). Oldest-first; the client bubbles it by
+ * direction. `state` is the message status (received/sent/delivered/failed/
+ * scheduled) for display only.
+ *
+ * @generated from message babelconnect.v1.SmsMessage
+ */
+export declare class SmsMessage extends Message<SmsMessage> {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * INBOUND = received, OUTBOUND = sent
+     *
+     * @generated from field: babelconnect.v1.CallDirection direction = 2;
+     */
+    direction: CallDirection;
+    /**
+     * @generated from field: string from = 3;
+     */
+    from: string;
+    /**
+     * @generated from field: string to = 4;
+     */
+    to: string;
+    /**
+     * @generated from field: string text = 5;
+     */
+    text: string;
+    /**
+     * unix seconds (dateCreated)
+     *
+     * @generated from field: int64 ts = 6;
+     */
+    ts: bigint;
+    /**
+     * received/sent/delivered/failed/scheduled (display only)
+     *
+     * @generated from field: string state = 7;
+     */
+    state: string;
+    constructor(data?: PartialMessage<SmsMessage>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SmsMessage";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmsMessage;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmsMessage;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmsMessage;
+    static equals(a: SmsMessage | PlainMessage<SmsMessage> | undefined, b: SmsMessage | PlainMessage<SmsMessage> | undefined): boolean;
+}
+/**
+ * SmsThreadRequest / SmsThreadResponse page the messages of one SMS conversation.
+ *
+ * @generated from message babelconnect.v1.SmsThreadRequest
+ */
+export declare class SmsThreadRequest extends Message<SmsThreadRequest> {
+    /**
+     * @generated from field: string conversation_id = 1;
+     */
+    conversationId: string;
+    /**
+     * page size (default 50)
+     *
+     * @generated from field: int32 max = 2;
+     */
+    max: number;
+    /**
+     * 1-based page (default 1)
+     *
+     * @generated from field: int32 page = 3;
+     */
+    page: number;
+    constructor(data?: PartialMessage<SmsThreadRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SmsThreadRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmsThreadRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmsThreadRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmsThreadRequest;
+    static equals(a: SmsThreadRequest | PlainMessage<SmsThreadRequest> | undefined, b: SmsThreadRequest | PlainMessage<SmsThreadRequest> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.SmsThreadResponse
+ */
+export declare class SmsThreadResponse extends Message<SmsThreadResponse> {
+    /**
+     * @generated from field: repeated babelconnect.v1.SmsMessage messages = 1;
+     */
+    messages: SmsMessage[];
+    constructor(data?: PartialMessage<SmsThreadResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SmsThreadResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SmsThreadResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SmsThreadResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SmsThreadResponse;
+    static equals(a: SmsThreadResponse | PlainMessage<SmsThreadResponse> | undefined, b: SmsThreadResponse | PlainMessage<SmsThreadResponse> | undefined): boolean;
+}
+/**
+ * SetConversationOpen opens (reopens) or closes (resolves) an SMS conversation.
+ * The server flips SmsConversation.open optimistically and re-confirms.
+ *
+ * @generated from message babelconnect.v1.SetConversationOpen
+ */
+export declare class SetConversationOpen extends Message<SetConversationOpen> {
+    /**
+     * @generated from field: string conversation_id = 1;
+     */
+    conversationId: string;
+    /**
+     * @generated from field: bool open = 2;
+     */
+    open: boolean;
+    constructor(data?: PartialMessage<SetConversationOpen>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.SetConversationOpen";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): SetConversationOpen;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): SetConversationOpen;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetConversationOpen;
+    static equals(a: SetConversationOpen | PlainMessage<SetConversationOpen> | undefined, b: SetConversationOpen | PlainMessage<SetConversationOpen> | undefined): boolean;
+}
+/**
+ * MarkConversationRead clears the unread count on an SMS conversation (the agent
+ * opened its thread).
+ *
+ * @generated from message babelconnect.v1.MarkConversationRead
+ */
+export declare class MarkConversationRead extends Message<MarkConversationRead> {
+    /**
+     * @generated from field: string conversation_id = 1;
+     */
+    conversationId: string;
+    constructor(data?: PartialMessage<MarkConversationRead>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.MarkConversationRead";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MarkConversationRead;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MarkConversationRead;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MarkConversationRead;
+    static equals(a: MarkConversationRead | PlainMessage<MarkConversationRead> | undefined, b: MarkConversationRead | PlainMessage<MarkConversationRead> | undefined): boolean;
+}
+/**
+ * Conference is one multi-party call the agent is in. The server folds multi-party
+ * call updates into this entity and emits conference_upsert/remove patches. The
+ * client is a dumb renderer that shows the participant panel and sends conference
+ * intents. Usually 0 or 1 per agent. Upsert-by-id; removed when the conference
+ * finishes or the agent's own member leaves.
+ *
+ * @generated from message babelconnect.v1.Conference
+ */
+export declare class Conference extends Message<Conference> {
+    /**
+     * conference id
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * created|finishing|finished
+     *
+     * @generated from field: string state = 2;
+     */
+    state: string;
+    /**
+     * all members incl. the moderator and me
+     *
+     * @generated from field: repeated babelconnect.v1.ConferenceMember members = 3;
+     */
+    members: ConferenceMember[];
+    /**
+     * resolved server-side: is this agent the moderator?
+     *
+     * @generated from field: bool i_am_moderator = 4;
+     */
+    iAmModerator: boolean;
+    /**
+     * the agent's own member id (used for Leave)
+     *
+     * @generated from field: string my_member_id = 5;
+     */
+    myMemberId: string;
+    constructor(data?: PartialMessage<Conference>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Conference";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Conference;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Conference;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Conference;
+    static equals(a: Conference | PlainMessage<Conference> | undefined, b: Conference | PlainMessage<Conference> | undefined): boolean;
+}
+/**
+ * ConferenceMember is one participant. `display` is the resolved label (agent
+ * name, else the caller/dialed number, else "Anonymous"). `state` drives the UI:
+ * pending = ringing, added = live, removing/removed/failed = gone (clients filter
+ * removed/failed out of the participant list).
+ *
+ * @generated from message babelconnect.v1.ConferenceMember
+ */
+export declare class ConferenceMember extends Message<ConferenceMember> {
+    /**
+     * member id
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * pending|added|removing|removed|failed
+     *
+     * @generated from field: string state = 2;
+     */
+    state: string;
+    /**
+     * resolved participant label
+     *
+     * @generated from field: string display = 3;
+     */
+    display: string;
+    /**
+     * this member is the conference moderator
+     *
+     * @generated from field: bool moderator = 4;
+     */
+    moderator: boolean;
+    /**
+     * this member is the current agent
+     *
+     * @generated from field: bool is_me = 5;
+     */
+    isMe: boolean;
+    /**
+     * the member's call leg id
+     *
+     * @generated from field: string call_id = 6;
+     */
+    callId: string;
+    /**
+     * member is on hold
+     *
+     * @generated from field: bool on_hold = 7;
+     */
+    onHold: boolean;
+    /**
+     * agent UUID when the member is an agent
+     *
+     * @generated from field: string agent_id = 8;
+     */
+    agentId: string;
+    /**
+     * phone number when the member is an external party
+     *
+     * @generated from field: string number = 9;
+     */
+    number: string;
+    constructor(data?: PartialMessage<ConferenceMember>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.ConferenceMember";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ConferenceMember;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ConferenceMember;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ConferenceMember;
+    static equals(a: ConferenceMember | PlainMessage<ConferenceMember> | undefined, b: ConferenceMember | PlainMessage<ConferenceMember> | undefined): boolean;
+}
+/**
+ * StartConference opens a conference around the agent's current call. `hold` puts
+ * the existing party on hold while the first new member is dialed.
+ *
+ * @generated from message babelconnect.v1.StartConference
+ */
+export declare class StartConference extends Message<StartConference> {
+    /**
+     * @generated from field: bool hold = 1;
+     */
+    hold: boolean;
+    constructor(data?: PartialMessage<StartConference>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.StartConference";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): StartConference;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): StartConference;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): StartConference;
+    static equals(a: StartConference | PlainMessage<StartConference> | undefined, b: StartConference | PlainMessage<StartConference> | undefined): boolean;
+}
+/**
+ * AddConferenceMember invites a participant — exactly one of agent_id / number.
+ * Starts a conference first if none is active.
+ *
+ * @generated from message babelconnect.v1.AddConferenceMember
+ */
+export declare class AddConferenceMember extends Message<AddConferenceMember> {
+    /**
+     * @generated from field: string agent_id = 1;
+     */
+    agentId: string;
+    /**
+     * @generated from field: string number = 2;
+     */
+    number: string;
+    constructor(data?: PartialMessage<AddConferenceMember>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.AddConferenceMember";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AddConferenceMember;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AddConferenceMember;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AddConferenceMember;
+    static equals(a: AddConferenceMember | PlainMessage<AddConferenceMember> | undefined, b: AddConferenceMember | PlainMessage<AddConferenceMember> | undefined): boolean;
+}
+/**
+ * KickConferenceMember removes a member from the conference (moderator only).
+ *
+ * @generated from message babelconnect.v1.KickConferenceMember
+ */
+export declare class KickConferenceMember extends Message<KickConferenceMember> {
+    /**
+     * @generated from field: string member_id = 1;
+     */
+    memberId: string;
+    constructor(data?: PartialMessage<KickConferenceMember>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.KickConferenceMember";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): KickConferenceMember;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): KickConferenceMember;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): KickConferenceMember;
+    static equals(a: KickConferenceMember | PlainMessage<KickConferenceMember> | undefined, b: KickConferenceMember | PlainMessage<KickConferenceMember> | undefined): boolean;
+}
+/**
+ * EndConference tears down the whole conference (moderator only).
+ *
+ * @generated from message babelconnect.v1.EndConference
+ */
+export declare class EndConference extends Message<EndConference> {
+    constructor(data?: PartialMessage<EndConference>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.EndConference";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EndConference;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EndConference;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EndConference;
+    static equals(a: EndConference | PlainMessage<EndConference> | undefined, b: EndConference | PlainMessage<EndConference> | undefined): boolean;
+}
+/**
+ * LeaveConference hangs up only the agent's own leg; the others stay connected.
+ *
+ * @generated from message babelconnect.v1.LeaveConference
+ */
+export declare class LeaveConference extends Message<LeaveConference> {
+    constructor(data?: PartialMessage<LeaveConference>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.LeaveConference";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LeaveConference;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LeaveConference;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LeaveConference;
+    static equals(a: LeaveConference | PlainMessage<LeaveConference> | undefined, b: LeaveConference | PlainMessage<LeaveConference> | undefined): boolean;
+}
+/**
+ * HoldConferenceMember holds or unholds an individual member (moderator only).
+ *
+ * @generated from message babelconnect.v1.HoldConferenceMember
+ */
+export declare class HoldConferenceMember extends Message<HoldConferenceMember> {
+    /**
+     * @generated from field: string member_id = 1;
+     */
+    memberId: string;
+    /**
+     * @generated from field: bool on = 2;
+     */
+    on: boolean;
+    constructor(data?: PartialMessage<HoldConferenceMember>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.HoldConferenceMember";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): HoldConferenceMember;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): HoldConferenceMember;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): HoldConferenceMember;
+    static equals(a: HoldConferenceMember | PlainMessage<HoldConferenceMember> | undefined, b: HoldConferenceMember | PlainMessage<HoldConferenceMember> | undefined): boolean;
+}
+/**
+ * MuteConferenceMember mutes or unmutes an individual member (moderator only).
+ *
+ * @generated from message babelconnect.v1.MuteConferenceMember
+ */
+export declare class MuteConferenceMember extends Message<MuteConferenceMember> {
+    /**
+     * @generated from field: string member_id = 1;
+     */
+    memberId: string;
+    /**
+     * @generated from field: bool on = 2;
+     */
+    on: boolean;
+    constructor(data?: PartialMessage<MuteConferenceMember>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.MuteConferenceMember";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): MuteConferenceMember;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): MuteConferenceMember;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): MuteConferenceMember;
+    static equals(a: MuteConferenceMember | PlainMessage<MuteConferenceMember> | undefined, b: MuteConferenceMember | PlainMessage<MuteConferenceMember> | undefined): boolean;
+}