Send a speaking packet (op 5). This determines the green circle around the avatar in the voice channel
 @param value [true, false] Whether or not the bot should be speaking
434223
def send_speaking(value)
      @bot.debug("Speaking: #{value}")
      @client.send({
        op: 5,
        d: {
          speaking: value,
          delay: 0
        }
      }.to_json)
    end
127599
def send_framer(self, value):
        

        if not isinstance(value, framers.Framer):
            raise ValueError("framer must be an instance of tendril.Framer")

        self._send_framer = value
786232
def setOption(self, key, value):
    
    self.send_setOption(key, value)
    self.recv_setOption()
308288
public void setValue(String value) {
		try {			
			ContactHeader contactHeader = (ContactHeader) SipFactoryImpl.headerFactory.createHeader(
					ContactHeader.NAME, value);
			this.address = SipFactoryImpl.addressFactory.createAddress(value);
			this.parameters = getParameters(((Parameters) contactHeader));
		} catch (Exception ex) {
			throw new IllegalArgumentException("Illegal argument", ex);
		}
	}
1298826
public final void setMediated(boolean value) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setMediated", Boolean.valueOf(value));
        setFlagValue(MEDIATED_FLAG, value);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setMediated");
    }
315920
function protocol(value) {
  var val = value.slice(-6).toLowerCase()
  return val === mailto || val.slice(-5) === https || val.slice(-4) === http
}
678299
def _send_int(self,value):
        

        # Coerce to int. This will throw a ValueError if the value can't 
        # actually be converted.
        if type(value) != int:
            new_value = int(value)

            if self.give_warnings:
                w = "Coercing {} into int ({})".format(value,new_value)
                warnings.warn(w,Warning)
                value = new_value

        # Range check
        if value > self.board.int_max or value < self.board.int_min:
            err = "Value {} exceeds the size of the board's int.".format(value)
            raise OverflowError(err)
           
        return struct.pack(self.board.int_type,value)
1252269
def acknowledged(self, value):
        
        assert (isinstance(value, bool))
        self._acknowledged = value
        if value:
            self._timeouted = False
            self._rejected = False
            self._cancelled = False
1052803
function sendChat(roomId, content) {
        return retryAction(() => forum._emit('modules.chats.send', {
            roomId: roomId,
            message: content
        }), 5);
    }
284794
public static void setRequiresUserConsent(boolean value) {
        if (!sIsInitialized) {
            // We can't read hasUserConsent() before we're initialized
            sRequiresUserConsent = value;
        } else {
            boolean hadUserConsent = hasUserConsent();
            sRequiresUserConsent = value;
            Log.w(TAG, "WonderPush.setRequiresUserConsent(" + value + ") called after WonderPush.initialize(). Although supported, a proper implementation typically only calls it before.");
            // Refresh user consent
            boolean nowHasUserConsent = hasUserConsent();
            if (hadUserConsent != nowHasUserConsent) {
                hasUserConsentChanged(nowHasUserConsent);
            }
        }
    }
606128
function speakIt({ action }) {
    const { toSpeak } = action.payload

    // Remember: unlike Promises, which share a similar construction,
    // the observable function is not run until the Observable recieves
    // a subscribe() call.
    return new Observable(observer => {
      try {
        const say = require("say")
        say.speak(toSpeak, null, null, () => {
          observer.complete()
        })

        // An Observable allows for cancellation by returning a
        // cancellation function
        return () => {
          say.stop()
        }
      } catch (error) {
        log("-- speech synthesis not available --")
        observer.error()
      }
    })
  }
481462
def setZValue(self, value):
        
        super(XNodeConnection, self).setZValue(value)

        if self._textItem:
            self._textItem.setZValue(value)
255731
def on_send(node)
      name     = node.children[1].to_s
      name     = SEND_MAPPING.fetch(name, name)
      callback = "on_send_#{name}"

      value_stack.add_stack

      execute_callback(callback, node)
    end
643304
def _send_char(self,value):
        

        if type(value) != str and type(value) != bytes:
            err = "char requires a string or bytes array of length 1"
            raise ValueError(err)

        if len(value) != 1:
            err = "char must be a single character, not \"{}\"".format(value)
            raise ValueError(err)

        if type(value) != bytes:
            value = value.encode("ascii")

        if value in self._escaped_characters:
            err = "Cannot send a control character as a single char to arduino.  Send as string instead."
            raise OverflowError(err)

        return struct.pack('c',value)
841411
def propose_value(self, value, assume_leader=False):
        
        if value is None:
            raise ValueError("Not allowed to propose value None")
        paxos = self.paxos_instance
        paxos.leader = assume_leader
        msg = paxos.propose_value(value)
        if msg is None:
            msg = paxos.prepare()
        self.setattrs_from_paxos(paxos)
        self.announce(msg)
        return msg
750660
def send(self, sender: PytgbotApiBot):
        
        return sender.send_voice(
            # receiver, self.media, disable_notification=self.disable_notification, reply_to_message_id=reply_id
            voice=self.voice, chat_id=self.receiver, reply_to_message_id=self.reply_id, caption=self.caption, parse_mode=self.parse_mode, duration=self.duration, disable_notification=self.disable_notification, reply_markup=self.reply_markup
        )
841307
public void onMuted(AVIMClient client, AVIMConversation conversation, String operator) {
    LOGGER.d("Notification --- " + " you are muted by " + operator );
  }