---
title: "Model information"
description: "Query model information using useModel to retrieve details on tables, columns, relations, domains, processings, reports, and folders."
lang: en
languages:
  en: https://docs.vismasoftware.no/businessnxtapi/apireference/schema/modelinfo/index.md
lastmod: 2026-07-10
---

> Documentation index: https://docs.vismasoftware.no/businessnxtapi/apireference/schema/llms.txt


# Model information

Last modified July 10, 2026

> Query model information using useModel to retrieve details on tables, columns, relations, domains, processings, reports, and folders.


## Overview

You can query information from the data model. This is possible using the `useModel` field in the top-level query. This allows to retrieve information about the following entities:

- tables
- columns
- relations
- domains and domain members
- processings
- reports
- folders

You can query the core model only, the extension model only, or both models together.

The information that is available for each entity include:

- primary key (such as `tableNo` for tables, `columnNo` and `tableNo` for columns, etc.)
- identifier, which is a language-independent name of the field; this is what the GraphQL schema uses for entity names
- name, which is a language-specific name for the entity
- access restrictions and availability

In addition, each type of entity has it's own specific fields.

The languages supported for translations are:

- English (this is the default, if no language is specified)
- Norwegian
- Swedish
- Danish
- Finnish

## Examples

Here is an example for fetching table information: ID, identifier, name in Norwgian, and the database type it belongs to (which can be either `COMPANY` or `SYSTEM`) for all the existing tables in the core model:

```graphql { title = "Query" }
query get_tables_info
{
  useModel(lang: NORWEGIAN)
  {
    tables
    {
      tableNo
      name
      identifier
      databaseType
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "tables": [
        {
          "tableNo": 1,
          "name": "Arbeidsområde­vindu",
          "identifier": "WorkspaceWindow",
          "databaseType": "SYSTEM"
        },
        {
          "tableNo": 2,
          "name": "Arbeidsområde­element",
          "identifier": "WorkspacePageElement",
          "databaseType": "SYSTEM"
        },
        # ...
        {
          "tableNo": 457,
          "name": "Inngående betalingslinje",
          "identifier": "AutopayVipPaymentLine",
          "databaseType": "COMPANY"
        },
        {
          "tableNo": 458,
          "name": "Inngående betaling ekstratekst",
          "identifier": "AutopayVipTextInfo",
          "databaseType": "COMPANY"
        }
      ]
    }
  }
}
```

On the other hand, it's possible to ask for this information for a specific table by specifying the table number:

```graphql { title = "Query" }
query get_table_info
{
  useModel(lang: NORWEGIAN)
  {
    tables(tableNo : 152)
    {
      tableNo
      name
      identifier
      databaseType
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "tables": [
        {
          "tableNo": 152,
          "name": "Aktør",
          "identifier": "Associate",
          "databaseType": "COMPANY"
        }
      ]
    }
  }
}
```

For a table it is possible to fetch the following information:

- the list of columns
- the list of processings and reports
- the list of relations from and to the table

The following example shows how to do this:

```graphql { title = "Query" }
query get_table_info
{
  useModel(lang: NORWEGIAN)
  {
    tables(tableNo : 65)
    {
      tableNo
      name
      identifier
      databaseType
      view
      primaryKeyClustered
      orgUnitClass
      folderNo
      formView
      primaryKeyAssignment
      columns
      {
        columnNo
        name
        identifier
        domain
        {
          domainNo
          domainTypeNo
          domainMembers
          {
            name
            identifier
            groupName
            valueNo
          }
        }
      }
      
      fromRelationsNo
      fromRelations
      {
        relationNo
        name
        identifier
        fromTableNo
        toTableNo
        fromColumnsNo
        toColumnsNo
      }
      
      toRelationsNo
      toRelations
      {
        relationNo
        name
        identifier
        fromTableNo
        toTableNo
        fromColumnsNo
        toColumnsNo
      }

      processingsNo
      processings
      {
        processingNo
        name
        identifier
        description
        rowIndependent
      }
      reportsNo
      reports
      {
         reportNo
         name
         identifier
         description
      }

      visible
      cloudVisible
      insertable
      cloudInsertable
      updatable
      cloudUpdatable
      deletable
      cloudDeletable
      readAccess
      cloudReadAccess
      insertAccess
      cloudInsertAccess
      updateAccess
      cloudUpdateAccess
      deleteAccess
      cloudDeleteAccess
      availability
    }
  }
}
```

Similarly, you can query, for instance, for:

- all the columns in the system
- all the columns of a specified table
- a single column specifed by its column number

In the next example, we query information about all the columns from the `Associate` table:

```graphql { title = "Query" }
query get_columns_info
{
  useModel(lang: NORWEGIAN)
  {
    columns(tableNo : 152)
    {
      columnNo
      tableNo
      name
      identifier
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "columns": [
        {
          "columnNo": 4028,
          "name": "Aktørnr",
          "identifier": "AssociateNo"
        },
        {
          "columnNo": 4029,
          "name": "Navn",
          "identifier": "Name"
        },
        # ...
      ]
    }
  }}
```

On the other hand, in the next example, we query information about the associate number column (from the `Associate` table):

```graphql { title = "Query" }
query get_column_info
{
  useModel(lang: NORWEGIAN)
  {
    columns(columnNo: 4028)
    {
      columnNo
      tableNo
      name
      identifier
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "columns": [
        {
          "columnNo": 4028,
          "tableNo": 152,
          "name": "Aktørnr",
          "identifier": "AssociateNo"
        }
      ]
    }
  }
}
```

You can additionaly query for domain information for a column, as shown in the following example:

```graphql { title = "Query" }
query read_column_info
{
  useModel(lang: NORWEGIAN)
  {
    columns(columnNo : 3363)
    {
      columnNo
      tableNo
      name
      domain
      {
        domainNo
        name
        length
        columnWidth
        storeFixedDecimals
        displayFixedDecimals
        fixedDecimals
        dataType
        fieldJustification
        fileName
        domainMembers
        {
          name
          identifier
          valueNo
          includeValue
          initiallyOn
        }
      }
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "columns": [
        {
          "columnNo": 3363,
          "tableNo": 52,
          "name": "Ordrenr",
          "domain": {
            "domainNo": 555,
            "name": "Ordrenr",
            "length": 0,
            "columnWidth": 8,
            "storeFixedDecimals": false,
            "displayFixedDecimals": false,
            "fixedDecimals": 0,
            "dataType": "INT_32",
            "fieldJustification": "RIGHT",
            "fileName": false,
            "domainMembers": []
          }
        }
      ]
    }
  }
}
```

You can also query domains directly, by specifying the domain number:

```graphql { title = "Query" }
query read_domain_info
{
  useModel(lang: NORWEGIAN)
  {
    domains(domainNo : 555)
    {
      domainNo
      name
      length
      columnWidth
      storeFixedDecimals
      displayFixedDecimals
      fixedDecimals
      dataType
      fieldJustification
      fileName
      domainMembers
      {
        name
        identifier
        groupName
        valueNo
        includeValue
        groupIncludeValue
        initiallyOn
      }
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "domains": [
        {
          "domainNo": 555,
          "name": "Ordrenr",
          "length": 0,
          "columnWidth": 8,
          "storeFixedDecimals": false,
          "displayFixedDecimals": false,
          "fixedDecimals": 0,
          "dataType": "INT_32",
          "fieldJustification": "RIGHT",
          "fileName": false,
          "domainMembers": []
        }
      ]
    }
  }
}
```

Some domains are enumeration types. They define a set of possible values that can be stored in a column. The `domainMembers` field in the domain information query returns a list of domain members. An example is shown below:

```graphql { title = "Query" }
query read_domain_info
{
  useModel(lang: NORWEGIAN)
  {
    domains(domainNo : 111)
    {
      domainNo
      name
      length
      columnWidth
      storeFixedDecimals
      displayFixedDecimals
      fixedDecimals
      dataType
      fieldJustification
      fileName
      domainMembers
      {
        name
        identifier
        groupName
        valueNo
        includeValue
        groupIncludeValue
        initiallyOn
      }
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "domains": [
        {
          "domainNo": 111,
          "name": "Dok.­type",
          "length": 0,
          "columnWidth": 8,
          "storeFixedDecimals": false,
          "displayFixedDecimals": false,
          "fixedDecimals": 0,
          "dataType": "INT_32",
          "fieldJustification": "RIGHT",
          "fileName": false,
          "domainMembers": [
            {
              "name": "Purrebrev",
              "identifier": "Reminder",
              "groupName": "",
              "valueNo": 1,
              "includeValue": -1,
              "groupIncludeValue": -1,
              "initiallyOn": false
            },
            {
              "name": "Rentenota",
              "identifier": "InterestNote",
              "groupName": "",
              "valueNo": 2,
              "includeValue": -1,
              "groupIncludeValue": -1,
              "initiallyOn": false
            }
          ]
        }
      ]
    }
  }
}
```

## Selecting the model

It is possible to query the core mode, the customer specific extensions to the model, or both together. This is done using the `model` argument for the `useModel` field, which can take the following values:

| Value | Description |
| ----- | ----------- |
| `CORE` | Only the core model is queried. This is the default value. |
| `EXTENSIONS` | Only the extension model is queried. |
| `ALL` | Both the core and the extension model are queried. |

If you specify a core model but a model number such as table number or column number from the extensions or vice versa, no results will be returned, since the specified model does not contain the specified entity.

When the model is explicitly specified, a customer number is also required, since extensions are customer specific. If a customer number is not specified, an error will be returned.

The following example shows how to query all the tables from the extensions:

```graphql { title = "Query" }
query read_tables($cno : Int!)
{
    useModel(customer : $cno, model : EXTENSIONS)
    {
        tables
        {
            tableNo
            name
            identifier
            databaseType
        }
    }
}
```

## Query arguments

There are several arguments that allow you to customize the query:

| Argument | Description |
| -------- | ----------- |
| `lang` | Specifies the language for the translated text fields. Possible values are `ENGLISH`, `NORWEGIAN`, `SWEDISH`, and `DANISH`. |
| `langNo` | Specifies the language for the translated text fields using a numeric value. Possible values are `44` (English), `45` (Danish), `46` (Swedish), and `47` (Norwegian). If both `lang` and `langNo` are specified, `lang` is used and `langNo` is ignored. |
| `transform` | Indicates how the text of the name field should be transformed. |
| `transformArgs` | Defines the transformation arguments when the `CUSTOM` value is specified for the `transform` argument. More information about text transformation can be found in the next section. |

These areguments are found on the `useModel` field. A deprecated way to specify the arguments is on the individual fields such as `tables`, `columns`, etc. When present on both the `useModel` field and the individual fields, the arguments on the individual fields are ignored.

In addition to these arguments, each field for retrieving model information (such as `tables`, `columns`, etc.) has its own specific arguments, typically for selecting a single entity, we was shown in the examples above (e.g. `tableNo` for tables, `columnNo` for columns, etc.).

### Language selection

The language for the translations can be specified in two ways:

- using the `lang` argument in the query, with one of the following values: `ENGLISH`, `NORWEGIAN`, `SWEDISH`, `DANISH`
- using the `langNo` argument in the query, with one of the following values: `44` (English), `45` (Danish), `46` (Swedish), `47` (Norwegian)

If both arguments are specified, the `lang` argument is used (`langNo` is ignored).

The following two examples are equivalent:

```graphql { title = "Query" }
query get_tables_info
{
  useModel(lang: NORWEGIAN)
  {
    tables
    {
      tableNo
      name
      identifier
      databaseType
    }
  }
}
```

```graphql { title = "Result" }
query get_tables_info
{
  useModel(langNo: 47)
  {
    tables
    {
      tableNo
      name
      identifier
      databaseType
    }
  }
}
```

The `langNo` argument is useful for specifying the language based directly on settings, such as the user's language preference (from the `User` table).

### Text transformations

The translated text may contain several application-specific escape characters or sequences. These are:

- `^` for a hyphen
- `|` for a new line (`\n`)
- `&` for an access key accelerator
- `{Ampersand}` for an `&` character

When you retrieve the translated texts, these are automatically replaced with the appropriate character or sequence of characters. However, you can opt to perform your own custom replacement. This is possible with the following two arguments, available for all the fields under `useModel`:

| Argument | Description |
| -------- | ----------- |
| `transform` | Indicates the transformation type: `AUTO` (the default option, application defined transformations), `NONE` (no transformation is performed), and `CUSTOM` (user-specified transformations are applied). |
| `transformArgs` | Defines the transformation arguments when the `CUSTOM` value is specified for the `transform` argument. |

The properties of the `transformArgs` parameter are as follows:

| Property | Type | Description |
| -------- | ---- | ----------- |
| `modifyOptionalHyphen` | Boolean | Indicates whether hyphen replacement will be performed. |
| `optionalHyphen` | String | Text for replacing the escape character (`^`) for a hyphen. |
| `modifyManualLineBreak` | Boolean | Indicates whether manual line break replacement will be performed. |
| `manualLineBreak` | String | Text replacing the escape character for manual line break. |
| `modifyAccessKey` | Boolean | Indicates whether access key replacement will be performed. |
| `accessKey` | String | Text for replacing the escape character (`&`) for an access key. |
| `modifyAmpersandSubstitute` | Boolean | Indicates whether ampersand substitute replacement will be performed. |
| `ampersandSubstitute` | String | Text for replacing the `{Ampersand}` escape sequence. |

Here is an example for fetching raw texts:

```graphql { title = "Query" }
query get_table_info
{
  useModel(lang: NORWEGIAN, transform : NONE)
  {
    tables(tableNo : 138)
    {
      tableNo
      name
      identifier
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "tables": [
        {
          "tableNo": 138,
          "name": "Ordre^journal",
          "identifier": "OrderJournal"
        }
      ]
    }
  }
}
```

On the other hand, the following sample shows how to perform user-defined transformations:

```graphql { title = "Query" }
query get_table_info
{
  useModel(lang: NORWEGIAN,
           transform : CUSTOM,
           transformArgs : {
              modifyOptionalHyphen : true
              optionalHyphen : "-"
          })
  {
    tables(tableNo : 138)
    {
      tableNo
      name
      identifier
    }
  }
}
```

```graphql { title = "Result" }
{
  "data": {
    "useModel": {
      "tables": [
        {
          "tableNo": 138,
          "name": "Ordre-journal",
          "identifier": "OrderJournal"
        }
      ]
    }
  }
}
```

## Access restrictions and availability

Most model entities provide properties that indicate the availability and access restrictions. These properties are:

| Property | Type | Description | Applies to |
| -------- | ---- | ----------- | ---------- |
| `visible` | `Bool` | Indicates whether the entity is visible in the on-premise application. | All |
| `cloudVisible` | `Bool` | Indicates whether the entity is visible in the Business NXT front-end application. | All |
| `writable` | `Bool` | Indicates whether the entity is writable in the on-premise application. | Columns, domain members |
| `cloudWritable` | `Bool` | Indicates whether the entity is writable in the Business NXT front-end application. | Columns, domain members |
| `insertable` | `Bool` | Indicates whether the entity is insertable in the on-premise application. | Tables |
| `cloudInsertable` | `Bool` | Indicates whether the entity is insertable in the Business NXT front-end application. | Tables |
| `updatable` | `Bool` | Indicates whether the entity is updatable in the on-premise application. | Tables |
| `cloudUpdatable` | `Bool` | Indicates whether the entity is updatable in the Business NXT front-end application. | Tables |
| `deletable` | `Bool` | Indicates whether the entity is deletable in the on-premise application. | Tables |
| `cloudDeletable` | `Bool` | Indicates whether the entity is deletable in the Business NXT front-end application. | Tables |
| `readAccess` | `Access` | Indicates the read access level for the entity in the on-premise application. | All |
| `cloudReadAccess` | `CloudAccess` | Indicates the read access level for the entity in the Business NXT front-end application. | All |
| `writeAccess` | `Access` | Indicates the write access level for the entity in the on-premise application. | Columns, domain members |
| `cloudWriteAccess` | `CloudAccess` | Indicates the write access level for the entity in the Business NXT front-end application. | Columns, domain members |
| `insertAccess` | `Access` | Indicates the insert access level for the entity in the on-premise application. | Tables |
| `cloudInsertAccess` | `CloudAccess` | Indicates the insert access level for the entity in the Business NXT front-end application. | Tables |
| `updateAccess` | `Access` | Indicates the update access level for the entity in the on-premise application. | Tables |
| `cloudUpdateAccess` | `CloudAccess` | Indicates the update access level for the entity in the Business NXT front-end application. | Tables |
| `deleteAccess` | `Access` | Indicates the delete access level for the entity in the on-premise application. | Tables |
| `cloudDeleteAccess` | `CloudAccess` | Indicates the delete access level for the entity in the Business NXT front-end application. | Tables |
| `deleteAccess` | `Access` | Indicates the delete access level for the entity in the on-premise application. | Tables |
| `cloudDeleteAccess` | `CloudAccess` | Indicates the delete access level for the entity in the Business NXT front-end application. | Tables |
| `executionAccess` | `Access` | Indicates the execution access level for the entity in the on-premise application. | Processings, reports |
| `cloudExecutionAccess` | `CloudAccess` | Indicates the execution access level for the entity in the Business NXT front-end application. | Processings, reports |
| `availability` | `Availability` | Indicates whether the entity is available for use (`CURRENT`), it will be available in the future (`FUTURE`), or it is available but it is deprecated and will be removed (`OBSOLETE`). | All |

The `Default` value for `CloudAccess` indicates that the access level is inherited from the on-premise application.

For a column to be available in GraphQL for reading, the following conditions must be met:

- `availability` should be `CURRENT`
- `cloudReadAccess` must be different than `NONE` and `DEFAULT`
- if `cloudReadAccess` is `DEFAULT` then `readAccess` must be different than `NONE`

Similar rules are used for writing, inserting, updating, deleting, and executing access.

## Model information properties

### Tables

The following properties are available for tables :

| Property | Type | Description |
| -------- | ---- | ----------- |
| `tableNo` | `Long` | The table number. |
| `name` | `String` | The translated name of the table. |
| `identifier` | `String` | A language-independent identifier of the table. |
| `databaseType` | `DatabaseTypeNo` | One of `COMPANY` or `SYSTEM`. |
| `view` | `bool` | Indicates whether the table is a view. |
| `primaryKeys` | `[Long]` | The primary keys' column numbers in the order they're defined in the database. |
| `primaryKeyClustered` | `Bool` | Indicates whether the primary key is clustered. |
| `orgUnitClass` | `OrgUnitClass` | The property returns one of the twelve values `ORGUNITCLASS01` (1) – `ORGUNITCLASS12` (12) if the table is associated with an organisational unit class, else `NONE` (0). The table will not be visible if the corresponding `CompanyInformation.OrgUnit1Name` – `OrgUnit12Name` column is empty. |
| `folderNo` | `Long` | The folder number the table belongs to, or 0 if none. |
| `formView` | `Bool` | `true` if new table page elements against this table should initially be displayed in Form view (instead of Grid view). |
| `primaryKeyAssignment` | `PrimaryKeyAssignment` | Returns one of the following values for how the last primary key column is assigned a value on rows in the table: `NORMAL` - the ordinary behaviour of the table, `INCREMENTAL` - the last primary key column will get the next unused value when a value suggestion is requested, or `IDENTITY` - The last primary key column is created as an IDENTITY column in the database (the last two only for top tables that does not have a sort sequence column). |
| `columns` | `[Query_UseModel_Tables_Columns]` | A collection of column objects for the columns in the table. |
| `fromRelationsNo` | `[Long]` | A collection of relation numbers **from** the table. |
| `fromRelations` | `[Query_UseModel_Tables_Relations]` | A collection of relation **from** the table. |
| `toRelationsNo` | `[Long]` | A collection of relation numbers for the relations **to** the table. |
| `toRelations` | `[Query_UseModel_Tables_Relations]` | A collection of relation **to** the table. |
| `processingsNo` | `[Long]` | A collection of processing numbers for the processings in the table. |
| `processings` | `[Query_UseModel_Tables_Processings]` | A collection of processing in the table. |
| `reportsNo` | `[Long]` | A collection of report numbers for the reports in the table. |
| `reports` | `[Query_UseModel_Tables_Reports]` | A collection of report in the table. |

### Relations

The following properties are available for relations:

| Property | Type | Description |
| -------- | ---- | ----------- |
| `relationNo` | `Long` | The relation number. |
| `name` | `String` | The translated name of the relation. |
| `identifier` | `String` | A language-independent identifier of the relation. |
| `fromTableNo` | `Long` | The table number that this relation refers from. |
| `toTableNo` | `Long` | The table number that this relation refers to. |
| `fromColumnsNo` | `[Long]` | A collection of column numbers that define the from columns. |
| `toColumnsNo` | `[Long]` | A collection of column numbers that define the to columns. |
| `switchOfColumnNo` | `Long` | The number of a column for this relation to apply to. |
| `switchValue` | `Int` | The value that a column needs to have for this relation to apply. E.g. the debit (or credit) account type column on a voucher row that determines whether the debit (or credit) account number column refers to (1) a customer, (2) supplier, (3) general ledger account, or (4) capital asset. |
| `noLookup` | `Bool` | `true` if the relation is not applicable for lookup, but e.g. only for (left outer) join purposes in i.a. layouts. |
| `necessity` | `Necessity` | Returns one of the following values for how necessary a corresponding reference is: `REQUIRED`, `OPTIONAL`, or `PASS`. |
| `deleteRule` | `DeleteRule` | Returns one of the following values to determine behavior when deleting or discarding a parent row: `CASCADE` will also delete or discard child rows, recursively downwards the hierarchy, or `RESTRICT` that demands that no references exist, e.g. to reject deletion of accounts with transactions. |

### Columns

The following properties are available for columns:

| Field | Type | Description |
| ----- | ---- | ----------- |
| `columnNo` | `Long` | The column number. |
| `tableNo` | `Long` | The table number that this column belongs to. |
| `name` | `String` | The translated name of the column. |
| `identifier` | `String` | A language-independent identifier of the column. |
| `orgUnitClass` | `OrgUnitClass` | One of the twelve values `ORGUNITCLASS01` – `ORGUNITCLASS12` if the column is associated with an organisational unit class, else `NONE`. The column will not be visible if the corresponding `CompanyInformation.OrgUnit1Name` – `OrgUnit12Name` column is empty. |
| `suggestValueInInterval` | `Bool` | `true` if the column supports suggesting values in intervals. |
| `breakValues` | `Bool` | `true` if the column by default should show an aggregated value on group and total rows. |
| `accumulateOnMerge` | `Bool` | true if the value in the column should be accumulated when rows are merged, e.g. on collection invoices. |
| `recalculation` | `Recalculation` | one of the following values for whether the value in the column should be recalculated according to the actual value on the current, parent row (order line), when page elements (e.g. stock balance or shipment) are joined via an underlying table (e.g. product): `NO`, `UNIT`, or `PRICE`. |
| `formatting` | `Formatting` | one of the following values for whether the column should apply formatting defined on the row: `NO`, `ROWFRONT`, or `UNDERLINE`. |
| `viewZero` | `ViewZero` | one of the following values for whether 0 should be shown if the column is empty: `NO`, `ZEROIFEMPTY`, or `ZEROIFNOTSUMLINE`. |
| `debitCreditType` | `DebitCreditType` | one of the following values for how the memory column should be calculated: `NONE`, `DEBIT`, `CREDIT`. |
| `currencyHandling` | `CurrencyHandling` | one of the following values for whether the column is involved in currency calculations: `NORMAL`, `LOGISTICSDOMESTICVALUE`, `ACCOUNTINGCURRENCYVALUE`, `ACCOUNTINGDOMESTICVALUE`, `EUROVALUE`, or `CURRENCY2VALUE`. |
| `lookupProcessingNo` | `Long` | The number of the processing that declares the lookup dialog for this column, if any. |
| `domain` | `Query_UseModel_Columns_Domains` | Information about the domain for the column. |
| `sqlName` | `String` | The actual name of the column in the database. |

### Domains and domain members

The following properties are available for domains:

| Field | Type | Description |
| ----- | ---- | ----------- |
| `domainNo` | `Long` | The domain number. |
| `name` | `String` | The translated name of the domain. |
| `identifier` | `String` | A language-independent identifier of the domain. |
| `domainTypeNo` | `Int` | The domain type as a numeric value. |
| `domainTypeNoAsEnum` | `DomainTypeNo` | The domain type as an enumeration value. Can be one of: `VALUE` (1), `TEXTTYPE` (2), `MODELNO` (3), `FLAGS` (4), `INTEGER` (5), `DECIMAL` (6), `LIMITEDSTRING` (7), `UNLIMITEDSTRING` (8), `BLOB` (9), or `DATETIME` (10). |
| `dataType` | `DataType` | The kind of data that is stored in the column. Can be one of: `INT_8`, `INT_16`, `INT_32`, `INT_64`, `DECIMAL`, `LIMITED_STRING`, `UNLIMITED_STRING`, `BLOB`. |
| `lenght` | `Int` | The maximum number of characters that can be stored, or 0 if the domain type is not `LIMITED_STRING`. |
| `columnWidth` | `Decimal` | The default column width, measured in the average number of characters that will fit in the column. |
| `storeFixedDecimals` | `Bool` | `true` if the domain type is `DECIMAL` and a fixed number of decimals should be stored. |
| `displayFixedDecimals` | `Bool` | `true` if the domain type is `DECIMAL` and a fixed number of decimals should be displayed by default. |
| `fixedDecimals` | `Int` | The actual number of fixed decimals (up to 6) that may be applied by default if the domain type is `DECIMAL`, else 0. |
| `fieldJustification` | `FieldJustification` | Returns one of the following values for how the values (and the column heading in grid view) should be aligned by default: `CENTER`, `LEFT`, or `RIGHT`. |
| `fileName` | `Bool` | `true` if the domain type is LimitedString and file name lookup is applicable. |
| `domainMembers` | [`Query_UseModel_Domains_DomainMembers`] | A list of domain member objects. |

The following properties are available for domain members:

| Field | Type | Description |
| ----- | ---- | ----------- |
| `valueNo` | `Long` | Unique domain member indentification number. |
| `identifier` | `String` | A language-independent identifier of the domain member. |
| `name` | `String` | The name of the domain member. |
| `includeValue` | `Int` | An integer value to include in the name, or -1 if not applicable. |
| `groupName` | `String` | The name of the group the domain member belongs to. |
| `groupIncludeValue` | `Int` | An integer value to include in the group name, or -1 if not applicable. |
| `initiallyOn` | `Bool` | `true` if this flag domain member is intended to be initially ON. |

### Processings

The following properties are available for processings:

| Field | Type | Description |
| ----- | ---- | ----------- |
| `processingNo` | `Long` | The processing number. |
| `name` | `String` | The translated name of the processing. |
| `identifier` | `String` | A language-independent identifier of the processing. |
| `description` | `String` | A textual description of the processing. |
| `dialogOnly` | `Bool` | `true` if the processing is intended to only show a dialog, typically visualizing one or more columns. Such processings have no parameters, and no processing contributions in the backend, so operations for getting data for a processing dialog, or executing a processing, should not be performed on them. |
| `rowIndependent` | `Bool` | `true` if the processing is row-independent. |

### Reports

The following properties are available for reports:

| Field | Type | Description |
| ----- | ---- | ----------- |
| `processingNo` | `Long` | The report number. |
| `name` | `String` | The translated name of the report. |
| `identifier` | `String` | A language-independent report of the processing. |
| `description` | `String` | A textual description of the report. |

### Folders

The following properties are available for folders:

| Field | Type | Description |
| ----- | ---- | ----------- |
| `folderNo` | `Long` | The folder number. |
| `name` | `String` | The translated name of the folder. |
| `identifier` | `String` | A language-independent identifier of the folder. |
| `isRoot` | `Lool` | `true` if the folder is a root folder. |
| `parentFolderNo` | `Long` | The number of the parent folder, or 0 if the folder is a root folder. |
| `childFoldersNo` | `[Long]` | A collection of folder numbers for the child folders. |


---

[View this page](https://docs.vismasoftware.no/businessnxtapi/apireference/schema/modelinfo/)
