@babelforce/babelconnect-sdk 0.10.0 → 0.12.0

package/dist/gen/babelconnect/v1/babelconnect_pb.js

@@ -52,6 +52,93 @@ proto3.util.setEnumType(AgentState, "babelconnect.v1.AgentState", [
     { no: 6, name: "AGENT_STATE_RINGING" },
     { no: 7, name: "AGENT_STATE_BUSY" },
 ]);
+/**
+ * CampaignMemberState mirrors the backend's AgentStatus.Status enum exactly
+ * (sbf/services AgentStatus.groovy) — the predictive-dialer campaign
+ * membership lifecycle: offline -> logging_in -> waiting -> in_progress ->
+ * disposition (-> waiting for the next lead), with idle as the paused branch
+ * (waiting/logging_in <-> idle via pause/resume) and leave returning to
+ * offline from any state.
+ *
+ * @generated from enum babelconnect.v1.CampaignMemberState
+ */
+export var CampaignMemberState;
+(function (CampaignMemberState) {
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_UNSPECIFIED = 0;
+     */
+    CampaignMemberState[CampaignMemberState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_OFFLINE = 1;
+     */
+    CampaignMemberState[CampaignMemberState["OFFLINE"] = 1] = "OFFLINE";
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_LOGGING_IN = 2;
+     */
+    CampaignMemberState[CampaignMemberState["LOGGING_IN"] = 2] = "LOGGING_IN";
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_WAITING = 3;
+     */
+    CampaignMemberState[CampaignMemberState["WAITING"] = 3] = "WAITING";
+    /**
+     * paused
+     *
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_IDLE = 4;
+     */
+    CampaignMemberState[CampaignMemberState["IDLE"] = 4] = "IDLE";
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_IN_PROGRESS = 5;
+     */
+    CampaignMemberState[CampaignMemberState["IN_PROGRESS"] = 5] = "IN_PROGRESS";
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_DISPOSITION = 6;
+     */
+    CampaignMemberState[CampaignMemberState["DISPOSITION"] = 6] = "DISPOSITION";
+})(CampaignMemberState || (CampaignMemberState = {}));
+// Retrieve enum metadata with: proto3.getEnumType(CampaignMemberState)
+proto3.util.setEnumType(CampaignMemberState, "babelconnect.v1.CampaignMemberState", [
+    { no: 0, name: "CAMPAIGN_MEMBER_STATE_UNSPECIFIED" },
+    { no: 1, name: "CAMPAIGN_MEMBER_STATE_OFFLINE" },
+    { no: 2, name: "CAMPAIGN_MEMBER_STATE_LOGGING_IN" },
+    { no: 3, name: "CAMPAIGN_MEMBER_STATE_WAITING" },
+    { no: 4, name: "CAMPAIGN_MEMBER_STATE_IDLE" },
+    { no: 5, name: "CAMPAIGN_MEMBER_STATE_IN_PROGRESS" },
+    { no: 6, name: "CAMPAIGN_MEMBER_STATE_DISPOSITION" },
+]);
+/**
+ * TransferTargetKind discriminates a TransferTarget. Mirrors the backend's
+ * TransferTargetItem.Type enum exactly (agent/number/application — there is no
+ * "phonebook" kind on the backend; bc-v2's UI groups results that way, but the
+ * wire type only ever carries these three).
+ *
+ * @generated from enum babelconnect.v1.TransferTargetKind
+ */
+export var TransferTargetKind;
+(function (TransferTargetKind) {
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_UNSPECIFIED = 0;
+     */
+    TransferTargetKind[TransferTargetKind["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_AGENT = 1;
+     */
+    TransferTargetKind[TransferTargetKind["AGENT"] = 1] = "AGENT";
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_NUMBER = 2;
+     */
+    TransferTargetKind[TransferTargetKind["NUMBER"] = 2] = "NUMBER";
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_APPLICATION = 3;
+     */
+    TransferTargetKind[TransferTargetKind["APPLICATION"] = 3] = "APPLICATION";
+})(TransferTargetKind || (TransferTargetKind = {}));
+// Retrieve enum metadata with: proto3.getEnumType(TransferTargetKind)
+proto3.util.setEnumType(TransferTargetKind, "babelconnect.v1.TransferTargetKind", [
+    { no: 0, name: "TRANSFER_TARGET_KIND_UNSPECIFIED" },
+    { no: 1, name: "TRANSFER_TARGET_KIND_AGENT" },
+    { no: 2, name: "TRANSFER_TARGET_KIND_NUMBER" },
+    { no: 3, name: "TRANSFER_TARGET_KIND_APPLICATION" },
+]);
 /**
  * @generated from enum babelconnect.v1.CallDirection
  */
@@ -1086,6 +1173,35 @@ export class AgentInfo extends Message {
      * @generated from field: repeated babelconnect.v1.Account accounts = 19;
      */
     accounts = [];
+    /**
+     * The agent's own email (GET /agent/me item.email — distinct from `username`,
+     * which is the *login* identity from user/me/introspection and may differ).
+     * Populated for the embedding bridge's legacy-shaped `agent.loaded` payload
+     * (EMB20, bc-connect parity) — bc-connect hosts match/route on it.
+     *
+     * @generated from field: string email = 20;
+     */
+    email = "";
+    /**
+     * Subset of `available_numbers` the backend marks SMS-capable (GET
+     * /api/v2/agent/numbers item `sms`, sourced from core_number.sms_enabled;
+     * mirrors bc-v2's AgentNumberFreeText.vue `smsOnly` filter). Drives the SMS
+     * composer's From picker (SMSC4); empty/unknown ⇒ client falls back to
+     * `available_numbers` (see docs/designs/messaging.md).
+     *
+     * @generated from field: repeated string sms_capable_numbers = 21;
+     */
+    smsCapableNumbers = [];
+    /**
+     * Outbound-dialer (predictive campaign) membership state — folded from the
+     * `/agent/{id}/obd` Faye push plus a GET /agent/outbound/status enrichment
+     * read (OBDA1–4). Unset/UNSPECIFIED means the agent has never touched a
+     * campaign this session; explicit OFFLINE means they left/aren't in one.
+     * See docs/designs/obd.md.
+     *
+     * @generated from field: babelconnect.v1.CampaignStatus campaign_status = 22;
+     */
+    campaignStatus;
     constructor(data) {
         super();
         proto3.util.initPartial(data, this);
@@ -1112,6 +1228,9 @@ export class AgentInfo extends Message {
         { no: 17, name: "account_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
         { no: 18, name: "line_blocked", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
         { no: 19, name: "accounts", kind: "message", T: Account, repeated: true },
+        { no: 20, name: "email", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 21, name: "sms_capable_numbers", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+        { no: 22, name: "campaign_status", kind: "message", T: CampaignStatus },
     ]);
     static fromBinary(bytes, options) {
         return new AgentInfo().fromBinary(bytes, options);
@@ -1126,6 +1245,236 @@ export class AgentInfo extends Message {
         return proto3.util.equals(AgentInfo, a, b);
     }
 }
+/**
+ * CampaignStatus is the agent's outbound-dialer campaign membership envelope
+ * (OBDA1–4 CORE). `campaign_id`/`campaign_name` and `state` come from a GET
+ * /agent/outbound/status read (backend: ObdAgentService.getStatus); `state`
+ * and `last_reason` are additionally kept live by the `/agent/{id}/obd` Faye
+ * push (AgentPushService.pushObdEvent — that push carries ONLY status +
+ * last_reason, never campaign/lead, hence the enrichment read). `last_reason`
+ * mirrors the backend's AgentStatus.Reason enum as a lowercase string (e.g.
+ * "unreachable", "no_answer", "busy", "answer", "hungup", "none") — kept as a
+ * string rather than a wire enum since the client only ever compares it
+ * against "unreachable" for the OBDA4 toast. `paused` is a convenience mirror
+ * of `state == CAMPAIGN_MEMBER_STATE_IDLE`. The lead the agent is currently
+ * dialing, disposition reasons, and live campaign metrics are additive fields
+ * below (OBDB1/OBDD1) layered on top of this envelope.
+ *
+ * @generated from message babelconnect.v1.CampaignStatus
+ */
+export class CampaignStatus extends Message {
+    /**
+     * @generated from field: string campaign_id = 1;
+     */
+    campaignId = "";
+    /**
+     * @generated from field: string campaign_name = 2;
+     */
+    campaignName = "";
+    /**
+     * @generated from field: babelconnect.v1.CampaignMemberState state = 3;
+     */
+    state = CampaignMemberState.UNSPECIFIED;
+    /**
+     * @generated from field: bool paused = 4;
+     */
+    paused = false;
+    /**
+     * @generated from field: string last_reason = 5;
+     */
+    lastReason = "";
+    /**
+     * unix seconds this state was entered/last confirmed
+     *
+     * @generated from field: int64 since = 6;
+     */
+    since = protoInt64.zero;
+    /**
+     * lead is the customer the dialer connected the agent to (OBDB1) — set once
+     * GET /agent/outbound/status's `lead` sub-object is non-empty (IN_PROGRESS/
+     * DISPOSITION), unset otherwise. Also kept live by a genuine backend push (a
+     * `cti.outbound.lead` Faye event — sbf/services AgentCtiService#pushLead,
+     * CTIA3) that arrives the moment the dialer connects a lead, ahead of the
+     * next enrichment poll.
+     *
+     * @generated from field: babelconnect.v1.Lead lead = 7;
+     */
+    lead;
+    /**
+     * metrics is the campaign's live pacing snapshot (OBDD1), refreshed
+     * alongside the enrichment read while `state == IDLE` (paused) — the only
+     * state the Outbound tab shows it in; unset otherwise (and left unset if the
+     * GET /agent/outbound/metrics read 404s, e.g. between polls).
+     *
+     * @generated from field: babelconnect.v1.CampaignMetrics metrics = 8;
+     */
+    metrics;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.CampaignStatus";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "campaign_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "campaign_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 3, name: "state", kind: "enum", T: proto3.getEnumType(CampaignMemberState) },
+        { no: 4, name: "paused", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+        { no: 5, name: "last_reason", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 6, name: "since", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+        { no: 7, name: "lead", kind: "message", T: Lead },
+        { no: 8, name: "metrics", kind: "message", T: CampaignMetrics },
+    ]);
+    static fromBinary(bytes, options) {
+        return new CampaignStatus().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new CampaignStatus().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new CampaignStatus().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(CampaignStatus, a, b);
+    }
+}
+/**
+ * Lead is the customer the outbound dialer connected the agent to (OBDB1),
+ * grounded in GET /agent/outbound/status's `lead` sub-object (sbf/services
+ * ObdAgentService#getStatus) and the `cti.outbound.lead` Faye push's `body`
+ * (AgentPushMessages.Lead.LeadBody, CTIA3) — both share the uid/number/data
+ * shape; `id`/`rank` are only present on the richer (list-enriched) form the
+ * GET read can return. `id` is the internal lead-list-item id — DISTINCT from
+ * `uid`, the customer-provided identifier the OBDB1 acceptance calls the
+ * lead's "id" in the UI.
+ *
+ * @generated from message babelconnect.v1.Lead
+ */
+export class Lead extends Message {
+    /**
+     * internal lead-list-item id (uuid); may be empty
+     *
+     * @generated from field: string id = 1;
+     */
+    id = "";
+    /**
+     * customer-provided lead identifier — the UI's "id"
+     *
+     * @generated from field: string uid = 2;
+     */
+    uid = "";
+    /**
+     * @generated from field: string number = 3;
+     */
+    number = "";
+    /**
+     * @generated from field: int32 rank = 4;
+     */
+    rank = 0;
+    /**
+     * arbitrary customer-supplied key/values
+     *
+     * @generated from field: map<string, string> data = 5;
+     */
+    data = {};
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.Lead";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "uid", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 3, name: "number", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 4, name: "rank", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 5, name: "data", kind: "map", K: 9 /* ScalarType.STRING */, V: { kind: "scalar", T: 9 /* ScalarType.STRING */ } },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Lead().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Lead().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Lead().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Lead, a, b);
+    }
+}
+/**
+ * CampaignMetrics is the campaign's live pacing snapshot (OBDD1), grounded in
+ * GET /agent/outbound/metrics's flat dot-key map (sbf/services
+ * ObdController#metrics, itself a filtered subset of Vicidial's realtime
+ * report) — always this exact 6-key subset, never more.
+ *
+ * @generated from message babelconnect.v1.CampaignMetrics
+ */
+export class CampaignMetrics extends Message {
+    /**
+     * agents.in_calls
+     *
+     * @generated from field: int32 agents_in_calls = 1;
+     */
+    agentsInCalls = 0;
+    /**
+     * agents.in_disp
+     *
+     * @generated from field: int32 agents_in_disp = 2;
+     */
+    agentsInDisp = 0;
+    /**
+     * agents.paused
+     *
+     * @generated from field: int32 agents_paused = 3;
+     */
+    agentsPaused = 0;
+    /**
+     * agents.waiting
+     *
+     * @generated from field: int32 agents_waiting = 4;
+     */
+    agentsWaiting = 0;
+    /**
+     * calls.being_placed
+     *
+     * @generated from field: int32 calls_being_placed = 5;
+     */
+    callsBeingPlaced = 0;
+    /**
+     * calls.ringing
+     *
+     * @generated from field: int32 calls_ringing = 6;
+     */
+    callsRinging = 0;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.CampaignMetrics";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "agents_in_calls", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 2, name: "agents_in_disp", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 3, name: "agents_paused", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 4, name: "agents_waiting", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 5, name: "calls_being_placed", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 6, name: "calls_ringing", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new CampaignMetrics().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new CampaignMetrics().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new CampaignMetrics().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(CampaignMetrics, a, b);
+    }
+}
 /**
  * PhonebookEntry is one dialable contact (or a recent number) for the dialer's
  * autocomplete.
@@ -1245,6 +1594,140 @@ export class PhonebookResponse extends Message {
         return proto3.util.equals(PhonebookResponse, a, b);
     }
 }
+/**
+ * TransferTarget is one autocomplete result for a blind transfer / add-member
+ * pick. `id` is the backend id to pass back on Transfer/AddConferenceMember
+ * (an agent or application UUID; for a synthetic NUMBER result it is the raw
+ * query, not a stable id — clients should send `number`, not `id`, for that
+ * kind). `category` is the IVR module name (APPLICATION only, e.g.
+ * "simpleMenu"); `browser` marks an agent reachable only via browser phone
+ * (no PSTN number) — AGENT only.
+ *
+ * @generated from message babelconnect.v1.TransferTarget
+ */
+export class TransferTarget extends Message {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id = "";
+    /**
+     * @generated from field: babelconnect.v1.TransferTargetKind kind = 2;
+     */
+    kind = TransferTargetKind.UNSPECIFIED;
+    /**
+     * @generated from field: string label = 3;
+     */
+    label = "";
+    /**
+     * NUMBER kind, and AGENT kind when it has a PSTN number
+     *
+     * @generated from field: string number = 4;
+     */
+    number = "";
+    /**
+     * APPLICATION only: the IVR module name
+     *
+     * @generated from field: string category = 5;
+     */
+    category = "";
+    /**
+     * AGENT only: browser-phone-reachable, no PSTN number
+     *
+     * @generated from field: bool browser = 6;
+     */
+    browser = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.TransferTarget";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "kind", kind: "enum", T: proto3.getEnumType(TransferTargetKind) },
+        { no: 3, name: "label", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 4, name: "number", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 5, name: "category", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 6, name: "browser", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new TransferTarget().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TransferTarget().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TransferTarget().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TransferTarget, a, b);
+    }
+}
+/**
+ * TransferTargetsRequest / TransferTargetsResponse back the transfer-target
+ * autocomplete (blind transfer + add-member dialogs). `query` filters
+ * server-side; empty returns the default result set (a synthetic NUMBER
+ * target only appears once `query` looks like a number).
+ *
+ * @generated from message babelconnect.v1.TransferTargetsRequest
+ */
+export class TransferTargetsRequest extends Message {
+    /**
+     * @generated from field: string query = 1;
+     */
+    query = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.TransferTargetsRequest";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "query", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new TransferTargetsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TransferTargetsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TransferTargetsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TransferTargetsRequest, a, b);
+    }
+}
+/**
+ * @generated from message babelconnect.v1.TransferTargetsResponse
+ */
+export class TransferTargetsResponse extends Message {
+    /**
+     * @generated from field: repeated babelconnect.v1.TransferTarget targets = 1;
+     */
+    targets = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.TransferTargetsResponse";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "targets", kind: "message", T: TransferTarget, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new TransferTargetsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TransferTargetsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TransferTargetsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TransferTargetsResponse, a, b);
+    }
+}
 /**
  * PresenceOption is one selectable agent presence — "Available" or a configured
  * pause reason. `available` is whether the agent can receive calls in it.
@@ -1376,6 +1859,17 @@ export class CallState extends Message {
      * @generated from field: repeated babelconnect.v1.IceServer ice_servers = 17;
      */
     iceServers = [];
+    /**
+     * can_transfer_to_application is server-computed: true for inbound calls and
+     * taken callbacks (source == CALL_SOURCE_CALLBACK), false otherwise. Plain
+     * outbound calls must not be offered application (IVR module) transfer
+     * targets — forwarding them into a queue module strands the agent
+     * (DEV-549/B2-526). Clients gate the "App" transfer-target segment on this
+     * flag instead of re-deriving the rule from direction/source themselves.
+     *
+     * @generated from field: bool can_transfer_to_application = 18;
+     */
+    canTransferToApplication = false;
     constructor(data) {
         super();
         proto3.util.initPartial(data, this);
@@ -1400,6 +1894,7 @@ export class CallState extends Message {
         { no: 15, name: "recording_tags", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
         { no: 16, name: "recording_flagged", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
         { no: 17, name: "ice_servers", kind: "message", T: IceServer, repeated: true },
+        { no: 18, name: "can_transfer_to_application", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     ]);
     static fromBinary(bytes, options) {
         return new CallState().fromBinary(bytes, options);
@@ -1545,6 +2040,7 @@ export class StateUpdate extends Message {
         { no: 3, name: "patch", kind: "message", T: Patch, oneof: "update" },
         { no: 4, name: "error", kind: "message", T: Error, oneof: "update" },
         { no: 5, name: "keepalive", kind: "message", T: Keepalive, oneof: "update" },
+        { no: 6, name: "ping", kind: "message", T: Ping, oneof: "update" },
     ]);
     static fromBinary(bytes, options) {
         return new StateUpdate().fromBinary(bytes, options);
@@ -1590,6 +2086,43 @@ export class Keepalive extends Message {
         return proto3.util.equals(Keepalive, a, b);
     }
 }
+/**
+ * Ping is a liveness probe the server sends on the heartbeat tick (replacing the
+ * bare Keepalive frame). The client echoes `seq` back in a Pong command; the server
+ * measures round-trip time (RTT) from the reply and tracks per-session liveness.
+ * Like Keepalive it keeps the connection warm, carries no state, and does NOT
+ * advance `seq` — caches ignore it, and the reply is handled in the client's stream
+ * loop, not the state reducer. (APP-A5/CALL-M6.)
+ *
+ * @generated from message babelconnect.v1.Ping
+ */
+export class Ping extends Message {
+    /**
+     * @generated from field: uint64 seq = 1;
+     */
+    seq = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.Ping";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "seq", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Ping().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Ping().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Ping().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Ping, a, b);
+    }
+}
 /**
  * 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.
@@ -1775,6 +2308,12 @@ export class Command extends Message {
         { no: 27, name: "mute_conference_member", kind: "message", T: MuteConferenceMember, oneof: "command" },
         { no: 28, name: "set_conversation_open", kind: "message", T: SetConversationOpen, oneof: "command" },
         { no: 29, name: "mark_conversation_read", kind: "message", T: MarkConversationRead, oneof: "command" },
+        { no: 30, name: "pong", kind: "message", T: Pong, oneof: "command" },
+        { no: 31, name: "join_campaign", kind: "message", T: JoinCampaign, oneof: "command" },
+        { no: 32, name: "leave_campaign", kind: "message", T: LeaveCampaign, oneof: "command" },
+        { no: 33, name: "pause_campaign", kind: "message", T: PauseCampaign, oneof: "command" },
+        { no: 34, name: "end_campaign_call", kind: "message", T: EndCampaignCall, oneof: "command" },
+        { no: 35, name: "dispose_call", kind: "message", T: DisposeCall, oneof: "command" },
     ]);
     static fromBinary(bytes, options) {
         return new Command().fromBinary(bytes, options);
@@ -1789,6 +2328,40 @@ export class Command extends Message {
         return proto3.util.equals(Command, a, b);
     }
 }
+/**
+ * Pong replies to a server Ping (StateUpdate.ping), echoing its `seq` so the server
+ * can match it to the outstanding ping and compute RTT. Sent automatically by the
+ * SDK from its stream-receive loop — not a user intent. (APP-A5/CALL-M6.)
+ *
+ * @generated from message babelconnect.v1.Pong
+ */
+export class Pong extends Message {
+    /**
+     * @generated from field: uint64 seq = 1;
+     */
+    seq = protoInt64.zero;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.Pong";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "seq", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Pong().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Pong().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Pong().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Pong, a, b);
+    }
+}
 /**
  * @generated from message babelconnect.v1.Register
  */
@@ -2467,6 +3040,354 @@ export class SetAgentNumber extends Message {
         return proto3.util.equals(SetAgentNumber, a, b);
     }
 }
+/**
+ * Campaign is one outbound-dialer campaign the agent may join (the picker's
+ * entries). `test_mode` drives the "name (live)" / "name (test)" label
+ * (OBDA1). Sourced from GET /api/v2/agent/outbound/campaigns (sbf/services
+ * ObdController#listCampaigns / ObdModel.Campaign.Simple).
+ *
+ * @generated from message babelconnect.v1.Campaign
+ */
+export class Campaign extends Message {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id = "";
+    /**
+     * @generated from field: string name = 2;
+     */
+    name = "";
+    /**
+     * @generated from field: bool test_mode = 3;
+     */
+    testMode = false;
+    /**
+     * @generated from field: bool active = 4;
+     */
+    active = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.Campaign";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 3, name: "test_mode", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+        { no: 4, name: "active", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new Campaign().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new Campaign().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new Campaign().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(Campaign, a, b);
+    }
+}
+/**
+ * ListCampaignsRequest / ListCampaignsResponse back the campaign picker
+ * (OBDA1). Empty request: the server always asks the backend for active
+ * campaigns only (`?active=true`) — there is no agent-facing use for
+ * inactive ones.
+ *
+ * @generated from message babelconnect.v1.ListCampaignsRequest
+ */
+export class ListCampaignsRequest extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.ListCampaignsRequest";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new ListCampaignsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListCampaignsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListCampaignsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListCampaignsRequest, a, b);
+    }
+}
+/**
+ * @generated from message babelconnect.v1.ListCampaignsResponse
+ */
+export class ListCampaignsResponse extends Message {
+    /**
+     * @generated from field: repeated babelconnect.v1.Campaign campaigns = 1;
+     */
+    campaigns = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.ListCampaignsResponse";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "campaigns", kind: "message", T: Campaign, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ListCampaignsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListCampaignsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListCampaignsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListCampaignsResponse, a, b);
+    }
+}
+/**
+ * JoinCampaign enters a campaign (POST /api/v2/agent/outbound/enter
+ * {campaignId, paused}). `paused` mirrors the backend's own field (NOT
+ * "unpause" — bc-v2's client sent that stale name, which the backend command
+ * object silently ignores, defaulting `paused` true); the client normally
+ * sends false so the agent starts `waiting` for a lead right away.
+ *
+ * @generated from message babelconnect.v1.JoinCampaign
+ */
+export class JoinCampaign extends Message {
+    /**
+     * @generated from field: string campaign_id = 1;
+     */
+    campaignId = "";
+    /**
+     * @generated from field: bool paused = 2;
+     */
+    paused = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.JoinCampaign";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "campaign_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "paused", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new JoinCampaign().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new JoinCampaign().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new JoinCampaign().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(JoinCampaign, a, b);
+    }
+}
+/**
+ * LeaveCampaign exits the current campaign (POST /api/v2/agent/outbound/leave
+ * — no body; the backend resolves the agent's current campaign server-side).
+ * Available both from the campaign selector row and from within an active
+ * call (OBDA3).
+ *
+ * @generated from message babelconnect.v1.LeaveCampaign
+ */
+export class LeaveCampaign extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.LeaveCampaign";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new LeaveCampaign().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LeaveCampaign().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LeaveCampaign().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LeaveCampaign, a, b);
+    }
+}
+/**
+ * PauseCampaign pauses (`on=true`, POST .../pause) or resumes (`on=false`,
+ * POST .../unpause) the campaign — no request body either way (OBDA2), same
+ * on/off shape as Mute/Hold.
+ *
+ * @generated from message babelconnect.v1.PauseCampaign
+ */
+export class PauseCampaign extends Message {
+    /**
+     * @generated from field: bool on = 1;
+     */
+    on = false;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.PauseCampaign";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "on", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new PauseCampaign().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new PauseCampaign().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new PauseCampaign().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(PauseCampaign, a, b);
+    }
+}
+/**
+ * EndCampaignCall ends the agent's live campaign call (POST
+ * /api/v2/agent/outbound/hangup — no body; OBDB2). Grounded distinct from the
+ * generic Hangup: the backend's VicidialWrapperService#hangup both tells
+ * Vicidial's own dialer to release the channel AND drives the campaign
+ * member-state transition to DISPOSITION (sbf/services), neither of which a
+ * plain SIP/media-plane hangup would trigger.
+ *
+ * @generated from message babelconnect.v1.EndCampaignCall
+ */
+export class EndCampaignCall extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.EndCampaignCall";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new EndCampaignCall().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new EndCampaignCall().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new EndCampaignCall().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(EndCampaignCall, a, b);
+    }
+}
+/**
+ * DisposeCall records the outcome of a campaign call (POST
+ * /api/v2/agent/outbound/dispose {code, callbackDate?} — OBDC1/OBDC2). `code`
+ * is one of ListDispositionsResponse's codes (e.g. "no_answer", "callback").
+ * `callback_date` is ISO `YYYY-MM-DDTHH:mmZZ` and is set ONLY for the
+ * "callback" disposition (OBDC2) — omitted (empty) otherwise, matching the
+ * backend command object's own optional field (grounded: a `pause` field also
+ * exists on the backend but is `@ApiStatus(not_implemented)`, so it is
+ * intentionally not exposed here).
+ *
+ * @generated from message babelconnect.v1.DisposeCall
+ */
+export class DisposeCall extends Message {
+    /**
+     * @generated from field: string code = 1;
+     */
+    code = "";
+    /**
+     * @generated from field: string callback_date = 2;
+     */
+    callbackDate = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.DisposeCall";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "callback_date", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new DisposeCall().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new DisposeCall().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new DisposeCall().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(DisposeCall, a, b);
+    }
+}
+/**
+ * ListDispositionsRequest / ListDispositionsResponse back the disposition
+ * picker (OBDC1). Empty request: the list is a static global on the backend,
+ * not campaign- or agent-scoped.
+ *
+ * @generated from message babelconnect.v1.ListDispositionsRequest
+ */
+export class ListDispositionsRequest extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.ListDispositionsRequest";
+    static fields = proto3.util.newFieldList(() => []);
+    static fromBinary(bytes, options) {
+        return new ListDispositionsRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListDispositionsRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListDispositionsRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListDispositionsRequest, a, b);
+    }
+}
+/**
+ * @generated from message babelconnect.v1.ListDispositionsResponse
+ */
+export class ListDispositionsResponse extends Message {
+    /**
+     * raw codes, e.g. "no_answer", "callback"
+     *
+     * @generated from field: repeated string reasons = 1;
+     */
+    reasons = [];
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "babelconnect.v1.ListDispositionsResponse";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "reasons", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+    ]);
+    static fromBinary(bytes, options) {
+        return new ListDispositionsResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new ListDispositionsResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new ListDispositionsResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(ListDispositionsResponse, a, b);
+    }
+}
 /**
  * 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;
@@ -3014,7 +3935,14 @@ export class StartConference extends Message {
 }
 /**
  * AddConferenceMember invites a participant — exactly one of agent_id / number.
- * Starts a conference first if none is active.
+ * Starts a conference first if none is active. `hold_others` parks every other
+ * live, non-held member of the CURRENT conference before the invite goes out
+ * (bc-v2's add-member "hold others" checkbox, `AddNewMemberModal.vue`, default
+ * off) so they don't overhear the new invitee ringing; the server unholds them
+ * again once the invitee reaches a terminal state (added = joined, or
+ * failed/removed = rejected/timed out) — see CA4 / docs/designs/conferencing.md.
+ * No effect when starting a brand-new conference: StartConference(hold=true)
+ * already parks the original party unconditionally in that case.
  *
  * @generated from message babelconnect.v1.AddConferenceMember
  */
@@ -3027,6 +3955,10 @@ export class AddConferenceMember extends Message {
      * @generated from field: string number = 2;
      */
     number = "";
+    /**
+     * @generated from field: bool hold_others = 3;
+     */
+    holdOthers = false;
     constructor(data) {
         super();
         proto3.util.initPartial(data, this);
@@ -3036,6 +3968,7 @@ export class AddConferenceMember extends Message {
     static fields = proto3.util.newFieldList(() => [
         { no: 1, name: "agent_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
         { no: 2, name: "number", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 3, name: "hold_others", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
     ]);
     static fromBinary(bytes, options) {
         return new AddConferenceMember().fromBinary(bytes, options);