@babelforce/babelconnect-sdk 0.11.0 → 0.13.0

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

@@ -37,6 +37,74 @@ export declare enum AgentState {
      */
     BUSY = 7
 }
+/**
+ * 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 declare enum CampaignMemberState {
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_OFFLINE = 1;
+     */
+    OFFLINE = 1,
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_LOGGING_IN = 2;
+     */
+    LOGGING_IN = 2,
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_WAITING = 3;
+     */
+    WAITING = 3,
+    /**
+     * paused
+     *
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_IDLE = 4;
+     */
+    IDLE = 4,
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_IN_PROGRESS = 5;
+     */
+    IN_PROGRESS = 5,
+    /**
+     * @generated from enum value: CAMPAIGN_MEMBER_STATE_DISPOSITION = 6;
+     */
+    DISPOSITION = 6
+}
+/**
+ * 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 declare enum TransferTargetKind {
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_AGENT = 1;
+     */
+    AGENT = 1,
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_NUMBER = 2;
+     */
+    NUMBER = 2,
+    /**
+     * @generated from enum value: TRANSFER_TARGET_KIND_APPLICATION = 3;
+     */
+    APPLICATION = 3
+}
 /**
  * @generated from enum babelconnect.v1.CallDirection
  */
@@ -167,7 +235,7 @@ export declare class SubscribeRequest extends Message<SubscribeRequest> {
 /**
  * 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.
+ * Subscribe stream, never in this reply.
  *
  * @generated from message babelconnect.v1.Ack
  */
@@ -777,6 +845,35 @@ export declare class AgentInfo extends Message<AgentInfo> {
      * @generated from field: repeated babelconnect.v1.Account accounts = 19;
      */
     accounts: Account[];
+    /**
+     * 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: string;
+    /**
+     * 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: string[];
+    /**
+     * 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?: CampaignStatus;
     constructor(data?: PartialMessage<AgentInfo>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "babelconnect.v1.AgentInfo";
@@ -786,6 +883,183 @@ export declare class AgentInfo extends Message<AgentInfo> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AgentInfo;
     static equals(a: AgentInfo | PlainMessage<AgentInfo> | undefined, b: AgentInfo | PlainMessage<AgentInfo> | undefined): boolean;
 }
+/**
+ * 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 declare class CampaignStatus extends Message<CampaignStatus> {
+    /**
+     * @generated from field: string campaign_id = 1;
+     */
+    campaignId: string;
+    /**
+     * @generated from field: string campaign_name = 2;
+     */
+    campaignName: string;
+    /**
+     * @generated from field: babelconnect.v1.CampaignMemberState state = 3;
+     */
+    state: CampaignMemberState;
+    /**
+     * @generated from field: bool paused = 4;
+     */
+    paused: boolean;
+    /**
+     * @generated from field: string last_reason = 5;
+     */
+    lastReason: string;
+    /**
+     * unix seconds this state was entered/last confirmed
+     *
+     * @generated from field: int64 since = 6;
+     */
+    since: bigint;
+    /**
+     * 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?: 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?: CampaignMetrics;
+    constructor(data?: PartialMessage<CampaignStatus>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.CampaignStatus";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CampaignStatus;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CampaignStatus;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CampaignStatus;
+    static equals(a: CampaignStatus | PlainMessage<CampaignStatus> | undefined, b: CampaignStatus | PlainMessage<CampaignStatus> | undefined): boolean;
+}
+/**
+ * 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 declare class Lead extends Message<Lead> {
+    /**
+     * internal lead-list-item id (uuid); may be empty
+     *
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * customer-provided lead identifier — the UI's "id"
+     *
+     * @generated from field: string uid = 2;
+     */
+    uid: string;
+    /**
+     * @generated from field: string number = 3;
+     */
+    number: string;
+    /**
+     * @generated from field: int32 rank = 4;
+     */
+    rank: number;
+    /**
+     * arbitrary customer-supplied key/values
+     *
+     * @generated from field: map<string, string> data = 5;
+     */
+    data: {
+        [key: string]: string;
+    };
+    constructor(data?: PartialMessage<Lead>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Lead";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Lead;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Lead;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Lead;
+    static equals(a: Lead | PlainMessage<Lead> | undefined, b: Lead | PlainMessage<Lead> | undefined): boolean;
+}
+/**
+ * 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 declare class CampaignMetrics extends Message<CampaignMetrics> {
+    /**
+     * agents.in_calls
+     *
+     * @generated from field: int32 agents_in_calls = 1;
+     */
+    agentsInCalls: number;
+    /**
+     * agents.in_disp
+     *
+     * @generated from field: int32 agents_in_disp = 2;
+     */
+    agentsInDisp: number;
+    /**
+     * agents.paused
+     *
+     * @generated from field: int32 agents_paused = 3;
+     */
+    agentsPaused: number;
+    /**
+     * agents.waiting
+     *
+     * @generated from field: int32 agents_waiting = 4;
+     */
+    agentsWaiting: number;
+    /**
+     * calls.being_placed
+     *
+     * @generated from field: int32 calls_being_placed = 5;
+     */
+    callsBeingPlaced: number;
+    /**
+     * calls.ringing
+     *
+     * @generated from field: int32 calls_ringing = 6;
+     */
+    callsRinging: number;
+    constructor(data?: PartialMessage<CampaignMetrics>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.CampaignMetrics";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CampaignMetrics;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CampaignMetrics;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CampaignMetrics;
+    static equals(a: CampaignMetrics | PlainMessage<CampaignMetrics> | undefined, b: CampaignMetrics | PlainMessage<CampaignMetrics> | undefined): boolean;
+}
 /**
  * PhonebookEntry is one dialable contact (or a recent number) for the dialer's
  * autocomplete.
@@ -863,6 +1137,96 @@ export declare class PhonebookResponse extends Message<PhonebookResponse> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PhonebookResponse;
     static equals(a: PhonebookResponse | PlainMessage<PhonebookResponse> | undefined, b: PhonebookResponse | PlainMessage<PhonebookResponse> | undefined): boolean;
 }
+/**
+ * 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 declare class TransferTarget extends Message<TransferTarget> {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: babelconnect.v1.TransferTargetKind kind = 2;
+     */
+    kind: TransferTargetKind;
+    /**
+     * @generated from field: string label = 3;
+     */
+    label: string;
+    /**
+     * NUMBER kind, and AGENT kind when it has a PSTN number
+     *
+     * @generated from field: string number = 4;
+     */
+    number: string;
+    /**
+     * APPLICATION only: the IVR module name
+     *
+     * @generated from field: string category = 5;
+     */
+    category: string;
+    /**
+     * AGENT only: browser-phone-reachable, no PSTN number
+     *
+     * @generated from field: bool browser = 6;
+     */
+    browser: boolean;
+    constructor(data?: PartialMessage<TransferTarget>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.TransferTarget";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransferTarget;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransferTarget;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransferTarget;
+    static equals(a: TransferTarget | PlainMessage<TransferTarget> | undefined, b: TransferTarget | PlainMessage<TransferTarget> | undefined): boolean;
+}
+/**
+ * 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 declare class TransferTargetsRequest extends Message<TransferTargetsRequest> {
+    /**
+     * @generated from field: string query = 1;
+     */
+    query: string;
+    constructor(data?: PartialMessage<TransferTargetsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.TransferTargetsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransferTargetsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransferTargetsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransferTargetsRequest;
+    static equals(a: TransferTargetsRequest | PlainMessage<TransferTargetsRequest> | undefined, b: TransferTargetsRequest | PlainMessage<TransferTargetsRequest> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.TransferTargetsResponse
+ */
+export declare class TransferTargetsResponse extends Message<TransferTargetsResponse> {
+    /**
+     * @generated from field: repeated babelconnect.v1.TransferTarget targets = 1;
+     */
+    targets: TransferTarget[];
+    constructor(data?: PartialMessage<TransferTargetsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.TransferTargetsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TransferTargetsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TransferTargetsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TransferTargetsResponse;
+    static equals(a: TransferTargetsResponse | PlainMessage<TransferTargetsResponse> | undefined, b: TransferTargetsResponse | PlainMessage<TransferTargetsResponse> | undefined): boolean;
+}
 /**
  * PresenceOption is one selectable agent presence — "Available" or a configured
  * pause reason. `available` is whether the agent can receive calls in it.
@@ -979,6 +1343,17 @@ export declare class CallState extends Message<CallState> {
      * @generated from field: repeated babelconnect.v1.IceServer ice_servers = 17;
      */
     iceServers: IceServer[];
+    /**
+     * 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: boolean;
     constructor(data?: PartialMessage<CallState>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "babelconnect.v1.CallState";
@@ -1056,7 +1431,7 @@ export declare class WrapUpStatus extends Message<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
+ * StateUpdate is the single server → client message on the Subscribe 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 /
@@ -1118,7 +1493,7 @@ export declare class StateUpdate extends Message<StateUpdate> {
     static equals(a: StateUpdate | PlainMessage<StateUpdate> | undefined, b: StateUpdate | PlainMessage<StateUpdate> | undefined): boolean;
 }
 /**
- * Keepalive is an empty heartbeat frame sent on the Session/Subscribe streams so
+ * Keepalive is an empty heartbeat frame sent on the Subscribe stream so
  * idle connections through proxies/LBs are not closed as idle. Notably the AWS
  * Classic ELB in front of ingress-nginx (dev/prod EKS) has a 300s connection
  * idle timeout; without these frames a quiet agent's gRPC-web server-stream is
@@ -1554,6 +1929,50 @@ export declare class Command extends Message<Command> {
          */
         value: Pong;
         case: "pong";
+    } | {
+        /**
+         * Outbound-dialer campaign controls (OBDA1–3 CORE).
+         *
+         * enter a campaign (the picker's "Enter")
+         *
+         * @generated from field: babelconnect.v1.JoinCampaign join_campaign = 31;
+         */
+        value: JoinCampaign;
+        case: "joinCampaign";
+    } | {
+        /**
+         * leave the campaign (selector row or in-call)
+         *
+         * @generated from field: babelconnect.v1.LeaveCampaign leave_campaign = 32;
+         */
+        value: LeaveCampaign;
+        case: "leaveCampaign";
+    } | {
+        /**
+         * pause (on=true) / resume (on=false) the campaign
+         *
+         * @generated from field: babelconnect.v1.PauseCampaign pause_campaign = 33;
+         */
+        value: PauseCampaign;
+        case: "pauseCampaign";
+    } | {
+        /**
+         * Outbound-dialer call/disposition controls (OBDB2/OBDC1/OBDC2 follow-up).
+         *
+         * end the live campaign call (OBDB2)
+         *
+         * @generated from field: babelconnect.v1.EndCampaignCall end_campaign_call = 34;
+         */
+        value: EndCampaignCall;
+        case: "endCampaignCall";
+    } | {
+        /**
+         * record the call outcome, optionally with a callback (OBDC1/OBDC2)
+         *
+         * @generated from field: babelconnect.v1.DisposeCall dispose_call = 35;
+         */
+        value: DisposeCall;
+        case: "disposeCall";
     } | {
         case: undefined;
         value?: undefined;
@@ -2012,6 +2431,227 @@ export declare class SetAgentNumber extends Message<SetAgentNumber> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): SetAgentNumber;
     static equals(a: SetAgentNumber | PlainMessage<SetAgentNumber> | undefined, b: SetAgentNumber | PlainMessage<SetAgentNumber> | undefined): boolean;
 }
+/**
+ * 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 declare class Campaign extends Message<Campaign> {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from field: string name = 2;
+     */
+    name: string;
+    /**
+     * @generated from field: bool test_mode = 3;
+     */
+    testMode: boolean;
+    /**
+     * @generated from field: bool active = 4;
+     */
+    active: boolean;
+    constructor(data?: PartialMessage<Campaign>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.Campaign";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Campaign;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Campaign;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Campaign;
+    static equals(a: Campaign | PlainMessage<Campaign> | undefined, b: Campaign | PlainMessage<Campaign> | undefined): boolean;
+}
+/**
+ * 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 declare class ListCampaignsRequest extends Message<ListCampaignsRequest> {
+    constructor(data?: PartialMessage<ListCampaignsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.ListCampaignsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListCampaignsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListCampaignsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListCampaignsRequest;
+    static equals(a: ListCampaignsRequest | PlainMessage<ListCampaignsRequest> | undefined, b: ListCampaignsRequest | PlainMessage<ListCampaignsRequest> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.ListCampaignsResponse
+ */
+export declare class ListCampaignsResponse extends Message<ListCampaignsResponse> {
+    /**
+     * @generated from field: repeated babelconnect.v1.Campaign campaigns = 1;
+     */
+    campaigns: Campaign[];
+    constructor(data?: PartialMessage<ListCampaignsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.ListCampaignsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListCampaignsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListCampaignsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListCampaignsResponse;
+    static equals(a: ListCampaignsResponse | PlainMessage<ListCampaignsResponse> | undefined, b: ListCampaignsResponse | PlainMessage<ListCampaignsResponse> | undefined): boolean;
+}
+/**
+ * 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 declare class JoinCampaign extends Message<JoinCampaign> {
+    /**
+     * @generated from field: string campaign_id = 1;
+     */
+    campaignId: string;
+    /**
+     * @generated from field: bool paused = 2;
+     */
+    paused: boolean;
+    constructor(data?: PartialMessage<JoinCampaign>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.JoinCampaign";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): JoinCampaign;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): JoinCampaign;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): JoinCampaign;
+    static equals(a: JoinCampaign | PlainMessage<JoinCampaign> | undefined, b: JoinCampaign | PlainMessage<JoinCampaign> | undefined): boolean;
+}
+/**
+ * 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 declare class LeaveCampaign extends Message<LeaveCampaign> {
+    constructor(data?: PartialMessage<LeaveCampaign>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.LeaveCampaign";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LeaveCampaign;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LeaveCampaign;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LeaveCampaign;
+    static equals(a: LeaveCampaign | PlainMessage<LeaveCampaign> | undefined, b: LeaveCampaign | PlainMessage<LeaveCampaign> | undefined): boolean;
+}
+/**
+ * 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 declare class PauseCampaign extends Message<PauseCampaign> {
+    /**
+     * @generated from field: bool on = 1;
+     */
+    on: boolean;
+    constructor(data?: PartialMessage<PauseCampaign>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.PauseCampaign";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PauseCampaign;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PauseCampaign;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PauseCampaign;
+    static equals(a: PauseCampaign | PlainMessage<PauseCampaign> | undefined, b: PauseCampaign | PlainMessage<PauseCampaign> | undefined): boolean;
+}
+/**
+ * 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 declare class EndCampaignCall extends Message<EndCampaignCall> {
+    constructor(data?: PartialMessage<EndCampaignCall>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.EndCampaignCall";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EndCampaignCall;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EndCampaignCall;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EndCampaignCall;
+    static equals(a: EndCampaignCall | PlainMessage<EndCampaignCall> | undefined, b: EndCampaignCall | PlainMessage<EndCampaignCall> | undefined): boolean;
+}
+/**
+ * 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 declare class DisposeCall extends Message<DisposeCall> {
+    /**
+     * @generated from field: string code = 1;
+     */
+    code: string;
+    /**
+     * @generated from field: string callback_date = 2;
+     */
+    callbackDate: string;
+    constructor(data?: PartialMessage<DisposeCall>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.DisposeCall";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisposeCall;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisposeCall;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisposeCall;
+    static equals(a: DisposeCall | PlainMessage<DisposeCall> | undefined, b: DisposeCall | PlainMessage<DisposeCall> | undefined): boolean;
+}
+/**
+ * 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 declare class ListDispositionsRequest extends Message<ListDispositionsRequest> {
+    constructor(data?: PartialMessage<ListDispositionsRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.ListDispositionsRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListDispositionsRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListDispositionsRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListDispositionsRequest;
+    static equals(a: ListDispositionsRequest | PlainMessage<ListDispositionsRequest> | undefined, b: ListDispositionsRequest | PlainMessage<ListDispositionsRequest> | undefined): boolean;
+}
+/**
+ * @generated from message babelconnect.v1.ListDispositionsResponse
+ */
+export declare class ListDispositionsResponse extends Message<ListDispositionsResponse> {
+    /**
+     * raw codes, e.g. "no_answer", "callback"
+     *
+     * @generated from field: repeated string reasons = 1;
+     */
+    reasons: string[];
+    constructor(data?: PartialMessage<ListDispositionsResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "babelconnect.v1.ListDispositionsResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListDispositionsResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListDispositionsResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListDispositionsResponse;
+    static equals(a: ListDispositionsResponse | PlainMessage<ListDispositionsResponse> | undefined, b: ListDispositionsResponse | PlainMessage<ListDispositionsResponse> | 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;
@@ -2400,7 +3040,14 @@ export declare class StartConference extends Message<StartConference> {
 }
 /**
  * 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
  */
@@ -2413,6 +3060,10 @@ export declare class AddConferenceMember extends Message<AddConferenceMember> {
      * @generated from field: string number = 2;
      */
     number: string;
+    /**
+     * @generated from field: bool hold_others = 3;
+     */
+    holdOthers: boolean;
     constructor(data?: PartialMessage<AddConferenceMember>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "babelconnect.v1.AddConferenceMember";