• data: array data
• rules: object Rules

{
    "type":"object",
    "properties":{
        "data":{
            "type":"array",
            "items":{
                "type":"array",
                "items":{
                    "type":"string"
                }
            }
        },
        "rules":{
            "$ref":"#/definitions/Rules"
        }
    }
}

• Array of: array items

{
    "type":"array",
    "items":{
        "type":"array",
        "items":{
            "type":"string"
        }
    }
}

• bibpm: boolean
• columnOperations: array columnOperations

  Rule operations available to perform at the field level. For example, you can move a field to a new position in the record.

• dataLoadOptions: object DataLoadOptions

  Rule operations available to perform on the data in a field; for example, changing how data affects existing values, clearing values, or flipping signs. Not applicable for dimension build rules.

• dataSource: object DataSource

  General Source Properties of a dimension build or data load rule. Use to broadly set how the rule behaves with respect to the source data.

• dimensionBuildOptions: object DimBuildOptions

  Global properties affecting all dimensions included in a dimension build rule.

• dimensions: array dimensions

  Properties defined per dimension, to set how the rule behaves for a dimension.

• editorOptions: object EditorOptions
• encoding: string
  Allowed Values: [ "NONE", "NONUNICODE", "UTF8" ]

  The encoding type of the rule file.

• essbaseInfo: object EssbaseInfo
• fields: array fields

  Array of field information, including general properties for all fields, as well as information about specific fields.

• flatFileBased: boolean

  true if the rule is associated with a flat file.

• locale: string
• name: string
• studio: boolean

  true if the rule is Index-based, and false if the rule is Regular. Index-based rules (sometimes called BPM rules) have different structure than Regular rules. Fields can be in any order; for example, Generation 2 can come before Generation 1, and a property of Generation 1 can come before the actual Generation 1 column. An index-based rule does not offer column operations (join, split, and move), but you can accomplish the same using field expressions.

• timeStamp: integer(int64)
• xolap: boolean

{
    "type":"object",
    "properties":{
        "dimensions":{
            "type":"array",
            "description":"<p>Properties defined per dimension, to set how the rule behaves for a dimension.</p>",
            "items":{
                "$ref":"#/definitions/Dimension"
            }
        },
        "fields":{
            "type":"array",
            "description":"<p>Array of field information, including general properties for all fields, as well as information about specific fields.</p>",
            "items":{
                "$ref":"#/definitions/Field"
            }
        },
        "timeStamp":{
            "type":"integer",
            "format":"int64"
        },
        "dataSource":{
            "description":"<p>General Source Properties of a dimension build or data load rule. Use to broadly set how the rule behaves with respect to the source data.</p>",
            "$ref":"#/definitions/DataSource"
        },
        "dimensionBuildOptions":{
            "$ref":"#/definitions/DimBuildOptions"
        },
        "dataLoadOptions":{
            "$ref":"#/definitions/DataLoadOptions"
        },
        "editorOptions":{
            "$ref":"#/definitions/EditorOptions"
        },
        "encoding":{
            "type":"string",
            "description":"<p>The encoding type of the rule file.</p>",
            "enum":[
                "NONE",
                "NONUNICODE",
                "UTF8"
            ]
        },
        "name":{
            "type":"string"
        },
        "locale":{
            "type":"string"
        },
        "studio":{
            "type":"boolean",
            "description":"<p><b>true</b> if the rule is Index-based, and <b>false</b> if the rule is Regular. Index-based rules (sometimes called BPM rules) have different structure than Regular rules. Fields can be in any order; for example, Generation 2 can come before Generation 1, and a property of Generation 1 can come before the actual Generation 1 column. An index-based rule does not offer column operations (join, split, and move), but you can accomplish the same using field expressions.</p>"
        },
        "bibpm":{
            "type":"boolean"
        },
        "xolap":{
            "type":"boolean"
        },
        "flatFileBased":{
            "type":"boolean",
            "description":"<p><b>true</b> if the rule is associated with a flat file.</p>"
        },
        "essbaseInfo":{
            "$ref":"#/definitions/EssbaseInfo"
        },
        "columnOperations":{
            "type":"array",
            "description":"<p>Rule operations available to perform at the field level. For example, you can move a field to a new position in the record.</p>",
            "items":{
                "$ref":"#/definitions/ColumnOperation"
            }
        }
    }
}

• Array of: string

{
    "type":"array",
    "items":{
        "type":"string"
    }
}

• Array of: object ColumnOperation

  Rule operations available to perform at the field level. For example, you can move a field to a new position in the record.

{
    "type":"array",
    "description":"<p>Rule operations available to perform at the field level. For example, you can move a field to a new position in the record.</p>",
    "items":{
        "$ref":"#/definitions/ColumnOperation"
    }
}

• clearCombinations: array clearCombinations

  Array of text values to clear while loading the data.

• option: string
  Allowed Values: [ "NONE", "OVERWRITE", "ADD", "SUBTRACT" ]

  A data load option to specify how newly loaded data values affect existing data values. By default, Essbase overwrites the existing values of the cube with the values of the source data. For example, if you load weekly values, you can specify the ADD option to create monthly values in the cube.

• removeAll: integer(int32)
• signFlipDimension: string

  Dimension name in which to flip signs. You can reverse, or flip, the value of a data field by flipping its sign. Sign flips are based on the UDA (user defined attribute) that you specify in signFlipUDA. When loading data into the accounts dimension, for example, you can specify that any record whose accounts member has a UDA of Expense change from a plus sign to a minus sign.

• signFlipUDA: string

  UDA (user defined attribute) for which to flip signs. You can reverse, or flip, the value of a data field by flipping its sign. Also specify the signFlipDimension.

{
    "type":"object",
    "description":"<p>Rule operations available to perform on the data in a field; for example, changing how data affects existing values, clearing values, or flipping signs. Not applicable for dimension build rules.</p>",
    "properties":{
        "clearCombinations":{
            "type":"array",
            "description":"<p>Array of text values to clear while loading the data.</p>",
            "items":{
                "type":"string"
            }
        },
        "option":{
            "type":"string",
            "description":"<p>A data load option to specify how newly loaded data values affect existing data values. By default, Essbase overwrites the existing values of the cube with the values of the source data. For example, if you load weekly values, you can specify the ADD option to create monthly values in the cube.</p>",
            "enum":[
                "NONE",
                "OVERWRITE",
                "ADD",
                "SUBTRACT"
            ]
        },
        "removeAll":{
            "type":"integer",
            "format":"int32"
        },
        "signFlipDimension":{
            "type":"string",
            "description":"<p>Dimension name in which to flip signs. You can reverse, or flip, the value of a data field by flipping its sign. Sign flips are based on the UDA (user defined attribute) that you specify in <i>signFlipUDA</i>. When loading data into the accounts dimension, for example, you can specify that any record whose accounts member has a UDA of Expense change from a plus sign to a minus sign.</p>"
        },
        "signFlipUDA":{
            "type":"string",
            "description":"<p>UDA (user defined attribute) for which to flip signs. You can reverse, or flip, the value of a data field by flipping its sign. Also specify the <i>signFlipDimension</i>.</p>"
        }
    }
}

• fileProperties: object FileProperties

  File properties you can set for rules that are associated with flat files or Excel files. For example, the delimiter, the width (for fixed-width records), and record numbers indicating headers vs the first record to load.

• header: string

  Header string used in the source data, if known. This will be skipped during the dimension build or data load.

• name: string
• sqlProperties: object SQLProperties

  SQL Properties enable connectivity to an external system such as an RDBMS to extract data from a relational system using a query.

• tokens: array tokens

  Ignore source data records during the dimension build or data load if the record contains the specified token(s). A token is one delimited string in the source data. To specify multiple tokens, be sure to delimit them and specify a tokensCombineOption. Example of tokens delimited by space: "tokens" : [ "&& UNDEFINED" ]

• tokensCombineOption: string
  Allowed Values: [ "AND", "OR" ]

  If you listed multiple tokens to ignore, specify AND if Essbase should ignore only records that contain all of the tokens. Specify OR if Essbase should ignore records that contain any of the tokens.

{
    "type":"object",
    "description":"<p>General Source Properties of a dimension build or data load rule. Use to broadly set how the rule behaves with respect to the source data.</p>",
    "properties":{
        "header":{
            "type":"string",
            "description":"<p>Header string used in the source data, if known. This will be skipped during the dimension build or data load.</p>"
        },
        "name":{
            "type":"string"
        },
        "tokens":{
            "type":"array",
            "description":"<p>Ignore source data records during the dimension build or data load if the record contains the specified token(s). A token is one delimited string in the source data. To specify multiple tokens, be sure to delimit them and specify a <i>tokensCombineOption</i>. Example of tokens delimited by space:<code> \"tokens\" : [ \"&&    UNDEFINED\" ]</code></p>",
            "items":{
                "type":"string"
            }
        },
        "tokensCombineOption":{
            "type":"string",
            "description":"<p>If you listed multiple tokens to ignore, specify AND if Essbase should ignore only records that contain all of the tokens. Specify OR if Essbase should ignore records that contain any of the tokens.</p>",
            "enum":[
                "AND",
                "OR"
            ]
        },
        "sqlProperties":{
            "description":"<p>SQL Properties enable connectivity to an external system such as an RDBMS to extract data from a relational system using a query.</p>",
            "$ref":"#/definitions/SQLProperties"
        },
        "fileProperties":{
            "$ref":"#/definitions/FileProperties"
        }
    }
}

• aliasTable: string

  Select which alias table to update with new aliases from the source data. If unspecified, dimension build updates the default alias table.

• arrangeDimensions: boolean

  Set to true to arrange dimensions in hourglass order for calculation performance. Applicable to block storage cubes only. The order is: 1- densest dimensions (accounts and time), 2- remaining dense dimensions (largest to smallest), 3- sparse dimensions (smallest to largest), 4- attribute dimensions.

• autoConfig: boolean

  Set to true let Essbase automatically assign dimensions as dense or sparse. By default, density/sparsity settings are kept as either the existing setting or the setting specified in the dimension build rule. Applicable to block storage cubes only.

• smartLists: array smartLists

  Array to add or update a text list object, also known as a Smart List. Text list objects are a way to store metrics as textual values, when your accounts dimension is designed to work with text measures and your outline is enabled for typed measures. To see a sample cube that uses a textual measure dimension, import the sample application Facility Rating, available in the gallery section of the Files catalog.

{
    "type":"object",
    "description":"<p>Global properties affecting all dimensions included in a dimension build rule.</p>",
    "properties":{
        "autoConfig":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> let Essbase automatically assign dimensions as dense or sparse. By default, density/sparsity settings are kept as either the existing setting or the setting specified in the dimension build rule. Applicable to block storage cubes only.</p>"
        },
        "arrangeDimensions":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> to arrange dimensions in hourglass order for calculation performance. Applicable to block storage cubes only. The order is: 1- densest dimensions (accounts and time), 2- remaining dense dimensions (largest to smallest), 3- sparse dimensions (smallest to largest), 4- attribute dimensions.</p>"
        },
        "aliasTable":{
            "type":"string",
            "description":"<p>Select which alias table to update with new aliases from the source data. If unspecified, dimension build updates the default alias table.</p>"
        },
        "smartLists":{
            "type":"array",
            "description":"<p>Array to add or update a text list object, also known as a Smart List. Text list objects are a way to store metrics as textual values, when your accounts dimension is designed to work with text measures and your outline is enabled for typed measures. To see a sample cube that uses a textual measure dimension, import the sample application Facility Rating, available in the gallery section of the Files catalog.</p>",
            "items":{
                "$ref":"#/definitions/SmartList"
            }
        }
    }
}

• Array of: object Dimension

{
    "type":"array",
    "description":"<p>Properties defined per dimension, to set how the rule behaves for a dimension.</p>",
    "items":{
        "$ref":"#/definitions/Dimension"
    }
}

• application: string
• database: string
• dataFile: string
• dataFileApplication: string
• dataFileDatabase: string
• dataFileServer: string
• dataFileType: string
  Allowed Values: [ "NONE", "EXCEL", "LOTUS2", "LOTUS3", "LOTUS4", "TEXT" ]
• object: string
• server: string
• startRecord: integer(int32)
• viewCount: integer(int32)
• viewGridLines: boolean
• viewIgnored: boolean
• viewMode: string
  Allowed Values: [ "DIMBUILD", "DATALOAD" ]
• viewRawData: boolean
• viewToolbar: boolean

{
    "type":"object",
    "properties":{
        "application":{
            "type":"string"
        },
        "database":{
            "type":"string"
        },
        "server":{
            "type":"string"
        },
        "object":{
            "type":"string"
        },
        "dataFile":{
            "type":"string"
        },
        "dataFileApplication":{
            "type":"string"
        },
        "dataFileDatabase":{
            "type":"string"
        },
        "dataFileServer":{
            "type":"string"
        },
        "startRecord":{
            "type":"integer",
            "format":"int32"
        },
        "viewCount":{
            "type":"integer",
            "format":"int32"
        },
        "viewGridLines":{
            "type":"boolean"
        },
        "viewIgnored":{
            "type":"boolean"
        },
        "viewRawData":{
            "type":"boolean"
        },
        "viewToolbar":{
            "type":"boolean"
        },
        "viewMode":{
            "type":"string",
            "enum":[
                "DIMBUILD",
                "DATALOAD"
            ]
        },
        "dataFileType":{
            "type":"string",
            "enum":[
                "NONE",
                "EXCEL",
                "LOTUS2",
                "LOTUS3",
                "LOTUS4",
                "TEXT"
            ]
        }
    }
}

• application: string
• database: string
• password: string
• server: string
• user: string

{
    "type":"object",
    "properties":{
        "server":{
            "type":"string"
        },
        "application":{
            "type":"string"
        },
        "database":{
            "type":"string"
        },
        "user":{
            "type":"string"
        },
        "password":{
            "type":"string"
        }
    }
}

• Array of: object Field

  Field properties for performing load rule operations at the record level. For example, you can filter to select or reject certain records before they are loaded into the cube.

{
    "type":"array",
    "description":"<p>Array of field information, including general properties for all fields, as well as information about specific fields.</p>",
    "items":{
        "$ref":"#/definitions/Field"
    }
}

• position: integer(int32)

  Target position for column move operation.

• type: string
  Allowed Values: [ "CREATE", "JOIN", "SPLIT", "MOVE", "CREATETEXT", "SUBSTRING" ]

  Type of column operation.

• updateColumns: boolean

  True if the fields should be updated.

{
    "type":"object",
    "description":"<p>Rule operations available to perform at the field level. For example, you can move a field to a new position in the record.</p>",
    "properties":{
        "updateColumns":{
            "type":"boolean",
            "description":"<p>True if the fields should be updated.</p>"
        },
        "type":{
            "type":"string",
            "description":"<p>Type of column operation.</p>",
            "enum":[
                "CREATE",
                "JOIN",
                "SPLIT",
                "MOVE",
                "CREATETEXT",
                "SUBSTRING"
            ]
        },
        "position":{
            "type":"integer",
            "description":"<p>Target position for column move operation.</p>",
            "format":"int32"
        }
    }
}

• Array of: string

{
    "type":"array",
    "description":"<p>Array of text values to clear while loading the data.</p>",
    "items":{
        "type":"string"
    }
}

• dataloadRecordNumber: integer(int32)

  The number of the record to start with when performing a data load.

• delimiter: string

  If the rule is associated with a delimited file, the delimiter.

• dimensionBuildRecordNumber: integer(int32)

  The number of the record to start with when performing a dimension build.

• headerRecordNumber: integer(int32)

  The number of header rows to skip when performing a data load or dimension build. For example, 1 if the first record is a header. 0 if there is no header.

• lineSkipCount: integer(int32)

  Number of lines at the top of the data source to skip.

• width: integer(int32)

  If the rule is associated with a fixed-width flat file, the width in bytes.

{
    "type":"object",
    "description":"<p>File properties you can set for rules that are associated with flat files or Excel files. For example, the delimiter, the width (for fixed-width records), and record numbers indicating headers vs the first record to load.</p>",
    "properties":{
        "delimiter":{
            "type":"string",
            "description":"<p>If the rule is associated with a delimited file, the delimiter.</p>"
        },
        "width":{
            "type":"integer",
            "format":"int32",
            "description":"<p>If the rule is associated with a fixed-width flat file, the width in bytes.</p>"
        },
        "dataloadRecordNumber":{
            "type":"integer",
            "format":"int32",
            "description":"<p>The number of the record to start with when performing a data load.</p>"
        },
        "dimensionBuildRecordNumber":{
            "type":"integer",
            "format":"int32",
            "description":"<p>The number of the record to start with when performing a dimension build.</p>"
        },
        "headerRecordNumber":{
            "type":"integer",
            "description":"<p>The number of header rows to skip when performing a data load or dimension build. For example, 1 if the first record is a header. 0 if there is no header.</p>",
            "format":"int32"
        },
        "lineSkipCount":{
            "type":"integer",
            "format":"int32",
            "description":"<p>Number of lines at the top of the data source to skip.</p>"
        }
    }
}

• application: string

  Essbase application name, if connectivity is to another Essbase cube.

• database: string

  Essbase database name, if connectivity is to another Essbase cube.

• dictionary: string
• from: string

  The FROM clause of the query, excluding FROM.

• select: string

  The SELECT clause of the query, excluding SELECT.

• server: string

  Connection string or Datasource info to establish SQL-based connectivity. Example for Datasource: REST;URL=LOCAL;DS=Orcl_DS. For Oracle Database with SID: oracle://somedb99:1521/orcl. For Oracle Database with service name: ORACLESERVICE:oracle://somedb99:1234/esscs.host1.oraclecloud.com. For Microsoft SQL Server: sqlserver://myMSSQLHost:1433:myDbName. For MySQL: mysql://HostName:3306:DBName. For Teradata: teradata://192.0.2.110:1025/myDBName. For IBM DB2: db2://myDB2Host:1234:myDbName.

• where: string

  The WHERE clause of the query, excluding WHERE.

{
    "type":"object",
    "description":"<p>SQL Properties enable connectivity to an external system such as an RDBMS to extract data from a relational system using a query.</p>",
    "properties":{
        "server":{
            "type":"string",
            "description":"<p>Connection string or Datasource info to establish SQL-based connectivity. Example for Datasource: <code>REST;URL=LOCAL;DS=Orcl_DS</code>. For Oracle Database with SID: <code>oracle://somedb99:1521/orcl</code>. For Oracle Database with service name: <code>ORACLESERVICE:oracle://somedb99:1234/esscs.host1.oraclecloud.com</code>. For Microsoft SQL Server: <code>sqlserver://myMSSQLHost:1433:myDbName</code>. For MySQL: <code>mysql://HostName:3306:DBName</code>. For Teradata: <code>teradata://192.0.2.110:1025/myDBName</code>. For IBM DB2:  <code>db2://myDB2Host:1234:myDbName</code>.</p>"
        },
        "application":{
            "type":"string",
            "description":"<p>Essbase application name, if connectivity is to another Essbase cube.</p>"
        },
        "database":{
            "type":"string",
            "description":"<p>Essbase database name, if connectivity is to another Essbase cube.</p>"
        },
        "dictionary":{
            "type":"string"
        },
        "select":{
            "type":"string",
            "description":"<p>The SELECT clause of the query, excluding SELECT.</p>"
        },
        "from":{
            "type":"string",
            "description":"<p>The FROM clause of the query, excluding FROM.</p>"
        },
        "where":{
            "type":"string",
            "description":"<p>The WHERE clause of the query, excluding WHERE.</p>"
        }
    }
}

• Array of: string

{
    "type":"array",
    "description":"<p>Ignore source data records during the dimension build or data load if the record contains the specified token(s). A token is one delimited string in the source data. To specify multiple tokens, be sure to delimit them and specify a <i>tokensCombineOption</i>. Example of tokens delimited by space:<code> \"tokens\" : [ \"&&    UNDEFINED\" ]</code></p>",
    "items":{
        "type":"string"
    }
}

• Array of: object SmartList

{
    "type":"array",
    "description":"<p>Array to add or update a text list object, also known as a Smart List. Text list objects are a way to store metrics as textual values, when your accounts dimension is designed to work with text measures and your outline is enabled for typed measures. To see a sample cube that uses a textual measure dimension, import the sample application Facility Rating, available in the gallery section of the Files catalog.</p>",
    "items":{
        "$ref":"#/definitions/SmartList"
    }
}

• incrementalNumber: integer(int32)
• missingName: string
• name: string
• outOfRangeName: string
• removeUnspecified: integer(int32)
• startNumber: integer(int32)

{
    "type":"object",
    "properties":{
        "incrementalNumber":{
            "type":"integer",
            "format":"int32"
        },
        "startNumber":{
            "type":"integer",
            "format":"int32"
        },
        "missingName":{
            "type":"string"
        },
        "name":{
            "type":"string"
        },
        "outOfRangeName":{
            "type":"string"
        },
        "removeUnspecified":{
            "type":"integer",
            "format":"int32"
        }
    }
}

• added: boolean

  Set to true for a new dimension that does not yet exist in the outline. If true, the new dimension will be created during the dimension build. If false, dimension build will fail for a new dimension.

• addMemberOption: string
  Allowed Values: [ "GENERATION", "SIBLING_LOWEST_LEVEL", "CHILD", "SIBLING_MATCHING_STRING", "LEVEL", "PARENT_CHILD", "GEN_NULLS", "LEVEL_NULLS" ]

  The build method algorithm to add, change, or remove dimensions, members, and aliases in this dimension. Should be based on the properties of the source data; for example, if each record specifies a parent and later a child member, in that order, then PARENT_CHILD is a good method.

• aggregateLevelUsage: integer(int32)
• allowassociationChanges: boolean
• allowFormulaChanges: boolean
• allowMoves: string
  Allowed Values: [ "NOTOK", "OK", "IGNORE", "GEN2", "NOTGEN2" ]

  Set to OK to allow moving of members and their children to new parents, allowing Essbase to recognize primary members and match them with the source data. Not available for duplicate member outlines. Leave as NOTOK if updateOption = RESET_DIMENSION.

• allowPropertyChanges: boolean
• allowUDAChanges: boolean
• attributeOptions: object AttributeOptions
• autoFixSharedMember: boolean
• configOption: string
  Allowed Values: [ "EXISTING", "DENSE", "SPARSE" ]
• createAttributeMembers: boolean

  Set to true to allow Essbase to create attribute members. If false, prevents Essbase from creating attribute members.

• dimensionSolveOrder: integer(int32)

  Solve order of the dimension.

• flexible: boolean
• generations: array generations
• hierarchyType: string
  Allowed Values: [ "EXISTING", "MULTIPLE", "STORED", "DYNAMIC" ]

  MULTIPLE if multiple hierarchies should be enabled in this dimension (applicable to aggregate storage cube only). EXISTING to keep the setting unchanged. STORED for aggregate storage stored hierarchy type (no formulas). DYNAMIC for aggregate storage hierarchy type that aggregates using formulas (includes Accounts dimension).

• incrementalSort: boolean

  Set to true to sort members after Essbase has processed and added all members from the source data.

• levels: array levels
• measureOptions: object MeasureOptions

  Load rule definition properties relating primarily to the Accounts dimension.

• memberName: string

  Parent member name under which to add children. Used with Add as child of build method.

• name: string
• share: boolean

  Set to true if the dimension includes shared members.

• solveOrder: integer(int32)

  Priority in which the dimension or member is calculated (0 to 127). Higher solve order means the member is calculated later. Members not assigned a solve order inherit it from their dimension.

• sortOption: string
  Allowed Values: [ "NONE", "ASCENDING", "DESCENDING" ]

  Whether and how to sort this dimension's children in hierarchies: None (do not sort), ascending, or descending.

• storageType: string
  Allowed Values: [ "EXISTING", "STORE", "NEVER_SHARE", "LABEL_ONLY", "DYNAMIC_CALC_STORE", "DYNAMIC_CALC" ]
• type: string
  Allowed Values: [ "EXISTING", "NONE", "ACCOUNTS", "TIME", "COUNTRY", "ATTRIBUTES" ]
• unique: string
  Allowed Values: [ "EXISTING", "UNIQUE", "DUPLICATE", "NONE" ]
• updateOption: string
  Allowed Values: [ "MERGE", "REMOVE_UNSPECIFIED", "RESET_DIMENSION" ]

  Incremental dimension build update option. Incremental dimension building is the process of updating existing dimensions by adding, moving, deleting, and reordering members. MERGE (the default) adds new members while retaining existing members. REMOVE_UNSPECIFIED removes members that are not specified in the source (available only when addMemberOption = GENERATION, LEVEL, or PARENT_CHILD). Outlines are invalid if removing members results in level 0 Dynamic Calc members without formulas. RESET_DIMENSION is available only for Index-based rules (i.e. studio = true). Reset Dimension rebuilds the entire dimension. This option enables insert, reorder, move, and delete operations during incremental dimension build, persisting member placement in the hierarchy instead of moving them to the end. To use Reset Dimension, allowMoves should be NOTOK; otherwise, you cannot build shared hierarchies.

{
    "type":"object",
    "properties":{
        "generations":{
            "type":"array",
            "items":{
                "$ref":"#/definitions/Level"
            }
        },
        "levels":{
            "type":"array",
            "items":{
                "$ref":"#/definitions/Level"
            }
        },
        "allowassociationChanges":{
            "type":"boolean"
        },
        "allowFormulaChanges":{
            "type":"boolean"
        },
        "allowPropertyChanges":{
            "type":"boolean"
        },
        "allowUDAChanges":{
            "type":"boolean"
        },
        "measureOptions":{
            "$ref":"#/definitions/MeasureOptions"
        },
        "aggregateLevelUsage":{
            "type":"integer",
            "format":"int32"
        },
        "addMemberOption":{
            "type":"string",
            "description":"<p>The build method algorithm to add, change, or remove dimensions, members, and aliases in this dimension. Should be based on the properties of the source data; for example, if each record specifies a parent and later a child member, in that order, then PARENT_CHILD is a good method.</p>",
            "enum":[
                "GENERATION",
                "SIBLING_LOWEST_LEVEL",
                "CHILD",
                "SIBLING_MATCHING_STRING",
                "LEVEL",
                "PARENT_CHILD",
                "GEN_NULLS",
                "LEVEL_NULLS"
            ]
        },
        "attributeOptions":{
            "$ref":"#/definitions/AttributeOptions"
        },
        "configOption":{
            "type":"string",
            "enum":[
                "EXISTING",
                "DENSE",
                "SPARSE"
            ]
        },
        "unique":{
            "type":"string",
            "enum":[
                "EXISTING",
                "UNIQUE",
                "DUPLICATE",
                "NONE"
            ]
        },
        "hierarchyType":{
            "type":"string",
            "description":"<p>MULTIPLE if multiple hierarchies should be enabled in this dimension (applicable to aggregate storage cube only). EXISTING to keep the setting unchanged. STORED for aggregate storage stored hierarchy type (no formulas). DYNAMIC for aggregate storage hierarchy type that aggregates using formulas (includes Accounts dimension).</p>",
            "enum":[
                "EXISTING",
                "MULTIPLE",
                "STORED",
                "DYNAMIC"
            ]
        },
        "sortOption":{
            "type":"string",
            "description":"<p>Whether and how to sort this dimension's children in hierarchies: None (do not sort), ascending, or descending.</p>",
            "enum":[
                "NONE",
                "ASCENDING",
                "DESCENDING"
            ]
        },
        "storageType":{
            "type":"string",
            "enum":[
                "EXISTING",
                "STORE",
                "NEVER_SHARE",
                "LABEL_ONLY",
                "DYNAMIC_CALC_STORE",
                "DYNAMIC_CALC"
            ]
        },
        "type":{
            "type":"string",
            "enum":[
                "EXISTING",
                "NONE",
                "ACCOUNTS",
                "TIME",
                "COUNTRY",
                "ATTRIBUTES"
            ]
        },
        "updateOption":{
            "type":"string",
            "description":"<p>Incremental dimension build update option. Incremental dimension building is the process of updating existing dimensions by adding, moving, deleting, and reordering members. MERGE (the default) adds new members while retaining existing members. REMOVE_UNSPECIFIED removes members that are not specified in the source (available only when <i>addMemberOption</i> = <code>GENERATION</code>, <code>LEVEL</code>, or <code>PARENT_CHILD</code>). Outlines are invalid if removing members results in level 0 Dynamic Calc members without formulas. RESET_DIMENSION is available only for Index-based rules (i.e. <i>studio</i> = <code>true</code>). Reset Dimension rebuilds the entire dimension. This option enables insert, reorder, move, and delete operations during incremental dimension build, persisting member placement in the hierarchy instead of moving them to the end. To use Reset Dimension, <i>allowMoves</i> should be <code>NOTOK</code>; otherwise, you cannot build shared hierarchies.</p>",
            "enum":[
                "MERGE",
                "REMOVE_UNSPECIFIED",
                "RESET_DIMENSION"
            ]
        },
        "allowMoves":{
            "type":"string",
            "description":"<p>Set to <b>OK</b> to allow moving of members and their children to new parents, allowing Essbase to recognize primary members and match them with the source data. Not available for duplicate member outlines. Leave as <b>NOTOK</b> if <i>updateOption</i> = <code>RESET_DIMENSION</code>.</p>",
            "enum":[
                "NOTOK",
                "OK",
                "IGNORE",
                "GEN2",
                "NOTGEN2"
            ]
        },
        "solveOrder":{
            "type":"integer",
            "description":"<p>Priority in which the dimension or member is calculated (0 to 127). Higher solve order means the member is calculated later. Members not assigned a solve order inherit it from their dimension.</p>",
            "format":"int32"
        },
        "createAttributeMembers":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> to allow Essbase to create attribute members. If <b>false</b>, prevents Essbase from creating attribute members.</p>"
        },
        "share":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> if the dimension includes shared members.</p>"
        },
        "incrementalSort":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> to sort members after Essbase has processed and added all members from the source data.</p>"
        },
        "autoFixSharedMember":{
            "type":"boolean"
        },
        "flexible":{
            "type":"boolean"
        },
        "memberName":{
            "type":"string",
            "description":"<p>Parent member name under which to add children. Used with Add as child of build method.</p>"
        },
        "name":{
            "type":"string"
        },
        "dimensionSolveOrder":{
            "type":"integer",
            "format":"int32",
            "description":"<p>Solve order of the dimension.</p>"
        },
        "added":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> for a new dimension that does not yet exist in the outline. If <b>true</b>, the new dimension will be created during the dimension build. If <b>false</b>, dimension build will fail for a new dimension.</p>"
        }
    }
}

• baseDimension: string
• indepDimensions: array indepDimensions
• modified: boolean
• scaassociationMode: string
  Allowed Values: [ "NOOVERWRITE", "OVERWRITE" ]
• scadisAssociationMode: string
  Allowed Values: [ "NOOVERWRITE", "OVERWRITE", "EXTEND" ]
• type: string
  Allowed Values: [ "NUMERIC", "BOOLEAN", "TEXT", "DATE", "EXISTING" ]

{
    "type":"object",
    "properties":{
        "indepDimensions":{
            "type":"array",
            "items":{
                "$ref":"#/definitions/IndepDimension"
            }
        },
        "type":{
            "type":"string",
            "enum":[
                "NUMERIC",
                "BOOLEAN",
                "TEXT",
                "DATE",
                "EXISTING"
            ]
        },
        "baseDimension":{
            "type":"string"
        },
        "modified":{
            "type":"boolean"
        },
        "scadisAssociationMode":{
            "type":"string",
            "enum":[
                "NOOVERWRITE",
                "OVERWRITE",
                "EXTEND"
            ]
        },
        "scaassociationMode":{
            "type":"string",
            "enum":[
                "NOOVERWRITE",
                "OVERWRITE"
            ]
        }
    }
}

• Array of: object Level

{
    "type":"array",
    "items":{
        "$ref":"#/definitions/Level"
    }
}

• Array of: object Level

{
    "type":"array",
    "items":{
        "$ref":"#/definitions/Level"
    }
}

• currencyCategory: string

  If the dimension is associated with a currency conversion application, the currency category. This is an Accounts member from the currency cube. Example: P&L.

• currencyConversion: string
  Allowed Values: [ "EXISTING", "NONE", "CATEGORY", "NO_CONVERSION" ]

  Currency conversion action to take during the dimension build. Mark any members that should not be currency-converted as NO_CONVERSION. NONE does not indicate no conversion; rather, it indicates that the conversion category is unspecified (thus inherited).

• currencyName: string

  If the dimension is associated with a currency conversion application, the currency name. This is a Country dimension type member from the currency cube. Examples: USD, CND, GPB, EUR

• skip: string
  Allowed Values: [ "NONE", "NA", "MISSING", "ZERO", "MISSING_ZERO" ]

  If you set the timeBalanceOption as FIRST, LAST, or AVERAGE, then use the skip property to indicate how to calculate the parent value when missing- or zero-values are encountered. NONE: Does not skip data when calculating parent value. MISSING: Skips #MISSING data. ZERO: Skips data that equals zero. MISSING_ZERO: Skips #MISSING data and data that equals zero.

• timeBalanceOption: string
  Allowed Values: [ "EXISTING", "NONE", "FIRST", "LAST", "AVERAGE" ]

  The time balance property, if used. By default, a parent in the time dimension is calculated based on the consolidation and formulas of its children. For example, in the Sample.Basic database, the Qtr1 member is the sum of its children (Jan, Feb, and Mar). However, setting a time balance property causes parents, for example Qtr1, to roll up differently.

• twoPass: boolean

  True to mark the dimension as using two-pass calculation.

• varianceReporting: string
  Allowed Values: [ "EXISTING", "NON_EXPENSE", "EXPENSE" ]

  Whether to treat accounts members as expense items. EXISTING to keep the current setting.

{
    "type":"object",
    "description":"<p>Load rule definition properties relating primarily to the Accounts dimension.</p>",
    "properties":{
        "currencyCategory":{
            "type":"string",
            "description":"<p>If the dimension is associated with a currency conversion application, the currency category. This is an Accounts member from the currency cube. Example: P&L.</p>"
        },
        "currencyName":{
            "type":"string",
            "description":"<p>If the dimension is associated with a currency conversion application, the currency name. This is a Country dimension type member from the currency cube. Examples: USD, CND, GPB, EUR</p>"
        },
        "currencyConversion":{
            "type":"string",
            "description":"<p>Currency conversion action to take during the dimension build. Mark any members that should not be currency-converted as NO_CONVERSION. NONE does not indicate no conversion; rather, it indicates that the conversion category is unspecified (thus inherited).</p>",
            "enum":[
                "EXISTING",
                "NONE",
                "CATEGORY",
                "NO_CONVERSION"
            ]
        },
        "skip":{
            "type":"string",
            "description":"<p>If you set the <i>timeBalanceOption</i> as FIRST, LAST, or AVERAGE, then use the skip property to indicate how to calculate the parent value when missing- or zero-values  are encountered. NONE: Does not skip data when calculating parent value. MISSING: Skips #MISSING data. ZERO: Skips data that equals zero. MISSING_ZERO: Skips #MISSING data and data that equals zero.</p>",
            "enum":[
                "NONE",
                "NA",
                "MISSING",
                "ZERO",
                "MISSING_ZERO"
            ]
        },
        "timeBalanceOption":{
            "type":"string",
            "description":"<p>The time balance property, if used. By default, a parent in the time dimension is calculated based on the consolidation and formulas of its children. For example, in the Sample.Basic database, the Qtr1 member is the sum of its children (Jan, Feb, and Mar). However, setting a time balance property causes parents, for example Qtr1, to roll up differently.</p>",
            "enum":[
                "EXISTING",
                "NONE",
                "FIRST",
                "LAST",
                "AVERAGE"
            ]
        },
        "varianceReporting":{
            "type":"string",
            "description":"<p>Whether to treat accounts members as expense items. EXISTING to keep the current setting.</p>",
            "enum":[
                "EXISTING",
                "NON_EXPENSE",
                "EXPENSE"
            ]
        },
        "twoPass":{
            "type":"boolean",
            "description":"<p>True to mark the dimension as using two-pass calculation.</p>"
        }
    }
}

• Array of: object IndepDimension

{
    "type":"array",
    "items":{
        "$ref":"#/definitions/IndepDimension"
    }
}

• name: string
• type: string
  Allowed Values: [ "CONTINUOUS", "DISCRETE" ]

{
    "type":"object",
    "properties":{
        "name":{
            "type":"string"
        },
        "type":{
            "type":"string",
            "enum":[
                "CONTINUOUS",
                "DISCRETE"
            ]
        }
    }
}

• name: string
• number: integer(int32)
• unique: boolean

{
    "type":"object",
    "properties":{
        "name":{
            "type":"string"
        },
        "number":{
            "type":"integer",
            "format":"int32"
        },
        "unique":{
            "type":"boolean"
        }
    }
}

• case: string
  Allowed Values: [ "NOOP", "LOWER_CASE", "UPPER_CASE", "FIRST_CAPITAL_CASE" ]

  Select a character case-conversion operation to perform on incoming data while loading to Essbase. NOOP: perform no conversion. LOWER_CASE: convert upper case to lower case. UPPER_CASE: convert lower case to upper case. FIRST_CAPITAL_CASE: convert the first character to upper case and the remaining characters to lower case.

• convertSpaceToUnderScore: boolean

  Convert spaces in source data fields to underscores while loading to Essbase.

• dataloadOptions: object FieldDataLoadOptions

  Field-level options you can set for data-load rules. For example, Essbase can ignore, rescale, and perform extractions on fields from the source data.

• dateFormat: string

  Date format for the field, if applicable.

• dimensionBuildOptions: object FieldDimBuildOptions

  Field-level options you can set for dimension-build rules. For example, Essbase can ignore, split, join, and reposition fields.

• name: string
• option: string(byte)
• prefix: string

  Prefix for the field, if applicable.

• rejectFilterJoinOption: string
  Allowed Values: [ "AND", "OR" ]

  If you define more than one rejection filter, choose a logical join operator, AND or OR. AND means that all the defined rejection criteria must apply (if even one criterion is not met for any given record, then the filter does not apply to that record). OR means the opposite (if even one criterion is met for a given record, the filter applies).

• rejectFilters: array rejectFilters

  Rejection filter criteria for omitting data load or dimension build records while loading to the Essbase cube. Filtration options include string or numeric matching of specific values, logical join options, and case sensitivity.

• replaceInformation: array replaceInformation

  Replacement value specification, if the filter is designed for finding and replacing values in source records as you load them to Essbase.

• selectFilterJoinOption: string
  Allowed Values: [ "AND", "OR" ]

  If you define more than one selection filter, choose a logical join operator, AND or OR. AND means that all the defined selection criteria must apply (if even one criterion is not met for any given record, then the filter does not apply to that record). OR means the opposite (if even one criterion is met for a given record, the filter applies).

• selectFilters: array selectFilters

  Selection filter criteria for approval of data load or dimension build records while loading to the Essbase cube. Filtration options include string or numeric matching of specific values, logical join options, and case sensitivity.

• smartList: string

  Text list object (smart list) associated with the field, if applicable.

• suffix: string

  Suffix for the field, if applicable.

• transform: object Transform

  Transformation options for data processing that you can use in an index-based dimension build rule. Types can be COLUMN, SUBSTR for substring function, CONCAT for joins, STATICSTR for static strings, or IGNORE. The following index-based rule transformation spec is the same as the Essbase Web interface using a field expression of join(column0,column1). "transform" : {"type": "CONCAT", "nodes": [ {"type": "COLUMN", "index" : 0}, {"type": "COLUMN", "index": 1}]}}.

• trim: boolean

  Trim leading or trailing spaces from around source data fields so that they map correctly to Essbase member names.

• width: number(double)

  Width of the field, if applicable (if the source data fields are fixed width).

{
    "type":"object",
    "description":"<p>Field properties for performing load rule operations at the record level. For example, you can filter to select or reject certain records before they are loaded into the cube.</p>",
    "properties":{
        "rejectFilters":{
            "type":"array",
            "description":"<p>Rejection filter criteria for omitting data load or dimension build records while loading to the Essbase cube. Filtration options include string or numeric matching of specific values, logical join options, and case sensitivity. </p>",
            "items":{
                "$ref":"#/definitions/Filter"
            }
        },
        "selectFilters":{
            "type":"array",
            "description":"<p>Selection filter criteria for approval of data load or dimension build records while loading to the Essbase cube. Filtration options include string or numeric matching of specific values, logical join options, and case sensitivity.</p>",
            "items":{
                "$ref":"#/definitions/Filter"
            }
        },
        "replaceInformation":{
            "type":"array",
            "description":"<p>Replacement value specification, if the filter is designed for finding and replacing values in source records as you load them to Essbase.</p>",
            "items":{
                "$ref":"#/definitions/ReplaceInfo"
            }
        },
        "selectFilterJoinOption":{
            "type":"string",
            "description":"<p>If you define more than one selection filter, choose a logical join operator, AND or OR. AND means that all the defined selection criteria must apply (if even one criterion is not met for any given record, then the filter does not apply to that record). OR means the opposite (if even one criterion is met for a given record, the filter applies).</p>",
            "enum":[
                "AND",
                "OR"
            ]
        },
        "rejectFilterJoinOption":{
            "type":"string",
            "description":"<p>If you define more than one rejection filter, choose a logical join operator, AND or OR. AND means that all the defined rejection criteria must apply (if even one criterion is not met for any given record, then the filter does not apply to that record). OR means the opposite (if even one criterion is met for a given record, the filter applies).</p>",
            "enum":[
                "AND",
                "OR"
            ]
        },
        "dateFormat":{
            "type":"string",
            "description":"<p>Date format for the field, if applicable.</p>"
        },
        "name":{
            "type":"string"
        },
        "prefix":{
            "type":"string",
            "description":"<p>Prefix for the field, if applicable.</p>"
        },
        "suffix":{
            "type":"string",
            "description":"<p>Suffix for the field, if applicable.</p>"
        },
        "option":{
            "type":"string",
            "format":"byte"
        },
        "convertSpaceToUnderScore":{
            "type":"boolean",
            "description":"<p>Convert spaces in source data fields to underscores while loading to Essbase.</p>"
        },
        "trim":{
            "type":"boolean",
            "description":"<p>Trim leading or trailing spaces from around source data fields so that they map correctly to Essbase member names.</p>"
        },
        "width":{
            "type":"number",
            "format":"double",
            "description":"<p>Width of the field, if applicable (if the source data fields are fixed width).</p>"
        },
        "smartList":{
            "type":"string",
            "description":"<p>Text list object (smart list) associated with the field, if applicable.</p>"
        },
        "dimensionBuildOptions":{
            "description":"<p>Field-level options you can set for dimension-build rules. For example, Essbase can ignore, split, join, and reposition fields.</p>",
            "$ref":"#/definitions/FieldDimBuildOptions"
        },
        "dataloadOptions":{
            "$ref":"#/definitions/FieldDataLoadOptions"
        },
        "transform":{
            "$ref":"#/definitions/Transform"
        },
        "case":{
            "type":"string",
            "description":"<p>Select a character case-conversion operation to perform on incoming data while loading to Essbase. NOOP: perform no conversion. LOWER_CASE: convert upper case to lower case. UPPER_CASE: convert lower case to upper case. FIRST_CAPITAL_CASE: convert the first character to upper case and the remaining characters to lower case.</p>",
            "enum":[
                "NOOP",
                "LOWER_CASE",
                "UPPER_CASE",
                "FIRST_CAPITAL_CASE"
            ]
        }
    }
}

• data: boolean

  Set to true to indicate that the field is a data (non-metadata) field.

• ignore: boolean

  Ignore (do not load) this data-source column.

• referDimension: string

  For duplicate member outlines, specify the dimension and the referOption that indicates the build method (level reference or generation reference) that Essbase uses to map the field.

• referNumber: integer(int32)

  For duplicate member outlines, use with referOption to specify the generation or level number expected for the source data field.

• referOption: integer(int32)

  For duplicate member outlines, specify referOption that indicates the build method (level reference or generation reference) that Essbase uses to map the field. Use level reference when fields are organized bottom-up in the source data. Use generation reference when fields are organized top down in the source data.

• scale: boolean

  Available only for data fields. Set to true if you want to scale the values of the source data to match the scale of values stored in the cube. Must be used with scalingfactor.

• scalingfactor: number(double)

  Available only for data fields and when scale is set to true. A scaling factor, if the values of the source data are not in the same scale as the values of the cube. For example, assume the real value of sales is $5,460. If the Sales source data tracks the values in hundreds, the value is 54.6. If the Essbase cube tracks the real value, you must multiply the value coming in from the Sales source data (54.6) by 100 to have the value display correctly in the Essbase cube (as 5460).

• storeType: string
  Allowed Values: [ "MIN", "MAX", "AVG", "SUM", "COUNT" ]

  Column-level options to extract the source data in a specific way. Available only for data fields. MIN stores the minimim value of the incoming data, including a comparison with existing cube data. MAX stores the maximum value. SUM behaves the same as the ADD global option, adding the incoming data to existing cube data. COUNT stores the count of values present in the incoming data.

• storeTypeCountMissing: boolean
• useReference: boolean

{
    "type":"object",
    "description":"<p>Field-level options you can set for data-load rules. For example, Essbase can ignore, rescale, and perform extractions on fields from the source data.</p>",
    "properties":{
        "referDimension":{
            "type":"string",
            "description":"<p>For duplicate member outlines, specify the dimension and the <i>referOption</i> that indicates the build method (level reference or generation reference) that Essbase uses to map the field. </p>"
        },
        "referNumber":{
            "type":"integer",
            "description":"<p>For duplicate member outlines, use with <i>referOption</i> to specify the generation or level number expected for the source data field.</p>",
            "format":"int32"
        },
        "referOption":{
            "type":"integer",
            "description":"<p>For duplicate member outlines, specify <i>referOption</i> that indicates the build method (level reference or generation reference) that Essbase uses to map the field. Use level reference when fields are organized bottom-up in the source data. Use generation reference when fields are organized top down in the source data.</p>",
            "format":"int32"
        },
        "ignore":{
            "type":"boolean",
            "description":"<p>Ignore (do not load) this data-source column.</p>"
        },
        "scale":{
            "type":"boolean",
            "description":"<p>Available only for data fields. Set to true if you want to scale the values of the source data to match the scale of values stored in the cube. Must be used with <b>scalingfactor</b>.</p>"
        },
        "useReference":{
            "type":"boolean"
        },
        "data":{
            "type":"boolean",
            "description":"<p>Set to <b>true</b> to indicate that the field is a data (non-metadata) field.</p>"
        },
        "scalingfactor":{
            "type":"number",
            "description":"<p>Available only for data fields and when <b>scale</b> is set to true. A scaling factor, if the values of the source data are not in the same scale as the values of the cube. For example, assume the real value of sales is $5,460. If the Sales source data tracks the values in hundreds, the value is 54.6. If the Essbase cube tracks the real value, you must multiply the value coming in from the Sales source data (54.6) by 100 to have the value display correctly in the Essbase cube (as 5460).</p>",
            "format":"double"
        },
        "storeType":{
            "type":"string",
            "description":"<p>Column-level options to extract the source data in a specific way. Available only for data fields. MIN stores the minimim value of the incoming data, including a comparison with existing cube data. MAX stores the maximum value. SUM behaves the same as the ADD global option, adding the incoming data to existing cube data. COUNT stores the count of values present in the incoming data.</p>",
            "enum":[
                "MIN",
                "MAX",
                "AVG",
                "SUM",
                "COUNT"
            ]
        },
        "storeTypeCountMissing":{
            "type":"boolean"
        }
    }
}

• alias: string
• attributeBuildProperties: object AttributeBuildProperties

  Dimension build properties for attribute dimensions that use numeric ranges.

• attributeDimension: string
• dimension: string
• endIndepColumns: array endIndepColumns
• generation: integer(int32)
• generationProperty: string
  Allowed Values: [ "NONE", "CONSOLIDATIONTYPE", "STORAGETYPE", "TIMEBALANCE", "SKIP", "VARIANCEREPORT", "TWOPASSCALC", "HIERARCHYTYPE" ]
• generationType: string
  Allowed Values: [ "NONE", "PARENT", "CHILD", "GENERATION", "LEVEL", "ATTRIBUTE_MEMBER", "ALIAS", "PROPERTY", "FORMULA", "MEMBER_ID", "SOLVE_ORDER", "UDA", "DUPGEN", "DUPLEVEL", "DUPGEN_ALIAS", "DUPLEVEL_ALIAS", "CURRENCY_NAME", "CURRENCY_CATEGORY", "NUMTYPES", "ATTRIBUTE_DIM_LABEL", "ATTRIBUTE_PARENT", "DUPGEN_CAPTION", "DUPLEVEL_CAPTION", "AGGLEVELUSAGE", "ATTR_ASSOCIATE", "REFMEMBER", "GEN_RIGHTJOIN", "COMMENT", "SHARED_GEN", "GEN_NATUREJOIN", "GEN_LEFTJOIN", "GEN_OTLMBR", "COMMENT_EX", "REFMEMBERID", "SMARTLISTID", "SMARTLISTTEXT", "FORMATSTRING" ]

  Type you assign to the source data field to help Essbase build the dimension correctly.

• ignore: boolean

  true if record should be ignored during data loads and dimension builds.

• parent: integer(int32)

  Parent field generation of this field. For example, a field of generation 3 has a generation-2 field as a parent.

• refer: integer(int32)

  Which field number this field refers to.

• referIndex: integer(int32)
• shared: integer(int32)
• startIndepColumns: array startIndepColumns
• staticField: boolean

  Whether the field value is static. If true, then the name is used for loading.

{
    "type":"object",
    "description":"<p>Field-level options you can set for dimension-build rules. For example, Essbase can ignore, split, join, and reposition fields.</p>",
    "properties":{
        "parent":{
            "type":"integer",
            "description":"<p>Parent field generation of this field. For example, a field of generation 3 has a generation-2 field as a parent.</p>",
            "format":"int32"
        },
        "generationType":{
            "type":"string",
            "description":"<p>Type you assign to the source data field to help Essbase build the dimension correctly.</p>",
            "enum":[
                "NONE",
                "PARENT",
                "CHILD",
                "GENERATION",
                "LEVEL",
                "ATTRIBUTE_MEMBER",
                "ALIAS",
                "PROPERTY",
                "FORMULA",
                "MEMBER_ID",
                "SOLVE_ORDER",
                "UDA",
                "DUPGEN",
                "DUPLEVEL",
                "DUPGEN_ALIAS",
                "DUPLEVEL_ALIAS",
                "CURRENCY_NAME",
                "CURRENCY_CATEGORY",
                "NUMTYPES",
                "ATTRIBUTE_DIM_LABEL",
                "ATTRIBUTE_PARENT",
                "DUPGEN_CAPTION",
                "DUPLEVEL_CAPTION",
                "AGGLEVELUSAGE",
                "ATTR_ASSOCIATE",
                "REFMEMBER",
                "GEN_RIGHTJOIN",
                "COMMENT",
                "SHARED_GEN",
                "GEN_NATUREJOIN",
                "GEN_LEFTJOIN",
                "GEN_OTLMBR",
                "COMMENT_EX",
                "REFMEMBERID",
                "SMARTLISTID",
                "SMARTLISTTEXT",
                "FORMATSTRING"
            ]
        },
        "refer":{
            "type":"integer",
            "format":"int32",
            "description":"<p>Which field number this field refers to.</p>"
        },
        "referIndex":{
            "type":"integer",
            "format":"int32"
        },
        "shared":{
            "type":"integer",
            "format":"int32"
        },
        "attributeBuildProperties":{
            "$ref":"#/definitions/AttributeBuildProperties"
        },
        "dimension":{
            "type":"string"
        },
        "attributeDimension":{
            "type":"string"
        },
        "alias":{
            "type":"string"
        },
        "endIndepColumns":{
            "type":"array",
            "items":{
                "type":"integer",
                "format":"int32"
            }
        },
        "startIndepColumns":{
            "type":"array",
            "items":{
                "type":"integer",
                "format":"int32"
            }
        },
        "generationProperty":{
            "type":"string",
            "enum":[
                "NONE",
                "CONSOLIDATIONTYPE",
                "STORAGETYPE",
                "TIMEBALANCE",
                "SKIP",
                "VARIANCEREPORT",
                "TWOPASSCALC",
                "HIERARCHYTYPE"
            ]
        },
        "generation":{
            "type":"integer",
            "format":"int32"
        },
        "ignore":{
            "type":"boolean",
            "description":"<p> <b>true</b> if record should be ignored during data loads and dimension builds.</p>"
        },
        "staticField":{
            "type":"boolean",
            "description":"<p>Whether the field value is static. If <b>true</b>, then the name is used for loading.</p>"
        }
    }
}

• Array of: object Filter

{
    "type":"array",
    "description":"<p>Rejection filter criteria for omitting data load or dimension build records while loading to the Essbase cube. Filtration options include string or numeric matching of specific values, logical join options, and case sensitivity. </p>",
    "items":{
        "$ref":"#/definitions/Filter"
    }
}

• Array of: object ReplaceInfo

{
    "type":"array",
    "description":"<p>Replacement value specification, if the filter is designed for finding and replacing values in source records as you load them to Essbase.</p>",
    "items":{
        "$ref":"#/definitions/ReplaceInfo"
    }
}

• Array of: object Filter

{
    "type":"array",
    "description":"<p>Selection filter criteria for approval of data load or dimension build records while loading to the Essbase cube. Filtration options include string or numeric matching of specific values, logical join options, and case sensitivity.</p>",
    "items":{
        "$ref":"#/definitions/Filter"
    }
}

• nodes: array nodes
• type: string
  Allowed Values: [ "COLUMN", "SUBSTR", "CONCAT", "STATICSTR", "IGNORE" ]

{
    "type":"object",
    "description":"<p>Transformation options for data processing that you can use in an index-based dimension build rule. Types can be COLUMN, SUBSTR for substring function, CONCAT for joins, STATICSTR for static strings, or IGNORE. The following index-based rule transformation spec is the same as the Essbase Web interface using a field expression of <code>join(column0,column1)</code>. <code>\"transform\" : {\"type\": \"CONCAT\", \"nodes\": [ {\"type\": \"COLUMN\", \"index\" : 0}, {\"type\": \"COLUMN\", \"index\": 1}]}}</code>.</p>",
    "properties":{
        "nodes":{
            "type":"array",
            "items":{
                "$ref":"#/definitions/Transform"
            }
        },
        "type":{
            "type":"string",
            "enum":[
                "COLUMN",
                "SUBSTR",
                "CONCAT",
                "STATICSTR",
                "IGNORE"
            ]
        }
    }
}

• rangeIncrementValue: number(double)

  Increment value for numeric attribute ranges.

• rangeStartValue: number(double)

  Start value for numeric attribute ranges.

• removeAll: boolean
• useRanges: boolean

  True if current attribute dimension is using numeric ranges.

{
    "type":"object",
    "description":"<p>Dimension build properties for attribute dimensions that use numeric ranges.</p>",
    "properties":{
        "rangeIncrementValue":{
            "type":"number",
            "format":"double",
            "description":"<p>Increment value for numeric attribute ranges.</p>"
        },
        "rangeStartValue":{
            "type":"number",
            "format":"double",
            "description":"<p>Start value for numeric attribute ranges.</p>"
        },
        "removeAll":{
            "type":"boolean"
        },
        "useRanges":{
            "type":"boolean",
            "description":"<p>True if current attribute dimension is using numeric ranges.</p>"
        }
    }
}

• Array of: integer(int32)

{
    "type":"array",
    "items":{
        "type":"integer",
        "format":"int32"
    }
}

• Array of: integer(int32)

{
    "type":"array",
    "items":{
        "type":"integer",
        "format":"int32"
    }
}

• caseSensitive: boolean
• condition: string
  Allowed Values: [ "EQUAL_TO", "NOT_EQUAL_TO", "GREATER_THAN", "GREATER_THAN_EQUAL_TO", "LESS_THAN", "LESS_THAN_EQUAL_TO", "CONTAIN", "DOES_NOT_CONTAIN" ]

  Logical condition of the selection or rejection filter.

• stringFilter: boolean

  If true, the condition applies to string matching, and if false, it applies to numeric values.

• type: string
  Allowed Values: [ "REJECT", "SELECT" ]

  The type of filter: SELECT if the filter is defined with conditions for approving records to load. REJECT if the filter is defined with conditions for rejecting records to load.

• value: string

{
    "type":"object",
    "properties":{
        "stringFilter":{
            "type":"boolean",
            "description":"<p>If <b>true</b>, the condition applies to string matching, and if <b>false</b>, it applies to numeric values.</p>"
        },
        "value":{
            "type":"string"
        },
        "condition":{
            "type":"string",
            "description":"<p>Logical condition of the selection or rejection filter.</p>",
            "enum":[
                "EQUAL_TO",
                "NOT_EQUAL_TO",
                "GREATER_THAN",
                "GREATER_THAN_EQUAL_TO",
                "LESS_THAN",
                "LESS_THAN_EQUAL_TO",
                "CONTAIN",
                "DOES_NOT_CONTAIN"
            ]
        },
        "caseSensitive":{
            "type":"boolean"
        },
        "type":{
            "type":"string",
            "description":"<p>The type of filter: SELECT if the filter is defined with conditions for approving records to load. REJECT if the filter is defined with conditions for rejecting records to load.</p>",
            "enum":[
                "REJECT",
                "SELECT"
            ]
        }
    }
}

• caseSensitive: boolean
• find: string
• matchWholeWord: boolean
• replace: string
• replaceAll: boolean

{
    "type":"object",
    "properties":{
        "find":{
            "type":"string"
        },
        "replace":{
            "type":"string"
        },
        "matchWholeWord":{
            "type":"boolean"
        },
        "replaceAll":{
            "type":"boolean"
        },
        "caseSensitive":{
            "type":"boolean"
        }
    }
}

• Array of: object Transform

  Transformation options for data processing that you can use in an index-based dimension build rule. Types can be COLUMN, SUBSTR for substring function, CONCAT for joins, STATICSTR for static strings, or IGNORE. The following index-based rule transformation spec is the same as the Essbase Web interface using a field expression of join(column0,column1). "transform" : {"type": "CONCAT", "nodes": [ {"type": "COLUMN", "index" : 0}, {"type": "COLUMN", "index": 1}]}}.

{
    "type":"array",
    "items":{
        "$ref":"#/definitions/Transform"
    }
}