Ensure the given argument is a valid webhook ID.

 @param id [String] webhook ID
 @return true if valid
 @raise Wavefront::Exceptions::InvalidWebhook if not valid
18009
def wf_webhook_id?(id)
      return true if id.is_a?(String) && id =~ /^[a-zA-Z0-9]{16}$/
      raise Wavefront::Exception::InvalidWebhookId
    end
1193331
def id=(id)

      if !id.nil? && id.to_s.length > 255
        fail ArgumentError, "invalid value for 'id', the character length must be smaller than or equal to 255."
      end

      @id = id
    end
1000869
def valid_usaf_id_or_raise(usaf_id):
    
    conn = metadata_db_connection_proxy.get_connection()
    cur = conn.cursor()

    cur.execute(
        """
      select exists (
        select
          usaf_id
        from
          isd_station_metadata
        where
          usaf_id = ?
      )
    """,
        (usaf_id,),
    )
    (exists,) = cur.fetchone()
    if exists:
        return True
    else:
        raise UnrecognizedUSAFIDError(usaf_id)
540642
def is_img_id_valid(img_id):
    
    t = re.sub(r'[^a-z0-9_:\-\.]', '', img_id, re.IGNORECASE)
    t = re.sub(r'\.+', '.', t)
    if img_id != t or img_id.count(':') != 1:
        return False
    profile, base_name = img_id.split(':', 1)
    if not profile or not base_name:
        return False
    try:
        get_profile_configs(profile)
    except ValueError:
        return False
    return True
578098
def verify(self, id):
        
        url = self._url('%s/verify' % (id))
        return self.client.post(url)
280155
def update!
      client.put("/webhooks/#{id}", {
        description: description,
        idModel: id_model,
        callbackURL: callback_url,
        active: active
      })
    end
1074558
def should_see_id(self, element_id):
    

    elements = ElementSelector(
        world.browser,
        'id("%s")' % element_id,
        filter_displayed=True,
    )
    if not elements:
        raise AssertionError("Expected element with given id.")
65778
def id_exists(api, search_id):
    
    response = utils.checked_api_call(api, 'get_specific', id=search_id)
    return response is not None
587092
function isGitHooks () {
  return co(function * () {
    const ppid = yield getPPID()

    debug(`ppid: ${ppid}`)

    return isRunByHusky(ppid)
  }).catch(/* istanbul ignore next */ function (err) {
    debug('error: %o', err)
    return false
  })
}
1007600
def type_id=(id)
      type_id = id.to_i

      raise InvalidShippingTypeError,
        "invalid #{id.inspect} type id" unless TYPE.value?(type_id)

      @type_id = type_id
      @type_name = TYPE.key(type_id)
    end
1116273
def is_valid(self, wordid) -> bool:
        
        return self.finished() or wordid != self.eos_id or (self.num_needed() == 1 and self.eos_id in self.allowed())
431090
def wf_source_id?(source)
      if source.is_a?(String) && source.match(/^[\w\.\-]+$/) &&
         source.size < 1024
        return true
      end

      raise Wavefront::Exception::InvalidSourceId
    end
1170487
def location_id=(location_id)
      if location_id.nil?
        fail ArgumentError, "location_id cannot be nil"
      end

      if location_id.to_s.length < 1
        fail ArgumentError, "invalid value for 'location_id', the character length must be great than or equal to 1."
      end

      @location_id = location_id
    end
631984
def wf_alert_severity?(severity)
      return true if %w[INFO SMOKE WARN SEVERE].include?(severity)
      raise Wavefront::Exception::InvalidAlertSeverity
    end
742510
private boolean isUbiqueInBothContexts(String id)
	{
		return context.containsKey(id) && context.get(id) == null;
	}
1106062
def verify_chatwork_webhook_signature!(token = nil)
      ChatworkWebhookVerify.verify!(
        token:     token,
        body:      request.env["rack.input"].read,
        signature: request.headers["X-ChatWorkWebhookSignature"] || params[:chatwork_webhook_signature],
      )
    rescue ChatworkWebhookVerify::InvalidSignatureError, ::ArgumentError
      raise ActionController::BadRequest, "signature is invalid"
    end
155817
def wf_link_template?(template)
      if template.is_a?(String) &&
         template.start_with?('http://', 'https://')
        return true
      end

      raise Wavefront::Exception::InvalidLinkTemplate
    end