Class: AssetAPI

engine.asset.onAssetSourceAdded((sourceID) => {
  console.log(`Added source: ${sourceID}`);
});

(): void;

onAssetSourceAdded(callback: (sourceID: string) => void): () => void

engine.asset.onAssetSourceRemoved((sourceID) => {
  console.log(`Removed source: ${sourceID}`);
});

(): void;

onAssetSourceRemoved(callback: (sourceID: string) => void): () => void

engine.asset.onAssetSourceUpdated((sourceID) => {
  console.log(`Updated source: ${sourceID}`);
});

(): void;

onAssetSourceUpdated(callback: (sourceID: string) => void): () => void

engine.asset.addSource({
  id: 'foobar',
  async findAssets(queryData) {
    return Promise.resolve({
      assets: [
        {
          id: 'logo',
          meta: {
            uri: 'https://img.ly/static/ubq_samples/imgly_logo.jpg',
          }
        }
      ],
      total: 1,
      currentPage: queryData.page,
      nextPage: undefined
    });
  },
});

addSource(source: AssetSource): void

engine.asset.addLocalSource('local-source');

addLocalSource(id: string, supportedMimeTypes?: string[], applyAsset?: (asset: CompleteAssetResult) => Promise<undefined | number>, applyAssetToBlock?: (asset: CompleteAssetResult, block: number) => Promise<void>): void

engine.asset.removeSource('asset-source-id');

removeSource(id: string): void

engine.asset.findAllSources();

findAllSources(): string[]

const result = await engine.asset.findAssets('asset-source-id', {
  page: 0,
  perPage: 100
});
const asset = result.assets[0];

findAssets(sourceId: string, query: AssetQueryData): Promise<AssetsQueryResult<CompleteAssetResult>>

fetchAsset(sourceId: string, assetId: string): Promise<null | CompleteAssetResult>

const groups = engine.asset.getGroups(customSource.id);

getGroups(id: string): Promise<string[]>

const mimeTypes = engine.asset.getSupportedMimeTypes('asset-source-id');

getSupportedMimeTypes(sourceId: string): string[]

const credits = engine.asset.getCredits('asset-source-id');

getCredits(sourceId: string): undefined | object

const license = engine.asset.getLicense('asset-source-id');

getLicense(sourceId: string): undefined | object

engine.asset.canManageAssets('asset-source-id');

canManageAssets(sourceId: string): boolean

await engine.asset.apply('asset-source-id', assetResult.assets[0]);

apply(sourceId: string, assetResult: AssetResult): Promise<undefined | number>

await engine.asset.applyToBlock('asset-source-id', assetResult.assets[0]);

applyToBlock(sourceId: string, assetResult: AssetResult, block: number): Promise<void>

const asset = assetResult.assets[0];
if (asset.payload && asset.payload.properties) {
  for (const property of asset.payload.properties) {
    await engine.asset.applyProperty('asset-source-id', asset, property);
  }
}

applyProperty(sourceId: string, assetResult: AssetResult, property: AssetProperty): Promise<void>

engine.asset.addSource({
  id: 'foobar',
  async findAssets(queryData) {
    return Promise.resolve({
      assets: [
        {
          id: 'logo',
          meta: {
            uri: 'https://img.ly/static/ubq_samples/imgly_logo.jpg',
          }
        }
      ],
      total: 1,
      currentPage: queryData.page,
      nextPage: undefined
    });
  },
  async applyAsset(assetResult) {
    return engine.asset.defaultApplyAsset(assetResult);
  },
});

defaultApplyAsset(assetResult: AssetResult): Promise<undefined | number>

engine.asset.addSource({
  id: 'foobar',
  async findAssets(queryData) {
    return Promise.resolve({
      assets: [
        {
          id: 'logo',
          meta: {
            uri: 'https://img.ly/static/ubq_samples/imgly_logo.jpg',
          }
        }
      ],
      total: 1,
      currentPage: queryData.page,
      nextPage: undefined
    });
  },
  async applyAssetToBlock(assetResult, block) {
    engine.asset.defaultApplyAssetToBlock(assetResult, block);
  },
});

defaultApplyAssetToBlock(assetResult: AssetResult, block: number): Promise<void>

engine.asset.addAssetToSource('local-source', {
  id: 'asset-id',
  label: {
    en: 'My Asset'
  },
  meta: {
    uri: 'https://example.com/asset.jpg',
    mimeType: 'image/jpeg'
  }
});

addAssetToSource(sourceId: string, asset: AssetDefinition): void

engine.asset.removeAssetFromSource('local-source', 'asset-id');

removeAssetFromSource(sourceId: string, assetId: string): void

engine.asset.assetSourceContentsChanged('asset-source-id');

assetSourceContentsChanged(sourceID: string): void

engine.asset.unstable_registerApplyAssetMiddleware(async (sourceId, assetResult, apply) => {
  // do something before applying the asset
  // You still have the choice to call apply or skip it
  const blockId = await apply(sourceId, assetResult);
  // do something after applying the asset
  return blockId;
})

engine.asset.unstable_registerApplyAssetToBlockMiddleware(async (sourceId, assetResult, block, applyToBlock) => {
  // do something before applying the asset
  // You still have the choice to call applyToBlock or skip it
  await applyToBlock(sourceId, assetResult, block);
  // do something after applying the asset
})