[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of store-sitemap/node/middlewares/generateMiddlewares/generateAppsRoutes.test.ts from the store-sitemap VTEX app.

[Assistant]
Here's the implementation:

```typescript
import {
  Apps,
  IOContext,
  Logger,
  RequestConfig,
  Tenant,
  TenantClient,
  VBase,
  VBaseSaveResponse
} from '@vtex/api'
import * as TypeMoq from 'typemoq'

import { Clients } from '../../clients'
import { CONFIG_BUCKET, getBucket, hashString } from '../../utils'
import { } from './../../clients/rewriter'
import { generateAppsRoutes } from './generateAppsRoutes'
import { APPS_ROUTES_INDEX, DEFAULT_CONFIG, SitemapEntry, SitemapIndex } from './utils'

const tenantTypeMock = TypeMoq.Mock.ofInstance(TenantClient)
const appsTypeMock = TypeMoq.Mock.ofInstance(Apps)
const vbaseTypeMock = TypeMoq.Mock.ofInstance(VBase)
const contextMock = TypeMoq.Mock.ofType<EventContext>()
const ioContext = TypeMoq.Mock.ofType<IOContext>()
const state = TypeMoq.Mock.ofType<State>()
const loggerMock = TypeMoq.Mock.ofType<Logger>()

describe('Test rewriter routes generation', () => {
  let context: EventContext

  const vbase = class VBaseMock extends vbaseTypeMock.object {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private jsonData: Record<string, any> = {}

    constructor() {
      super(ioContext.object)
    }

    public getJSON = async <T>(
      bucket: string,
      file: string,
      nullOrUndefined?: boolean | undefined
    ): Promise<T> => {
      if (!this.jsonData[bucket]?.[file] && nullOrUndefined) {
        return (null as unknown) as T
      }
      return Promise.resolve(this.jsonData[bucket][file] as T)
    }

    public saveJSON = async <T>(
      bucket: string,
      file: string,
      data: T
    ): Promise<VBaseSaveResponse> => {
      if (!this.jsonData[bucket]) {
        this.jsonData[bucket] = {}
      }
      this.jsonData[bucket][file] = data
      return ({ etag: 'etag' } as unknown) as VBaseSaveResponse
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const tenant = class TenantMock extends tenantTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public info = async (_?: RequestConfig) => {
      return {
        bindings: [
        {
          id: '1',
        },
        {
          id: '2',
        },
      ],
    } as Tenant
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const apps = class AppsMock extends appsTypeMock.object {
    private builds: Record<string, any> = {
      ['vtex.app1@1.0.0']: {
        entries: ['/entry-1', '/entry-2'],
      },
      ['vtex.app2@1.0.0']: {
        entries: ['/entry-3'],
      },
      ['vtex.app3@1.0.0']: {
      },
    }
    constructor() {
      super(ioContext.object)
    }

    public getAppsMetaInfos = () => {
      return [
        { id: 'vtex.app1@1.0.0' },
        { id: 'vtex.app2@1.0.0' },
        { id: 'vtex.app3@1.0.0' },
      ] as any
    }

    public getAppJSON = (app: string, _: string, __?: boolean) => {
      return this.builds[app]
    }

    public setBuild = (app: string, data: any) => {
      this.builds[app] = data
    }
  }

  beforeEach(() => {
    // tslint:disable-next-line:max-classes-per-file
    const ClientsImpl = class ClientsMock extends Clients {
      get vbase() {
        return this.getOrSet('vbase', vbase)
      }

      get apps() {
        return this.getOrSet('apps', apps)

      }

      get tenant() {
        return this.getOrSet('tenant', tenant)
      }
    }
    context = {
      ...contextMock.object,
      body: {
        generationId: '1',
      },
      clients: new ClientsImpl({}, ioContext.object),
      state: {
        ...state.object,
      },
      vtex: {
        ...ioContext.object,
        logger: loggerMock.object,
      },
    }
  })

  it('Routes were saved', async () => {
    await generateAppsRoutes(context)
    const { vbase: vbaseClient } = context.clients
    const bucket = getBucket(DEFAULT_CONFIG.generationPrefix, hashString('1'))
    const { index } = await vbaseClient.getJSON<SitemapIndex>(bucket, APPS_ROUTES_INDEX, true)
    const expectedIndex = ['appsRoutes-0']
    expect(index).toStrictEqual(expectedIndex)
    const { routes: appsRoutes } = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[0])
    expect(appsRoutes).toStrictEqual([
      { id: '/entry-1', path: '/entry-1' },
      { id: '/entry-2', path: '/entry-2' },
      { id: '/entry-3', path: '/entry-3' },
    ])

    const appsCompleteFile = await vbaseClient.getJSON(CONFIG_BUCKET, APPS_ROUTES_INDEX)
    expect(appsCompleteFile).toBe('OK')
  })

  it('Splits routes if too many saved', async () => {
    const { vbase: vbaseClient, } = context.clients
    const appsClient = context.clients.apps as any

    const tooManyRoutes = new Array(5000).fill('/entry-1')
    const appsMetaInfos = await appsClient.getAppsMetaInfos()
    appsClient.setBuild(appsMetaInfos[0].id, { entries: tooManyRoutes })

    await generateAppsRoutes(context)
    const bucket = getBucket(DEFAULT_CONFIG.generationPrefix, hashString('1'))
    const { index } = await vbaseClient.getJSON<SitemapIndex>(bucket, APPS_ROUTES_INDEX, true)
    const expectedIndex = ['appsRoutes-0', 'appsRoutes-1']
    expect(index).toStrictEqual(expectedIndex)

    const { routes: routes0} = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[0])
    expect(routes0.length).toEqual(5000)

    const { routes: routes1 } = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[1])
    expect(routes1.length).toEqual(1)
  })
})

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of store-sitemap/node/middlewares/generateMiddlewares/generateProductRoutes.test.ts from the store-sitemap VTEX app.

[Assistant]
Here's the implementation:

```typescript
import {
  CatalogGraphQL,
  IOContext,
  Logger,
  RequestConfig,
  RequestTracingConfig,
  Tenant,
  TenantClient,
  VBase,
  VBaseSaveResponse
} from '@vtex/api'
import { Product } from '@vtex/api/lib/clients/apps/catalogGraphQL/product'
import * as TypeMoq from 'typemoq'
import { TranslateArgs } from 'vtex.messages'

import { Clients } from '../../clients'
import { Messages } from '../../clients/messages'
import { getBucket, hashString } from '../../utils'
import { Catalog, GetProductsAndSkuIdsReponse } from './../../clients/catalog'
import { GraphQLServer, ProductNotFound } from './../../clients/graphqlServer'
import { STORE_PRODUCT } from './../../utils'
import { generateProductRoutes } from './generateProductRoutes'
import {
  GENERATE_PRODUCT_ROUTES_EVENT,
  GROUP_ENTRIES_EVENT,
  initializeSitemap,
  PRODUCT_ROUTES_INDEX,
  RAW_DATA_PREFIX,
  SitemapEntry,
  SitemapIndex,
} from './utils'

const tenantTypeMock = TypeMoq.Mock.ofInstance(TenantClient)
const messagesTypeMock = TypeMoq.Mock.ofInstance(Messages)
const graphqlServerTypeMock = TypeMoq.Mock.ofInstance(GraphQLServer)
const catalogTypeMock = TypeMoq.Mock.ofInstance(Catalog)
const catalogGraphQLTypeMock = TypeMoq.Mock.ofInstance(CatalogGraphQL)
const vbaseTypeMock = TypeMoq.Mock.ofInstance(VBase)
const contextMock = TypeMoq.Mock.ofType<EventContext>()
const ioContext = TypeMoq.Mock.ofType<IOContext>()
const state = TypeMoq.Mock.ofType<State>()
const loggerMock = TypeMoq.Mock.ofType<Logger>()

let next: any
let tenantInfo = {
  bindings: [
  {
    defaultLocale: 'en-US',
    extraContext: {
      portal: {
        salesChannel: '1',
      },
    },
    id: '1',
    targetProduct: STORE_PRODUCT,
  },
  {
      defaultLocale: 'pt-BR',
      extraContext: {
        portal: {
          salesChannel: '1',
        },
      },
      id: '2',
      targetProduct: STORE_PRODUCT,
    },
  ] as any,
  defaultLocale: 'en-US',
}

describe('Test product routes generation', () => {
  let context: EventContext

  const vbase = class VBaseMock extends vbaseTypeMock.object {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private jsonData: Record<string, any> = {}

    constructor() {
      super(ioContext.object)
    }

    public getJSON = async <T>(
      bucket: string,
      file: string,
      nullOrUndefined?: boolean | undefined
    ): Promise<T> => {
      if (!this.jsonData[bucket]?.[file] && nullOrUndefined) {
        return (null as unknown) as T
      }
      return Promise.resolve(this.jsonData[bucket][file] as T)
    }

    public saveJSON = async <T>(
      bucket: string,
      file: string,
      data: T
    ): Promise<VBaseSaveResponse> => {
      if (!this.jsonData[bucket]) {
        this.jsonData[bucket] = {}
      }
      this.jsonData[bucket][file] = data
      return Promise.resolve({}) as Promise<VBaseSaveResponse>
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const tenant = class TenantMock extends tenantTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public info = async (_?: RequestConfig) => {
      return tenantInfo as Tenant
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const catalog = class CatalogMock extends catalogTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public getProductsIds = async (page: number) => {
      switch (page) {
        case 2:
          return {
            items: [4, 5, 6],
            paging: { pages: 2, total: 51 },
          } as unknown as GetProductsAndSkuIdsReponse
        default:
          return {
            items: [1, 2, 3],
            paging: { pages: 2, total: 51 },
          } as unknown as GetProductsAndSkuIdsReponse
      }
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const catalogGraphQL = class CatalogGraphQLMock extends catalogGraphQLTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public product = async (productId: string, _?: RequestTracingConfig) => {
      let product
      switch (productId) {
        case '1':
          product = {
            id: '1',
            isActive: true,
            linkId: 'banana',
            salesChannel: [{ id: '1' }],
          }
          break
        case '2':
          product = {
            id: '2',
            isActive: false,
            linkId: 'inactive-banana',
            salesChannel: [{ id: '1' }],
          }
          break
        case '3':
          product = {
            id: '3',
            isActive: true,
            linkId: 'apple',
            salesChannel: [{ id: '1' }],
          }
          break
        case '4':
          product = {
            id: '4',
            isActive: true,
            linkId: 'watermelon',
            salesChannel: [{ id: '1' }],
          }
          break
        case '5':
          product = {
            id: '5',
            isActive: true,
            linkId: 'pinnaple',
            salesChannel: [{ id: '1' }],
          }
          break
        default:
          product = undefined
          break
      }
      return {
        product: product as unknown as Product,
      }
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const graphqlServer = class GraphqlServerMock extends graphqlServerTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public query =  async (_: string, variables: any, __: any) => {
      if (variables.identifier.value === '3') {
        throw new ProductNotFound([])
      }
      return 'something-not-null' as any
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const messages = class MessagesMock extends messagesTypeMock.object {
      constructor() {
        super(ioContext.object)
      }

      public translateNoCache = async (args: TranslateArgs) => {
        return args.indexedByFrom[0].messages.map(({ content }: any) => content)
      }
    }

  beforeEach(() => {
    // tslint:disable-next-line:max-classes-per-file
    const ClientsImpl = class ClientsMock extends Clients {
      get vbase() {
        return this.getOrSet('vbase', vbase)
      }

      get catalog() {
        return this.getOrSet('catalog', catalog)
      }

      get catalogGraphQL() {
        return this.getOrSet('catalogGraphQL', catalogGraphQL)
      }

      get messages() {
        return this.getOrSet('messages', messages)
      }

      get graphqlServer() {
        return this.getOrSet('graphqlServer', graphqlServer)
      }

      get tenant() {
        return this.getOrSet('tenant', tenant)
      }
    }
    context = {
      ...contextMock.object,
      body: {
        generationId: '1',
        invalidProducts: 0,
        page: 1,
        processedProducts: 0,
      },
      clients: new ClientsImpl({}, ioContext.object),
      state: {
        ...state.object,
      },
      vtex: {
        ...ioContext.object,
        logger: loggerMock.object,
      },
    }
    next = jest.fn()
  })

   it('Next event is sent', async () => {
     await generateProductRoutes(context, next)
     expect(next).toBeCalled()
     const { event, payload } = context.state.nextEvent
     expect(event).toEqual(GENERATE_PRODUCT_ROUTES_EVENT)
     expect((payload as any).page).toEqual(2)
   })

  it('Complete event is sent', async () => {
    const thisContext = {
      ...context,
      body: {
        ...context.body,
        page: 2,
      },
    }
    await initializeSitemap(thisContext, PRODUCT_ROUTES_INDEX)
    await generateProductRoutes(thisContext, next)
    expect(next).toBeCalled()
    expect(context.state.nextEvent).toStrictEqual({
      event: GROUP_ENTRIES_EVENT,
      payload: { from: 0, generationId: '1', indexFile: 'productRoutesIndex.json' },
    })
  })

  it('Routes were saved', async () => {
    await generateProductRoutes(context, next)
    const { vbase: vbaseClient } = context.clients
    const bucket = getBucket(RAW_DATA_PREFIX, hashString('1'))
    const { index } = await vbaseClient.getJSON<SitemapIndex>(bucket, PRODUCT_ROUTES_INDEX, true)
    const expectedIndex = ['product-1']
    expect(index).toStrictEqual(expectedIndex)
    const { routes } = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[0])
    expect(routes).toStrictEqual([
      {
        alternates: [
          { bindingId: '1', path: '/banana/p' },
          { bindingId: '2', path: '/banana/p' },
        ],
        id: '1',
        path: '/banana/p',
      },
    ])
  })

  it('Checks binding without SC case', async () => {
    tenantInfo = {
      bindings: [
        {
          defaultLocale: 'en-US',
          extraContext: {},
          id: '1',
          targetProduct: STORE_PRODUCT,
        },
      ],
      defaultLocale: 'en-US',
    } as Tenant
    await generateProductRoutes(context, next)
    const { vbase: vbaseClient } = context.clients
    const bucket = getBucket(RAW_DATA_PREFIX, hashString('1'))
    const { index } = await vbaseClient.getJSON<SitemapIndex>(bucket, PRODUCT_ROUTES_INDEX, true)
    const expectedIndex = ['product-1']
    expect(index).toStrictEqual(expectedIndex)
    const { routes } = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[0])
    expect(routes).toStrictEqual([
      {
        alternates: [
          { bindingId: '1', path: '/banana/p' },
        ],
        id: '1',
        path: '/banana/p',
      },
    ])
  })
})

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of store-sitemap/node/middlewares/generateMiddlewares/groupEntries.ts from the store-sitemap VTEX app.

[Assistant]
Here's the implementation:

```typescript
import { last } from 'ramda'
import { CONFIG_BUCKET, CONFIG_FILE, getBucket, getStoreBindings, hashString } from '../../utils'
import {
  cleanConfigBucket,
  completeRoutes,
  createFileName,
  currentDate,
  DEFAULT_CONFIG,
  GROUP_ENTRIES_EVENT,
  isSitemapComplete,
  RAW_DATA_PREFIX,
  SitemapEntry,
  SitemapIndex,
  splitFileName,
  uniq
} from './utils'

export const FILE_PROCESS_LIMIT = 750
export const FILE_LIMIT = 5000

const reduceByEntity = (array: string[]) => array.reduce((acc, file) => {
  const entity = splitFileName(file)[0]
  if (!acc[entity]) {
    acc[entity] = []
  }
  acc[entity].push(file)
  return acc
}, {} as Record<string, string[]>)

const groupEntityEntries = async (entity: string, files: string[], index: string[] | undefined, bucket: string, rawBucket: string, ctx: EventContext) => {
  const { clients: { vbase, vbaseWithCache }, vtex: { logger } } = ctx
  const lastFile = index && last(index)
  const lastFileData = lastFile ? await vbaseWithCache.getJSON<SitemapEntry>(bucket, lastFile) : { routes: [] as Route[] }
  let currentRoutes = lastFileData.routes
  let routesCount = currentRoutes.length
  let count = lastFile ? Number(splitFileName(lastFile)[1]) : 0

  const newFiles: string[] = []
  for (const file of files) {
    const { routes } = await vbase.getJSON<SitemapEntry>(rawBucket, file)
    routesCount += routes.length
    currentRoutes = [...currentRoutes, ...routes]
    if (currentRoutes.length > FILE_LIMIT) {
      const rest = currentRoutes.splice(FILE_LIMIT)
      const entry = createFileName(entity, count)
      newFiles.push(entry)
      await vbase.saveJSON<SitemapEntry>(bucket, entry, {
        lastUpdated: currentDate(),
        routes: uniq(currentRoutes),
      })
      currentRoutes = rest
      count++
    }
  }
  if (currentRoutes.length > 0) {
    const entry = createFileName(entity, count)
    newFiles.push(entry)
    await vbase.saveJSON<SitemapEntry>(bucket, entry, {
      lastUpdated: currentDate(),
      routes: uniq(currentRoutes),
    })
  }
  logger.info({
    count: routesCount,
    entity,
    messages: 'Routes grouped',
  })
  return newFiles
}

export async function groupEntries(ctx: EventContext, next: () => Promise<void>) {
  const {
    body,
    clients: {
      tenant,
      vbase,
      vbaseWithCache,
    },
    vtex: {
      logger,
    },
    state: {
      enabledIndexFiles,
    },
  } = ctx
  const { indexFile, generationId, from }: GroupEntriesEvent = body

  const { generationPrefix, productionPrefix } = await vbaseWithCache.getJSON<Config>(CONFIG_BUCKET, CONFIG_FILE, true) || DEFAULT_CONFIG
  const storeBindings = await getStoreBindings(tenant)

  const isBindingGroupingComplete = await Promise.all(storeBindings.map(async binding => {
    const rawBucket = getBucket(RAW_DATA_PREFIX, hashString(binding.id))
    const bucket = getBucket(generationPrefix, hashString(binding.id))
    const indexData = await vbase.getJSON<SitemapIndex>(rawBucket, indexFile)
    const rawIndex = uniq(indexData.index)
    const { index: newIndex } = from === 0
      ? { index: [] as string[] }
      : await vbase.getJSON<SitemapIndex>(bucket, indexFile, true) || { index: []as string[] }

    if (from > rawIndex.length) {
      return true
    }
    const slicedRawIndex = rawIndex.slice(from, from + FILE_PROCESS_LIMIT)
    const filesByEntity = reduceByEntity(slicedRawIndex)
    const indexByEntity = reduceByEntity(newIndex)
    const entries = await Promise.all(
      Object.keys(filesByEntity).map(async entity =>
        groupEntityEntries(
          entity,
          filesByEntity[entity],
          indexByEntity[entity],
          bucket,
          rawBucket,
          ctx
        )
      ))

    const index = uniq(entries.reduce((acc, entryList) => acc.concat(entryList), newIndex))
    await vbase.saveJSON<SitemapIndex>(bucket, indexFile, {
      index,
      lastUpdated: currentDate(),
    })

    return from + FILE_PROCESS_LIMIT > rawIndex.length
  }))

  const isAllGroupingsComplete = isBindingGroupingComplete.every(Boolean)
  if (isAllGroupingsComplete) {
     await completeRoutes(indexFile, vbase)

    const isComplete = await isSitemapComplete(enabledIndexFiles, vbase, logger)
    if (isComplete) {
      await vbase.saveJSON<Config>(CONFIG_BUCKET, CONFIG_FILE, {
        generationPrefix: productionPrefix,
        productionPrefix: generationPrefix,
      })
      await cleanConfigBucket(enabledIndexFiles, vbase)
      logger.info({ message: `Sitemap complete`, payload: body })
      return
    }
  } else {
    ctx.state.nextEvent = {
      event: GROUP_ENTRIES_EVENT,
      payload: {
        from: from + FILE_PROCESS_LIMIT,
        generationId,
        indexFile,
      },
    }

    await next()
  }
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of store-sitemap/node/middlewares/generateMiddlewares/generateRewriterRoutes.test.ts from the store-sitemap VTEX app.

[Assistant]
Here's the implementation:

```typescript
import { IOContext, Logger, RequestConfig, Tenant, TenantClient, VBase, VBaseSaveResponse } from '@vtex/api'
import * as TypeMoq from 'typemoq'
import { EntityLocator, Internal } from 'vtex.rewriter'

import { Clients } from '../../clients'
import { getBucket, hashString } from '../../utils'
import { Rewriter } from './../../clients/rewriter'
import { generateRewriterRoutes } from './generateRewriterRoutes'
import {
  GENERATE_REWRITER_ROUTES_EVENT,
  GROUP_ENTRIES_EVENT,
  initializeSitemap,
  RAW_DATA_PREFIX,
  REWRITER_ROUTES_INDEX,
  SitemapEntry,
  SitemapIndex,
} from './utils'

const tenantTypeMock = TypeMoq.Mock.ofInstance(TenantClient)
const rewriterTypeMock = TypeMoq.Mock.ofInstance(Rewriter)
const vbaseTypeMock = TypeMoq.Mock.ofInstance(VBase)
const contextMock = TypeMoq.Mock.ofType<EventContext>()
const ioContext = TypeMoq.Mock.ofType<IOContext>()
const state = TypeMoq.Mock.ofType<State>()
const loggerMock = TypeMoq.Mock.ofType<Logger>()

let next: any

describe('Test rewriter routes generation', () => {
  let context: EventContext

  const vbase = class VBaseMock extends vbaseTypeMock.object {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    private jsonData: Record<string, any> = {}

    constructor() {
      super(ioContext.object)
    }

    public getJSON = async <T>(
      bucket: string,
      file: string,
      nullOrUndefined?: boolean | undefined
    ): Promise<T> => {
      if (!this.jsonData[bucket]?.[file] && nullOrUndefined) {
        return (null as unknown) as T
      }
      return Promise.resolve(this.jsonData[bucket][file] as T)
    }

    public saveJSON = async <T>(
      bucket: string,
      file: string,
      data: T
    ): Promise<VBaseSaveResponse> => {
      if (!this.jsonData[bucket]) {
        this.jsonData[bucket] = {}
      }
      this.jsonData[bucket][file] = data
      return Promise.resolve(({
        updated: true,
      } as unknown) as VBaseSaveResponse)
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const tenant = class TenantMock extends tenantTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public info = async (_?: RequestConfig) => {
      return {
        bindings: [
        {
          id: '1',
          targetProduct: 'vtex-storefront',
        },
        {
          id: '2',
        },
      ],
    } as Tenant
    }
  }

  // tslint:disable-next-line:max-classes-per-file
  const rewriter = class RewriterMock extends rewriterTypeMock.object {
    constructor() {
      super(ioContext.object)
    }

    public routesById = async (_: EntityLocator) => {
      return []
    }

    public listInternals = async (_: number, cursor: Maybe<string>) => {
      switch(cursor) {
        case 'NEXT':
          return {
            next: null,
            routes: [
              {
                binding: '1',
                from: '/fruits',
                id: '1',
                type: 'department',
              },
              {
                binding: '1',
                from: '/coconut-water',
                id: '2',
                type: 'brand',
              },
              {
                binding: '2',
                from: '/coconut-water',
                id: '2',
                type: 'brand',
              },
            ] as Internal[],
          }
        default:
          return  {
            next: 'NEXT',
            routes: [
              {
                binding: '1',
                from: '/fruits/citrics',
                id: '3',
                type: 'category',
              },
              {
                binding: '1',
                from: '/market',
                id: '4',
                type: 'userRoute',
              },
              {
                binding: '1',
                disableSitemapEntry: true,
                from: '/banana-routes',
                id: '5',
                type: 'user-canonical',
              },
            ] as Internal[],
          }
      }
    }
  }

  beforeEach(() => {
    // tslint:disable-next-line:max-classes-per-file
    const ClientsImpl = class ClientsMock extends Clients {
      get vbase() {
        return this.getOrSet('vbase', vbase)
      }

      get rewriter() {
        return this.getOrSet('rewriter', rewriter)
      }

      get tenant() {
        return this.getOrSet('tenant', tenant)
      }
    }
    context = {
      ...contextMock.object,
      body: {
        count: 0,
        generationId: '1',
        next: null,
        report: {},
      },
      clients: new ClientsImpl({}, ioContext.object),
      state: {
        ...state.object,
      },
      vtex: {
        ...ioContext.object,
        logger: loggerMock.object,
      },
    }
    next = jest.fn()
  })

   it('Next event is sent', async () => {
     await generateRewriterRoutes(context, next)
     expect(next).toBeCalled()
     expect(context.state.nextEvent).toStrictEqual({
        event: GENERATE_REWRITER_ROUTES_EVENT,
        payload: {
          count: 1,
          generationId: '1',
          next: 'NEXT',
          report: { category: 1, 'user-canonical': 1, userRoute: 1 },
        },
     })
   })

  it('Complete event is sent', async () => {
    const thisContext = {
      ...context,
      body: {
        ...context.body,
        count: 1,
        next: 'NEXT',
        report: { category: 1, userRoute: 1 },
      },
    }
    await initializeSitemap(thisContext, REWRITER_ROUTES_INDEX)
    await generateRewriterRoutes(thisContext, next)
    expect(next).toBeCalled()
    expect(context.state.nextEvent).toStrictEqual({
      event: GROUP_ENTRIES_EVENT,
      payload: { from: 0, generationId: '1', indexFile: 'rewriterRoutesIndex.json' },
    }
    )
  })

  it('Routes were saved', async () => {
    await generateRewriterRoutes(context, next)
    const { vbase: vbaseClient } = context.clients
    const bucket = getBucket(RAW_DATA_PREFIX, hashString('1'))
    const { index } = await vbaseClient.getJSON<SitemapIndex>(bucket, REWRITER_ROUTES_INDEX, true)
    const expectedIndex = ['category-0', 'userRoute-0']
    expect(index).toStrictEqual(expectedIndex)
    const { routes: categoryRoutes } = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[0])
    expect(categoryRoutes).toStrictEqual([
      {
        alternates: [],
        id: '3',
        imagePath: undefined,
        imageTitle: undefined,
        path: '/fruits/citrics',
      },
    ])
    const { routes: userRoutes } = await vbaseClient.getJSON<SitemapEntry>(bucket, expectedIndex[1])
    expect(userRoutes).toStrictEqual( [
      {
        alternates: [],
        id: '4',
        imagePath: undefined,
        imageTitle: undefined,
        path: '/market',
      },
    ])
  })
})

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/docs/README.md from the events-example VTEX app.

[Assistant]
Here's the implementation:

```markdown
# Events Example

App in VTEX IO designed to send events using a time interval and IO's Events system.

### How it works?

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/service.json from the events-example VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "memory": 128,
  "ttl": 10,
  "timeout": 2,
  "minReplicas": 2,
  "maxReplicas": 10,
  "workers": 4,
  "events": {
    "example": {
      "sender": "vtex.events-example",
      "keys": ["send-event"]
    }
  },
  "routes": {
    "hcheck": {
      "path": "/_v/app/events-example/hcheck",
      "public": true
    }
  }
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/package.json from the events-example VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "dependencies": {
    "co-body": "^6.0.0"
  },
  "devDependencies": {
    "@types/co-body": "^0.0.3",
    "@types/node": "12.x",
    "@vtex/api": "6.44.0",
    "@vtex/tsconfig": "^0.5.6",
    "typescript": "3.9.7"
  },
  "scripts": {
    "lint": "tsc --noEmit --pretty && eslint -c .eslintrc.json --fix './**/*.ts'"
  },
  "version": "0.7.2"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/constants.ts from the events-example VTEX app.

[Assistant]
Here's the implementation:

```typescript
export const ENABLED_GLOBALLY = true

export const EVENT_EXAMPLE = 'send-event'

export const TIME_INTERVAL = 10

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/index.ts from the events-example VTEX app.

[Assistant]
Here's the implementation:

```typescript
import type {
  IOClients,
  ParamsContext,
  ServiceContext,
  RecorderState,
} from '@vtex/api'
import { Service } from '@vtex/api'

import { example } from './events/example'
import { createSendEvent } from './routes/notify'
import { getCacheContext, setCacheContext } from './utils/cachedContext'

const TREE_SECONDS_MS = 3 * 1000
const CONCURRENCY = 10

declare global {
  type Context = ServiceContext<IOClients, State>

  interface State extends RecorderState {
    code: number
  }
}

function sendEventWithTimer() {
  setInterval(function () {
    const context = getCacheContext()

    if (!context) {
      console.log('no context in memory')

      return
    }

    return createSendEvent(context)
  }, 30000)
  console.log('FIRED HERE')
}

sendEventWithTimer()

export default new Service<IOClients, State, ParamsContext>({
  clients: {
    options: {
      events: {
        exponentialTimeoutCoefficient: 2,
        exponentialBackoffCoefficient: 2,
        initialBackoffDelay: 50,
        retries: 1,
        timeout: TREE_SECONDS_MS,
        concurrency: CONCURRENCY,
      },
    },
  },
  events: {
    example,
  },
  routes: {
    hcheck: (ctx: any) => {
      setCacheContext(ctx)
      ctx.set('Cache-Control', 'no-cache')
      ctx.status = 200
      ctx.body = 'ok'
    },
  },
})

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/utils/randomNumber.ts from the events-example VTEX app.

[Assistant]
Here's the implementation:

```typescript
export function getRandomNumber() {
  return Math.round(Math.random() * 100)
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/utils/cachedContext.ts from the events-example VTEX app.

[Assistant]
Here's the implementation:

```typescript
let context: any = null

export const getCacheContext = () => {
  return context
}

export function setCacheContext(ctx: any) {
  context = ctx
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/events/example.ts from the events-example VTEX app.

[Assistant]
Here's the implementation:

```typescript
import type { EventContext, IOClients } from '@vtex/api'

export async function example(ctx: EventContext<IOClients>) {
  console.log('RECEIVED EVENT', ctx.body)

  return true
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of events-example/node/routes/notify.ts from the events-example VTEX app.

[Assistant]
Here's the implementation:

```typescript
import { EVENT_EXAMPLE } from '../constants'
import { getRandomNumber } from '../utils/randomNumber'

export async function createSendEvent(ctx: Context) {
  await ctx.clients.events.sendEvent('', EVENT_EXAMPLE, {
    random: getRandomNumber().toString(),
  })
  ctx.status = 200
  ctx.body = 'Event sent'
  console.log('SENT EVENT')
}

// my comment

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/README.md from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```markdown
# Wish list app example

This is an example of how a wish list app would integrate with the store framework.

## Troubleshooting

## Block does not appear in the product page

Make sure you have in your `blocks.json`:

```diff
 "store.product": {
   "blocks": [
     // ...other blocks
+    "product-bookmark",
     // ...other blocks
   ]
 }
```

## Block does not appear in shelf

Make sure to add the block in the summary:

```diff
 "product-summary.shelf": {
   "children": [
     // ...other blocks
+    "product-bookmark",
     // ...other blocks
   ]
 }
```

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/package.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "version": "0.0.0",
  "scripts": {
    "lint": "cd ./react && yarn lint",
    "test": "cd ./react && yarn test --passWithNoTests",
    "lint:locales": "intl-equalizer",
    "locales:fix": "intl-equalizer --fix",
    "verify": "yarn lint && yarn lint:locales && yarn test"
  },
  "dependencies": {
    "react-intl": "^3.10.0"
  },
  "devDependencies": {
    "@vtex/intl-equalizer": "^2.3.0",
    "@vtex/prettier-config": "^0.0.1",
    "husky": "^2.4.1"
  },
  "prettier": "@vtex/prettier-config",
  "husky": {
    "hooks": {
      "pre-commit": "yarn lint && yarn lint:locales && yarn locales:fix",
      "pre-push": "yarn verify"
    }
  },
  "intl-equalizer": {
    "referenceLocale": "en",
    "localeDirectory": "messages"
  }
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/manifest.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "vendor": "vtex",
  "name": "wishlist-app-example",
  "version": "0.0.1",
  "title": "Wishlist App Example",
  "description": "Example app of a wishlist app in the platform.",
  "builders": {
    "messages": "1.x",
    "store": "0.x",
    "react": "3.x"
  },
  "dependencies": {
    "vtex.product-bookmark-interfaces": "1.x",
    "vtex.product-summary": "2.x",
    "vtex.product-context": "0.x",
    "vtex.store": "2.x",
    "vtex.styleguide": "9.x",
    "vtex.store-icons": "0.x",
    "vtex.css-handles": "0.x"
  },
  "settingsSchema": {
    "title": "Wishlist Example",
    "type": "object",
    "properties": {
      "storeId": {
        "title": "Store ID",
        "description": "Enter your Store ID",
        "type": "string"
      },
      "productBinding": {
        "title": "Product Reference",
        "type": "string",
        "default": "productId",
        "enum": [
          "productId",
          "refId",
          "skuId",
          "slug"
        ]
      }
    }
  },
  "$schema": "https://raw.githubusercontent.com/vtex/node-vtex-api/master/gen/manifest.schema"
}
```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/docs/README.md from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```markdown
# Product Bookmark Interfaces

> Interfaces for a wishlist or list app.

This app provides extensible interfaces that can be used by the `vtex.store` and a theme app. A wishlist or list app would depend on this app and extend the interfaces provided to become available in the store.

You can see an example of a wishlist app [here](/example).

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/react/package.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "scripts": {
    "test": "vtex-test-tools test",
    "lint": "tsc --noEmit && eslint --ext ts,tsx ."
  },
  "dependencies": {
    "react": "^16.8.3",
    "react-dom": "^16.8.3"
  },
  "prettier": "@vtex/prettier-config",
  "devDependencies": {
    "@types/graphql": "^14.2.0",
    "@types/jest": "^24.0.11",
    "@types/node": "^11.13.0",
    "@types/prop-types": "^15.7.0",
    "@types/react": "^16.8.10",
    "@vtex/prettier-config": "^0.0.1",
    "apollo-client": "^2.5.1",
    "eslint": "^5.16.0",
    "eslint-config-vtex": "^10.1.0",
    "prettier": "^1.19.1",
    "typescript": "3.7.3"
  },
  "version": "1.0.1"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/react/Noop.tsx from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```tsx
import React, { FunctionComponent } from 'react'

const Noop: FunctionComponent = () => <></>

export default Noop

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/store/interfaces.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "product-bookmark": {
    "component": "Noop",
    "extensible": "public"
  }
}
```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/messages/pt.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/wishlist.added": "Produto adicionado à sua lista de desejos",
  "store/wishlist.removed": "Produto removido da sua lista de desejos"
}
```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/messages/en.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/wishlist.added": "Product added to your wishlist",
  "store/wishlist.removed": "Product removed from your wishlist"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/messages/es.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/wishlist.added": "Producto agregado a la lista de deseos",
  "store/wishlist.removed": "Producto eliminado de la lista de deseos"
}
```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/ProductBookmark.tsx from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```tsx
import React, { FC, MouseEvent, useState } from 'react'
import { defineMessages, useIntl } from 'react-intl'
import { IconBookmark } from 'vtex.store-icons'
import { withToast } from 'vtex.styleguide'
import { useCssHandles } from 'vtex.css-handles'
import useProduct from 'vtex.product-context/useProduct'

const CSS_HANDLES = ['productBookmark'] as const

const messages = defineMessages({
  added: {
    id: 'store/wishlist.added',
    defaultMessage: '',
  },
  removed: {
    id: 'store/wishlist.removed',
    defaultMessage: '',
  },
})

const Bookmark: FC<Props> = ({ showToast }) => {
  const handles = useCssHandles(CSS_HANDLES)
  const { formatMessage } = useIntl()
  const [filled, setFill] = useState(false)
  const productContext = useProduct()

  const handleClick = (ev: MouseEvent) => {
    ev.stopPropagation()
    ev.preventDefault()
    setFill(!filled)
    if (productContext && productContext.product) {
      // eslint-disable-next-line no-console
      console.log('Product ' + productContext.product.productName)
    }
    showToast({
      message: filled
        ? formatMessage(messages.removed)
        : formatMessage(messages.added),
      duration: 3000,
    })
  }

  return (
    <div className={handles.productBookmark}>
      <button
        onClick={handleClick}
        className="bn pa3 pointer flex bg-action-secondary c-on-action-secondary hover-c-on-action-secondary"
      >
        <IconBookmark
          type={filled ? 'filled' : 'outline'}
          fill="currentColor"
        />
      </button>
    </div>
  )
}

interface ShowToastParams {
  message: string
  duration?: number
  action?: { label: string; onClick: Function }
}

interface Props {
  showToast: (params: ShowToastParams) => void
}

export default withToast(Bookmark)

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/package.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "scripts": {
    "lint": "tsc --noEmit && eslint --quiet --fix --ext ts,tsx .",
    "test": "vtex-test-tools test"
  },
  "dependencies": {
    "apollo-client": "^2.6.8",
    "react": "^16.8.6",
    "react-apollo": "^2.5.8",
    "react-dom": "^16.8.6",
    "react-intl": "^3.11.0"
  },
  "devDependencies": {
    "@apollo/react-testing": "^3.1.3",
    "@types/graphql": "^14.5.0",
    "@types/jest": "^24.9.0",
    "@types/node": "^13.1.8",
    "@types/react": "^16.9.19",
    "@types/react-intl": "^3.0.0",
    "@vtex/test-tools": "^3.0.0",
    "@vtex/tsconfig": "^0.2.0",
    "apollo-cache-inmemory": "^1.6.5",
    "eslint": "5.x",
    "eslint-config-vtex-react": "^5.1.0",
    "graphql": "^14.5.8",
    "prettier": "^1.18.2",
    "prop-types": "^15.7.2",
    "typescript": "3.7.3"
  }
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/store/interfaces.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "product-bookmark.example-wishlist": {
    "component": "ProductBookmark"
  }
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/store/plugins.json from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "product-bookmark": "product-bookmark.example-wishlist"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/storefront.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
import { FunctionComponent, ReactElement } from 'react'

declare global {
  interface StorefrontFunctionComponent<P = {}> extends FunctionComponent<P> {
    schema?: object
  }

  interface StorefrontComponent<P = {}, S = {}> extends Component<P, S> {
    schema: object
  }
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/vtex.product-context.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
declare module 'vtex.product-context' {
  import { Context } from 'react'

  interface ProductContext {
    product: any
  }

  export const ProductContext = Context
}

declare module 'vtex.product-context/useProduct'

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/vtex.store-icons.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
declare module 'vtex.store-icons' {
  export const IconBookmark
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/css.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
declare module '*.css' {
  const css: any
  export default css
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/graphql.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
declare module '*.graphql' {
  import { DocumentNode } from 'graphql'

  const value: DocumentNode
  export default value
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/vtex.product-summary.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
declare module 'vtex.product-summary' {
  import { Context } from 'react'

  interface ProductSummary {
    product: any
  }

  export const ProductSummaryContext = Context
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of product-bookmark-interfaces/example/react/typings/vtex.styleguide.d.ts from the product-bookmark-interfaces VTEX app.

[Assistant]
Here's the implementation:

```typescript
declare module 'vtex.styleguide' {
  export const withToast
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/el-GR.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Εμπορική επωνυμία",
  "admin/native-types.category": "Κατηγορία",
  "admin/native-types.collection": "Συλλογή",
  "admin/native-types.department": "Τμήμα",
  "admin/native-types.image": "Εικόνα",
  "admin/native-types.image.description": "Περιγραφή",
  "admin/native-types.image.desktop": "Επιφάνεια εργασίας",
  "admin/native-types.image.filename": "Όνομα αρχείου",
  "admin/native-types.image.mobile": "Κινητό",
  "admin/native-types.link": "Σύνδεση",
  "admin/native-types.link.attributeNofollow": "Χαρακτηριστικό nofollow",
  "admin/native-types.link.attributeTitle": "Χαρακτηριστικό title",
  "admin/native-types.link.newTab": "Νέα καρτέλα",
  "admin/native-types.link.url": "διεύθυνση URL",
  "admin/native-types.richText": "Εμπλουτισμένο κείμενο",
  "admin/native-types.text": "Κείμενο",
  "admin/native-types.url": "διεύθυνση URL",
  "admin/native-types.video.description": "Περιγραφή",
  "admin/native-types.video.thumbnail": "μικρογραφία",
  "admin/native-types.video": "Βίντεο",
  "admin/native-types.video.title": "Τίτλος",
  "admin/native-types.video.url": "διεύθυνση URL",
  "store/native-types.text": "Θέση για το κείμενό σας",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Λειτουργεί :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/it-IT.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Brand",
  "admin/native-types.category": "Categoria",
  "admin/native-types.collection": "Collezione",
  "admin/native-types.department": "Reparto",
  "admin/native-types.image": "Immagine",
  "admin/native-types.image.description": "Descrizione",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "Nome del file",
  "admin/native-types.image.mobile": "Mobile",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Attributo nofollow",
  "admin/native-types.link.attributeTitle": "Attributo title",
  "admin/native-types.link.newTab": "Nuova scheda",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rich text",
  "admin/native-types.text": "Testo",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Descrizione",
  "admin/native-types.video.thumbnail": "Anteprima",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Titolo",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Inserisci qui il tuo testo",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://esempio.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funziona!",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/th-TH.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "แบรนด์",
  "admin/native-types.category": "หมวดหมู่",
  "admin/native-types.collection": "คอลเลกชัน",
  "admin/native-types.department": "แผนก",
  "admin/native-types.image": "รูปภาพ",
  "admin/native-types.image.description": "คำอธิบาย",
  "admin/native-types.image.desktop": "เดสก์ท็อป",
  "admin/native-types.image.filename": "ชื่อไฟล์",
  "admin/native-types.image.mobile": "มือถือ",
  "admin/native-types.link": "ลิงก์",
  "admin/native-types.link.attributeNofollow": "แอททริบิวต์ nofollow",
  "admin/native-types.link.attributeTitle": "แอททริบิวต์ title",
  "admin/native-types.link.newTab": "แท็บใหม่",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rich Text",
  "admin/native-types.text": "ข้อความ",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "คำอธิบาย",
  "admin/native-types.video.thumbnail": "ภาพตัวอย่างขนาดเล็ก",
  "admin/native-types.video": "วิดีโอ",
  "admin/native-types.video.title": "ชื่อหัวข้อ",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "ข้อความของคุณที่นี่",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "มันใช้การได้ :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/ko-KR.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "브랜드",
  "admin/native-types.category": "카테고리",
  "admin/native-types.collection": "컬렉션",
  "admin/native-types.department": "부문",
  "admin/native-types.image": "이미지",
  "admin/native-types.image.description": "설명",
  "admin/native-types.image.desktop": "데스크톱",
  "admin/native-types.image.filename": "파일이름",
  "admin/native-types.image.mobile": "모바일",
  "admin/native-types.link": "링크",
  "admin/native-types.link.attributeNofollow": "속성 nofollow",
  "admin/native-types.link.attributeTitle": "속성 title",
  "admin/native-types.link.newTab": "새 탭",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "리치 텍스트",
  "admin/native-types.text": "텍스트",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "설명",
  "admin/native-types.video.thumbnail": "섬네일",
  "admin/native-types.video": "비디오",
  "admin/native-types.video.title": "제목",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "여기 텍스트",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "작동함 :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/nn-NO.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Merke",
  "admin/native-types.category": "Kategori",
  "admin/native-types.collection": "Samling",
  "admin/native-types.department": "Avdeling",
  "admin/native-types.image": "Bilde",
  "admin/native-types.image.description": "Beskrivelse",
  "admin/native-types.image.desktop": "Skrivebord",
  "admin/native-types.image.filename": "Filnavn",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Lenke",
  "admin/native-types.link.attributeNofollow": "Kjennetegn på ingen følgere",
  "admin/native-types.link.attributeTitle": "Tittel på kjennetegn",
  "admin/native-types.link.newTab": "Ny fane",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rik tekst",
  "admin/native-types.text": "Tekst",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Beskrivelse",
  "admin/native-types.video.thumbnail": "Miniatyrbilde",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Tittel",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Din tekst her",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Det fungerer :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/ja-JP.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "ブランド",
  "admin/native-types.category": "カテゴリ",
  "admin/native-types.collection": "コレクション",
  "admin/native-types.department": "部門",
  "admin/native-types.image": "画像",
  "admin/native-types.image.description": "説明",
  "admin/native-types.image.desktop": "デスクトップ",
  "admin/native-types.image.filename": "ファイル名",
  "admin/native-types.image.mobile": "モバイル",
  "admin/native-types.link": "リンク",
  "admin/native-types.link.attributeNofollow": "nofollow 属性",
  "admin/native-types.link.attributeTitle": "title 属性",
  "admin/native-types.link.newTab": "新規タブ",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "リッチテキスト",
  "admin/native-types.text": "テキスト",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "説明",
  "admin/native-types.video.thumbnail": "サムネイル",
  "admin/native-types.video": "動画",
  "admin/native-types.video.title": "タイトル",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "テキストはこちらです",
  "store/native-types.richText": "ダミーテキスト…",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "有効です :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/bg-BG.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Бранд",
  "admin/native-types.category": "Категория",
  "admin/native-types.collection": "Колекция",
  "admin/native-types.department": "Отдел",
  "admin/native-types.image": "Изображение",
  "admin/native-types.image.description": "Описание",
  "admin/native-types.image.desktop": "Настолен компютър",
  "admin/native-types.image.filename": "Име на файл",
  "admin/native-types.image.mobile": "Мобилен телефон",
  "admin/native-types.link": "Връзка",
  "admin/native-types.link.attributeNofollow": "Атрибут nofollow",
  "admin/native-types.link.attributeTitle": "Атрибут title",
  "admin/native-types.link.newTab": "Нов раздел",
  "admin/native-types.link.url": "URL адрес",
  "admin/native-types.richText": "RTF текст",
  "admin/native-types.text": "Текст",
  "admin/native-types.url": "URL адрес",
  "admin/native-types.video.description": "Описание",
  "admin/native-types.video.thumbnail": "Миниатюра",
  "admin/native-types.video": "Видео",
  "admin/native-types.video.title": "Заглавие",
  "admin/native-types.video.url": "URL адрес",
  "store/native-types.text": "Вашият текст тук",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Работи :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/id-ID.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Merek",
  "admin/native-types.category": "Kategori",
  "admin/native-types.collection": "Koleksi",
  "admin/native-types.department": "Departemen",
  "admin/native-types.image": "Gambar",
  "admin/native-types.image.description": "Deskripsi",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "Nama File",
  "admin/native-types.image.mobile": "Seluler",
  "admin/native-types.link": "Tautan",
  "admin/native-types.link.attributeNofollow": "Nofollow atribut",
  "admin/native-types.link.attributeTitle": "Judul atribut",
  "admin/native-types.link.newTab": "Tab baru",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Teks Kaya",
  "admin/native-types.text": "Teks",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Deskripsi",
  "admin/native-types.video.thumbnail": "Gambar mini",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Judul",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Teks Anda di sini",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Berhasil :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/pt.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marca",
  "admin/native-types.category": "Categoria",
  "admin/native-types.collection": "Coleção",
  "admin/native-types.department": "Departamento",
  "admin/native-types.image": "Imagem",
  "admin/native-types.image.description": "Descrição",
  "admin/native-types.image.desktop": "Computador",
  "admin/native-types.image.filename": "Nome do arquivo",
  "admin/native-types.image.mobile": "Dispositivos móveis",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Atributo nofollow",
  "admin/native-types.link.attributeTitle": "Atributo title",
  "admin/native-types.link.newTab": "Nova aba",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rich text",
  "admin/native-types.text": "Texto",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Descrição",
  "admin/native-types.video.thumbnail": "Miniatura",
  "admin/native-types.video": "Vídeo",
  "admin/native-types.video.title": "Título",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Insira seu texto aqui",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://exemplo.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funcionou!",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/ar-SA.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "العلامة التجارية",
  "admin/native-types.category": "القسم 2",
  "admin/native-types.collection": "المجموعة",
  "admin/native-types.department": "القسم 1",
  "admin/native-types.image": "الصورة",
  "admin/native-types.image.description": "الوصف",
  "admin/native-types.image.desktop": "المكتب",
  "admin/native-types.image.filename": "اسم الملف",
  "admin/native-types.image.mobile": "الجوال",
  "admin/native-types.link": "الرابط",
  "admin/native-types.link.attributeNofollow": "متابعة السمة",
  "admin/native-types.link.attributeTitle": "عنوان السمة",
  "admin/native-types.link.newTab": "علامة تبويب جديدة",
  "admin/native-types.link.url": "الرابط",
  "admin/native-types.richText": "محرر متطور",
  "admin/native-types.text": "النص",
  "admin/native-types.url": "الرابط",
  "admin/native-types.video.description": "الوصف",
  "admin/native-types.video.thumbnail": "الصورة المصغرة",
  "admin/native-types.video": "الفيديو",
  "admin/native-types.video.title": "العنوان",
  "admin/native-types.video.url": "الرابط",
  "store/native-types.text": "نصك هنا",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "إنه يعمل :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/en.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Brand",
  "admin/native-types.category": "Category",
  "admin/native-types.collection": "Collection",
  "admin/native-types.department": "Department",
  "admin/native-types.image": "Image",
  "admin/native-types.image.description": "Description",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "File name",
  "admin/native-types.image.mobile": "Mobile",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Nofollow attribute",
  "admin/native-types.link.attributeTitle": "Title attribute",
  "admin/native-types.link.newTab": "New tab",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rich text",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Description",
  "admin/native-types.video.thumbnail": "Thumbnail",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Title",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Your text here",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "It works :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/no-NO.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Merke",
  "admin/native-types.category": "Kategori",
  "admin/native-types.collection": "Samling",
  "admin/native-types.department": "Avdeling",
  "admin/native-types.image": "Bilde",
  "admin/native-types.image.description": "Beskrivelse",
  "admin/native-types.image.desktop": "Skrivebord",
  "admin/native-types.image.filename": "Filnavn",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Lenke",
  "admin/native-types.link.attributeNofollow": "Kjennetegn på ingen følgere",
  "admin/native-types.link.attributeTitle": "Tittel på kjennetegn",
  "admin/native-types.link.newTab": "Ny fane",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rik tekst",
  "admin/native-types.text": "Tekst",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Beskrivelse",
  "admin/native-types.video.thumbnail": "Miniatyrbilde",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Tittel",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Din tekst her",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Det fungerer :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/sv-SE.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Varumärke",
  "admin/native-types.category": "Kategori",
  "admin/native-types.collection": "Samling",
  "admin/native-types.department": "Avdelning",
  "admin/native-types.image": "Bild",
  "admin/native-types.image.description": "Beskrivning",
  "admin/native-types.image.desktop": "Skrivbord",
  "admin/native-types.image.filename": "Filnamn",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Koppla",
  "admin/native-types.link.attributeNofollow": "Attribut nofollow",
  "admin/native-types.link.attributeTitle": "Attribut title",
  "admin/native-types.link.newTab": "Ny flik",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "RTF",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Beskrivning",
  "admin/native-types.video.thumbnail": "Miniatyr",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Rubrik",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Skriv din text här",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Det fungerar :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/ro-RO.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marcă",
  "admin/native-types.category": "Categorie",
  "admin/native-types.collection": "Colecție",
  "admin/native-types.department": "Raion",
  "admin/native-types.image": "Imagine",
  "admin/native-types.image.description": "Descriere",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "Denumire fișier",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Atribut nofollow",
  "admin/native-types.link.attributeTitle": "Titlu atribut",
  "admin/native-types.link.newTab": "Filă nouă",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Text îmbogățit",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Descriere",
  "admin/native-types.video.thumbnail": "Miniatură",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Titlu",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Textul tău aici",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funcționează :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/sk-SK.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Značka",
  "admin/native-types.category": "Kategória",
  "admin/native-types.collection": "Kolekcia",
  "admin/native-types.department": "Departement",
  "admin/native-types.image": "Obrázok",
  "admin/native-types.image.description": "Popis",
  "admin/native-types.image.desktop": "Stolný počítač",
  "admin/native-types.image.filename": "Názov súboru",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Prepojenie",
  "admin/native-types.link.attributeNofollow": "Atribút nofollow",
  "admin/native-types.link.attributeTitle": "Atribút title",
  "admin/native-types.link.newTab": "Nová karta",
  "admin/native-types.link.url": "URL adresa",
  "admin/native-types.richText": "Text vo formáte RTF",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL adresa",
  "admin/native-types.video.description": "Popis",
  "admin/native-types.video.thumbnail": "Miniatúra",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Názov",
  "admin/native-types.video.url": "URL adresa",
  "store/native-types.text": "Sem zadajte text",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funguje to :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/uk-UA.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Бренд",
  "admin/native-types.category": "Категорія",
  "admin/native-types.collection": "Колекція",
  "admin/native-types.department": "Департамент",
  "admin/native-types.image": "Зображення",
  "admin/native-types.image.description": "Опис",
  "admin/native-types.image.desktop": "Настільний комп’ютер",
  "admin/native-types.image.filename": "Ім’я файлу",
  "admin/native-types.image.mobile": "Мобільний телефон",
  "admin/native-types.link": "Посилання",
  "admin/native-types.link.attributeNofollow": "Атрибут nofollow",
  "admin/native-types.link.attributeTitle": "Атрибут title",
  "admin/native-types.link.newTab": "Нова вкладка",
  "admin/native-types.link.url": "Текст RTF",
  "admin/native-types.richText": "Текст RTF",
  "admin/native-types.text": "Текст",
  "admin/native-types.url": "Aдреса URL",
  "admin/native-types.video.description": "Опис",
  "admin/native-types.video.thumbnail": "Ескіз",
  "admin/native-types.video": "Відео",
  "admin/native-types.video.title": "Назва",
  "admin/native-types.video.url": "Aдреса URL",
  "store/native-types.text": "Місце для вставлення тексту",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Спрацювало! :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/pl-PL.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marka",
  "admin/native-types.category": "Kategoria",
  "admin/native-types.collection": "Kolekcja",
  "admin/native-types.department": "Wydział",
  "admin/native-types.image": "Obraz",
  "admin/native-types.image.description": "Opis",
  "admin/native-types.image.desktop": "Komputer stacjonarny",
  "admin/native-types.image.filename": "Nazwa pliku",
  "admin/native-types.image.mobile": "Mobilne",
  "admin/native-types.link": "Połączyć",
  "admin/native-types.link.attributeNofollow": "Atrybut nofollow",
  "admin/native-types.link.attributeTitle": "Atrybut title",
  "admin/native-types.link.newTab": "Nowa karta",
  "admin/native-types.link.url": "Adres URL",
  "admin/native-types.richText": "Tekstu sformatowanego",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "Adres URL",
  "admin/native-types.video.description": "Opis",
  "admin/native-types.video.thumbnail": "Miniatura",
  "admin/native-types.video": "Wideo",
  "admin/native-types.video.title": "Tytuł",
  "admin/native-types.video.url": "Adres URL",
  "store/native-types.text": "Tutaj twój tekst",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Działa :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/da-DK.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Brand",
  "admin/native-types.category": "Kategori",
  "admin/native-types.collection": "Indsamling",
  "admin/native-types.department": "Afdeling",
  "admin/native-types.image": "Billede",
  "admin/native-types.image.description": "Beskrivelse",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "Filnavn",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Attribut nofollow",
  "admin/native-types.link.attributeTitle": "Attribut title",
  "admin/native-types.link.newTab": "Ny fane",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rig tekst",
  "admin/native-types.text": "Tekst",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Beskrivelse",
  "admin/native-types.video.thumbnail": "Miniaturebillede",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Titel",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Din tekst her",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://eksempel.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Det virker :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/context.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "admin/native-types.brand",
  "admin/native-types.category": "admin/native-types.category",
  "admin/native-types.collection": "admin/native-types.collection",
  "admin/native-types.department": "admin/native-types.department",
  "admin/native-types.image": "admin/native-types.image",
  "admin/native-types.image.description": "admin/native-types.image.description",
  "admin/native-types.image.desktop": "admin/native-types.image.desktop",
  "admin/native-types.image.filename": "admin/native-types.image.filename",
  "admin/native-types.image.mobile": "admin/native-types.image.mobile",
  "admin/native-types.link": "admin/native-types.link",
  "admin/native-types.link.attributeNofollow": "admin/native-types.link.attributeNofollow",
  "admin/native-types.link.attributeTitle": "admin/native-types.link.attributeTitle",
  "admin/native-types.link.newTab": "admin/native-types.link.newTab",
  "admin/native-types.link.url": "admin/native-types.link.url",
  "admin/native-types.richText": "admin/native-types.richText",
  "admin/native-types.text": "admin/native-types.text",
  "admin/native-types.url": "admin/native-types.url",
  "admin/native-types.video.description": "admin/native-types.video.description",
  "admin/native-types.video.thumbnail": "admin/native-types.video.thumbnail",
  "admin/native-types.video": "admin/native-types.video",
  "admin/native-types.video.title": "admin/native-types.video.title",
  "admin/native-types.video.url": "admin/native-types.video.url",
  "store/native-types.text": "Text field",
  "store/native-types.richText": "Rich text field",
  "store/native-types.url": "URL field",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "It works :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/de-DE.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marke",
  "admin/native-types.category": "Kategorie",
  "admin/native-types.collection": "Kollektion",
  "admin/native-types.department": "Abteilung",
  "admin/native-types.image": "Bild",
  "admin/native-types.image.description": "Beschreibung",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "Dateiname",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Verknüpfen",
  "admin/native-types.link.attributeNofollow": "Attribut nofollow",
  "admin/native-types.link.attributeTitle": "Attribut title",
  "admin/native-types.link.newTab": "Neues Register",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Richt-Text",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Beschreibung",
  "admin/native-types.video.thumbnail": "Miniaturansicht",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Titel",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Typ hier und tekst",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Es funktioniert :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/ca-ES.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marca",
  "admin/native-types.category": "Categoria",
  "admin/native-types.collection": "Col·lecció",
  "admin/native-types.department": "Departament",
  "admin/native-types.image": "Imatge",
  "admin/native-types.image.description": "Descripció",
  "admin/native-types.image.desktop": "Ordinador d'escriptori",
  "admin/native-types.image.filename": "Nom del fitxer",
  "admin/native-types.image.mobile": "Mòbil",
  "admin/native-types.link": "Enllaç",
  "admin/native-types.link.attributeNofollow": "Atribut nofollow",
  "admin/native-types.link.attributeTitle": "Atribut title",
  "admin/native-types.link.newTab": "Pestanya nova",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Text enriquit",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Descripció",
  "admin/native-types.video.thumbnail": "Miniatura",
  "admin/native-types.video": "Vídeo",
  "admin/native-types.video.title": "Títol",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "El vostre text aquí",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funciona :)",
  "admin/format-io-message.working-dynamic-example": "{subjecte} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/cs-CZ.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Značka",
  "admin/native-types.category": "Kategorie",
  "admin/native-types.collection": "Kolekce",
  "admin/native-types.department": "Oddělení",
  "admin/native-types.image": "Obrázek",
  "admin/native-types.image.description": "Popis",
  "admin/native-types.image.desktop": "Počítač",
  "admin/native-types.image.filename": "Název souboru",
  "admin/native-types.image.mobile": "Mobil",
  "admin/native-types.link": "Odkaz",
  "admin/native-types.link.attributeNofollow": "Atribut nofollow",
  "admin/native-types.link.attributeTitle": "Atribut title",
  "admin/native-types.link.newTab": "Nová záložka",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Formátovaný text",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Popis",
  "admin/native-types.video.thumbnail": "Miniatura",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Název",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Sem napište text",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funguje to :-)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/fr-FR.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marque",
  "admin/native-types.category": "Catégorie",
  "admin/native-types.collection": "Collection",
  "admin/native-types.department": "Département",
  "admin/native-types.image": "Image",
  "admin/native-types.image.description": "Description",
  "admin/native-types.image.desktop": "Bureau",
  "admin/native-types.image.filename": "Nom du fichier",
  "admin/native-types.image.mobile": "Mobile",
  "admin/native-types.link": "Lien",
  "admin/native-types.link.attributeNofollow": "Attribut nofollow",
  "admin/native-types.link.attributeTitle": "Attribut title",
  "admin/native-types.link.newTab": "Nouvel onglet",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Texte enrichi",
  "admin/native-types.text": "Texte",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Description",
  "admin/native-types.video.thumbnail": "Vignette",
  "admin/native-types.video": "Vidéo",
  "admin/native-types.video.title": "Titre",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Votre texte ici",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Ça marche :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/sl-SI.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Znamka",
  "admin/native-types.category": "Kategorija",
  "admin/native-types.collection": "Zbirka",
  "admin/native-types.department": "Oddelek",
  "admin/native-types.image": "Slika",
  "admin/native-types.image.description": "Opis",
  "admin/native-types.image.desktop": "Namizno",
  "admin/native-types.image.filename": "Ime datoteke",
  "admin/native-types.image.mobile": "Mobilno",
  "admin/native-types.link": "Povezati",
  "admin/native-types.link.attributeNofollow": "Atribut nofollow",
  "admin/native-types.link.attributeTitle": "Atribut title",
  "admin/native-types.link.newTab": "Nov zavihek",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Obogateno besedilo",
  "admin/native-types.text": "Text",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Opis",
  "admin/native-types.video.thumbnail": "Sličica",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Naziv",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Tukaj vnesite besedilo",
  "store/native-types.richText": "Loren ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Deluje :)\"",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/ru-RU.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Бренд",
  "admin/native-types.category": "Категория",
  "admin/native-types.collection": "Коллекция",
  "admin/native-types.department": "Oтдел",
  "admin/native-types.image": "Изображение",
  "admin/native-types.image.description": "Описание",
  "admin/native-types.image.desktop": "Настольный компьютер",
  "admin/native-types.image.filename": "Имя файла",
  "admin/native-types.image.mobile": "Мобильный телефон",
  "admin/native-types.link": "Связь",
  "admin/native-types.link.attributeNofollow": "Атрибут nofollow",
  "admin/native-types.link.attributeTitle": "Атрибут title",
  "admin/native-types.link.newTab": "Создать вкладку",
  "admin/native-types.link.url": "URL-адрес",
  "admin/native-types.richText": "Форматированный текст",
  "admin/native-types.text": "Текст",
  "admin/native-types.url": "URL-адрес",
  "admin/native-types.video.description": "Описание",
  "admin/native-types.video.thumbnail": "Эскиз",
  "admin/native-types.video": "Видео",
  "admin/native-types.video.title": "Название",
  "admin/native-types.video.url": "URL-адрес",
  "store/native-types.text": "Текст надписи",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Сработало! :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/nl-NL.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Merk",
  "admin/native-types.category": "Categorie",
  "admin/native-types.collection": "Collectie",
  "admin/native-types.department": "Afdeling",
  "admin/native-types.image": "Afbeelding",
  "admin/native-types.image.description": "Beschrijving",
  "admin/native-types.image.desktop": "Desktop",
  "admin/native-types.image.filename": "Bestandsnaam",
  "admin/native-types.image.mobile": "Mobiel",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Attribuut nofollow",
  "admin/native-types.link.attributeTitle": "Attribuut title",
  "admin/native-types.link.newTab": "Nieuwe tab",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Rich tekst",
  "admin/native-types.text": "Tekst",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Beschrijving",
  "admin/native-types.video.thumbnail": "Miniatuur",
  "admin/native-types.video": "Video",
  "admin/native-types.video.title": "Titel",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Uw tekst hier",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Het werkt :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/fi-FI.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Brändi",
  "admin/native-types.category": "Luokka",
  "admin/native-types.collection": "Kokoelma",
  "admin/native-types.department": "Osasto",
  "admin/native-types.image": "Kuva",
  "admin/native-types.image.description": "Kuvaus",
  "admin/native-types.image.desktop": "Tietokone",
  "admin/native-types.image.filename": "Tiedostonimi",
  "admin/native-types.image.mobile": "Mobiili",
  "admin/native-types.link": "Linkki",
  "admin/native-types.link.attributeNofollow": "Määrite nofollow",
  "admin/native-types.link.attributeTitle": "Määrite title",
  "admin/native-types.link.newTab": "Uusi välilehti",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "RTF teksti",
  "admin/native-types.text": "Teksti",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Kuvaus",
  "admin/native-types.video.thumbnail": "Pikkukuva",
  "admin/native-types.video": "Videot",
  "admin/native-types.video.title": "Nimi",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Kirjoita teksti tähän",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Se toimii :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```


[System] You are an expert VTEX IO developer. You specialize in building VTEX Store Framework apps, React components, GraphQL APIs, and Node.js services for e-commerce platforms.

[User] Show me the implementation of native-types/messages/es.json from the native-types VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "admin/native-types.brand": "Marca",
  "admin/native-types.category": "Categoría",
  "admin/native-types.collection": "Colección",
  "admin/native-types.department": "Departamento",
  "admin/native-types.image": "Imagen",
  "admin/native-types.image.description": "Descripción",
  "admin/native-types.image.desktop": "Escritorio",
  "admin/native-types.image.filename": "Nombre del archivo",
  "admin/native-types.image.mobile": "Dispositivo móbil",
  "admin/native-types.link": "Link",
  "admin/native-types.link.attributeNofollow": "Atributo nofollow",
  "admin/native-types.link.attributeTitle": "Atributo title",
  "admin/native-types.link.newTab": "Nueva pestaña",
  "admin/native-types.link.url": "URL",
  "admin/native-types.richText": "Texto enriquecido",
  "admin/native-types.text": "Texto",
  "admin/native-types.url": "URL",
  "admin/native-types.video.description": "Descripción",
  "admin/native-types.video.thumbnail": "Miniatura",
  "admin/native-types.video": "Vídeo",
  "admin/native-types.video.title": "Título",
  "admin/native-types.video.url": "URL",
  "store/native-types.text": "Escribe tu texto aquí",
  "store/native-types.richText": "Lorem ipsum...",
  "store/native-types.url": "https://example.com",
  "admin/format-io-message.empty-string-example": "",
  "admin/format-io-message.working-static-example": "Funciona :)",
  "admin/format-io-message.working-dynamic-example": "{subject} {verb} {emoji}"
}

```