Use this API to add authenticationradiusaction resources.
359448
public static base_responses add(nitro_service client, authenticationradiusaction resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			authenticationradiusaction addresources[] = new authenticationradiusaction[resources.length];
			for (int i=0;i<resources.length;i++){
				addresources[i] = new authenticationradiusaction();
				addresources[i].name = resources[i].name;
				addresources[i].serverip = resources[i].serverip;
				addresources[i].serverport = resources[i].serverport;
				addresources[i].authtimeout = resources[i].authtimeout;
				addresources[i].radkey = resources[i].radkey;
				addresources[i].radnasip = resources[i].radnasip;
				addresources[i].radnasid = resources[i].radnasid;
				addresources[i].radvendorid = resources[i].radvendorid;
				addresources[i].radattributetype = resources[i].radattributetype;
				addresources[i].radgroupsprefix = resources[i].radgroupsprefix;
				addresources[i].radgroupseparator = resources[i].radgroupseparator;
				addresources[i].passencoding = resources[i].passencoding;
				addresources[i].ipvendorid = resources[i].ipvendorid;
				addresources[i].ipattributetype = resources[i].ipattributetype;
				addresources[i].accounting = resources[i].accounting;
				addresources[i].pwdvendorid = resources[i].pwdvendorid;
				addresources[i].pwdattributetype = resources[i].pwdattributetype;
				addresources[i].defaultauthenticationgroup = resources[i].defaultauthenticationgroup;
				addresources[i].callingstationid = resources[i].callingstationid;
			}
			result = add_bulk_request(client, addresources);
		}
		return result;
	}
339287
def auth_add(name, service, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('auth:group:members:add', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
        'service': service,
    })
1333669
@Override
    void authenticate(Map<String, Object> options) {
        final Map<String, Object> auth = new HashMap<>();
        auth.put(AbstractReplicatorConfiguration.REPLICATOR_AUTH_TYPE, AbstractReplicatorConfiguration.AUTH_TYPE_BASIC);
        auth.put(AbstractReplicatorConfiguration.REPLICATOR_AUTH_USER_NAME, username);
        auth.put(AbstractReplicatorConfiguration.REPLICATOR_AUTH_PASSWORD, password);
        options.put(AbstractReplicatorConfiguration.REPLICATOR_AUTH_OPTION, auth);
    }
1187022
function addPermission(rbac, action, resource, cb) {
  rbac.getPermission(action, resource, (err, permission) => {
    if (err) {
      return cb(err);
    }

    if (!permission) {
      return cb(new Error('Permission not exists'));
    }

    if (indexOf(this.permissions, permission.name) !== -1) {
      return cb(new Error('Permission is already assigned'));
    }

    this.permissions.push(permission.name);
    return this.save((err2, user) => {
      if (err2) {
        return cb(err2);
      }

      if (!user) {
        return cb(new Error('User is undefined'));
      }

      return cb(null, true);
    });
  });

  return this;
}
47746
def add(self, auth, method, args, notimeout=False):
        """"""
        authstr = self._authstr(auth)
        self._requests.setdefault(authstr, []).append((method, args))
        self._notimeouts.setdefault(authstr, False)
        if notimeout:
            self._notimeouts[authstr] = notimeout
1359382
public void configReady() {
        if (authenticationService != null) {
            JAASChangeNotifier notifier = jaasChangeNotifierService.getService();
            if (notifier != null) {
                notifier.notifyListeners();
            }
        }
    }
594378
@InterfaceAudience.Public
    public void setAuthenticator(Authenticator authenticator) {
        properties.put(ReplicationField.AUTHENTICATOR, authenticator);
        replicationInternal.setAuthenticator(authenticator);
    }
99841
public void registerAuthenticationListener(String realm, AuthenticationListener listener) {
        if (realm == null || realm.isEmpty()) {
            throw new InvalidParameterException("The realm name can't be null or empty.");
        }

        if (listener == null) {
            throw new InvalidParameterException("The authentication listener object can't be null.");
        }

        ChallengeHandler handler = new ChallengeHandler();
        handler.initialize(realm, listener);
        challengeHandlers.put(realm, handler);
    }
345649
public SID addSubAuthority(byte[] sub) {
        if (sub == null || sub.length != 4) {
            throw new IllegalArgumentException("Invalid sub-authority to be added");
        }

        this.subAuthorities.add(Arrays.copyOf(sub, sub.length));
        return this;
    }
1260834
async def AddPendingResources(self, addcharmwithauthorization, entity, resources):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Resources',
                   request='AddPendingResources',
                   version=1,
                   params=_params)
        _params['AddCharmWithAuthorization'] = addcharmwithauthorization
        _params['Entity'] = entity
        _params['Resources'] = resources
        reply = await self.rpc(msg)
        return reply
66172
public void authenticate() {
    if (mAccount == null) {
      // Create account also performs authentication.
      createAccount();
    } else {
      mAccess = mAccount.authenticate();
      if (mRegion != null) {
        mAccess.setPreferredRegion(mRegion);
      }
    }
  }
404315
function AuthenticationOAuth(options) {
    AuthenticationAbstract.call(this, options);
    options = options || {};
    this._token = {
        access: options.accessToken || null
    };
}
878728
@Override
    public SignUpRequest addAuthenticationParameters(Map<String, Object> parameters) {
        authenticationRequest.addAuthenticationParameters(parameters);
        return this;
    }
880145
def add_client_to_manifest(self, client_id, client_secret, manifest):
        
        assert self.is_admin, "Must authenticate() as admin to create client"
        return self.uaac.add_client_to_manifest(client_id, client_secret,
                manifest)
238540
@Override
    public T setResourceAdapterXML(Asset resource) throws IllegalArgumentException {
        Validate.notNull(resource, "Resource must be specified");
        return addAsManifestResource(resource, "ra.xml");
    }
107079
@Override
    public AuthenticationRequest setRealm(String realm) {
        if (hasLegacyPath()) {
            Log.w(TAG, "Not setting the 'realm' parameter as the request is using a Legacy Authorization API endpoint that doesn't support it.");
            return this;
        }
        addParameter(REALM_KEY, realm);
        return this;
    }
843624
public void startAuthActivity(Context context, Bundle extras) {
        if (!startDelegateActivity(context, delegate.getAuthStartIntent(), extras)) {
            startActivity(context, extras, AuthActivity.class);
        }
    }