text: /* eslint-disable no-template-curly-in-string */
  export default {
    navigation: {
      namespace: 'Namespaces',
      module: 'Modules',
      page: 'Pages',
      chart: 'Charts',
      automation: 'Automation',
      publicPages: 'Public pages',
      configuration: 'Configuration',
      adminPanel: 'Admin panel',
      more: 'More',
      noPageTitle: 'No page title',
      help: {
        forum: 'Help',
        documentation: 'Documentation',
        feedback: 'Send feedback',
        version: 'Version:',
      },
      userSettings: {
        loggedInAs: 'Logged in as {{user}}',
        profile: 'Profile',
        changePassword: 'Change password',
        logout: 'Logout',
      },
      editPage: 'Edit Page',
      viewPage: 'View Page',
    },
    sidebar: {
      searchPlaceholder: 'Search pages...',
      noPages: 'No pages',
      pickNamespace: 'Select a namespace',
      namespaceList: 'Namespace list',
    },
    onboarding: {
      message: {
        noPages: 'It seems this namespace has no visible pages yet.',
        startBuilding: 'Follow these steps to start building',
        notifyAdministrator: 'Notify your system administrator.',
      },
      step: {
        optional: 'This step is optional!',
        module: {
          create: 'Create Module',
          view: 'Your Modules',
        },
        chart: {
          create: 'Make Chart',
          view: 'Your Charts',
        },
        page: {
          create: 'Build Page',
          view: 'Your Pages',
        },
      },
    },
    block: {
      general: {
        title: 'Add new block',
        changeBlock: 'Change existing block',
        titleLabel: '$t(general.label.title)',
        titlePlaceholder: 'Block title',
        descriptionLabel: '$t(general.label.description)',
        descriptionPlaceholder: 'Block description',
        headerStyle: 'Block header style (color)',
        module: 'Module',
        style: {
          default: 'Dark variant',
          primary: 'Primary variant',
          secondary: 'Secondary variant',
          success: 'Success variant',
          warning: 'Warning variant',
          danger: 'Danger variant',
        },
      },
      recordOrganizer: {
        label: 'Record organizer',
        noRecords: 'No records in module linked with record organizer. Drag and drop records here.',
        notConfigured: 'Record organizer is not configured correctly.',
        labelField: {
          label: 'Label field',
          footnote: 'Field value will be used as record label',
        },
        descriptionField: {
          label: 'Description field',
          footnote: 'Field value will be used as record description',
        },
        positionField: {
          label: 'Record sort field',
          footnote: 'Records will be sorted based on this field',
        },
        groupField: {
          label: 'Key field',
          footnote: 'Field whose value will change when a record is moved into the record organizer',
        },
        group: {
          label: 'Key value',
          footnote: 'Value that will be set to the key field. This does not affect the filtering. Make sure to specify the prefilter where needed.',
        },
        preview: {
          label: 'Record Organizer block for module {{0}}. Label field {{1}}, Description field {{2}}. Value setting field: {{3}}, Sorted by position field: {{4}}.',
          moduleNotSelected: 'Record Organizer module not selected.',
        },
      },
      file: {
        label: 'File',
        preview: {
          label: 'File block',
        },
      },
      iframe: {
        label: 'IFrame',
        srcLabel: 'URL to show in the iframe',
        srcDesc: 'Used as a fallback when set in combination with record field.',
        srcFieldLabel: 'Field (URL) from record to use for the iframe',
        srcFieldDesc: 'Only available on record pages and on modules with existing "url" field kind',
        pickURLField: 'Pick an URL field',
      },
      calendar: {
        label: 'Calendar',
        calendarHeader: 'Calendar header',
        hideHeader: 'Hide calendar header',
        hideNavigation: 'Hide prev/next button',
        hideToday: 'Hide today button',
        hideTitle: 'Hide title text',
        addEventsSource: 'Add events source',
        viewLabel: '$t(block.calendar.label)',
        feedLabel: 'Configure events source',
        feedPlaceholder: 'Select a feed source',
        today: 'Today',
        view: {
          enabled: 'Enabled views',
          default: 'Default view',
          footnote: 'Make sure default is one of the available views',
          dayGridMonth: 'Month',
          timeGridWeek: 'Week',
          timeGridDay: 'Day',
          listMonth: 'Agenda',
        },
        recordFeed: {
          optionLabel: 'Records',
          moduleLabel: 'Select module',
          modulePlaceholder: '(No module)',
          colorLabel: 'Event color',
          titleLabel: 'Title',
          titlePlaceholder: '(No field)',
          eventStartFieldLabel: 'Event start',
          eventStartFieldPlaceholder: '(No field)',
          eventEndFieldLabel: 'Event end',
          eventEndFieldPlaceholder: '(No field, event will last 1 hour)',
          eventAllDay: 'Show as all-day-events',
          prefilterLabel: 'Prefilter events',
          prefilterPlaceholder: 'field1 = 1 AND field2 = 232',
          noMultiFields: 'Multi-value fields are currently not supported',
        },
        reminderFeed: {
          optionLabel: 'Reminders',
          colorLabel: 'Event color',
        },
      },
      automation: {
        label: 'Automation',
        editButton: 'Edit',
        configuredButtons: 'Configured buttons',
        availableScriptsAndWorkflow: 'Available scripts and workflows ({{count}})',
        addPlaceholderLabel: 'Add placeholder (dummy button)',
        searchPlaceholder: 'Filter available scripts by label, script name and description',
        noScript: 'There is no script or workflow configured for this button',
        noScripts: 'There are no manual scripts compatible with this page block',
        noLabel: 'Unlabeled',
        noDescription: 'No description',
        dummyButtonLabel: 'Dummy',
        removeAll: 'Remove all',
        buttonLabel: 'Label',
        buttonVariant: 'Variant',
        primaryButton: 'Primary',
        secondaryButton: 'Secondary',
        lightButton: 'Light',
        successButton: 'Success',
        dangerButton: 'Danger',
        warningButton: 'Warning',
        darkButton: 'Dark',
        stepID: 'stepID: {{stepID}}',
  
        badge: {
          workflow: 'workflow',
          script: 'script',
        },
  
        editTitle: {
          workflow: 'Edit workflow button',
          script: 'Edit automation script button',
        },
      },
      recordList: {
        label: 'Record list',
        federated: 'Federated',
        moduleFootnote: 'Modules without a {{0}} can only be used in a record list as an inline editor',
        recordPage: 'record page',
        addRecord: 'Add',
        selected: '{{count}} of {{total}} records selected',
        selectable: 'Enable record selection',
        hideRecordReminderButton: 'Hide record reminder button',
        hideRecordCloneButton: 'Hide clone record button',
        hideRecordEditButton: 'Hide edit record button',
        hideRecordViewButton: 'Hide view record button',
        hideRecordPermissionsButton: 'Hide record permissions button',
        cancelSelection: 'Cancel',
        fields: 'Module fields',
        editFields: 'Editable module fields',
        noRecords: 'There are no records matching your request',
  
        pagination: {
          showing: '{{from}} - {{to}} of {{count}} records',
          single: 'One record',
          single_plural: '{{count}} records',
  
          prev: 'Previous',
          next: 'Next',
        },
  
        refField: {
          label: 'Parent field',
          footnote: 'Field that links records with the parent record',
        },
  
        positionField: {
          label: 'Record sort field',
          footnote: 'Records will be sorted based on this field',
        },
  
        filter: {
          title: 'Record list filter',
          update: 'Update filter',
          label: 'Filter',
          addField: 'Add new filter field',
          field: 'Filter field',
          fieldPlaceholder: 'Pick a field',
          fieldValue: 'Field value',
          fieldValuePlaceholder: 'Input field filter',
          deletedRecords: 'Deleted records',
          without: 'Without',
          including: 'Including',
          only: 'Only',
          byValue: 'Filter records based on field value',
          note: 'Note: If Field value is undefined, the filter will look for records where that field value is undefined.',
          where: 'Where',
          addFilter: '+ Add filter',
          operators: {
            equal: 'Equal',
            notEqual: 'Not equal',
            contains: 'Contains',
            greaterThan: 'Greater than',
            lessThan: 'Less than',
          },
          conditions: {
            and: 'AND',
            or: 'OR',
          },
        },
        record: {
          inlineEditor: 'Inline editor',
          inlineEditorAllow: 'Allow inline record editing',
          inlineEditorFootnote: 'Only one inline editor with the same module can be present the same page',
          draggable: 'Can drag & drop records to order them',
          newLabel: 'New records',
          hideAddButton: 'Hide add record button',
          prefilterLabel: 'Prefilter records',
          prefilterPlaceholder: 'field1 = 1 AND field2 = 232',
          prefilterFootnote: 'Simplified SQL condition (WHERE ...) syntax is supported. Variables like {{0}}, {{1}} and {{2}} are evaluated (when available)',
          prefilterHideSearch: 'Hide search box',
          presortLabel: 'Presort records',
          presortPlaceholder: 'field1 DESC, field2 ASC',
          presortFootnote: 'Simplified SQL condition (ORDER BY ...) syntax is supported.',
          presortHideSort: 'Hide sorting',
          perPage: 'Records per page',
          hidePaging: 'Hide paging',
          showTotalCount: 'Show total record count',
          fullPageNavigation: 'Full page navigation',
          noPermission: 'No permission to read record',
        },
        preview: {
          recordFromModule: 'Showing records from {{0}} module with columns: {{1}}',
          isHidden: '{{0}} is hidden.',
          isShown: '{{0}} is shown',
          isDisabled: '{{0}} is disabled.',
          isEnabled: '{{0}} is enabled.',
          bePaged: '{{0}} be paged.',
          addRecordButton: 'Add record button',
          usersSee: 'Users see {{0}}.',
          searchInput: 'Search inputbox',
          usersSearchThrough: 'Users search through the records.',
          resultsPrefiltered: 'Results are prefiltered:',
          tableHeader: 'Table header',
          sorting: 'Sorting',
          withPresortedRecords: 'with presorted ({{0}}) records.',
          resultsCant: 'Results can not',
          resultsCan: 'Results can',
          recordsPerPage: '{{0}} records are shown per page.',
          moduleNotSelected: 'Block with table of records, module not selected.',
        },
        export: {
          allow: 'Allow records export',
          selectFields: 'Select fields you want to export:',
          limitations: 'CSV export limitation: only the first value in the multi value fields will be exported',
          rangeBy: 'Set range by:',
          dateRange: 'Select date range:',
          recordCount: '{{count}} records ready for export',
          json: 'JSON Export',
          csv: 'CSV Export',
  
          specifyTimezone: 'Export to timezone',
          timezonePlaceholder: 'Select timezone',
  
          includeQuery: 'Filter by search query',
          query: 'Search query',
          all: 'Export all records',
          inRange: 'Set date range',
          selection: 'Selected records',
  
          filter: {
            createdAt: 'Record created',
            updatedAt: 'Record updated',
            lastMonth: 'Last month',
            thisMonth: 'This month',
            lastWeek: 'Last week',
            thisWeek: 'This week',
            today: 'Today',
            custom: 'Custom',
          },
        },
        import: {
          to: 'Import to {{modulename}}',
          uploadFile: 'Upload the file you want to import (.csv or JSON format)',
          dropzoneLabel: 'Click or drop file here to upload (.csv or JSON)',
          dropzoneFileAdded: '{{name}} was uploaded and is ready for import ({{count}} record)',
          dropzoneFileAdded_plural: '{{name}} was uploaded and is ready for import ({{count}} records)',
          matchFields: 'Match imported columns with existing ones:',
          hasRequiredFileFields: 'This module has required file upload fields that are not yet supported via the importer',
          fileColumns: 'File columns',
          moduleFields: 'Module fields',
          pickModuleField: 'Pick a module field',
          progressRatio: '{{completed}} / {{entryCount}} rows',
          success: 'Import successful.',
          failed: 'Something went wrong during the import. Please try again: {{failReason}}',
          onError: 'If any record fails to import:',
          onErrorFail: 'Cancel import',
          onErrorSkip: 'Skip record',
          report: {
            title: 'Record import error report',
            startedAt: 'Started At',
            finishedAt: 'Finished At',
            totalRecords: 'Total records',
            importedRecords: 'Imported records',
            failedRecords: 'Failed records',
            detectedErrors: 'Detected errors',
            error: 'Error',
            count: 'Number of records',
            failedEntries: 'Failed source entries',
            failedEntriesLines: 'Entries from to (inclusive)',
            failedEntriesLine: 'Entry',
          },
        },
      },
      record: {
        label: 'Record',
        deleteRecord: 'Delete record',
        recordDeleted: 'This record was deleted',
        confirmDelete: 'Are you sure you want to delete this record?',
        preview: {
          fieldsFromModule: 'Single record block, displaying fields ({{0}}) from module {{1}}',
          blockNoRecord: 'Can not render this block without a record',
          untitled: 'Untitled',
        },
      },
      socialFeed: {
        label: 'Twitter feed',
        twitterProfileField: 'Field that contains Twitter Profile URL for a record',
        twitterProfileLabel: 'Twitter Profile URL for list pages i.e (https://twitter.com/bloomberg)',
        noInput: 'No input for displaying social feed...',
        preview: {
          socialFeed: 'Twitterblo feed',
        },
      },
      chart: {
        label: 'Chart',
        display: 'Chart to display inside this block:',
        pick: 'Pick a chart',
        add: 'New Chart',
        addGeneric: 'Generic chart',
        addFunnel: 'Funnel chart',
        addGauge: 'Gauge chart',
        edit: 'Edit chart',
        configure: {
          label: 'Configure chart',
          reportsLabel: 'Reports',
          reportLabel: 'Report {{l}}',
        },
        preview: {
          chartId: 'Chart preview (ID {{0}})',
        },
      },
      metric: {
        label: 'Metric',
        defaultMetricLabel: 'Unnamed metric',
        edit: {
          tabTitle: 'Metric',
  
          labelLabel: 'Label',
          labelPlaceholder: 'Label',
          dimensionLabel: 'Dimension',
          metricLabel: 'Metric',
          moduleLabel: 'Module',
          modulePlaceholder: 'Pick a module',
          dimensionFieldLabel: 'Field',
          dimensionFieldPlaceholder: 'Dimension field',
          dateFormat: 'Date format',
          filterLabel: 'Filter',
          filterFootnote: 'Simplified SQL condition (WHERE ...) syntax is supported. Variables like {{0}}, {{1}} and {{2}} are evaluated (when available)',
          bucketLabel: 'Bucket size',
          bucketPlaceholder: 'Select a bucket size',
          metricFieldLabel: 'Field',
          metricFieldPlaceholder: 'Dimension field',
          operationLabel: 'Aggregation operation',
          operationPlaceholder: 'Aggregation operation',
          transformFunctionLabel: 'Transform value',
          transformFunctionDescription: 'v - current value; label - current value\'s label',
          prefixLabel: 'Prefix',
          suffixLabel: 'Suffix',
          refreshData: 'Refresh data',
          numberFormat: 'Number format',
  
          operationCountd: 'Count',
          operationSum: 'Sum',
          operationMax: 'Max',
          operationMin: 'Min',
          operationAvg: 'Avg',
          operationStd: 'Std',
        },
        editStyle: {
          labelLabel: 'Label style',
          valueLabel: 'Value style',
          color: 'Text color',
          backgroundColor: 'Background color',
          fontSize: 'Font size in pixels',
        },
      },
      content: {
        label: 'Content',
      },
    },
    module: {
      title: 'List of Modules',
      newLabel: 'Module Name *',
      newPlaceholder: 'Name used on the list of modules',
      createLabel: 'New Module',
      searchPlaceholder: 'Type here to search all modules in this namespace',
      federated: 'Federated',
      import: 'Module import',
      noModules: 'No modules in namespace',
      allRecords: {
        label: 'All records',
        list: {
          title: 'All records for module "{{name}}"',
        },
        edit: {
          title: 'Edit record for module "{{name}}"',
        },
        create: {
          title: 'Create record for module "{{name}}"',
        },
        view: {
          title: 'View record for module "{{name}}"',
        },
        selectFields: {
          title: 'Configure columns',
        },
      },
  
      recordPage: {
        create: 'Create record page',
        edit: 'Page builder',
      },
  
      forModule: {
        recordPage: 'Record page for module',
        recordListPage: 'Record List page for module',
        recordList: 'Record List for module',
      },
  
      fieldKinds: {
        Bool: { label: 'Checkbox (Y/N)' },
        DateTime: { label: 'Date and time' },
        Email: { label: 'Email input' },
        File: { label: 'File upload' },
        Select: { label: 'Select / dropdown' },
        Number: { label: 'Number input' },
        Record: { label: 'Record selector' },
        String: { label: 'Text input (string)' },
        Url: { label: 'URL input' },
        User: { label: 'User selector' },
      },
  
      edit: {
        edit: 'Edit module',
        create: 'Create module',
        moduleInfo: 'Module info',
        manageRecordFields: 'Manage record fields',
        moduleFieldSettings: 'Module field settings',
        specificFieldSettings: 'Field settings ({{name}})',
        newField: 'Add new field',
        systemFields: 'System fields:',
        reorderFields: 'Reorder fields',
        fieldPermissions: 'Field permissions',
        recordPermissions: 'Record permissions',
        federationSettings: {
          title: 'Federation Settings',
          specificTitle: 'Federation Settings ({{handle}})',
          pickServer: 'Pick a federated server',
          pickModule: 'Pick a federated module',
          pickModuleField: 'Pick a module field',
          errorFetchingData: 'Error fetching server data',
          noNodes: 'No federated servers available',
          noPermission: 'No permission to manage exposed module',
  
          general: {
            title: 'General',
            send: 'Send new records to the federated network (upstream)',
            receive: 'Receive new records from another organization (downstream)',
          },
          downstream: {
            title: 'Map',
            description: 'Match federated fields with existing ones:',
            allFields: 'All Fields',
          },
          upstream: {
            title: 'Expose',
            description: 'Select the fields you want to share with the selected network',
            allFields: 'All Fields',
          },
        },
        tooltip: {
          name: 'Must be a-z/A-Z, 0-9 or underscore',
          title: 'The name displayed in form input / data lists',
          attributes: 'Select if the field can hold multiple values, if it\'s required field or if contains sensitive data',
          required: 'Required field',
          private: 'Sensitive data',
        },
        steps: {
          recordPage: 'Record page',
          recordList: 'Page with record list',
        },
      },
    },
    page: {
      title: 'List of Pages',
      visible: 'Visible',
      notVisible: 'Hidden',
      invalid: 'Invalid configuration',
      view: 'View',
      newPlaceholder: 'Page title',
      instructions: 'Drag and drop pages to adjust the order and hierarchy.',
      noBlock: 'No block added yet',
      import: 'Import page(s):',
      createLabel: 'Create page',
      noPages: 'No pages in namespace',
      edit: {
        edit: 'Edit page',
        create: 'Create page',
        pageDescription: 'Page description',
        visible: 'Page visibility',
      },
      build: {
        addBlock: 'Add block',
        selectBlockTitle: 'Select type of the new block',
        selectBlockFootnote: 'Some types might be disabled for non-record pages',
      },
    },
    chart: {
      title: 'List of Charts',
      newLabel: 'Create a new chart:',
      newPlaceholder: 'Chart name',
      searchPlaceholder: 'Type here to search all charts in this namespace',
      import: 'Import chart(s):',
      colorScheme: 'Color scheme',
      colorLabel: '{{count}} colors',
      noCharts: 'No charts in namespace',
      edit: {
        title: 'Chart builder',
        modulePick: 'Pick a module',
        loadData: 'Load data',
        unconfiguredReport: 'Unconfigured report',
        yAxis: {
          label: 'Y-axis',
          logarithmicScale: 'Logarithmic scale',
          axisOnRight: 'Place axis on the right side',
          axisScaleFromZero: 'Always begin axis scale at zero',
          labelLabel: 'Axis label',
          labelPlaceholder: 'Axis label',
          minLabel: 'Min value',
          minPlaceholder: 'Minimum value',
          maxLabel: 'Max value',
          maxPlaceholder: 'Maximum value',
        },
        filter: {
          label: 'Filters',
          noFilter: '(no filter)',
          recordsCreatedThisYear: 'Records created this year',
          recordsCreatedLastYear: 'Records created last year',
          recordsCreatedThisQuarter: 'Records created this quarter',
          recordsCreatedLastQuarter: 'Records created last quarter',
          recordsCreatedThisMonth: 'Records created this month',
          recordsCreatedLastMonth: 'Records created last month',
          customize: 'Customize filter',
        },
        dimension: {
          label: 'Dimensions (datetime & select fields)',
          fieldLabel: 'Field',
          fieldPlaceholder: 'Select a dimension field',
          skipMissingValues: 'Skip missing values',
          defaultValueLabel: 'Default value',
          defaultValueFootnote: 'Use this value for missing dimension values',
          calculateLabelCount: 'Calculate how many labels can be shown',
          gaugeSteps: 'Steps',
          function: {
            label: 'Function',
            placeholder: 'Select dimension modifier (bucket size)',
            none: '(no grouping / buckets)',
            date: 'DATE',
            week: 'WEEK',
            month: 'MONTH',
            quarter: 'QUARTER',
            year: 'YEAR',
          },
        },
        metric: {
          title: 'Metrics (numeric fields)',
          label: 'Metric',
          labelLabel: 'Label',
          labelPlaceholder: 'Total',
          labelColor: 'Label color',
          fieldLabel: 'Field',
          fieldPlaceholder: 'Select metric field',
          fillArea: 'Fill area below the line',
          fixTooltips: 'Always show tooltips',
          relative: 'Show relative value',
          relativePrecision: 'Precision:',
          add: 'Add metric',
          gaugeColor: 'Color',
          legend: {
            positionPlaceholder: 'Legend position',
            top: 'Top',
            left: 'Left',
            bottom: 'Bottom',
            right: 'Right',
          },
          lineTension: {
            label: 'Line tension',
            placeholder: 'Line tension',
            straight: 'Straight lines',
            slight: 'Small curvatures',
            medium: 'Medium curvatures',
            curvy: 'Big curvatures',
          },
          fx: {
            label: 'Post processing function',
            description: 'n - current dataset value, m - previous dataset value',
          },
          function: {
            label: 'Function',
            placeholder: 'Select metric aggregate function',
            countd: 'COUNTD',
            sum: 'SUM',
            max: 'MAX',
            min: 'MIN',
            avg: 'AVG',
            std: 'STD',
          },
          output: {
            label: 'Output',
            placeholder: 'Select metric output',
            line: 'Line',
            bar: 'Bar',
            pie: 'Pie',
            doughnut: 'Doughnut',
          },
        },
      },
    },
  
    general: {
      reminder: {
        listLabel: 'Reminders',
        add: 'Add a new reminder',
        dismiss: 'Dismiss',
        snooze: 'Snooze',
        routesTo: 'Includes link to:',
        edit: {
          titleLabel: 'Title',
          titlePlaceholder: 'Title',
          notesLabel: 'Notes',
          notesPlaceholder: 'Notes',
          remindAtLabel: 'Notify me',
          remindAtNone: 'Never',
          assigneeLabel: 'Assignee',
          assigneePlaceholder: 'Myself (default)',
        },
      },
  
      label: {
        timeMinute: '{{t}}min',
        timeHour: '{{t}}h',
  
        label: 'Label',
        value: 'Value',
        openBookmarks: 'Open bookmarks',
        buttons: 'Buttons',
        name: 'Name',
        actions: 'Actions',
        status: 'Status',
        title: 'Title',
        description: 'Description',
        type: 'Type',
        attributes: 'Attributes',
        multi: 'Multi value',
        required: 'Required',
        private: 'Private',
        updatedAt: '$t(field.system.updatedAt)',
        pageBuilder: 'Page builder',
        recordPage: 'Record page',
        moduleName: 'Module name',
        search: 'Search',
        create: 'Create',
        clone: 'Clone',
        edit: 'Edit',
        save: 'Save',
        saveAndClose: 'Save and close',
        add: 'Add',
        remove: 'Remove',
        addNew: 'Add new',
        addValue: 'Add new value',
        close: 'Close',
        delete: 'Delete',
        back: 'Back',
        backWithoutSave: 'Back (without saving changes)',
        dropFiles: 'Click or drop files here to upload',
        fileTypeNotAllowed: 'File type not allowed',
        loading: 'Loading',
        uploading: 'Uploading',
        download: 'Download',
        attachmentFileInfo: '(File size: {{0}}, uploaded {{1}})',
        yes: 'Yes',
        no: 'No',
        ok: 'Ok',
        view: 'View',
        processing: 'Processing...',
        import: 'Import',
        importPlaceholder: 'Upload files to import',
        export: 'Export',
        cancel: 'Cancel',
        next: 'Next',
        makeDefault: 'Make default',
        removeDefault: 'Remove default',
        none: 'None',
        handle: 'Handle',
        noHandle: 'No handle',
        general: 'General',
        enabled: 'Enabled',
        active: 'Active',
        welcome: 'Welcome!',
        urlPlaceholder: 'https://example.tld',
        validation: 'Validation',
        here: 'here',
        permissions: 'Permissions',
        browse: 'Browse',
      },
      placeholder: {
        handle: 'handle (a - z, 0 - 9, underscore, dash)',
        sample: 'Sample',
      },
      tooltip: {
        dragAndDrop: 'Drag and drop to change order',
      },
  
    },
    permission: {
      saveChanges: 'Save changes',
      resetBack: 'Reset back to "{{current}}"',
      setFor: 'Set permissions for {{target}}',
  
      composeNamespace: {
        all: 'all namespaces',
        specific: 'namespace "{{target}}"',
  
        operations: {
          read: {
            title: 'Read any namespace',
            specific: 'Read namespace "{{target}}"',
            description: '',
          },
          update: {
            title: 'Update any namespace',
            specific: 'Update namespace "{{target}}"',
            description: '',
          },
          delete: {
            title: 'Delete any namespace',
            specific: 'Delete namespace "{{target}}"',
            description: '',
          },
          manage: {
            title: 'Manage any namespace',
            specific: 'Manage namespace "{{target}}"',
            description: 'Allow access to namespace\'s admin pages',
          },
          moduleCreate: {
            title: 'Create modules under any namespace',
            specific: 'Create modules under namespace "{{target}}"',
            description: '',
          },
          modulesSearch: {
            title: 'List and search modules under any namespace',
            specific: 'List and search modules under namespace "{{target}}"',
            description: '',
          },
          chartCreate: {
            title: 'Create charts under any namespace',
            specific: 'Create charts under namespace "{{target}}"',
            description: '',
          },
          chartsSearch: {
            title: 'List and search charts under any namespace',
            specific: 'List and search charts under namespace "{{target}}"',
            description: '',
          },
          pageCreate: {
            title: 'Create pages under any namespace',
            specific: 'Create pages under namespace "{{target}}"',
            description: '',
          },
          pagesSearch: {
            title: 'List and search pages under any namespace',
            specific: 'List and search pages under namespace "{{target}}"',
            description: '',
          },
        },
      },
      composePage: {
        all: 'all pages',
        specific: 'page "{{target}}"',
  
        operations: {
          read: {
            title: 'Read any page',
            specific: 'Read page "{{target}}"',
            description: 'Default: deny',
          },
          update: {
            title: 'Update any page',
            specific: 'Update page "{{target}}"',
            description: 'Default: deny',
          },
          delete: {
            title: 'Delete any page',
            specific: 'Delete page "{{target}}"',
            description: 'Default: deny',
          },
        },
      },
      composeModule: {
        all: 'all modules',
        specific: 'module "{{target}}"',
  
        operations: {
          read: {
            title: 'Read any module',
            specific: 'Read module "{{target}}"',
            description: 'Default: deny',
          },
          update: {
            title: 'Update any module',
            specific: 'Update module "{{target}}"',
            description: 'Default: deny',
          },
          delete: {
            title: 'Delete any module',
            specific: 'Delete module "{{target}}"',
            description: 'Default: deny',
          },
          recordCreate: {
            title: 'Create record of any module',
            specific: 'Create record of module "{{target}}"',
            description: 'Default: deny',
          },
          recordsSearch: {
            title: 'List and search records of any module',
            specific: 'List and search records of module "{{target}}"',
            description: 'Default: deny',
          },
        },
      },
  
      composeRecord: {
        all: 'all records',
        specific: 'record',
  
        operations: {
          read: {
            title: 'Read records of any module',
            specific: 'Read record',
            description: 'Default: deny',
          },
          update: {
            title: 'Update records of any module',
            specific: 'Update record',
            description: 'Default: deny',
          },
          delete: {
            title: 'Delete records of any module',
            specific: 'Delete record',
            description: 'Default: deny',
          },
        },
      },
      composeModuleField: {
        all: 'all module fields',
        specific: 'field "{{target}}"',
  
        operations: {
          recordValueRead: {
            title: 'Read record fields of any module',
            specific: 'Read "{{target}}" record fields ',
            description: 'Default: deny',
          },
          recordValueUpdate: {
            title: 'Update record fields of any module',
            specific: 'Update "{{target}}" record fields ',
            description: 'Default: deny',
          },
        },
      },
      composeChart: {
        all: 'all charts',
        specific: 'chart "{{target}}"',
  
        operations: {
          read: {
            title: 'Read any chart',
            specific: 'Read chart "{{target}}"',
            description: 'Default: deny',
          },
          update: {
            title: 'Update any chart',
            specific: 'Update chart "{{target}}"',
            description: 'Default: deny',
          },
          delete: {
            title: 'Delete any chart',
            specific: 'Delete chart "{{target}}"',
            description: 'Default: deny',
          },
        },
      },
    },
  
    field: {
      noPermission: 'No permission to read field value',
      defaultValue: 'Default value',
      defaultFieldValue: 'Default field value',
      options: {
        multiDelimiter: {
          label: 'Multiple value delimiter',
          customLabel: 'Or use a custom delimiter',
          customPlaceholder: 'Enter a custom delimiter',
          newline: 'Each value in a new line',
          comma: 'Separated by a comma',
          custom: 'A custom delimiter',
        },
        description: {
          label: {
            default: 'Description',
            view: 'Description view',
            edit: 'Description edit',
          },
          placeholder: {
            default: 'Description text...',
            view: 'Description when viewing record field...',
            edit: 'Description when editing record field...',
          },
          same: 'Show same description on view and edit',
        },
        hint: {
          label: {
            default: 'Hint',
            view: 'Hint view',
            edit: 'Hint edit',
          },
          placeholder: {
            default: 'Hint text...',
            view: 'Hint when viewing record field...',
            edit: 'Hint when editing record field...',
          },
          same: 'Show same hint on view and edit',
        },
      },
      system: {
        ownedBy: 'Owned by',
        createdBy: 'Created by',
        createdAt: 'Created at',
        updatedBy: 'Updated by',
        updatedAt: 'Updated at',
        deletedBy: 'Deleted by',
        deletedAt: 'Deleted at',
      },
      kind: {
        bool: {
          label: 'Checkbox (Y/N)',
          checkedValueLabel: 'Value when checked',
          checkedValuePlaceholder: 'Checked value',
          uncheckedValueLabel: 'Value when unchecked',
          uncheckedValuePlaceholder: 'Unchecked value',
        },
        dateTime: {
          label: 'Date and time',
          dateOnly: 'Date Only',
          timeOnly: 'Time Only',
          pastValuesOnly: 'Past Values Only',
          futureValuesOnly: 'Future Value Only',
          relativeOutput: 'Output Relative value (eg: 3 days ago)',
          outputFormat: 'Output format:',
          outputFormatFootnote: 'See {{0}} for formatting options',
          warning: {
            pastValuesOnly: 'Only dates in the past will be saved',
            futureValuesOnly: 'Only dates in the future will be saved',
          },
        },
        email: {
          label: 'Email',
          preventToLink: 'Don\'t turn email into a link',
        },
        select: {
          label: 'Select',
          placeholder: 'Select an option by clicking here',
          optionNotSelected: 'No option selected',
          optionsLabel: 'Options to select from',
          optionRemove: 'Remove',
          optionAdd: 'Add',
          optionValuePlaceholder: 'Value',
          optionLabelPlaceholder: 'Label',
          optionType: {
            label: 'Multiple value input type',
            default: 'Single input',
            each: 'Input for each value',
            multiple: 'Multiple select',
          },
        },
        number: {
          label: 'Number',
          prefixLabel: 'Prefix',
          prefixPlaceholder: 'Prefix',
          suffixLabel: 'Suffix',
          suffixPlaceholder: 'Suffix',
          precisionLabel: 'Precision',
          precisionPlaceholder: 'Precision',
          formatLabel: 'Format',
          formatPlaceholder: 'Format',
          examplesLabel: 'Format examples:',
          exampleInput: 'Input',
          exampleFormat: 'Format',
          exampleResult: 'Result',
        },
        record: {
          label: 'Record',
          moduleLabel: 'Module name',
          modulePlaceholder: 'Pick module',
          currentUnnamedModule: '(Current unnamed module)',
          recordFieldLabel: 'Record label from field',
          recordFieldPlaceholder: 'Pick field',
          queryFieldsLabel: 'Query fields on search',
          suggestionPlaceholder: 'Start typing to search for records',
          prefilterLabel: 'Prefilter records',
          prefilterPlaceholder: 'field1 = 1 AND field2 = 232',
          prefilterFootnote: 'Simplified SQL condition (WHERE ...) syntax is supported. Variables like {{0}}, {{1}} and {{2}} are evaluated (when available)',
        },
        string: {
          label: 'String',
          multiLine: 'Multi line',
          richText: 'Use Rich Text Editor',
        },
        url: {
          label: 'URL',
          trimHash: 'Trim \'#\' from the Url',
          trimQuestionMark: 'Trim \'?\' from the Url',
          trimToDomain: 'Trim Url down to domain only',
          sshOnly: 'Only allow SSL (https) Url',
          preventToLink: 'Don\'t turn Url into a link',
        },
        user: {
          label: 'User',
          presetWithCurrentUser: 'Preset with current user',
          suggestionPlaceholder: 'Start typing to search for users by email or name',
          na: 'N/A',
        },
        file: {
          label: 'File',
          view: {
            modeLabel: 'View mode',
            modeFootnote: 'How files are represented in record page blocks',
            mimetypesLabel: 'File type allow list',
            mimetypesFootnote: 'MIME types, sepparated with ",". Example: "text/plain,text/csv"',
            maxSizeLabel: 'Maximum file size',
            list: 'List',
            grid: 'Grid',
            single: 'Single image',
            gallery: 'Gallery of images',
            showName: 'Hide file name',
          },
        },
      },
      selector: {
        available: 'Columns available',
        selected: 'Columns selected',
        selectAll: 'Select all',
        unselectAll: 'Unselect all',
        systemField: '(system field)',
        footnote: 'Add fields by dragging or double-clicking on them. Selected fields can also be reordered',
      },
      valueExpr: {
        label: 'Field value expression',
        placeholder: '((floor(numField1) + numField2) / 10) + 0.5',
        description: 'Insert a formula or expression that calculates numeric values or combines and manipulates text values',
      },
      sanitizers: {
        label: 'Value sanitization',
        expression: {
          placeholder: 'trim(value)',
        },
        description: 'Trim spaces from text or do other kinds of value manipulation before validation',
        add: '+ Add',
        examples: 'Examples',
      },
      validators: {
        label: 'Value validation',
        expression: {
          placeholder: 'value == ""',
        },
        error: {
          placeholder: 'Text displayed when expression is true',
        },
        description: 'Set of expressions and error pairs that test validity of the input value.',
        disableBuiltIn: 'Disable built-in validators',
      },
    },
    namespace: {
      clickOpen: 'Click to open',
      title: 'Low Code Namespaces',
      noResults: 'No namespaces found',
      searchPlaceholder: 'Type here to search among all namespaces...',
      create: 'Create new namespace',
      edit: 'Edit namespace',
      visit: 'Visit namespace',
      disabled: 'Namespace is disabled',
      setPermissions: 'Set namespace permissions',
      name: {
        label: 'Full namespace name *',
        placeholder: 'Enter namespace name',
      },
      description: {
        label: 'Namespace description',
        placeholder: 'Enter namespace description',
      },
      subtitle: {
        label: 'Subtitle',
        placeholder: 'Enter namespace subtitle',
      },
      slug: {
        label: 'Short name *',
        placeholder: 'Enter a short name for the namespace',
        description: 'The short name will be used in the URL',
      },
      logo: {
        label: 'Logo',
        placeholder: 'Choose an image for namespace logo or drop it here...',
      },
      icon: {
        label: 'Icon',
        placeholder: 'Choose an image for namespace icon or drop it here...',
      },
      enabled: {
        label: 'Enable on namespace list',
      },
      application: {
        label: 'Enable on application list',
      },
    },
    preview: {
      pdf: {
        loading: 'Loading',
        downloadForAll: 'Download to see all pages',
        firstPagePreview: 'First page preview',
        pageLoadFailed: 'Page failed to load',
        pageLoading: '$t(preview.pdf.loading)',
        noPages: 'This document is empty',
        clickToRetry: 'Click to retry',
      },
    },
    notification: {
      color: {
        RGBA: {
          invalid: 'Invalid RGBA color format',
        },
      },
      general: {
        success: 'Success',
        error: 'Error',
        warning: 'Warning',
        composeAccessNotAllowed: 'Not allowed to access Compose',
      },
      namespace: {
        saveFailed: 'Could not save this namespace',
        deleteFailed: 'Could not delete this namespace',
        createFailed: 'Could not create namespace',
        saved: 'Namespace saved',
        disabled: 'Namespace disabled - redirecting',
        assetUploadFailed: 'Could not upload attached assets',
  
        application: {
          fetchFailed: 'Could not fetch namespace application',
          createFailed: 'Could not create namespace application',
          saveFailed: 'Could not save namespace application',
        },
      },
      field: {
        unsupportedKind: 'Unsupported field kind {{kind}}',
        missingRequired: 'Missing value on required field',
        unknownFieldKind: 'Error: Unknown field kind "{{kind}}", no viewer component found.',
      },
      'field-datetime': {
        valueNotFuture: 'Past value on future only field',
        valueNotPast: 'Future value on past only field',
      },
      page: {
        pageMoveFailed: 'Could not move this page',
        createFailed: 'Could not create a page',
        loadFailed: 'Could not load the page tree',
        saveFailed: 'Could not save this page',
        saveFailedRequired: 'Could not save this page, all required module fields must be present',
        deleteFailed: 'Could not delete this page',
        noPages: 'No pages found',
        reordered: 'Page reordered',
        saved: 'Page saved',
      },
      chart: {
        loadFailed: 'Could not load chart',
        saveFailed: 'Could not save this chart',
        deleteFailed: 'Could not delete this chart',
        createFailed: 'Could not create a chart',
        optionsBuildFailed: 'Could not build chart options',
        unsupportedRenderer: 'Unsupported renderer',
        saved: 'Chart saved',
        deleted: 'Chart deleted',
        invalidConfig: {
          missingDimensionsField: 'Dimensions field not defined',
          missingDimensionsModifier: 'Dimensions modifier not defined',
          missingMetricsField: 'Metrics field not defined',
          missingMetricsAggregate: 'Metrics aggregate not defined',
          missingMetricsType: 'Metrics chart type not defined',
          missingReports: 'Reports not defined',
          missingModuleID: 'Module not defined',
        },
      },
      record: {
        listLoadFailed: 'Could not load record list',
        validationErrors: 'check error messages on the form',
        createFailed: 'Could not create record',
        updateFailed: 'Could not update record',
        deleteFailed: 'Could not delete record',
        loadFailed: 'Could not load record',
        moduleOrPageNotSet: 'RecordList block error: module or page option not set',
        moduleMismatch: 'Module incompatible, module mismatch',
        invalidRecordVar: 'Can not use ${record...} variable in non-record pages',
        invalidOwnerVar: 'Can not use ${ownerID} variable in non-record pages',
        moduleNotDefined: 'Record module not defined',
        unexpectedValue: 'Unexpected value for record module ({{type}})',
        unexpectedInput: 'Unexpected input for values property, should be an array with name-value object pairs',
      },
      automation: {
        scriptFailed: 'Could not execute automation',
      },
      module: {
        saveFailed: 'Could not save this module',
        deleteFailed: 'Could not delete this module',
        createFailed: 'Could not create a module',
        saved: 'Module saved',
        deleted: 'Module deleted',
      },
      import: {
        typeMissmatch: 'Import error: trying to import object of type "{{type1}}" into a list of objects of type "{{type2}}"',
        readingError: 'Error reading file',
        failed: 'Import failed',
        successful: 'Import successful',
      },
    },
    'expressions-help': {
      field: 'Field Expressions',
      calculate: 'Field expressions provide a way to calculate field values based on the defined expression.',
      write: 'Writing field expressions is like writing an equation. Instead of only using constants, you can pass in the field name, and it will be evaluated as the field value for that record.',
      instructions: 'To write the expression you can use the following operators:',
      operators: {
        location: 'Depending on where the field expression is used it has access to different variables:',
        'value-expression': 'Value expression',
        'value-expressions': 'Value expressions: ',
        value: 'value',
        values: 'values',
        record: '(record), ',
        old: 'old',
        'old-value': 'oldValue',
        'old-value-brackets': '(old value), ',
        new: 'new',
        'new-value-with-comma': '(new-value), ',
        'new-value': '(new-value)',
        'all-new-values': '(all new values)',
        'field-name': 'field-name',
        sanitizers: 'Sanitizers: ',
        sanitizer: 'Sanitizer',
        validators: 'Validators: ',
        validator: 'Validator',
        modifiers: 'Modifiers: ',
        comparators: 'Comparators: ',
        logical: 'Logical: ',
        'control-order': 'Control order of evaluation: ',
        more: 'More: ',
      },
      examples: 'Examples',
      'example-description': 'Below are a few examples of different use cases of field expressions.',
      'helper-functions': {
        label: 'Helper functions',
        description: 'We provide a set of helper functions that extend the capabilites of field expressions.',
        note: 'NOTE: Only the "General" functions can be used on all types of fields. The other functions are limited to their respective field type.',
      },
      'formatting-parameters': {
        label: 'Formatting parameters',
        description: 'Here is a complete list of available formatting options.',
      },
      categories: {
        general: {
          label: 'General',
          description: 'Returns the first non null value',
        },
        number: {
          label: 'Number',
          min: 'Returns item with the lowest value',
          max: 'Returns item with the highest value',
          rounds: 'Rounds a floating point number to the specified number of digits',
          floor: 'Rounds number down to the nearest integer',
          ceil: 'Rounds number up to the nearest integer',
        },
        string: {
          label: 'String',
          trim: 'Removes spaces at the beginning and at the end of the string',
          trimLeft: 'Removes character from the beginning of the string',
          trimRight: 'Removes character from the end of the string',
          toLower: 'Converts all characters to lowercase',
          toUpper: 'Converts all characters to uppercase',
          shortest: 'Returns the shortest string',
          longest: 'Returns the longest string',
          format: 'Returns the formatted string',
        },
        dateTime: {
          label: 'Date and Time',
          strftime: 'Returns DateTime string for the specified date and format',
          modTime: 'Returns modified DateTime string',
          parseISOTime: 'Returns parsed ISO DateTime string',
          parseDuration: 'Returns parsed duration',
          earliest: 'Returns earliest DateTime',
          latest: 'Returns latest DateTime',
        },
      },
      formatCategories: {
        string: {
          label: 'String formatting',
          v: 'Returns the raw value',
          t: 'Returns the boolean value as true/false',
          b: 'Returns the number in base 2 (in the binary format)',
          d: 'Returns the number in base 10',
          o: 'Returns the number in base 8',
          O: 'Returns the number in base 8 with 0o prefix',
          x: 'Returns the number in base 16; lower-case a-f',
          X: 'Returns the number in base 16; upper-case A-F',
          binary: 'Returns the floating point number in scientific notation with binary exponent',
          e: 'Returns the floating point number in scientific notation; lower-case e',
          E: 'Returns the floating point number in scientific notation; upper-case E',
          f: 'Returns the floating point number with a decimal point',
        },
        dateTime: {
          label: 'Date and Time formatting',
          Y: 'Returns the year with century as a decimal number',
          y: 'Returns the year without century as a decimal number (00-99)',
          C: 'Returns year / 100 as a decimal number; single digits are preceded by a zero',
          m: 'Returns the month as a decimal number (01-12)',
          B: 'Returns the full national month name',
          b: 'Returns the abbreviated national month name',
          U: 'Returns the week number of the year (Sunday as the first day of the week) as a decimal number (00-53)',
          V: 'Returns the week number of the year (Monday as the first day of the week) as a decimal number (01-53)',
          W: 'Returns the week number of the year (Monday as the first day of the week) as a decimal number (00-53)',
          A: 'Returns the full national weekday name',
          a: 'Returns the abbreviated national weekday name',
          d: 'Returns the day of the month as a decimal number (01-31)',
          e: 'Returns the day of the month as a decimal number (1-31)',
          j: 'Returns the day of the year as a decimal number (001-366)',
          u: 'Returns the weekday (Monday as the first day of the week) as a decimal number (1-7)',
          w: 'Returns the weekday (Sunday as the first day of the week) as a decimal number (0-6)',
          H: 'Returns the hour (24-hour clock) as a decimal number (00-23)',
          k: 'Returns the hour (24-hour clock) as a decimal number (0-23)',
          I: 'Returns the hour (12-hour clock) as a decimal number (01-12)',
          l: 'Returns the hour (12-hour clock) as a decimal number (1-12)',
          M: 'Returns the minute as a decimal number (00-59)',
          'S-second': 'Returns the second as a decimal number (00-60)',
          'S-middle': 'Returns the millisecond as a decimal number (000-999)',
          p: 'Returns the national representation of either "ante meridiem" (a.m.)  or "post meridiem" (p.m.)',
          c: 'Returns the national representation of time and date',
          X: 'Returns the national representation of the time',
          x: 'Returns the national representation of the date',
          Z: 'Returns the time zone name',
          z: 'Returns the time zone offset from UTC',
          n: 'Returns a newline (\n)',
          t: 'Returns a tab',
          percent: 'Returns a %',
          F: 'Equivalent to %Y-%m-%d',
          D: 'Equivalent to %m/%d/%y',
          R: 'Equivalent to %H:%M',
          r: 'Equivalent to %I:%M:%S %p',
          T: 'Equivalent to %H:%M:%S',
          v: 'Equivalent to %e-%b-%Y',
        },
      },
    },
  }
  