[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 geolocation-graphql-interface/docs/README.md from the geolocation-graphql-interface VTEX app.

[Assistant]
Here's the implementation:

```markdown
# Geolocation GraphQL Interface

⚠ **This is an ongoing, unsupported, unfinished and undocumented project. We do not guarantee any results after installation.** ⚠

This app exports a GraphQL schema for geolocation results for Place Components.

## Usage

### Installation

To use it in your app, run the `vtex add vtex.geolocation-graphql-interface` command.

You may then use it in your front end component queries, for example, by writing the file `addressSuggestions.graphql`:

```graphql
query AddressSuggestions($searchTerm: String!) {
  addressSuggestions(searchTerm: $searchTerm)
    @context(provider: "vtex.geolocation-graphql-interface") {
    description
    mainText
    mainTextMatchInterval {
      offset
      length
    }
    secondaryText
    externalId
  }
}
```

> 9 The only difference from a standard query is the usage of a _directive_: `@context(provider: "vtex.geolocation-graphql-interface")`

To resolve this query, you must have installed in your workspace an app that implements the GraphQL interface. Currently, those are the available resolvers:

- [vtex.google-geolocation-resolver](https://github.com/vtex-apps/google-geolocation-resolver)

Having zero or more than one resolver installed will result in an error.

### Examples

Currently, this interface only supports autosuggest related operations, which is commonly used along with a text-based input like the [Location Search component](https://github.com/vtex-apps/place-components/#locationfield-search) used in `vtex.place-components`. In order to get the suggestions, each key-stroke might send a `addressSuggestions` query like:

```graphql
query {
  addressSuggestions(searchTerm: "Praia de bot") {
    description
    externalId
  }
}
```

This returns address suggestions using the resolver of your choice. Notice that the number of suggestions are handled by the resolver itself.

```graphql
{
  "data": {
    "addressSuggestions": [
      {
        "description": "Praia de Botafogo - Botafogo, Rio de Janeiro - RJ, Brasil",
        "externalId": "SAMPLE_ID_2718"
      },
      {
        "description": "Praia de Botafogo - Pista Direita - Botafogo, Rio de Janeiro - RJ, Brasil",
        "externalId": "SAMPLE_ID_0042"
      },
      {
        "description": "Alameda Praia de Botafogo - Patamares, Salvador - BA, Brasil",
        "externalId": "SAMPLE_ID_1123"
      },
      {
        "description": "Acesso Praia de Botafogo - Botafogo, Rio de Janeiro - RJ, Brasil",
        "externalId": "SAMPLE_ID_1001"
      },
      {
        "description": "Rua Praia de Botafogo - Vilatur, Saquarema - RJ, Brasil",
        "externalId": "SAMPLE_ID_8888"
      }
    ]
  }
}
```

If the user selects the first suggested address, we must use it's `externalId` to make an `address` query:

```graphql
query {
  address(id: "SAMPLE_ID_2718") {
    city
    neighborhood
    street
  }
}
```

Which returns an address object that can be used to autocomplete an address form.

```graphql
{
  "data": {
    "address": {
      "city": "Rio de Janeiro",
      "neighborhood": "Botafogo",
      "street": "Praia de Botafogo"
    }
  }
}
```

**Upcoming documentation:**

 - [CHK-435: Session token](https://github.com/vtex-apps/geolocation-graphql-interface/pull/6)

```


[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 geolocation-graphql-interface/graphql/schema.graphql from the geolocation-graphql-interface VTEX app.

[Assistant]
Here's the implementation:

```graphql
type Query {
  addressSuggestions(
    searchTerm: String!
    sessionToken: String
    """
    A two character, case insensitive, ISO 3166-1 Alpha-2 or Alpha-3 compatible country code, used to restrict the suggestion results
    """
    country: String
  ): [AddressSuggestion!]!

  address(externalId: String!, sessionToken: String): Address!

  providerLogo: Image!

  sessionToken: String!
}

```


[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 geolocation-graphql-interface/graphql/types/Address.graphql from the geolocation-graphql-interface VTEX app.

[Assistant]
Here's the implementation:

```graphql
type Address {
  addressId: ID
  addressType: AddressType
  city: String
  complement: String
  country: String
  geoCoordinates: [Float!]
  neighborhood: String
  number: String
  postalCode: String
  receiverName: String
  reference: String
  state: String
  street: String
}

enum AddressType {
  residential
  commercial
  inStore
  giftRegistry
  pickup
  search
}

```


[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 geolocation-graphql-interface/graphql/types/AddressSuggestion.graphql from the geolocation-graphql-interface VTEX app.

[Assistant]
Here's the implementation:

```graphql
type AddressSuggestion {
  description: String!
  mainText: String!
  mainTextMatchInterval: MatchInterval!
  secondaryText: String!
  externalId: String!
}

type MatchInterval {
  offset: Int!
  length: Int!
}

```


[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 checkout-resources/docs/README.md from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```markdown
# Checkout Resources

Centralizes all GraphQL operations used in Checkout IO, as well as some utility functions.

## Usage

```ts
import OrderFormQuery from 'vtex.checkout-resources/QueryOrderForm'
import UpdateItemMutation from 'vtex.checkout-resources/MutationUpdateItem'

const MyComponent: React.FC = () => {
    const { data } = useQuery(OrderFormQuery)
    const [updateItem] = useMutation(UpdateItemMutation)
    // ...
}
```

## Utility functions

### useCheckoutURL()

This is a React Hook that provides the URL to the Checkout Cart, which varies depending on the version of `vtex.checkout` installed in the account.

Returns an object with a `url` property containing the path to the cart (`/checkout/#/cart` or `/cart`, for instance).

#### Example usage

```tsx
import { useCheckoutURL } from 'vtex.checkout-resources/Utils'

const MyComponent: FunctionComponent = () => {
  const { url } = useCheckoutURL()

  return Go to cart
}
```

**Upcoming documentation:**

 - [Update saveCards mutation](https://github.com/vtex-apps/checkout-resources/pull/26)
 - [Update version of gateway-graphql](https://github.com/vtex-apps/checkout-resources/pull/29)
```


[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 checkout-resources/react/MutationSaveCards.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import saveCards from './mutations/saveCards.graphql'

export default saveCards

```


[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 checkout-resources/react/MutationSelectPickupOption.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import selectPickupOption from './mutations/selectPickupOption.graphql'

export default selectPickupOption

```


[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 checkout-resources/react/QueryGeolocationInstalled.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import geolocationInstalledQuery from './queries/geolocationInstalled.graphql'

export default geolocationInstalledQuery

```


[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 checkout-resources/react/MutationSavePaymentToken.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import savePaymentToken from './mutations/savePaymentToken.graphql'

export default savePaymentToken

```


[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 checkout-resources/react/MutationEstimateShipping.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import estimateShipping from './mutations/estimateShipping.graphql'

export default estimateShipping

```


[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 checkout-resources/react/Queries.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
/** DEPRECATED, being kept just for retrocompatibility.
 * Create individual entry points for each query instead */

import orderForm from './queries/orderForm.graphql'
import cardSessionId from './queries/cardSessionId.graphql'

export default {
  orderForm,
  cardSessionId,
}

```


[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 checkout-resources/react/MutationUpdateOrderFormPayment.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import updateOrderFormPaymentMutation from './mutations/updateOrderFormPayment.graphql'

export default updateOrderFormPaymentMutation
```


[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 checkout-resources/react/MutationUpdateItems.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import updateItems from './mutations/updateItems.graphql'

export default updateItems

```


[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 checkout-resources/react/MutationClearOrderFormMessages.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import clearOrderFormMessages from './mutations/clearOrderFormMessages.graphql'

export default clearOrderFormMessages

```


[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 checkout-resources/react/MutationUpdateClientPreferencesData.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import updateClientPreferencesData from './mutations/updateClientPreferencesData.graphql'

export default updateClientPreferencesData

```


[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 checkout-resources/react/package.json from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "name": "vtex.checkout-resources",
  "version": "0.50.1",
  "private": true,
  "license": "UNLICENSED",
  "scripts": {
    "test": "vtex-test-tools test",
    "lint": "tsc --noEmit && eslint --ext ts,tsx ."
  },
  "dependencies": {
    "@vtex/css-handles": "^1.0.0",
    "classnames": "^2.2.6",
    "ramda": "^0.26.1",
    "react": "^16.8.3",
    "react-apollo": "^3.1.3",
    "react-dom": "^16.8.3",
    "react-intl": "^2.7.2"
  },
  "devDependencies": {
    "@apollo/react-testing": "^3.1.3",
    "@types/classnames": "^2.2.7",
    "@types/graphql": "^14.5.0",
    "@types/jest": "^24.0.11",
    "@types/node": "^11.13.0",
    "@types/prop-types": "^15.7.0",
    "@types/ramda": "^0.26.5",
    "@types/react": "^16.8.10",
    "@types/react-intl": "^2.3.17",
    "@vtex/test-tools": "^2.1.1",
    "apollo-client": "^2.5.1",
    "typescript": "3.9.7",
    "vtex.apps-graphql": "http://vtex.vtexassets.com/_v/public/typings/v1/vtex.apps-graphql@3.12.0/public/@types/vtex.apps-graphql",
    "vtex.checkout-graphql": "http://vtex.vtexassets.com/_v/public/typings/v1/vtex.checkout-graphql@0.60.0/public/@types/vtex.checkout-graphql",
    "vtex.checkout-resources": "http://vtex.vtexassets.com/_v/public/typings/v1/vtex.checkout-resources@0.45.0/public/@types/vtex.checkout-resources",
    "vtex.gateway-graphql": "http://vtex.vtexassets.com/_v/public/typings/v1/vtex.gateway-graphql@1.0.0/public/@types/vtex.gateway-graphql",
    "vtex.render-runtime": "http://vtex.vtexassets.com/_v/public/typings/v1/vtex.render-runtime@8.128.2/public/@types/vtex.render-runtime"
  }
}

```


[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 checkout-resources/react/MutationUpdateOrderFormProfile.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import updateOrderFormProfileMutation from './mutations/updateOrderFormProfile.graphql'

export default updateOrderFormProfileMutation

```


[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 checkout-resources/react/QueryOrderForm.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import orderForm from './queries/orderForm.graphql'

export default orderForm

```


[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 checkout-resources/react/MutationSelectDeliveryOption.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import selectDeliveryOption from './mutations/selectDeliveryOption.graphql'

export default selectDeliveryOption

```


[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 checkout-resources/react/QueryCardSessionId.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import cardSessionId from './queries/cardSessionId.graphql'

export default cardSessionId

```


[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 checkout-resources/react/QueryProfile.ts from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```typescript
import profileQuery from './queries/profile.graphql'

export default profileQuery

```


[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 checkout-resources/react/Mutations.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
/** DEPRECATED, being kept just for retrocompatibility.
 * Create individual entry points for each mutation instead */

import addToCart from './mutations/addToCart.graphql'
import estimateShipping from './mutations/estimateShipping.graphql'
import insertCoupon from './mutations/insertCoupon.graphql'
import selectDeliveryOption from './mutations/selectDeliveryOption.graphql'
import updateItems from './mutations/updateItems.graphql'
import savePaymentToken from './mutations/savePaymentToken.graphql'
import saveCards from './mutations/saveCards.graphql'
import setManualPrice from './mutations/setManualPrice.graphql'

export default {
  addToCart,
  estimateShipping,
  insertCoupon,
  selectDeliveryOption,
  updateItems,
  savePaymentToken,
  saveCards,
  setManualPrice,
}

```


[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 checkout-resources/react/Utils.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import { useCheckoutURL } from './utils/useCheckoutURL'

export default {
  useCheckoutURL,
}

```


[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 checkout-resources/react/MutationUpdateSelectedAddress.ts from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```typescript
import updateSelectedAddress from './mutations/updateSelectedAddress.graphql'

export default updateSelectedAddress

```


[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 checkout-resources/react/MutationSetManualPrice.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import setManualPrice from './mutations/setManualPrice.graphql'

export default setManualPrice

```


[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 checkout-resources/react/useGeolocationEnabled.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import { useQuery } from 'react-apollo'

import QueryGeolocationInstalled from './QueryGeolocationInstalled'

export default function useGeolocationEnabled() {
  const { data, loading } = useQuery(QueryGeolocationInstalled)

  return [(data?.installedApp?.source ?? 'none') !== 'none', loading]
}

```


[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 checkout-resources/react/MutationInsertCoupon.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import insertCoupon from './mutations/insertCoupon.graphql'

export default insertCoupon

```


[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 checkout-resources/react/MutationAddToCart.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import addToCart from './mutations/addToCart.graphql'

export default addToCart

```


[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 checkout-resources/react/fragments/address.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
fragment Address on Address {
  addressId
  addressType
  city
  complement
  country
  neighborhood
  number
  postalCode
  receiverName
  reference
  state
  street
  isDisposable
  geoCoordinates
}

```


[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 checkout-resources/react/fragments/orderForm.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
#import './address.graphql'
#import './item.graphql'

fragment OrderFormFragment on OrderForm {
  id
  items {
    ...ItemFragment
  }
  canEditData
  loggedIn
  userProfileId
  userType
  marketingData {
    coupon
    utmCampaign
    utmMedium
    utmSource
    utmiCampaign
    utmiPart
    utmiPage
  }
  totalizers {
    id
    name
    value
  }
  shipping {
    countries
    availableAddresses {
      ...Address
    }
    selectedAddress {
      ...Address
    }
    deliveryOptions {
      id
      deliveryChannel
      price
      estimate
      isSelected
    }
    pickupOptions {
      id
      address {
        ...Address
      }
      deliveryChannel
      price
      estimate
      isSelected
      friendlyName
      additionalInfo
      storeDistance
      transitTime
      businessHours {
        dayNumber
        closed
        closingTime
        openingTime
      }
    }
    isValid
  }
  paymentData {
    paymentSystems {
      id
      name
      groupName
      validator {
        regex
        mask
        cardCodeRegex
        cardCodeMask
        weights
        useCvv
        useExpirationDate
        useCardHolderName
        useBillingAddress
      }
      stringId
      requiresDocument
      isCustom
      description
      requiresAuthentication
      dueDate
    }
    payments {
      paymentSystem
      bin
      accountId
      tokenId
      installments
      referenceValue
      value
    }
    installmentOptions {
      paymentSystem
      installments {
        count
        hasInterestRate
        interestRate
        value
        total
      }
    }
    availableAccounts {
      accountId
      paymentSystem
      paymentSystemName
      cardNumber
      bin
    }
    isValid
  }
  clientProfileData {
    email
    firstName
    lastName
    document
    documentType
    phone
    isValid
    isCorporate
    corporateName
    tradeName
    corporateDocument
    stateInscription
  }
  clientPreferencesData {
    locale
    optInNewsletter
  }
  messages {
    couponMessages {
      code
    }
    generalMessages {
      code
      text
      status
    }
  }
  value
  allowManualPrice
  customData {
    customApps {
      fields
      id
      major
    }
  }
}

```


[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 checkout-resources/react/fragments/item.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
#import './bundleItem.graphql'

fragment ItemFragment on Item {
  additionalInfo {
    brandName
  }
  attachments {
    name
    content
  }
  attachmentOfferings {
    name
    required
    schema
  }
  bundleItems {
    ...BundleItemFragment
  }
  parentAssemblyBinding
  parentItemIndex
  sellingPriceWithAssemblies
  options {
    assemblyId
    id
    quantity
    seller
    inputValues
    options {
      assemblyId
      id
      quantity
      seller
      inputValues
      options {
        assemblyId
        id
        quantity
        seller
        inputValues
      }
    }
  }
  availability
  detailUrl
  id
  imageUrls {
    at1x
    at2x
    at3x
  }
  listPrice
  manualPrice
  measurementUnit
  modalType
  name
  offerings {
    id
    name
    price
    type
    attachmentOfferings {
      name
      required
      schema
    }
  }
  price
  priceTags {
    identifier
    isPercentual
    name
    rawValue
    value
  }
  productCategories
  productCategoryIds
  productRefId
  productId
  quantity
  seller
  sellingPrice
  skuName
  skuSpecifications {
    fieldName
    fieldValues
  }
  unitMultiplier
  uniqueId
  refId
  priceTags {
    identifier
    isPercentual
    rawValue
    value
    name
    ratesAndBenefitsIdentifier {
      description
      id
      featured
      name
      matchedParameters
    }
  }
  isGift
  priceDefinition {
    calculatedSellingPrice
    total
    sellingPrices {
      quantity
      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 checkout-resources/react/fragments/bundleItem.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
fragment BundleItemFragment on Item {
  additionalInfo {
    brandName
  }
  attachments {
    name
    content
  }
  attachmentOfferings {
    name
    required
    schema
  }
  availability
  detailUrl
  id
  imageUrls {
    at1x
    at2x
    at3x
  }
  listPrice
  measurementUnit
  name
  offerings {
    id
    name
    price
    type
    attachmentOfferings {
      name
      required
      schema
    }
  }
  price
  productCategories
  productCategoryIds
  productRefId
  productId
  quantity
  seller
  sellingPrice
  skuName
  skuSpecifications {
    fieldName
    fieldValues
  }
  unitMultiplier
  uniqueId
  refId
}
```


[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 checkout-resources/react/mutations/updateOrderFormPayment.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation UpdateOrderFormPayment($paymentData: PaymentDataInput!) {
  updateOrderFormPayment(input: $paymentData) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/setManualPrice.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation SetManualPrice($manualPriceInput: ManualPriceInput!) {
  setManualPrice(input: $manualPriceInput) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/updateSelectedAddress.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation UpdateSelectedAddress($address: AddressInput!) {
  updateSelectedAddress(input: $address) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/savePaymentToken.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
mutation SavePaymentToken($paymentTokens: [PaymentToken]) {
  savePaymentToken(paymentTokens: $paymentTokens) {
    status
  }
}

```


[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 checkout-resources/react/mutations/updateClientPreferencesData.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation UpdateClientPreferencesData($clientPreferences: ClientPreferencesDataInput!) {
  updateClientPreferencesData(input: $clientPreferences) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/insertCoupon.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation insertCoupon($text: String) {
  insertCoupon(text: $text) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/saveCards.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
mutation SaveCards(
  $paymentData: [PaymentDataInput!]!
  $cardSessionId: String!
) {
  saveCards(paymentData: $paymentData, cardSessionId: $cardSessionId) {
    tokenizedCards {
      token
      bin
      lastDigits
      paymentSystem
    }
  }
}

```


[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 checkout-resources/react/mutations/selectDeliveryOption.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation selectDeliveryOption($deliveryOptionId: String) {
  selectDeliveryOption(deliveryOptionId: $deliveryOptionId)
    @context(provider: "vtex.checkout-graphql") {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/updateItems.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation updateItems(
  $orderItems: [ItemInput]
  $allowedOutdatedData: [String!]
  $splitItem: Boolean
) {
  updateItems(
    orderItems: $orderItems
    allowedOutdatedData: $allowedOutdatedData
    splitItem: $splitItem
  ) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/estimateShipping.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation estimateShipping($addressInput: AddressInput) {
  estimateShipping(address: $addressInput)
    @context(provider: "vtex.checkout-graphql") {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/updateOrderFormProfile.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation UpdateOrderFormProfile($profile: UserProfileInput!) {
  updateOrderFormProfile(input: $profile) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/selectPickupOption.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation selectPickupOption($pickupOptionId: String) {
  selectPickupOption(pickupOptionId: $pickupOptionId)
    @context(provider: "vtex.checkout-graphql") {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/addToCart.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation addToCart(
  $items: [ItemInput]
  $marketingData: MarketingDataInput
  $salesChannel: String
  $allowedOutdatedData: [String!]
) {
  addToCart(
    items: $items
    marketingData: $marketingData
    salesChannel: $salesChannel
    allowedOutdatedData: $allowedOutdatedData
  ) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/mutations/clearOrderFormMessages.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

mutation ClearOrderFormMessages($orderFormId: ID!) {
  clearOrderFormMessages(orderFormId: $orderFormId) {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/typings/graphql.d.ts from the checkout-resources 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 checkout-resources/react/queries/profile.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
query ProfileQuery($email: String!) {
  checkoutProfile(email: $email) {
    userProfileId
    profileProvider
    availableAccounts {
      accountId
      paymentSystem
      paymentSystemName
      cardNumber
      bin
    }
    userProfile {
      email
      firstName
      lastName
      document
      documentType
      phone
      corporateName
      tradeName
      corporateDocument
      stateInscription
      corporatePhone
      isCorporate
      profileCompleteOnLoading
      profileErrorOnLoading
      customerClass
    }
    availableAddresses {
      addressId
      addressType
      city
      complement
      country
      geoCoordinates
      neighborhood
      number
    }
  }
}

```


[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 checkout-resources/react/queries/geolocationInstalled.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
query GeolocationInstalled {
  installedApp: installedAppPublic(slug: "vtex.geolocation-graphql-interface") {
    source
  }
}

```


[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 checkout-resources/react/queries/orderForm.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
# import '../fragments/orderForm.graphql'

query orderForm($orderFormId: ID, $refreshOutdatedData: Boolean) {
  orderForm(orderFormId: $orderFormId, refreshOutdatedData: $refreshOutdatedData)
    @context(scope: "private") {
    ...OrderFormFragment
  }
}

```


[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 checkout-resources/react/utils/useCheckoutURL.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import { useQuery } from 'react-apollo'

import installedApp from './graphql/installedApp.graphql'

const CHECKOUT_URL = {
  V0: '/checkout/#/cart',
  V1: '/cart',
}

export const useCheckoutURL = () => {
  const { data } = useQuery(installedApp, {
    ssr: false,
    variables: {
      slug: 'vtex.checkout',
    },
  })

  const version = data?.installedApp?.version
  const major = version && parseInt(version.split('.')[0])

  return {
    url: major > 0 ? CHECKOUT_URL.V1 : CHECKOUT_URL.V0,
    major,
  }
}

```


[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 checkout-resources/react/utils/__tests__/useCheckoutURL.test.tsx from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```tsx
import React, { FC } from 'react'
import { flushPromises, render } from '@vtex/test-tools/react'
import { MockedProvider } from '@apollo/react-testing'

import installedApp from '../graphql/installedApp.graphql'
import { useCheckoutURL } from '../useCheckoutURL'

describe('useCheckoutURL', () => {
  it('should return the correct URL when checkout major is 0', async () => {
    jest.useFakeTimers()

    const Component: FC = () => {
      const { url } = useCheckoutURL()
      return <div>{url}</div>
    }

    const mockInstalledApp = {
      request: {
        query: installedApp,
        variables: {
          slug: 'vtex.checkout',
        },
      },
      result: {
        data: {
          installedApp: {
            version: '0.4.2',
          },
        },
      },
    }

    const { getByText } = render(<Component />, {
      graphql: { mocks: [mockInstalledApp] },
      MockedProvider,
    })

    await flushPromises()
    jest.runAllTimers()

    expect(getByText('/checkout/#/cart')).toBeTruthy()
  })

  it('should return the correct URL when checkout major is 1', async () => {
    jest.useFakeTimers()

    const Component = () => {
      const { url } = useCheckoutURL()
      return <div>{url}</div>
    }

    const mockInstalledApp = {
      request: {
        query: installedApp,
        variables: {
          slug: 'vtex.checkout',
        },
      },
      result: {
        data: {
          installedApp: {
            version: '1.4.2',
          },
        },
      },
    }

    const { getByText } = render(<Component />, {
      graphql: { mocks: [mockInstalledApp] },
      MockedProvider,
    })

    await flushPromises()
    jest.runAllTimers()

    expect(getByText('/cart')).toBeTruthy()
  })
})

```


[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 checkout-resources/react/utils/graphql/installedApp.graphql from the checkout-resources VTEX app.

[Assistant]
Here's the implementation:

```graphql
query installedApp($slug: String!) {
  installedApp: installedAppPublic(slug: $slug) {
    version
  }
}

```


[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-form/messages/nl.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Dit veld is verplicht",
  "store/form.error.maxLength": "Dit veld heeft een maximale lengte van: {value}",
  "store/form.error.minLength": "Dit veld heeft een minimale lengte van: {value}",
  "store/form.error.maxValue": "De maximale waarde die door dit veld wordt geaccepteerd is {value}",
  "store/form.error.minValue": "De minimale waarde die door dit veld wordt geaccepteerd is {value}",
  "store/form.error.notFloat": "Moet een getal zijn",
  "store/form.error.notInteger": "Moet een geheel getal zijn",
  "store/form.error.pattern": "Deze tekst komt niet overeen met het verwachte patroon",
  "store/form.error.notInEnum": "Moet een van de volgende waarden hebben: {values}",
  "store/form.error.multipleOf": "Moet een veelvoud zijn van {value}",
  "store/form.error.undefinedError": "Ongeldige waarde.",
  "store/form.submit.buttonLabel": "Versturen",
  "store/form.submit.error.userInputError": "Er zijn enkele fouten gevonden in de verstrekte gegevens, bekijk de aangegeven velden en probeer het opnieuw!",
  "store/form.submit.error.serverError": "Interne serverfout! Probeer het later opnieuw!",
  "store/form.schema.loading": "Formulier laden...",
  "store/form.schema.error": "Fout bij laden formulier, probeer het later opnieuw!",
  "store/form.operating.agreement": "Exploitatieovereenkomst",
  "store/form.add-button": "Toevoegen",
  "store/form.add-document.title": "Document uploaden",
  "store/form.add-document.label": "Document URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Bestand overschrijdt de limiet van 4 MB. Kies een kleinere.",
  "store/form.document-uploader.error.generic": "Er is iets fout gegaan. Probeer het opnieuw.",
  "store/form.upload-button": "Document uploaden",
  "store/form.upload-document-label": "Kies een document om te uploaden"
}

```


[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-form/messages/de.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Dies ist ein Pflichtfeld",
  "store/form.error.maxLength": "Dieses Feld hat eine maximale Länge von: {value}",
  "store/form.error.minLength": "Dieses Feld hat eine Mindestlänge von: {value}",
  "store/form.error.maxValue": "Der maximal zulässige Wert für dieses Feld ist {value}",
  "store/form.error.minValue": "Der Mindestwert für dieses Feld ist {value}",
  "store/form.error.notFloat": "Muss eine Zahl sein",
  "store/form.error.notInteger": "Muss eine ganze Zahl sein",
  "store/form.error.pattern": "Dieser Text entspricht nicht dem erwarteten Muster",
  "store/form.error.notInEnum": "Muss einer der folgenden Werte sein: {values}",
  "store/form.error.multipleOf": "Muss ein Vielfaches von {value} sein",
  "store/form.error.undefinedError": "Ungültiger Wert.",
  "store/form.submit.buttonLabel": "Absenden",
  "store/form.submit.error.userInputError": "Es wurden einige Fehler in den angegebenen Daten gefunden. Bitte überprüfen Sie die angegebenen Felder und versuchen Sie es erneut!",
  "store/form.submit.error.serverError": "Interner Serverfehler. Bitte versuchen Sie es später erneut!",
  "store/form.schema.loading": "Formular wird geladen...",
  "store/form.schema.error": "Fehler beim Laden. Versuche es später erneut!",
  "store/form.operating.agreement": "Betriebsvereinbarung",
  "store/form.add-button": "Zufügen",
  "store/form.add-document.title": "Dokument hochladen",
  "store/form.add-document.label": "Dokument-URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Dieses Photo liegt über der 4MB-Grenze. Wählen Sie ein kleineres.",
  "store/form.document-uploader.error.generic": "Etwas ist schiefgelaufen. Bitte versuche es erneut.",
  "store/form.upload-button": "Dokument hochladen",
  "store/form.upload-document-label": "Wählen Sie eine Datei zum Hochladen"
}

```


[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-form/messages/ru.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Это обязательное поле",
  "store/form.error.maxLength": "Максимальная длина поля: {value}",
  "store/form.error.minLength": "Минимальная длина поля: {value}",
  "store/form.error.maxValue": "Максимальное значение поля: {value}",
  "store/form.error.minValue": "Минимальное значение поля: {value}",
  "store/form.error.notFloat": "Должно быть числом",
  "store/form.error.notInteger": "Должно быть целым числом",
  "store/form.error.pattern": "Текст не соответствует ожидаемому шаблону",
  "store/form.error.notInEnum": "Должно иметь одно из следующих значений: {values}",
  "store/form.error.multipleOf": "Должно быть кратно {value}",
  "store/form.error.undefinedError": "Недопустимое значение.",
  "store/form.submit.buttonLabel": "Отправить",
  "store/form.submit.error.userInputError": "Во введенных данных обнаружены ошибки. Проверьте указанные поля и повторите попытку!",
  "store/form.submit.error.serverError": "Внутренняя ошибка сервера! Повторите попытку позже!",
  "store/form.schema.loading": "Загрузка формы...",
  "store/form.schema.error": "Ошибка загрузки формы. Попробуйте позже!",
  "store/form.operating.agreement": "Операционное соглашение",
  "store/form.add-button": "Добавить",
  "store/form.add-document.title": "Загрузить документ",
  "store/form.add-document.label": "URL документа",
  "store/form.add-document.placeholder": "URL-адрес",
  "store/form.document-uploader.error.file-size": "Файл превышает 4 Мб. Выберите меньший размер.",
  "store/form.document-uploader.error.generic": "Произошла ошибка. Повторите попытку.",
  "store/form.upload-button": "Загрузить документ",
  "store/form.upload-document-label": "Выберите документ для загрузки"
}

```


[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-form/messages/pl.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "To pole jest wymagane",
  "store/form.error.maxLength": "To pole ma maks. długość: {value}",
  "store/form.error.minLength": "To pole ma min. długość: {value}",
  "store/form.error.maxValue": "Maksymalna wartość akceptowana przez to pole wynosi {value}",
  "store/form.error.minValue": "Minimalna wartość akceptowana przez to pole wynosi {value}",
  "store/form.error.notFloat": "Musi być liczbą",
  "store/form.error.notInteger": "Musi być liczbą całkowitą",
  "store/form.error.pattern": "Ten tekst nie jest zgodny z oczekiwanym wzorem",
  "store/form.error.notInEnum": "Musi mieć jedną z następujących wartości: {values}",
  "store/form.error.multipleOf": "Musi być wielokrotnością {value}",
  "store/form.error.undefinedError": "Nieprawidłowa wartość.",
  "store/form.submit.buttonLabel": "Prześlij",
  "store/form.submit.error.userInputError": "Znaleziono błędy w podanych danych, przejrzyj wskazane pola i spróbuj ponownie!",
  "store/form.submit.error.serverError": "Wewnętrzny błąd serwera. Spróbuj ponownie później!",
  "store/form.schema.loading": "Ładowanie formularza...",
  "store/form.schema.error": "Błąd ładowania formularza, spróbuj ponownie później!",
  "store/form.operating.agreement": "Umowa operacyjna",
  "store/form.add-button": "Dodaj",
  "store/form.add-document.title": "Prześlij dokument",
  "store/form.add-document.label": "Adres URL dokumentu",
  "store/form.add-document.placeholder": "Adres URL",
  "store/form.document-uploader.error.file-size": "Plik przekracza limit rozmiaru 4 MB. Wybierz mniejszy.",
  "store/form.document-uploader.error.generic": "Coś poszło nie tak. Spróbuj ponownie.",
  "store/form.upload-button": "Prześlij dokument",
  "store/form.upload-document-label": "Wybierz dokument do przesłania"
}

```


[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-form/messages/uk.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Це поле обов’язкове",
  "store/form.error.maxLength": "Максимальна довжина поля: {value}",
  "store/form.error.minLength": "Мінімальна довжина поля: {value}",
  "store/form.error.maxValue": "Максимальне значення цього поля: {value}",
  "store/form.error.minValue": "Мінімальне значення цього поля: {value}",
  "store/form.error.notFloat": "Має бути числом",
  "store/form.error.notInteger": "Має бути ціле число",
  "store/form.error.pattern": "Цей текст не збігається з очікуваним шаблоном",
  "store/form.error.notInEnum": "Має мати одне з наступних значень: {values}",
  "store/form.error.multipleOf": "Має бути кратним {value}",
  "store/form.error.undefinedError": "Недійсне значення.",
  "store/form.submit.buttonLabel": "Відправити",
  "store/form.submit.error.userInputError": "У введених даних виявлені помилки. Перевірте зазначені поля та спробуйте ще раз!",
  "store/form.submit.error.serverError": "Внутрішня помилка сервера! Спробуйте пізніше!",
  "store/form.schema.loading": "Завантаження форми...",
  "store/form.schema.error": "Помилка завантаження форми, спробуйте пізніше!",
  "store/form.operating.agreement": "Операційна угода",
  "store/form.add-button": "Додати",
  "store/form.add-document.title": "Завантажити документ",
  "store/form.add-document.label": "URL-адреса документа",
  "store/form.add-document.placeholder": "URL-адреса",
  "store/form.document-uploader.error.file-size": "Файл перевищує 4 Мб. Виберіть менший розмір.",
  "store/form.document-uploader.error.generic": "Щось пішло не так. Спробуйте ще раз.",
  "store/form.upload-button": "Завантажити документ",
  "store/form.upload-document-label": "Виберіть документ для завантаження"
}

```


[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-form/messages/fi.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Tämä on pakollinen kenttä",
  "store/form.error.maxLength": "Tämän kentän enimmäispituus on: {value}",
  "store/form.error.minLength": "Tämän kentän vähimmäispituus on: {value}",
  "store/form.error.maxValue": "Tämän kentän suurin sallittu arvo on {value}",
  "store/form.error.minValue": "Tämän kentän pienin sallittu vähimmäisarvo on {value}",
  "store/form.error.notFloat": "On oltava numero",
  "store/form.error.notInteger": "On oltava kokonaisluku",
  "store/form.error.pattern": "Teksti ei vastaa odotettua kuviota",
  "store/form.error.notInEnum": "On oltava jokin seuraavista arvoista: {values}",
  "store/form.error.multipleOf": "On oltava arvon {value} kerrannainen",
  "store/form.error.undefinedError": "Virheellinen arvo.",
  "store/form.submit.buttonLabel": "Lähetä",
  "store/form.submit.error.userInputError": "Annetuissa tiedoissa oli virheitä. Tarkista merkityt kentät ja yritä uudelleen!",
  "store/form.submit.error.serverError": "Sisäinen palvelinvirhe! Yritä myöhemmin uudelleen!",
  "store/form.schema.loading": "Ladataan lomaketta...",
  "store/form.schema.error": "Virhe ladattaessa lomaketta. Yritä myöhemmin uudelleen!",
  "store/form.operating.agreement": "Toimintasopimus",
  "store/form.add-button": "Lisää",
  "store/form.add-document.title": "Lataa asiakirja",
  "store/form.add-document.label": "Asiakirjan URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Tiedosto ylittää 4 Mt:n kokorajan. Valitse pienempi tiedosto.",
  "store/form.document-uploader.error.generic": "Jokin meni pieleen. Yritä uudelleen.",
  "store/form.upload-button": "Lataa asiakirja",
  "store/form.upload-document-label": "Valitse ladattava asiakirja"
}

```


[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-form/messages/sk.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Toto pole je povinné",
  "store/form.error.maxLength": "Toto pole má maximálnu dĺžku: {value}",
  "store/form.error.minLength": "Toto pole má minimálnu dĺžku: {value}",
  "store/form.error.maxValue": "Maximálna hodnota akceptovaná týmto poľom je {value}",
  "store/form.error.minValue": "Minimálna hodnota akceptovaná týmto poľom je {value}",
  "store/form.error.notFloat": "Musí to byť číslo",
  "store/form.error.notInteger": "Musí to byť celé číslo",
  "store/form.error.pattern": "Tento text nezodpovedá očakávanému vzoru",
  "store/form.error.notInEnum": "Musí mať jednu z nasledujúcich hodnôt: {values}",
  "store/form.error.multipleOf": "Musí byť násobkom {value}",
  "store/form.error.undefinedError": "Neplatná hodnota.",
  "store/form.submit.buttonLabel": "Odoslať",
  "store/form.submit.error.userInputError": "V poskytnutých údajoch sa našli chyby, skontrolujte označené polia a skúste to znova.",
  "store/form.submit.error.serverError": "Interná chyba servera. Skúste to znova neskôr.",
  "store/form.schema.loading": "Načítava sa formulár...",
  "store/form.schema.error": "Pri načítaní formulára došlo k chybe. Skúste to znova neskôr.",
  "store/form.operating.agreement": "Prevádzková zmluva",
  "store/form.add-button": "Pridať",
  "store/form.add-document.title": "Nahrať dokument",
  "store/form.add-document.label": "Adresa URL dokumentu",
  "store/form.add-document.placeholder": "Adresa URL",
  "store/form.document-uploader.error.file-size": "Súbor prekračuje limit veľkosti 4 MB. Vyberte menší súbor.",
  "store/form.document-uploader.error.generic": "Niečo sa nepodarilo. Skúste to znova.",
  "store/form.upload-button": "Nahrať dokument",
  "store/form.upload-document-label": "Vyberte dokument, ktorý chcete nahrať"
}

```


[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-form/messages/pt.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Este campo é necessário",
  "store/form.error.maxLength": "Este campo deve ter até {value} caracteres",
  "store/form.error.minLength": "Este campo deve ter no mínimo {value} caracteres",
  "store/form.error.maxValue": "O valor máximo aceito neste campo é {value}",
  "store/form.error.minValue": "O valor mínimo aceito neste campo é {value}",
  "store/form.error.notFloat": "Deve ser um número",
  "store/form.error.notInteger": "Deve ser um número inteiro",
  "store/form.error.pattern": "Este texto não corresponde com o padrão esperado",
  "store/form.error.notInEnum": "Deve ser algum dos seguintes valores: {values}",
  "store/form.error.multipleOf": "Este campo deve ser um mútiplo de {value}",
  "store/form.error.undefinedError": "Valor inválido.",
  "store/form.submit.buttonLabel": "Enviar",
  "store/form.submit.error.userInputError": "Foram encontrados alguns erros nos dados fornecidos, revise os campos indicados e tente novamente.",
  "store/form.submit.error.serverError": "Erro interno do servidor! Por favor, tente novamente mais tarde!",
  "store/form.schema.loading": "Carregando o formulário...",
  "store/form.schema.error": "Erro carregando o formulário, tente de novo mais tarde!",
  "store/form.operating.agreement": "Acordo Operacional",
  "store/form.add-button": "Adicionar",
  "store/form.add-document.title": "Inserir documento",
  "store/form.add-document.label": "URL do documento",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "O arquivo excede 4MB. Por favor, escolhe um menor.",
  "store/form.document-uploader.error.generic": "Erro ao carregar. Por favor, tente novamente.",
  "store/form.upload-button": "Upload",
  "store/form.upload-document-label": "Escolha um documento para upload"
}

```


[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-form/messages/en.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "This field is required",
  "store/form.error.maxLength": "The maximum character length of this field is {value}",
  "store/form.error.minLength": "The minimum character length of this field is {value}",
  "store/form.error.maxValue": "The maximum value accepted by this field is {value}",
  "store/form.error.minValue": "The minimum value accepted by this field is {value}",
  "store/form.error.notFloat": "Must be a number",
  "store/form.error.notInteger": "Must be an integer",
  "store/form.error.pattern": "This text does not match the expected pattern",
  "store/form.error.notInEnum": "Must be one of the following values: {values}",
  "store/form.error.multipleOf": "Must be a multiple of {value}",
  "store/form.error.undefinedError": "Invalid value.",
  "store/form.submit.buttonLabel": "Submit",
  "store/form.submit.error.userInputError": "There are some errors in the information provided. Please check the highlighted fields and try again.",
  "store/form.submit.error.serverError": "Internal server error. Please try again later.",
  "store/form.schema.loading": "Loading form...",
  "store/form.schema.error": "Error loading form. Please try again later.",
  "store/form.operating.agreement": "Operating agreement",
  "store/form.add-button": "Add",
  "store/form.add-document.title": "Upload Document",
  "store/form.add-document.label": "Document URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "File exceeds the size limit of 4 MB. Please choose a smaller one.",
  "store/form.document-uploader.error.generic": "Something went wrong. Please try again.",
  "store/form.upload-button": "Upload Document",
  "store/form.upload-document-label": "Choose a document to upload"
}

```


[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-form/messages/it.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Questo campo è obbligatorio",
  "store/form.error.maxLength": "Questo campo deve avere una lunghezza massima di: {value}",
  "store/form.error.minLength": "Questo campo deve avere una lunghezza minima di: {value}",
  "store/form.error.maxValue": "Il valore massimo accettato da questo campo è {value}",
  "store/form.error.minValue": "Il valore minimo accettato da questo campo è {value}",
  "store/form.error.notFloat": "Deve essere un numero",
  "store/form.error.notInteger": "Deve essere un numero intero",
  "store/form.error.pattern": "Questo testo non corrisponde al modello previsto",
  "store/form.error.notInEnum": "Deve essere uno dei seguenti valori: {values}",
  "store/form.error.multipleOf": "Deve essere un multiplo di {value}",
  "store/form.error.undefinedError": "Valore non valido.",
  "store/form.submit.buttonLabel": "Invia",
  "store/form.submit.error.userInputError": "Sono stati riscontrati degli errori nei dati forniti, controlla di nuovo i campi indicati e riprova!",
  "store/form.submit.error.serverError": "Errore interno del server! Riprova tra poco!",
  "store/form.schema.loading": "Caricamento del modulo in corso...",
  "store/form.schema.error": "Errore nel caricamento del modulo, riprova tra poco!",
  "store/form.operating.agreement": "Accordo di gestione",
  "store/form.add-button": "Aggiungi",
  "store/form.add-document.title": "Carica documento",
  "store/form.add-document.label": "URL del documento",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Questo file supera la dimensione di 4 MB. Scegline uno di dimensioni minori.",
  "store/form.document-uploader.error.generic": "Si è verificato un errore. Riprova.",
  "store/form.upload-button": "Carica documento",
  "store/form.upload-document-label": "Scegli un documento da caricare"
}

```


[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-form/messages/fr.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Ce champ est obligatoire",
  "store/form.error.maxLength": "Ce champ a une longueur maximale de : {value}",
  "store/form.error.minLength": "Ce champ a une longueur minimale de : {value}",
  "store/form.error.maxValue": "La valeur maximale acceptée par ce champ est {value}",
  "store/form.error.minValue": "La valeur minimale acceptée par ce champ est {value}",
  "store/form.error.notFloat": "Doit être un nombre",
  "store/form.error.notInteger": "Doit être un nombre entier",
  "store/form.error.pattern": "Ce texte ne correspond pas au modèle attendu",
  "store/form.error.notInEnum": "Doit avoir l'une des valeurs suivantes : {values}",
  "store/form.error.multipleOf": "Doit être un multiple de {value}",
  "store/form.error.undefinedError": "Valeur invalide.",
  "store/form.submit.buttonLabel": "Envoyer",
  "store/form.submit.error.userInputError": "Des erreurs se sont glissées dans les données fournies, veuillez revoir les champs indiqués et réessayer !",
  "store/form.submit.error.serverError": "Erreur interne du serveur. Veuillez réessayer ultérieurement !",
  "store/form.schema.loading": "Chargement du formulaire...",
  "store/form.schema.error": "Erreur de chargement du formulaire, réessayez plus tard !",
  "store/form.operating.agreement": "Accord d'exploitation",
  "store/form.add-button": "Ajouter",
  "store/form.add-document.title": "Télécharger un document",
  "store/form.add-document.label": "URL du document",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Le fichier dépasse la limite de taille de 4MB. Veuillez en choisir un plus petit.",
  "store/form.document-uploader.error.generic": "Une erreur s’est produite. Veuillez réessayer.",
  "store/form.upload-button": "Télécharger un document",
  "store/form.upload-document-label": "Choisir un document à télécharger"
}

```


[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-form/messages/el.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Αυτό το πεδίο είναι υποχρεωτικό",
  "store/form.error.maxLength": "Αυτό το πεδίο έχει μέγιστο μήκος: {value}",
  "store/form.error.minLength": "Αυτό το πεδίο έχει ελάχιστο μήκος: {value}",
  "store/form.error.maxValue": "Η μέγιστη τιμή που δέχεται αυτό το πεδίο είναι {value}",
  "store/form.error.minValue": "Η ελάχιστη τιμή που δέχεται αυτό το πεδίο είναι {value}",
  "store/form.error.notFloat": "Πρέπει να είναι αριθμός",
  "store/form.error.notInteger": "Πρέπει να είναι ακέραιος αριθμός",
  "store/form.error.pattern": "Αυτό το κείμενο δεν ταιριάζει με το αναμενόμενο μοτίβο",
  "store/form.error.notInEnum": "Πρέπει να έχει μία από τις ακόλουθες τιμές: {values}",
  "store/form.error.multipleOf": "Πρέπει να είναι πολλαπλάσιο του {value}",
  "store/form.error.undefinedError": "Άκυρη τιμή.",
  "store/form.submit.buttonLabel": "Υποβολή",
  "store/form.submit.error.userInputError": "Βρέθηκαν κάποια σφάλματα στα παρεχόμενα δεδομένα, παρακαλούμε ελέγξτε τα υποδεικνυόμενα πεδία και δοκιμάστε ξανά!",
  "store/form.submit.error.serverError": "Σφάλμα εσωτερικού διακομιστή! Δοκιμάστε ξανά αργότερα!",
  "store/form.schema.loading": "Γίνεται φόρτωση εντύπου...",
  "store/form.schema.error": "Σφάλμα στη φόρτωση φόρμας, δοκιμάστε ξανά αργότερα!",
  "store/form.operating.agreement": "Συμφωνία λειτουργίας",
  "store/form.add-button": "Προσθήκη",
  "store/form.add-document.title": "Αποστολή εγγράφου",
  "store/form.add-document.label": "Αναγνωριστικό εγγράφου",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Το αρχείο υπερβαίνει το όριο μεγέθους των 4MB. Επιλέξτε ένα μικρότερο.",
  "store/form.document-uploader.error.generic": "Κάτι πήγε στραβά. Παρακαλώ προσπαθήστε ξανά.",
  "store/form.upload-button": "Αποστολή εγγράφου",
  "store/form.upload-document-label": "Επιλέξτε ένα έγγραφο για αποστολή"
}

```


[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-form/messages/bg.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Това поле е задължително",
  "store/form.error.maxLength": "Това поле има максимална дължина: {value}",
  "store/form.error.minLength": "Това поле има минимална дължина: {value}",
  "store/form.error.maxValue": "Максималната стойност, приемана от това поле, е {value}",
  "store/form.error.minValue": "Минималната стойност, приемана от това поле, е {value}",
  "store/form.error.notFloat": "Трябва да бъде число",
  "store/form.error.notInteger": "Трябва да бъде цяло число",
  "store/form.error.pattern": "Този текст не съвпада с очаквания модел",
  "store/form.error.notInEnum": "Трябва да има една от следните стойности: {values}",
  "store/form.error.multipleOf": "Трябва да бъде кратно на {value}",
  "store/form.error.undefinedError": "Невалидна стойност.",
  "store/form.submit.buttonLabel": "Изпращане",
  "store/form.submit.error.userInputError": "Открити са грешки в предоставените данни, моля, прегледайте посочените полета и опитайте отново!",
  "store/form.submit.error.serverError": "Вътрешна сървърна грешка! Моля, опитайте отново по-късно!",
  "store/form.schema.loading": "Зареждане на формуляра...",
  "store/form.schema.error": "Грешка при зареждане на формуляра, опитайте отново по-късно!",
  "store/form.operating.agreement": "Оперативно споразумение",
  "store/form.add-button": "Добавяне",
  "store/form.add-document.title": "Качване на документ",
  "store/form.add-document.label": "URL адрес на документа",
  "store/form.add-document.placeholder": "URL адрес",
  "store/form.document-uploader.error.file-size": "Файлът надвишава ограничението на 4 MB. Моля, изберете по-малък файл.",
  "store/form.document-uploader.error.generic": "Нещо се обърка. Моля, опитайте отново.",
  "store/form.upload-button": "Качване на документ",
  "store/form.upload-document-label": "Изберете документ за качване"
}

```


[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-form/messages/ro.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Acest câmp este obligatoriu",
  "store/form.error.maxLength": "Câmpul are o lungime maximă de: {value}",
  "store/form.error.minLength": "Câmpul are o lungime minimă de: {value}",
  "store/form.error.maxValue": "Valoarea maximă acceptată de acest câmp este {value}",
  "store/form.error.minValue": "Valoarea minimă acceptată de acest câmp este {value}",
  "store/form.error.notFloat": "Trebuie să fie un număr",
  "store/form.error.notInteger": "Trebuie să fie o integrală",
  "store/form.error.pattern": "Acest text nu se potrivește modelului așteptat",
  "store/form.error.notInEnum": "Trebuie să fie una dintre următoarele valori: {values}",
  "store/form.error.multipleOf": "Trebuie să fie multiplu de {value}",
  "store/form.error.undefinedError": "Valoare invalidă.",
  "store/form.submit.buttonLabel": "Trimite",
  "store/form.submit.error.userInputError": "S-au găsit erori în datele furnizate, te rugăm să revizuiești câmpurile indicate și să încerci din nou!",
  "store/form.submit.error.serverError": "Eroare internă de server! Te rugăm să încerci din nou!",
  "store/form.schema.loading": "Se încarcă formularul...",
  "store/form.schema.error": "Eroare în încărcarea formularului, încearcă din nou mai târziu!",
  "store/form.operating.agreement": "Acord de funcționare",
  "store/form.add-button": "Adaugă",
  "store/form.add-document.title": "Încarcă documentul",
  "store/form.add-document.label": "URL document",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Fișierul depășește limita de dimensiune de 4MB. Te rugăm să alegi unul mai mic.",
  "store/form.document-uploader.error.generic": "A apărut o eroare. Încearcă din nou.",
  "store/form.upload-button": "Încarcă documentul",
  "store/form.upload-document-label": "Alege un document pentru a-l încărca"
}

```


[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-form/messages/ca.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Aquest camp és obligatori",
  "store/form.error.maxLength": "La longitud màxima d'aquest camp és: {value}",
  "store/form.error.minLength": "La longitud mínima d'aquest camp és: {value}",
  "store/form.error.maxValue": "El valor màxim que accepta aquest camp és {value}",
  "store/form.error.minValue": "El valor mínim que accepta aquest camp és {value}",
  "store/form.error.notFloat": "Ha de ser un número",
  "store/form.error.notInteger": "Ha de ser un nombre enter",
  "store/form.error.pattern": "Aquest text no coincideix amb el patró previst",
  "store/form.error.notInEnum": "Ha de ser un dels valors següents: {values}",
  "store/form.error.multipleOf": "Ha de ser un múltiple de {value}",
  "store/form.error.undefinedError": "El valor no és vàlid.",
  "store/form.submit.buttonLabel": "Envia",
  "store/form.submit.error.userInputError": "S'han trobat alguns errors en les dades facilitades. Reviseu els camps indicats i torneu-ho a provar.",
  "store/form.submit.error.serverError": "Error al servidor intern. Torneu-ho a provar més endavant.",
  "store/form.schema.loading": "S'està carregant el formulari...",
  "store/form.schema.error": "S'ha produït un error en carregar el formulari. Torneu-ho a provar més endavant.",
  "store/form.operating.agreement": "Acord operatiu",
  "store/form.add-button": "Afegeix-ho",
  "store/form.add-document.title": "Puja el document",
  "store/form.add-document.label": "URL del document",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "La mida del fitxer supera el límit de 4 MB. Trieu-ne un de més petit.",
  "store/form.document-uploader.error.generic": "Alguna cosa ha anat malament. Torneu-ho a provar.",
  "store/form.upload-button": "Puja el document",
  "store/form.upload-document-label": "Trieu un document per pujar-lo"
}

```


[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-form/messages/context.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "This field is required",
  "store/form.error.maxLength": "This field has a max length of: {value}",
  "store/form.error.minLength": "This field has a min length of: {value}",
  "store/form.error.maxValue": "The maximum value accepted by this field is {value}",
  "store/form.error.minValue": "The minimum value accepted by this field is {value}",
  "store/form.error.notFloat": "Must be a number",
  "store/form.error.notInteger": "Must be an integer",
  "store/form.error.pattern": "This text does not match the expected pattern",
  "store/form.error.notInEnum": "Must one of the following values: {values}",
  "store/form.error.multipleOf": "Must be a multiple of {value}",
  "store/form.error.undefinedError": "Invalid value.",
  "store/form.submit.buttonLabel": "Submit",
  "store/form.submit.error.userInputError": "Found some errors in the data provided, please review the indicated fields try again!",
  "store/form.submit.error.serverError": "Internal Server Error! Please, try again later!",
  "store/form.schema.loading": "Loading form...",
  "store/form.schema.error": "Error loading form, try again later!"
}
```


[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-form/messages/id.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Bidang ini wajib diisi",
  "store/form.error.maxLength": "Bidang ini memiliki panjang maksimum: {value}",
  "store/form.error.minLength": "Bidang ini memiliki panjang minimum: {value}",
  "store/form.error.maxValue": "Nilai maksimum yang diterima oleh bidang ini adalah {value}",
  "store/form.error.minValue": "Nilai minimum yang diterima oleh bidang ini adalah {value}",
  "store/form.error.notFloat": "Harus berupa angka",
  "store/form.error.notInteger": "Harus berupa bilangan bulat",
  "store/form.error.pattern": "Teks ini tidak cocok dengan pola yang diharapkan",
  "store/form.error.notInEnum": "Harus salah satu dari nilai berikut: {values}",
  "store/form.error.multipleOf": "Harus berupa kelipatan {value}",
  "store/form.error.undefinedError": "Nilai tidak valid.",
  "store/form.submit.buttonLabel": "Kirim",
  "store/form.submit.error.userInputError": "Menemukan beberapa error di data yang diberikan, silakan periksa kembali bidang yang ditunjukkan, coba lagi!",
  "store/form.submit.error.serverError": "Server Internal Error! Silakan coba lagi nanti!",
  "store/form.schema.loading": "Memuat formulir...",
  "store/form.schema.error": "Terjadi error saat memuat formulir, coba lagi nanti!",
  "store/form.operating.agreement": "Perjanjian Operasi",
  "store/form.add-button": "Tambahkan",
  "store/form.add-document.title": "Unggah dokumen",
  "store/form.add-document.label": "URL Dokumen",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "File melebihi batas ukuran 4 MB. Pilih ukuran file yang lebih kecil.",
  "store/form.document-uploader.error.generic": "Terjadi kesalahan. Silakan coba lagi.",
  "store/form.upload-button": "Unggah dokumen",
  "store/form.upload-document-label": "Pilih dokumen untuk diunggah"
}

```


[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-form/messages/no.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Dette feltet er obligatorisk",
  "store/form.error.maxLength": "Dette feltet har maksimal lengde på: {value}",
  "store/form.error.minLength": "Dette feltet har en minimum lengde på: {value}",
  "store/form.error.maxValue": "Den maksimale verdien som godtas av dette feltet er {value}",
  "store/form.error.minValue": "Den minimale verdien som godtas av dette feltet er {value}",
  "store/form.error.notFloat": "Må være et tall",
  "store/form.error.notInteger": "Må være et heltall",
  "store/form.error.pattern": "Denne teksten samsvarer ikke med forventet mønster",
  "store/form.error.notInEnum": "Må én av følgende verdier: {values}",
  "store/form.error.multipleOf": "Må være multiplum av {value}",
  "store/form.error.undefinedError": "Ugyldig verdi.",
  "store/form.submit.buttonLabel": "Send inn",
  "store/form.submit.error.userInputError": "Fant noen feil i dataene som er oppgitt. Gå gjennom feltene som er angitt, prøv igjen!",
  "store/form.submit.error.serverError": "Intern serverfeil! Prøv igjen senere!",
  "store/form.schema.loading": "Laster inn skjema ...",
  "store/form.schema.error": "Feil ved innlasting av skjema, prøv igjen senere!",
  "store/form.operating.agreement": "Driftsavtale",
  "store/form.add-button": "Legg til",
  "store/form.add-document.title": "Last opp dokument",
  "store/form.add-document.label": "Dokument-URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Filen er større enn størrelsesgrensen på 4 MB. Velg en mindre.",
  "store/form.document-uploader.error.generic": "Noe gikk galt. Prøv igjen.",
  "store/form.upload-button": "Last opp dokument",
  "store/form.upload-document-label": "Velg et dokument å laste opp"
}

```


[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-form/messages/da.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Dette felt er påkrævet",
  "store/form.error.maxLength": "Dette felt har en maksimal længde på: {value}",
  "store/form.error.minLength": "Dette felt har en mindste længde på: {value}",
  "store/form.error.maxValue": "Den maksimale værdi, der accepteres af dette felt, er {value}",
  "store/form.error.minValue": "Den mindste værdi, der accepteres af dette felt, er {value}",
  "store/form.error.notFloat": "Skal være et tal",
  "store/form.error.notInteger": "Skal være et heltal",
  "store/form.error.pattern": "Denne tekst matcher ikke det forventede mønster",
  "store/form.error.notInEnum": "Skal en af følgende værdier: {values}",
  "store/form.error.multipleOf": "Skal være et flertal af {value}",
  "store/form.error.undefinedError": "Ugyldig værdi.",
  "store/form.submit.buttonLabel": "Indsend",
  "store/form.submit.error.userInputError": "Fandt nogle fejl i de leverede data. Gennemgå de angivne felter, prøv igen!",
  "store/form.submit.error.serverError": "Intern serverfejl! Prøv igen senere!",
  "store/form.schema.loading": "Indlæser formular...",
  "store/form.schema.error": "Fejl ved indlæsning af formular, prøv igen senere!",
  "store/form.operating.agreement": "Driftsaftale",
  "store/form.add-button": "Tilføj",
  "store/form.add-document.title": "Upload dokument",
  "store/form.add-document.label": "Dokument-URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Filen overskrider størrelsesgrænsen på 4 MB. Vælg en mindre fil.",
  "store/form.document-uploader.error.generic": "Noget gik galt. Prøv igen.",
  "store/form.upload-button": "Upload dokument",
  "store/form.upload-document-label": "Vælg et dokument til upload"
}

```


[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-form/messages/th.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "ต้องระบุฟิลด์นี้",
  "store/form.error.maxLength": "ฟิลด์นี้มีความยาวสูงสุด: {value}",
  "store/form.error.minLength": "ฟิลด์นี้มีความยาวต่ำสุด: {value}",
  "store/form.error.maxValue": "ค่าสูงสุดที่ฟิลด์นี่รับได้คือ {value}",
  "store/form.error.minValue": "ค่าต่ำสุดที่ฟิลด์นี่รับได้คือ {value}",
  "store/form.error.notFloat": "ต้องเป็นตัวเลข",
  "store/form.error.notInteger": "ต้องเป็นจำนวนเต็ม",
  "store/form.error.pattern": "ข้อความนี้ไม่ตรงกับรูปแบบที่คาดไว้",
  "store/form.error.notInEnum": "ต้องเป็นหนึ่งในค่าดังต่อไปนี้: {values}",
  "store/form.error.multipleOf": "ต้องเป็นผลคูณของ {value}",
  "store/form.error.undefinedError": "ค่าไม่ถูกต้อง",
  "store/form.submit.buttonLabel": "ส่ง",
  "store/form.submit.error.userInputError": "พบข้อผิดพลาดบางอย่างในข้อมูลที่ให้มา กรุณาตรวจสอบฟิลด์ที่ระบุ ลองอีกครั้ง!",
  "store/form.submit.error.serverError": "มีข้อผิดพลาดภายในเซิร์ฟเวอร์! กรุณาลองอีกครั้งในภายหลัง",
  "store/form.schema.loading": "กำลังโหลดแบบฟอร์ม...",
  "store/form.schema.error": "มีข้อผิดพลาดในการโหลดแบบฟอร์ม ลองอีกครั้งในภายหลัง!",
  "store/form.operating.agreement": "ข้อตกลงการดำเนินการ",
  "store/form.add-button": "เพิ่ม",
  "store/form.add-document.title": "อัปโหลดเอกสาร",
  "store/form.add-document.label": "URL เอกสาร",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "ขนาดไฟล์เกินขีดจำกัด 4MB โปรดเลือกไฟล์ที่เล็กกว่านี้",
  "store/form.document-uploader.error.generic": "มีบางอย่างผิดปกติ โปรดลองอีกครั้ง",
  "store/form.upload-button": "อัปโหลดเอกสาร",
  "store/form.upload-document-label": "เลือกเอกสารที่จะอัปโหลด"
}

```


[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-form/messages/sv.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Obligatoriskt fält",
  "store/form.error.maxLength": "Detta fält har en maxlängd av: {value}",
  "store/form.error.minLength": "Detta fält har en minimilängd av: {value}",
  "store/form.error.maxValue": "Det högsta värdet som accepteras av detta fält är {value}",
  "store/form.error.minValue": "Det lägsta värdet som accepteras av det här fältet är {value}",
  "store/form.error.notFloat": "Måste vara ett nummer",
  "store/form.error.notInteger": "Måste vara ett heltal",
  "store/form.error.pattern": "Denna text matchar inte det förväntade mönstret",
  "store/form.error.notInEnum": "Måste vara ett av följande värden: {values}",
  "store/form.error.multipleOf": "Måste vara en multipel av {value}",
  "store/form.error.undefinedError": "Ogiltigt värde.",
  "store/form.submit.buttonLabel": "Skicka in",
  "store/form.submit.error.userInputError": "Hittade några fel i de angivna uppgifterna, vänligen granska de angivna fälten försök igen!",
  "store/form.submit.error.serverError": "Internt serverfel! Vänligen försök igen senare!",
  "store/form.schema.loading": "Laddar formulär...",
  "store/form.schema.error": "Fel vid laddning av formulär, försök igen senare!",
  "store/form.operating.agreement": "Driftsavtal",
  "store/form.add-button": "Lägg till",
  "store/form.add-document.title": "Ladda upp dokument",
  "store/form.add-document.label": "Dokumentets URL",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "Filen överskrider maxstorleken på 4MB. Vänligen välj en mindre fil.",
  "store/form.document-uploader.error.generic": "Något gick fel. Vänligen försök igen.",
  "store/form.upload-button": "Ladda upp dokument",
  "store/form.upload-document-label": "Välj ett dokument att ladda upp"
}

```


[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-form/messages/es.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "Este campo es requerido",
  "store/form.error.maxLength": "Este campo tiene una longitud máxima de: {value}",
  "store/form.error.minLength": "Este campo tiene una longitud mínima de: {value}",
  "store/form.error.maxValue": "El valor máximo aceptado por este campo es {value}",
  "store/form.error.minValue": "El valor mínimo aceptado por este campo es {value}",
  "store/form.error.notFloat": "Debe ser un número",
  "store/form.error.notInteger": "Debe ser un entero",
  "store/form.error.pattern": "Este texto no coincide con el patrón esperado",
  "store/form.error.notInEnum": "Debe ser uno de los siguientes valores: {values}",
  "store/form.error.multipleOf": "Debe ser un mútiplo de {value}",
  "store/form.error.undefinedError": "Valor no válido.",
  "store/form.submit.buttonLabel": "Enviar",
  "store/form.submit.error.userInputError": "Encontrado algunos errores en los datos, revise los campos indicados e intente nuevamente.",
  "store/form.submit.error.serverError": "¡Error interno de servidor! ¡Por favor, inténtelo de nuevo más tarde!",
  "store/form.schema.loading": "Cargando formulario...",
  "store/form.schema.error": "Error al cargar el formulario¡Inténtalo de nuevo más tarde!",
  "store/form.operating.agreement": "Acuerdo de operación",
  "store/form.add-button": "Agregar",
  "store/form.add-document.title": "Subir documento",
  "store/form.add-document.label": "URL del documento",
  "store/form.add-document.placeholder": "URL",
  "store/form.document-uploader.error.file-size": "El archivo supera el límite de tamaño de 4 MB. Elija uno más pequeño.",
  "store/form.document-uploader.error.generic": "Se produjo un error. Vuelva a intentarlo.",
  "store/form.upload-button": "Subir el documento",
  "store/form.upload-document-label": "Elija un documento para cargar"
}
```


[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-form/messages/ar.json from the store-form VTEX app.

[Assistant]
Here's the implementation:

```json
{
  "store/form.error.required": "هذا الحقل مطلوب",
  "store/form.error.maxLength": "هذا الحقل له حد أقصى من الطول هو: {value}",
  "store/form.error.minLength": "هذا الحقل له حد أدنى من الطول هو: {value}",
  "store/form.error.maxValue": "القيمة القصوى المقبولة من هذا الحقل هي {value}",
  "store/form.error.minValue": "القيمة الدنيا المقبولة من هذا الحقل هي {value}",
  "store/form.error.notFloat": "يجب أن يكون رقماً",
  "store/form.error.notInteger": "يجب أن يكون عدد صحيح",
  "store/form.error.pattern": "هذا النص لا يتطابق مع النمط المتوقع",
  "store/form.error.notInEnum": "يجب أن تكون واحدة من القيم التالية: {values}",
  "store/form.error.multipleOf": "يجب أن يكون من مضاعفات {value}",
  "store/form.error.undefinedError": "قيمة غير صالحة.",
  "store/form.submit.buttonLabel": "إرسال",
  "store/form.submit.error.userInputError": "تم العثور على بعض الأخطاء في البيانات المقدمة، يرجى مراجعة الحقول المشار إليها حاول مرة أخرى!",
  "store/form.submit.error.serverError": "خطأ داخلي في الخادم! الرجاء المحاولة مرة أخرى لاحقاً!",
  "store/form.schema.loading": "تحميل الاستمارة...",
  "store/form.schema.error": "خطأ في تحميل الاستمارة، حاول مرة أخرى لاحقاً!",
  "store/form.operating.agreement": "اتفاقية التشغيل",
  "store/form.add-button": "إضافة",
  "store/form.add-document.title": "رفع مستند",
  "store/form.add-document.label": "رابط المستند",
  "store/form.add-document.placeholder": "الرابط",
  "store/form.document-uploader.error.file-size": "يتجاوز حجم الملف الحد الأقصى البالغ 4 ميغابايت. يُرجى اختيار واحد أصغر.",
  "store/form.document-uploader.error.generic": "حدث خطأ ما. يرجى المحاولة مرة أخرى.",
  "store/form.upload-button": "رفع مستند",
  "store/form.upload-document-label": "اختر مستندًا لرفعه"
}

```