Use this API to add appfwjsoncontenttype.
481490
public static base_response add(nitro_service client, appfwjsoncontenttype resource) throws Exception {
		appfwjsoncontenttype addresource = new appfwjsoncontenttype();
		addresource.jsoncontenttypevalue = resource.jsoncontenttypevalue;
		addresource.isregex = resource.isregex;
		return addresource.add_resource(client);
	}
1145753
def app_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/apps.json"
        return self.call(api_path, method="POST", data=data, **kwargs)
1325161
public static appfwjsoncontenttype[] get(nitro_service service, options option) throws Exception{
		appfwjsoncontenttype obj = new appfwjsoncontenttype();
		appfwjsoncontenttype[] response = (appfwjsoncontenttype[])obj.get_resources(service,option);
		return response;
	}
705348
function addJSONProperties(jsonData, propertiesGroups, filePath, currentNamesPath) {

        var i,
            group,
            propertyDefinition,
            propertyDefinitionWithoutObjectName,
            propertyName,
            data;

        if (currentNamesPath === undefined) {
            currentNamesPath = '';
        }

        // get all values
        for (i in jsonData) {

            // add to group if is a simply object
            if (jsonData[i] instanceof Array || jsonData[i] == null || typeof jsonData[i] !== 'object' || grunt.util._.isEmpty(jsonData[i])) {

                // find group
                propertyDefinition = (currentNamesPath ? currentNamesPath + '.' + i : i)
                    .replace(/^[^.]+\./, '');
                group = propertiesUtils.getGroup(propertyDefinition, propertiesGroups);

                if (!group) {
                    grunt.log.error('Object ' + propertyDefinition + ' without init file');
                    return;
                }

                grunt.verbose.ok(propertyDefinition);

                // generate property data
                propertyDefinitionWithoutObjectName = propertyDefinition
                    .replace(group.pattern, '')
                    .replace(/^\./, '');
                propertyName = propertyDefinitionWithoutObjectName
                    .replace(/^prototype\./i, '');

                data = {
                    name:     propertyName,
                    comment:  '',

                    type:     'object',
                    isPublic: propertiesUtils.isPublic(propertyName),
                    isFromPrototype: propertiesUtils.isFromPrototype(propertyDefinitionWithoutObjectName),
                    filePath: filePath
                };


                // string -> "string"
                // true   -> true
                switch (typeof jsonData[i]) {
                case 'object':
                    if (jsonData[i] != null) {
                        data.source = JSON.stringify(jsonData[i]);
                    }
                    break;
                case 'string':
                    data.source = '"' + jsonData[i].split('"').join('\\"') + '"';
                    break;
                }
                if (data.source === undefined) {
                    data.source = '' + jsonData[i];
                }

                // add property data to prototype or inline array
                group[(data.isFromPrototype ? 'prototypeProperties' : 'inlineProperties')].push(data);
            } else {
                // is object
                // add attributeName to path and try to add
                addJSONProperties(jsonData[i], propertiesGroups, filePath, currentNamesPath ? currentNamesPath + '.' + i : i);
            }
        }
    }
1025056
public static base_response Import(nitro_service client, appfwsignatures resource) throws Exception {
		appfwsignatures Importresource = new appfwsignatures();
		Importresource.src = resource.src;
		Importresource.name = resource.name;
		Importresource.xslt = resource.xslt;
		Importresource.comment = resource.comment;
		Importresource.overwrite = resource.overwrite;
		Importresource.merge = resource.merge;
		Importresource.sha1 = resource.sha1;
		return Importresource.perform_operation(client,"Import");
	}
455028
public static base_response add(nitro_service client, appfwconfidfield resource) throws Exception {
		appfwconfidfield addresource = new appfwconfidfield();
		addresource.fieldname = resource.fieldname;
		addresource.url = resource.url;
		addresource.isregex = resource.isregex;
		addresource.comment = resource.comment;
		addresource.state = resource.state;
		return addresource.add_resource(client);
	}
301563
function populateApiFromInterface(api, iface) {
  Object.keys(iface).forEach(function (key) {
    api.add(key, iface[key]);
  });
}
733779
def push_app(self, content, content_url=None):
        '''
        '''
        parameters = {
            'app_key': self.app_key,
            'app_secret': self.app_secret
        }
        return self._push(content, 'app', parameters, content_url)
1125044
public static appfwxmlcontenttype[] get(nitro_service service) throws Exception{
		appfwxmlcontenttype obj = new appfwxmlcontenttype();
		appfwxmlcontenttype[] response = (appfwxmlcontenttype[])obj.get_resources(service);
		return response;
	}
890185
def content_type(self, data):
        """"""
        self._content_type = str(data)
        self.add_header('Content-Type', str(data))
711628
public static base_responses update(nitro_service client, appfwprofile resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			appfwprofile updateresources[] = new appfwprofile[resources.length];
			for (int i=0;i<resources.length;i++){
				updateresources[i] = new appfwprofile();
				updateresources[i].name = resources[i].name;
				updateresources[i].starturlaction = resources[i].starturlaction;
				updateresources[i].starturlclosure = resources[i].starturlclosure;
				updateresources[i].denyurlaction = resources[i].denyurlaction;
				updateresources[i].refererheadercheck = resources[i].refererheadercheck;
				updateresources[i].cookieconsistencyaction = resources[i].cookieconsistencyaction;
				updateresources[i].cookietransforms = resources[i].cookietransforms;
				updateresources[i].cookieencryption = resources[i].cookieencryption;
				updateresources[i].cookieproxying = resources[i].cookieproxying;
				updateresources[i].addcookieflags = resources[i].addcookieflags;
				updateresources[i].fieldconsistencyaction = resources[i].fieldconsistencyaction;
				updateresources[i].csrftagaction = resources[i].csrftagaction;
				updateresources[i].crosssitescriptingaction = resources[i].crosssitescriptingaction;
				updateresources[i].crosssitescriptingtransformunsafehtml = resources[i].crosssitescriptingtransformunsafehtml;
				updateresources[i].crosssitescriptingcheckcompleteurls = resources[i].crosssitescriptingcheckcompleteurls;
				updateresources[i].sqlinjectionaction = resources[i].sqlinjectionaction;
				updateresources[i].sqlinjectiontransformspecialchars = resources[i].sqlinjectiontransformspecialchars;
				updateresources[i].sqlinjectiononlycheckfieldswithsqlchars = resources[i].sqlinjectiononlycheckfieldswithsqlchars;
				updateresources[i].fieldformataction = resources[i].fieldformataction;
				updateresources[i].defaultfieldformattype = resources[i].defaultfieldformattype;
				updateresources[i].defaultfieldformatminlength = resources[i].defaultfieldformatminlength;
				updateresources[i].defaultfieldformatmaxlength = resources[i].defaultfieldformatmaxlength;
				updateresources[i].bufferoverflowaction = resources[i].bufferoverflowaction;
				updateresources[i].bufferoverflowmaxurllength = resources[i].bufferoverflowmaxurllength;
				updateresources[i].bufferoverflowmaxheaderlength = resources[i].bufferoverflowmaxheaderlength;
				updateresources[i].bufferoverflowmaxcookielength = resources[i].bufferoverflowmaxcookielength;
				updateresources[i].creditcardaction = resources[i].creditcardaction;
				updateresources[i].creditcard = resources[i].creditcard;
				updateresources[i].creditcardmaxallowed = resources[i].creditcardmaxallowed;
				updateresources[i].creditcardxout = resources[i].creditcardxout;
				updateresources[i].requestcontenttype = resources[i].requestcontenttype;
				updateresources[i].responsecontenttype = resources[i].responsecontenttype;
				updateresources[i].xmldosaction = resources[i].xmldosaction;
				updateresources[i].xmlformataction = resources[i].xmlformataction;
				updateresources[i].xmlsqlinjectionaction = resources[i].xmlsqlinjectionaction;
				updateresources[i].xmlsqlinjectiononlycheckfieldswithsqlchars = resources[i].xmlsqlinjectiononlycheckfieldswithsqlchars;
				updateresources[i].xmlsqlinjectionparsecomments = resources[i].xmlsqlinjectionparsecomments;
				updateresources[i].xmlxssaction = resources[i].xmlxssaction;
				updateresources[i].xmlwsiaction = resources[i].xmlwsiaction;
				updateresources[i].xmlattachmentaction = resources[i].xmlattachmentaction;
				updateresources[i].xmlvalidationaction = resources[i].xmlvalidationaction;
				updateresources[i].xmlerrorobject = resources[i].xmlerrorobject;
				updateresources[i].customsettings = resources[i].customsettings;
				updateresources[i].signatures = resources[i].signatures;
				updateresources[i].xmlsoapfaultaction = resources[i].xmlsoapfaultaction;
				updateresources[i].usehtmlerrorobject = resources[i].usehtmlerrorobject;
				updateresources[i].errorurl = resources[i].errorurl;
				updateresources[i].htmlerrorobject = resources[i].htmlerrorobject;
				updateresources[i].logeverypolicyhit = resources[i].logeverypolicyhit;
				updateresources[i].stripcomments = resources[i].stripcomments;
				updateresources[i].striphtmlcomments = resources[i].striphtmlcomments;
				updateresources[i].stripxmlcomments = resources[i].stripxmlcomments;
				updateresources[i].exemptclosureurlsfromsecuritychecks = resources[i].exemptclosureurlsfromsecuritychecks;
				updateresources[i].defaultcharset = resources[i].defaultcharset;
				updateresources[i].postbodylimit = resources[i].postbodylimit;
				updateresources[i].fileuploadmaxnum = resources[i].fileuploadmaxnum;
				updateresources[i].canonicalizehtmlresponse = resources[i].canonicalizehtmlresponse;
				updateresources[i].enableformtagging = resources[i].enableformtagging;
				updateresources[i].sessionlessfieldconsistency = resources[i].sessionlessfieldconsistency;
				updateresources[i].sessionlessurlclosure = resources[i].sessionlessurlclosure;
				updateresources[i].semicolonfieldseparator = resources[i].semicolonfieldseparator;
				updateresources[i].excludefileuploadfromchecks = resources[i].excludefileuploadfromchecks;
				updateresources[i].sqlinjectionparsecomments = resources[i].sqlinjectionparsecomments;
				updateresources[i].invalidpercenthandling = resources[i].invalidpercenthandling;
				updateresources[i].type = resources[i].type;
				updateresources[i].checkrequestheaders = resources[i].checkrequestheaders;
				updateresources[i].comment = resources[i].comment;
			}
			result = update_bulk_request(client, updateresources);
		}
		return result;
	}
641107
public static base_response add(nitro_service client, appfwpolicylabel resource) throws Exception {
		appfwpolicylabel addresource = new appfwpolicylabel();
		addresource.labelname = resource.labelname;
		addresource.policylabeltype = resource.policylabeltype;
		return addresource.add_resource(client);
	}
1127559
def install(cls, type_, name, src, *args, **kwargs):
        """"""
        data = kwargs.pop('data', None)
        if data is None:
            data = {
                'addon': {
                    'type': type_,
                    'name': name,
                    'src': src,
                }
            }
        cls.create(data=data, *args, **kwargs)
386524
def add_swagger(app, json_route, html_route, **kwargs):
    
    spec = getattr(app, SWAGGER_ATTR_NAME)
    if spec:
        spec = spec.swagger_definition(**kwargs)
    else:
        spec = {}
    encoded_spec = json.dumps(spec).encode("UTF-8")

    @app.route(json_route)
    def swagger():
        return Response(
            encoded_spec,
            # we allow CORS, so this can be requested at swagger.io
            headers={"Access-Control-Allow-Origin": "*"},
            content_type="application/json",
        )

    # add the statics
    static_root = get_swagger_static_root()
    swagger_body = generate_swagger_html(
        STATIC_PATH, json_route
    ).encode("utf-8")

    @app.route(html_route)
    def swagger_ui():
        return Response(swagger_body, content_type="text/html")

    # the blueprint work is the easiest way to integrate a static
    # directory into flask.
    blueprint = Blueprint('swagger', __name__, static_url_path=STATIC_PATH,
                          static_folder=static_root)
    app.register_blueprint(blueprint)
455780
public static base_response update(nitro_service client, appfwfieldtype resource) throws Exception {
		appfwfieldtype updateresource = new appfwfieldtype();
		updateresource.name = resource.name;
		updateresource.regex = resource.regex;
		updateresource.priority = resource.priority;
		updateresource.comment = resource.comment;
		return updateresource.update_resource(client);
	}
1348072
public static base_response add(nitro_service client, appfwxmlcontenttype resource) throws Exception {
		appfwxmlcontenttype addresource = new appfwxmlcontenttype();
		addresource.xmlcontenttypevalue = resource.xmlcontenttypevalue;
		addresource.isregex = resource.isregex;
		return addresource.add_resource(client);
	}
688962
def _addappt(self, iden, appt):
        '''
        
        '''
        if appt.nexttime:
            heapq.heappush(self.apptheap, appt)
        self.appts[iden] = appt
        if self.apptheap and self.apptheap[0] is appt:
            self._wake_event.set()