Initializes the class for remote API Calls
@param {ChangeTipConfig} config
@returns {ChangeTip}
183812
function (config) {
        config = config || {};
        this.api_key = config.api_key;
        this.host = config.host || undefined;
        this.api_version = config.api_version || undefined;
        this.dev_mode = config.dev_mode || false;
        return this;
    }
230707
function(_config) {
        var self = this;

        if(!_config) {
            throw new Error("You must give bitcoinaddress config object");
        }
        this.config = _config;
        $ = this.config.jQuery || jQuery;
        this.scan();
        this.initUX();
    }
1320134
function (className,config)
		{
			var component = this.createClass(className,config);
			if (component)
				component.setParent(this);
			return component;
		}
271051
public static void initializeClient(Config config, String sessionToken) {
        // Override returnUrl until introduction of FilestackUi class which will allow to set this
        // all up manually.
        Config overridenConfig = new Config(config.getApiKey(), "filestack://done",
                config.getPolicy(), config.getSignature());

        client = new Client(overridenConfig);
        client.setSessionToken(sessionToken);
    }
539944
function(config) {
        this.audioBlob = config.audioBlob;
        this.videoBlob = config.videoBlob;
        this.gifBlob = config.gifBlob;

        this.init();

        return this;
    }
977775
function (config) {
        config = config || {};

        if (config.onStart !== undefined) {
            if (!isFunction(config.onStart)) {
                throw new core.TypeError({
                    code: 'application-configure',
                    message: "config.onStart must be a function"
                });
            }

            this.onStart = config.onStart;
        }

        if (config.onStop !== undefined) {
            if (!isFunction(config.onStop)) {
                throw new core.TypeError({
                    code: 'application-configure',
                    message: "config.onStop must be a function"
                });
            }
            this.onStop = config.onStop;
        }

        return this;
    }
633140
function INIT(config) {
  if (__init) return;

  CONF = _.extend(CONF, config)

  LOG = LOG.use(require('./lib/sentry')(CONF.sentry))

  JOBS = Q.init(CONF, LOG)

  if (CONF.auth)
    WWW.use('/'+CONF.admin_url_prefix,
            express.basicAuth(CONF.auth.user, CONF.auth.pass));

  WWW.use(express.bodyParser())
  WWW.use('/'+CONF.admin_url_prefix, Q.kue.app)

  __init = true
}
1117629
protected function initService($config) {
        $rs = NULL;

        if ($config instanceOf Closure) {
            $rs = $config();
        } elseif (is_string($config) && class_exists($config)) {
            $rs = new $config();
            if(is_callable(array($rs, 'onInitialize'))) {
                call_user_func(array($rs, 'onInitialize'));
            }
        } else {
            $rs = $config;
        }

        return $rs;
    }
1276837
function(config) {
  if (!(this instanceof CTRLLR)) {
    return new CTRLLR(config);
  }

  var alias = this;
  alias.init(config || null);

  return alias;
}
1225961
function (jsonConfig, treeId ) {

        /**
         * @param {object} jsonConfig
         * @param {number} treeId
         * @returns {Tree}
         */
        this.reset = function( jsonConfig, treeId ) {
            this.initJsonConfig = jsonConfig;
            this.initTreeId = treeId;

            this.id = treeId;

            this.CONFIG = UTIL.extend( Tree.CONFIG, jsonConfig.chart );
            this.drawArea = UTIL.findEl( this.CONFIG.container, true );
            if ( !this.drawArea ) {
                throw new Error( 'Failed to find element by selector "'+this.CONFIG.container+'"' );
            }

            UTIL.addClass( this.drawArea, 'Treant' );

            // kill of any child elements that may be there
            this.drawArea.innerHTML = '';

            this.imageLoader = new ImageLoader();

            this.nodeDB = new NodeDB( jsonConfig.nodeStructure, this );

            // key store for storing reference to node connectors,
            // key = nodeId where the connector ends
            this.connectionStore = {};

            this.loaded = false;

            this._R = new Raphael( this.drawArea, 100, 100 );

            return this;
        };

        /**
         * @returns {Tree}
         */
        this.reload = function() {
            this.reset( this.initJsonConfig, this.initTreeId ).redraw();
            return this;
        };

        this.reset( jsonConfig, treeId );
    }
904911
function (options) {
            var key;
            for (key in this.config) {
                if (this.config.hasOwnProperty(key) && this.config[key].singleton) {
                    this._init(key, options);
                }
            }
            return this;
        }
789187
function configureFetch(init) {
  // If the user only provided a query string
  if (typeof init === 'string') {
    var request = {
      method: init.method || 'POST',
      headers: init.headers || {
        'Content-Type': 'application/json',
        Accept: 'application/json'
      },
      body: JSON.stringify({
        query: init
      })
    };

    // If the user provided an actual configuration object
  } else {
    var request = {
      method: init.method || 'POST',
      headers: init.headers || {
        'Content-Type': 'application/json',
        Accept: 'application/json'
      },
      body:
        init.body ||
        JSON.stringify({
          query: init.fields,
          variables: init.variables
        }),
      mode: init.mode,
      credentials: init.credentials,
      cache: init.cache,
      redirect: init.redirect,
      referrer: init.referrer,
      referrerPolicy: init.referrerPolicy,
      integrity: init.integrity,
      keepalive: init.keepalive,
      signal: init.signal
    };
  }

  return request;
}
813408
function setConfig(configs) {
    configProperties = platformConfigs;
    provider.platform[platformName] = {};

    addConfig(configProperties, configProperties.platform[platformName]);

    createConfig(configProperties.platform[platformName], provider.platform[platformName], '');
  }
653394
function(suppliedConfig, global) {

    // Allows mokcing the window object if passed
    global = global || window;
    config.setGlobal(global)

    // Make sure that SDK is ready and debug flag is checked early
    var localConfig = config.setDefaults(suppliedConfig || {});
    config.update(localConfig);
    utils.logDebug(['Version:', getVersion()]);
    utils.logDebug(['Supplied config:', suppliedConfig]);

    // Set rootTarget to the target element and clean before child nodes before continuing
    try {
      render.prepareDOM(suppliedConfig || {});
    } catch (e) {
      utils.logError(e)
      return this
    }

    // Check whether a config is supplied
    if (!utils.doesConfigExist(suppliedConfig)) {
      render.triggerError('No configuration was supplied. Please supply a config object upon library initialization');
      return this
    }

    // Start from local config
    if (!utils.isRemoteProject(suppliedConfig) || suppliedConfig.disable_remote_load) {
      var mergedConfig = config.setDefaultsWithoutProject(suppliedConfig)
      return startWithConfig(mergedConfig)
    }

    // Load remote embedded config
    if (utils.isEmbeddedProject(suppliedConfig)) {
      loadRemoteEmbeddedProject(suppliedConfig)
    }

    // Load remote hosted config
    if (utils.isHostedProject(suppliedConfig)) {
      loadRemoteHostedProject(suppliedConfig)
    }

    return this
  }
1167243
function init(theConfig) {
        exports.config = theConfig;

        Inspector.on("error", _onError);
        Inspector.Inspector.on("detached", _onDetached);

        // Only listen for styleSheetAdded
        // We may get interim added/removed events when pushing incremental updates
        CSSAgent.on("styleSheetAdded.livedev", _styleSheetAdded);

        MainViewManager
            .on("currentFileChange", _onFileChanged);
        DocumentManager
            .on("documentSaved", _onDocumentSaved)
            .on("dirtyFlagChange", _onDirtyFlagChange);
        ProjectManager
            .on("beforeProjectClose beforeAppClose", close);

        // Initialize exports.status
        _setStatus(STATUS_INACTIVE);
    }
506463
function init(config) {
        exports.config = config;
        MainViewManager
            .on("currentFileChange", _onFileChange);
        DocumentManager
            .on("documentSaved", _onDocumentSaved)
            .on("dirtyFlagChange", _onDirtyFlagChange);
        ProjectManager
            .on("beforeProjectClose beforeAppClose", close);

        // Default transport for live connection messages - can be changed
        setTransport(NodeSocketTransport);

        // Default launcher for preview browser - can be changed
        setLauncher(DefaultLauncher);

        // Initialize exports.status
        _setStatus(STATUS_INACTIVE);
    }
742898
function init(config) {
    var deferred = Q.defer();

    connect(config.mongo.url, config.mongo.debug, config.mongo.mongos)
        .then(function () {

            IdxInfoModel = getModel({
                name: 'idx',
                fields: {
                    str: { type: String, index: { unique: true } },
                    name: String,
                    count: Number
                }
            });

            deferred.resolve(config);
        })
        .catch(function (err) {
            deferred.reject(err);
        });

    return deferred.promise;
}