Set this Filelink's transform_url to include the detect_faces task

@throws FilestackException   if API call fails

@return json object
778134
public function debug()
    {
        // call TransformationMixin functions
        $json_response = $this->sendDebug($this->transform_url,
            $this->api_key, $this->security);

        return $json_response;
    }
1251310
public function remakeJson()
    {
        $json = json_encode([
            'last_remote_check' => (!is_null($this->lastRemoteCheck) ? $this->lastRemoteCheck->timestamp : null),
            'hooks'             => $this->hooks(),
        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);

        file_put_contents(base_path('hooks/hooks.json'), $json);
    }
304329
function transformManifest(buffer) {
  const content = JSON.parse(buffer.toString())
  if (environment === 'production') {
    const locales = fs.readdirSync(paths.appLocales())
    content.locales = {}
    content.langs = []
    for (const idx in locales) {
      const localContent = require(path.join(paths.appLocales(), locales[idx]))
      const lang = locales[idx].match(/^([^.]*).json$/)[1]
      content.locales[lang] = localContent.manifest ? localContent.manifest : {}
      content.langs.push(lang)
    }
  }
  // icon will be stored in public folder for app with public page
  if (
    hasPublic &&
    content.icon &&
    !content.icon.match(new RegExp(`${publicFolderName}/`))
  ) {
    content.icon = path.join(publicFolderName, content.icon)
  }
  return JSON.stringify(content, null, '  ')
}
230060
def to_json(self):
    
    # Use the member variable (since we don't have access to the context) to
    # flush each pool to minimize the size of each filehandle before we
    # serialize it.
    for pool in self._pools:
      if pool is not None:
        pool.flush(True)
    return {"filehandles": pickle.dumps(self._filehandles)}
1167663
public function ldJson()
    {
        $attributes = [
            '@context' => 'http://schema.org',
            '@type' => 'WebSite',
            'url' => $this->Url->build('/', true),
            'potentialAction' => [
                '@type' => 'SearchAction',
                'query-input' => 'required name=search_term_string',
                'target' => $this->Url->build([
                    'plugin' => 'Wasabi/Cms',
                    'controller' => 'Frontend/Search',
                    'action' => 'search',
                    'language_id' => Wasabi::contentLanguage()->id
                ], true) . '?q={search_term_string}'
            ]
        ];

        if (!empty(WasabiCms::$instanceName)) {
            $attributes['name'] = WasabiCms::$instanceName;
        }

        $sameAsKeys = [
            'Settings.Cms.SEO.Social.facebook_url',
            'Settings.Cms.SEO.Social.instagram_url',
            'Settings.Cms.SEO.Social.linkedin_url',
            'Settings.Cms.SEO.Social.myspace_url',
            'Settings.Cms.SEO.Social.pinterest_url',
            'Settings.Cms.SEO.Social.youtube_url',
            'Settings.Cms.SEO.Social.googleplus_url'
        ];
        $sameAs = [];

        foreach ($sameAsKeys as $key) {
            $setting = Configure::read($key);
            if (!empty($setting)) {
                $sameAs[] = $setting;
            }
        }

        $twitterName = Configure::read('Settings.Cms.SEO.Social.twitter_username');
        if (!empty($twitterName)) {
            $sameAs[] = 'https://twitter.com/' . $twitterName;
        }

        if (!empty($sameAs)) {
            $attributes['sameAs'] = $sameAs;
        }

        return '<script type="application/ld+json">' . json_encode($attributes) . '</script>';
    }
242140
public boolean createGdalTranslateTask(Integer importJobId, Integer importTaskId,
                                           List<String> optsGdalTranslate) throws URISyntaxException, HttpException {
        RESTGdalTranslateTransform transformTask = new RESTGdalTranslateTransform();
        if (!optsGdalTranslate.isEmpty()) {
            transformTask.setOptions(optsGdalTranslate);
        }
        return this.createTransformTask(importJobId, importTaskId, transformTask);
    }
1191452
private void pretifyJson(String pathToJson) throws ReportException {
        final String outputPath = pathToJson + ".pretty";
        final File in = new File(pathToJson);
        final File out = new File(outputPath);
        try (JsonReader reader = new JsonReader(new InputStreamReader(new FileInputStream(in), StandardCharsets.UTF_8));
                JsonWriter writer = new JsonWriter(new OutputStreamWriter(new FileOutputStream(out), StandardCharsets.UTF_8))) {
            prettyPrint(reader, writer);
        } catch (IOException ex) {
            LOGGER.debug("Malformed JSON?", ex);
            throw new ReportException("Unable to generate json report", ex);
        }
        if (out.isFile() && in.isFile() && in.delete()) {
            try {
                org.apache.commons.io.FileUtils.moveFile(out, in);
            } catch (IOException ex) {
                LOGGER.error("Unable to generate pretty report, caused by: {}", ex.getMessage());
            }
        }
    }
860778
function transformPreloadJSON(oFile) {
  const oJSONRaw = oFile.contents.toString('utf8')
  const sPrelaodJSON = `jQuery.sap.registerPreloadedModules(${oJSONRaw});`
  oFile.contents = new Buffer(sPrelaodJSON)
  return oFile
}
118849
public function generateDetectedFaceImage() {
			$cacheFile = $this->owner->cacheDetectedFaceFilename();

			$backend = Injector::inst()->createWithArgs(Image::get_backend(), array(
				Director::baseFolder()."/" . $this->owner->Filename
			));

			if($backend->hasImageResource()){
				$backend = $backend->detectedFaceImage($this->DetectFace());
				
				if($backend){
					$backend->writeTo(Director::baseFolder()."/" . $cacheFile);
				}
			}
		}
409674
public RequestContext renderJSONPretty(final JSONObject json) {
        final JsonRenderer jsonRenderer = new JsonRenderer();
        jsonRenderer.setJSONObject(json);
        jsonRenderer.setPretty(true);

        this.renderer = jsonRenderer;

        return this;
    }
598847
public void setJsonPath(URL url) throws IOException {
        String path = url.toString();
        if (path.startsWith(ValueConsts.LOCAL_FILE_URL)) {
            setJsonPath(NetUtils.urlToString(url));
        } else {
            setJsonObject(FileExecutor.read(url));
        }
    }
693853
public function convertToPng()
    {
        $fileType = 'jpg';
        $target = sprintf(
            '%s/%s.%s',
            $this->getTarget(),
            $this->getName(),
            $fileType
        );
        $image = $this->createImageFrom($this->getFilePath());
        imagejpeg($image, $target, 100);
        imagedestroy($image);
        $this->setCovertVars([
            'ext' => $fileType,
            'filepath' => $target
        ]);
        return $this;
    }
598066
@Override
    protected void visitFacetChildren(F facetValue, Predicate<Facet> predicate, PojoVisitor visitor) {
        elementsOf(facetValue).forEach(element -> elementBinding.visitChild(element, predicate, visitor));
    }
247219
public function setInlineTca($json)
    {
        // Generate TCA for IRRE Fields and Tables
        $notIrreTables = array("pages", "tt_content", "sys_file_reference");
        if ($json) {
            foreach ($json as $table => $subJson) {
                $fieldTCA = array();
                if (array_search($table, $notIrreTables) === false) {
                    // Generate Table TCA
                    $this->generateTableTca($table, $subJson["tca"]);
                    // Generate Field TCA
                    $fieldTCA = $this->generateFieldsTca($subJson["tca"]);
                    \TYPO3\CMS\Core\Utility\ExtensionManagementUtility::addTCAcolumns($table, $fieldTCA);

                    // set label for inline
                    if (!empty($json["tt_content"]["tca"][$table]["inlineLabel"])) {
                        $fields = array_keys($subJson["tca"]);
                        if (array_search($json["tt_content"]["tca"][$table]["inlineLabel"], $fields) !== false) {
                            $GLOBALS["TCA"][$table]["ctrl"]['label'] = $json["tt_content"]["tca"][$table]["inlineLabel"];
                        }
                    }
                    // set icon for inline
                    if (!empty($json["tt_content"]["tca"][$table]["inlineIcon"])) {
                        $GLOBALS["TCA"][$table]["ctrl"]['iconfile'] = $json["tt_content"]["tca"][$table]["inlineIcon"];
                    } else {
                        $GLOBALS["TCA"][$table]["ctrl"]['iconfile'] = "EXT:mask/Resources/Public/Icons/Extension.svg";
                    }

                    // hide table in list view
                    $GLOBALS["TCA"][$table]['ctrl']['hideTable'] = true;
                }
            }
        }
    }
208620
public function load()
    {
        if (self::$json === null) {
            self::$json = array();
            if (!empty($this->extSettings['json'])) {
                $file = MaskUtility::getFileAbsFileName($this->extSettings['json']);
                if (file_exists($file)) {
                    self::$json = json_decode(file_get_contents($file), true);
                }
            }
        }
        return self::$json;
    }
416040
public static function getMapStyleJSON()
    {
        $folders = [
            'client/dist/js/',
            'client/dist/javascript/',
            'dist/js/',
            'dist/javascript/',
            'src/javascript/thirdparty',
            'js/',
            'javascript/',
        ];
        $file = 'mapStyle.json';

        foreach ($folders as $folder) {
            if ($style = ThemeResourceLoader::inst()->findThemedResource(
                "{$folder}{$file}",
                SSViewer::get_themes()
            )) {
                return $style;
            }
        }

        return false;
    }
181286
public RequestContext renderJSON() {
        final JsonRenderer jsonRenderer = new JsonRenderer();
        final JSONObject ret = new JSONObject().put(Keys.STATUS_CODE, false);
        jsonRenderer.setJSONObject(ret);

        this.renderer = jsonRenderer;

        return this;
    }