types

var (
	DataTypeEncryptedBlob = DataType{
		Description:        "Binary data encrypted at rest (secrets/ciphertext); native BLOB/BYTEA, base64 JSON string, []byte in Go.",
		APIParameterType:   APIParameterTypeEncryptedBlob,
		JSONType:           JSONTypeString,
		GoType:             GoTypeSliceByte,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BYTEA", base.DXDatabaseTypeSQLServer: "VARBINARY(MAX)", base.DXDatabaseTypeMariaDB: "LONGBLOB", base.DXDatabaseTypeOracle: "BLOB"},
	}
	DataTypeBlob = DataType{
		Description:        "Opaque binary payload (small inline files/images); native BLOB/BYTEA, base64 JSON string, []byte in Go. Large media belongs in object storage.",
		APIParameterType:   APIParameterTypeBlob,
		JSONType:           JSONTypeString,
		GoType:             GoTypeSliceByte,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BYTEA", base.DXDatabaseTypeSQLServer: "VARBINARY(MAX)", base.DXDatabaseTypeMariaDB: "LONGBLOB", base.DXDatabaseTypeOracle: "BLOB"},
	}

	DataTypeUID = DataType{
		Description:                "Legacy wide opaque public identifier, VARCHAR(1024) with a DB-generated timestamp-hex + UUID default (anti-IDOR/ENUM). Not index-safe on SQL Server (>900B); the platform now uses String255 for uid.",
		APIParameterType:           APIParameterTypeString,
		JSONType:                   JSONTypeString,
		GoType:                     GoTypeString,
		TypeByDatabaseType:         map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: "VARCHAR2(1024)"},
		DefaultValueByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: UIDDefaultExprPostgreSQL, base.DXDatabaseTypeSQLServer: UIDDefaultExprSQLServer, base.DXDatabaseTypeOracle: UIDDefaultExprOracle, base.DXDatabaseTypeMariaDB: UIDDefaultExprMariaDB},
	}

	DataTypeString = DataType{
		Description:        "General-purpose text up to 1024 chars (VARCHAR). Default when no length constraint matters.",
		APIParameterType:   APIParameterTypeString,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: OracleVARCHAR1024},
	}

	DataTypeProtectedString = DataType{
		Description:        "PII/sensitive text, masked at display by role; VARCHAR(1024). The protected marker drives masking, not storage.",
		APIParameterType:   APIParameterTypeProtectedString,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: OracleVARCHAR1024},
	}

	DataTypeProtectedSQLString = DataType{
		Description:        "Protected text also guarded against SQL injection (validated/escaped); VARCHAR(1024).",
		APIParameterType:   APIParameterTypeProtectedSQLString,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: OracleVARCHAR1024},
	}

	DataTypeProtectedNonEmptyString = DataType{
		Description:        "Protected text that must be non-empty; VARCHAR(1024).",
		APIParameterType:   APIParameterTypeProtectedNonEmptyString,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: OracleVARCHAR1024},
	}

	DataTypeNullableString = DataType{
		Description:        "Optional text (may be NULL); VARCHAR(1024), Go *string so NULL differs from empty.",
		APIParameterType:   APIParameterTypeNullableString,
		JSONType:           JSONTypeString,
		GoType:             GoTypeStringPointer,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: OracleVARCHAR1024},
	}

	DataTypeNonEmptyString = DataType{
		Description:        "Text that must be non-empty (rejects empty/whitespace); VARCHAR(1024).",
		APIParameterType:   APIParameterTypeNonEmptyString,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: OracleVARCHAR1024},
	}

	DataTypeEmail = DataType{
		Description:        "Email address, format-validated; VARCHAR(255).",
		APIParameterType:   APIParameterTypeEmail,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR255, base.DXDatabaseTypeSQLServer: VARCHAR255, base.DXDatabaseTypeMariaDB: VARCHAR255, base.DXDatabaseTypeOracle: OracleVARCHAR255},
	}

	DataTypePhoneNumber = DataType{
		Description:        "Phone number, format-validated; VARCHAR(255).",
		APIParameterType:   APIParameterTypePhoneNumber,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR255, base.DXDatabaseTypeSQLServer: VARCHAR255, base.DXDatabaseTypeMariaDB: VARCHAR255, base.DXDatabaseTypeOracle: OracleVARCHAR255},
	}

	DataTypeNPWP = DataType{
		Description:        "Indonesian taxpayer id (NPWP), format-validated; VARCHAR(255).",
		APIParameterType:   APIParameterTypeNPWP,
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR255, base.DXDatabaseTypeSQLServer: VARCHAR255, base.DXDatabaseTypeMariaDB: VARCHAR255, base.DXDatabaseTypeOracle: OracleVARCHAR255},
	}

	// DataTypeID is an integer identifier / primary key — same underlying type as
	// Int64 (BIGINT / int64) but a distinct named type + APIParameterType so it reads
	// as an identifier and is distinguishable by consumers (cf. UID vs String1024).
	DataTypeID = DataType{
		Description:        "Integer identifier / primary key (BIGINT, int64), JSON number. Internal/debug tier; public API exposes UID instead.",
		APIParameterType:   APIParameterTypeID,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGINT", base.DXDatabaseTypeSQLServer: "BIGINT", base.DXDatabaseTypeMariaDB: "BIGINT", base.DXDatabaseTypeOracle: "NUMBER(19)"},
	}

	DataTypeInt32 = DataType{
		Description:        "32-bit signed integer (INT), JSON number, Go int32.",
		APIParameterType:   APIParameterTypeInt32,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "INT", base.DXDatabaseTypeSQLServer: "INT", base.DXDatabaseTypeMariaDB: "INT", base.DXDatabaseTypeOracle: "NUMBER(10)"},
	}

	DataTypeInt32P = DataType{
		Description:        "32-bit positive integer (> 0); INT.",
		APIParameterType:   APIParameterTypeInt32P,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "INT", base.DXDatabaseTypeSQLServer: "INT", base.DXDatabaseTypeMariaDB: "INT", base.DXDatabaseTypeOracle: "NUMBER(10)"},
	}

	DataTypeInt32ZP = DataType{
		Description:        "32-bit zero-or-positive integer (>= 0); INT.",
		APIParameterType:   APIParameterTypeInt32ZP,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "INT", base.DXDatabaseTypeSQLServer: "INT", base.DXDatabaseTypeMariaDB: "INT", base.DXDatabaseTypeOracle: "NUMBER(10)"},
	}

	DataTypeNullableInt32 = DataType{
		Description:        "Optional 32-bit integer (may be left out of a request); INT, Go int32.",
		APIParameterType:   APIParameterTypeNullableInt32,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "INT", base.DXDatabaseTypeSQLServer: "INT", base.DXDatabaseTypeMariaDB: "INT", base.DXDatabaseTypeOracle: "NUMBER(10)"},
	}

	DataTypeInt64 = DataType{
		Description:        "64-bit signed integer (BIGINT), JSON number, Go int64.",
		APIParameterType:   APIParameterTypeInt64,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGINT", base.DXDatabaseTypeSQLServer: "BIGINT", base.DXDatabaseTypeMariaDB: "BIGINT", base.DXDatabaseTypeOracle: "NUMBER(19)"},
	}

	DataTypeInt64P = DataType{
		Description:        "64-bit positive integer (> 0); BIGINT.",
		APIParameterType:   APIParameterTypeInt64P,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGINT", base.DXDatabaseTypeSQLServer: "BIGINT", base.DXDatabaseTypeMariaDB: "BIGINT", base.DXDatabaseTypeOracle: "NUMBER(19)"},
	}

	DataTypeInt64ZP = DataType{
		Description:        "64-bit zero-or-positive integer (>= 0); BIGINT.",
		APIParameterType:   APIParameterTypeInt64ZP,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGINT", base.DXDatabaseTypeSQLServer: "BIGINT", base.DXDatabaseTypeMariaDB: "BIGINT", base.DXDatabaseTypeOracle: "NUMBER(19)"},
	}

	DataTypeNullableInt64 = DataType{
		Description:        "Optional 64-bit integer (may be NULL); BIGINT, Go *int64.",
		APIParameterType:   APIParameterTypeNullableInt64,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt64Pointer,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGINT", base.DXDatabaseTypeSQLServer: "BIGINT", base.DXDatabaseTypeMariaDB: "BIGINT", base.DXDatabaseTypeOracle: "NUMBER(19)"},
	}

	DataTypeFloat32 = DataType{
		Description:        "32-bit binary float (REAL), JSON number. Approximate and lossy; never use for money, use Money.",
		APIParameterType:   APIParameterTypeFloat32,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeFloat32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "REAL", base.DXDatabaseTypeSQLServer: "REAL", base.DXDatabaseTypeMariaDB: "FLOAT", base.DXDatabaseTypeOracle: "BINARY_FLOAT"},
	}

	DataTypeFloat32P = DataType{
		Description:        "Positive 32-bit float (> 0); REAL. Not for money.",
		APIParameterType:   APIParameterTypeFloat32P,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeFloat32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "REAL", base.DXDatabaseTypeSQLServer: "REAL", base.DXDatabaseTypeMariaDB: "FLOAT", base.DXDatabaseTypeOracle: "BINARY_FLOAT"},
	}

	DataTypeFloat32ZP = DataType{
		Description:        "Zero-or-positive 32-bit float (>= 0); REAL. Not for money.",
		APIParameterType:   APIParameterTypeFloat32ZP,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeFloat32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "REAL", base.DXDatabaseTypeSQLServer: "REAL", base.DXDatabaseTypeMariaDB: "FLOAT", base.DXDatabaseTypeOracle: "BINARY_FLOAT"},
	}

	DataTypeFloat64 = DataType{
		Description:        "64-bit binary float (DOUBLE), JSON number. Approximate and lossy; never use for money, use Money.",
		APIParameterType:   APIParameterTypeFloat64,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeFloat64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "DOUBLE PRECISION", base.DXDatabaseTypeSQLServer: "FLOAT", base.DXDatabaseTypeMariaDB: "DOUBLE", base.DXDatabaseTypeOracle: "BINARY_DOUBLE"},
	}

	DataTypeFloat64P = DataType{
		Description:        "Positive 64-bit float (> 0); DOUBLE. Not for money.",
		APIParameterType:   APIParameterTypeFloat64P,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeFloat64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "DOUBLE PRECISION", base.DXDatabaseTypeSQLServer: "FLOAT", base.DXDatabaseTypeMariaDB: "DOUBLE", base.DXDatabaseTypeOracle: "BINARY_DOUBLE"},
	}

	DataTypeFloat64ZP = DataType{
		Description:        "Zero-or-positive 64-bit float (>= 0); DOUBLE. Not for money.",
		APIParameterType:   APIParameterTypeFloat64ZP,
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeFloat64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "DOUBLE PRECISION", base.DXDatabaseTypeSQLServer: "FLOAT", base.DXDatabaseTypeMariaDB: "DOUBLE", base.DXDatabaseTypeOracle: "BINARY_DOUBLE"},
	}

	DataTypeBool = DataType{
		Description:        "Boolean true/false; BOOLEAN (BIT on SQL Server, NUMBER(1) on Oracle).",
		APIParameterType:   APIParameterTypeBoolean,
		JSONType:           JSONTypeBoolean,
		GoType:             GoTypeBool,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BOOLEAN", base.DXDatabaseTypeSQLServer: "BIT", base.DXDatabaseTypeMariaDB: "BOOLEAN", base.DXDatabaseTypeOracle: "NUMBER(1)"},
	}

	// DataTypeISO8601 is an instant, and the instant must survive the round trip.
	//
	// # Why MariaDB is text and the other three are not
	//
	// PostgreSQL, SQL Server and Oracle each have a column type that knows what an
	// instant is: TIMESTAMP WITH TIME ZONE, DATETIMEOFFSET, TIMESTAMP WITH TIME
	// ZONE. Write 12:00+07:00 and read back the same instant, whatever zone the
	// reader is in.
	//
	// MariaDB and MySQL have no such type. There are two candidates and neither
	// works:
	//
	//   DATETIME  stores the wall-clock digits it was handed and nothing else. The
	//             offset is dropped on write, silently. Two processes in different
	//             zones write "12:00" for instants seven hours apart and the column
	//             cannot tell them apart afterwards -- the information is gone, not
	//             merely unlabelled.
	//   TIMESTAMP normalises to UTC internally, which sounds right, but renders
	//             through the READER's session time_zone. The value you get back
	//             depends on the connection that asks, not on the row. Measured:
	//             written at session +07:00, the same row reads 12:00 at +07:00 and
	//             05:00 at +00:00. It also spans only 1970-2038.
	//
	// So this type used to map to DATETIME on MariaDB, which meant a type whose
	// whole promise is "instant with timezone" quietly kept the zone on three
	// engines and discarded it on the fourth. No error, no warning, and nothing
	// visible until a writer and a reader disagree about which zone the bare digits
	// were in -- at which point every value is wrong by an offset and there is no
	// way to tell by how much, because the offset was never recorded.
	//
	// Text is the only representation MariaDB has that can carry an offset at all,
	// so on MariaDB this type is ISO-8601 text and the DDL is VARCHAR(35). That is
	// a deliberate per-engine divergence: identical MEANING on all four, at the
	// cost of a different column type on one, which is the correct trade when the
	// alternative is a type that keeps its promise on three engines out of four.
	//
	// # The invariant that makes text safe
	//
	// Stored UTC-normalised and fixed-width -- "2006-01-02T15:04:05.000000000Z",
	// always nine fractional digits, never trimmed. That is what makes byte order
	// equal chronological order, which ORDER BY, BETWEEN, MIN and MAX on this
	// column all silently depend on. Mixed offsets would break all of them: with
	// "12:00:00+07:00" and "06:00:00Z" -- the same instant -- a string comparison
	// answers by the leading digit and gets it backwards. Trimmed fractions break
	// them too, because "…:05.5Z" sorts after "…:05.50Z" while being equal.
	//
	// Normalising to UTC discards the caller's original offset. That is the same
	// thing PostgreSQL's TIMESTAMP WITH TIME ZONE does, and it is not a loss: this
	// type is defined as an instant, and the instant is exact. A column that must
	// remember which zone a human was standing in needs a second column for it.
	//
	// The write path enforces this. models.NormalizeFieldValueForDBType converts a
	// time.Time to that layout when this type lands on a text column, because
	// go-sql-driver/mysql would otherwise encode it as a MySQL datetime literal --
	// "2026-08-31 12:00:00", no offset, not ISO-8601 -- which is worse than the
	// DATETIME this replaced. VARCHAR(35) rather than (30) leaves room for an
	// offset-bearing value written by something outside dxlib; such a value is
	// still read correctly, it just does not sort against the normalised ones.
	DataTypeISO8601 = DataType{
		Description:        "Instant with timezone (RFC3339/ISO-8601); JSON string, Go time.Time; TIMESTAMP WITH TIME ZONE, ISO-8601 text on MariaDB, which has no offset-bearing type.",
		APIParameterType:   APIParameterTypeISO8601,
		JSONType:           JSONTypeString,
		GoType:             GoTypeTime,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "TIMESTAMP WITH TIME ZONE", base.DXDatabaseTypeSQLServer: "DATETIMEOFFSET", base.DXDatabaseTypeMariaDB: "VARCHAR(35)", base.DXDatabaseTypeOracle: "TIMESTAMP WITH TIME ZONE"},
	}

	// ISO8601TextLayout is the on-disk form of DataTypeISO8601 wherever it is
	// stored as text. Fixed width and UTC, so byte order is chronological order.
	// See the comment on DataTypeISO8601 for why that matters.
	ISO8601TextLayout = "2006-01-02T15:04:05.000000000Z07:00"

	DataTypeDate = DataType{
		Description:        "Calendar date, no time; JSON string YYYY-MM-DD, Go time.Time; DATE.",
		APIParameterType:   APIParameterTypeDate,
		JSONType:           JSONTypeString,
		GoType:             GoTypeTime,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "DATE", base.DXDatabaseTypeSQLServer: "DATE", base.DXDatabaseTypeMariaDB: "DATE", base.DXDatabaseTypeOracle: "DATE"},
	}

	DataTypeTime = DataType{
		Description:        "Time of day, no date; JSON string HH:MM:SS, Go time.Time; TIME (DATE on Oracle).",
		APIParameterType:   APIParameterTypeTime,
		JSONType:           JSONTypeString,
		GoType:             GoTypeTime,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "TIME", base.DXDatabaseTypeSQLServer: "TIME", base.DXDatabaseTypeMariaDB: "TIME", base.DXDatabaseTypeOracle: "DATE"},
	}

	DataTypeJSON = DataType{
		Description:        "Structured JSON object; JSONB native, Go map. For schemaless/nested data.",
		APIParameterType:   APIParameterTypeJSON,
		JSONType:           JSONTypeObject,
		GoType:             GoTypeMapStringInterface,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "JSONB", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeJSONPassthrough = DataType{
		Description:        "JSON object stored verbatim (no re-serialization); JSONB, preserves exact client bytes.",
		APIParameterType:   APIParameterTypeJSONPassthrough,
		JSONType:           JSONTypeObject,
		GoType:             GoTypeMapStringInterface,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "JSONB", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeArray = DataType{
		Description:        "JSON array of mixed values; JSONB, Go []interface{}.",
		APIParameterType:   APIParameterTypeArray,
		JSONType:           JSONTypeArray,
		GoType:             GoTypeSliceInterface,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "JSONB", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeArrayString = DataType{
		Description:        "Array of strings; native TEXT[] on PostgreSQL, JSON elsewhere; Go []string.",
		APIParameterType:   APIParameterTypeArrayString,
		JSONType:           JSONTypeArray,
		GoType:             GoTypeSliceString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "TEXT[]", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeArrayInt64 = DataType{
		Description:        "Array of 64-bit integers; native BIGINT[] on PostgreSQL, JSON elsewhere; Go []int64.",
		APIParameterType:   APIParameterTypeArrayInt64,
		JSONType:           JSONTypeArray,
		GoType:             GoTypeSliceInt64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGINT[]", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeArrayJSONTemplate = DataType{
		Description:        "Array of JSON objects (templated rows); JSONB, Go []map.",
		APIParameterType:   APIParameterTypeArrayJSONTemplate,
		JSONType:           JSONTypeArray,
		GoType:             GoTypeSliceMapStringInterface,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "JSONB", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeMapStringString = DataType{
		Description:        "String-to-string map; JSONB object, Go map[string]string.",
		APIParameterType:   APIParameterTypeMapStringString,
		JSONType:           JSONTypeObject,
		GoType:             GoTypeMapStringString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "JSONB", base.DXDatabaseTypeSQLServer: "NVARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "JSON", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeSerial = DataType{
		Description:        "32-bit DB auto-increment primary key (SERIAL/IDENTITY); column-only, not an API param. Prefer BigSerial (64-bit) for new PKs.",
		APIParameterType:   "serial",
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "SERIAL", base.DXDatabaseTypeSQLServer: "INT IDENTITY(1,1)", base.DXDatabaseTypeMariaDB: "INT AUTO_INCREMENT", base.DXDatabaseTypeOracle: "NUMBER GENERATED BY DEFAULT AS IDENTITY"},
	}

	// DataTypeBigSerial is a 64-bit auto-increment primary key (the BIGINT counterpart
	// of DataTypeSerial). Column-only (like Serial): no Types-map / validation entry.
	DataTypeBigSerial = DataType{
		Description:        "64-bit DB auto-increment primary key (BIGSERIAL/IDENTITY); column-only. The default surrogate id.",
		APIParameterType:   "bigserial",
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt64,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "BIGSERIAL", base.DXDatabaseTypeSQLServer: "BIGINT IDENTITY(1,1)", base.DXDatabaseTypeMariaDB: "BIGINT AUTO_INCREMENT", base.DXDatabaseTypeOracle: "NUMBER(19) GENERATED BY DEFAULT AS IDENTITY"},
	}

	DataTypeInt = DataType{
		Description:        "32-bit integer (INT); the bare-named alias of Int32.",
		APIParameterType:   "int",
		JSONType:           JSONTypeNumber,
		GoType:             GoTypeInt32,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "INT", base.DXDatabaseTypeSQLServer: "INT", base.DXDatabaseTypeMariaDB: "INT", base.DXDatabaseTypeOracle: "NUMBER(10)"},
	}

	DataTypeString1 = DataType{
		Description:        "Text up to 1 char (VARCHAR(1)); one-char codes/flags.",
		APIParameterType:   "string1",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(1)", base.DXDatabaseTypeSQLServer: "VARCHAR(1)", base.DXDatabaseTypeMariaDB: "VARCHAR(1)", base.DXDatabaseTypeOracle: "VARCHAR2(1)"},
	}

	DataTypeString5 = DataType{
		Description:        "Text up to 5 chars (VARCHAR(5)).",
		APIParameterType:   "string5",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(5)", base.DXDatabaseTypeSQLServer: "VARCHAR(5)", base.DXDatabaseTypeMariaDB: "VARCHAR(5)", base.DXDatabaseTypeOracle: "VARCHAR2(5)"},
	}

	DataTypeString10 = DataType{
		Description:        "Text up to 10 chars (VARCHAR(10)).",
		APIParameterType:   "string10",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(10)", base.DXDatabaseTypeSQLServer: "VARCHAR(10)", base.DXDatabaseTypeMariaDB: "VARCHAR(10)", base.DXDatabaseTypeOracle: "VARCHAR2(10)"},
	}

	DataTypeString20 = DataType{
		Description:        "Text up to 20 chars (VARCHAR(20)).",
		APIParameterType:   "string20",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(20)", base.DXDatabaseTypeSQLServer: "VARCHAR(20)", base.DXDatabaseTypeMariaDB: "VARCHAR(20)", base.DXDatabaseTypeOracle: "VARCHAR2(20)"},
	}

	DataTypeString30 = DataType{
		Description:        "Text up to 30 chars (VARCHAR(30)).",
		APIParameterType:   "string30",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(30)", base.DXDatabaseTypeSQLServer: "VARCHAR(30)", base.DXDatabaseTypeMariaDB: "VARCHAR(30)", base.DXDatabaseTypeOracle: "VARCHAR2(30)"},
	}

	DataTypeString50 = DataType{
		Description:        "Text up to 50 chars (VARCHAR(50)).",
		APIParameterType:   "string50",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(50)", base.DXDatabaseTypeSQLServer: "VARCHAR(50)", base.DXDatabaseTypeMariaDB: "VARCHAR(50)", base.DXDatabaseTypeOracle: "VARCHAR2(50)"},
	}

	DataTypeString100 = DataType{
		Description:        "Text up to 100 chars (VARCHAR(100)).",
		APIParameterType:   "string100",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(100)", base.DXDatabaseTypeSQLServer: "VARCHAR(100)", base.DXDatabaseTypeMariaDB: "VARCHAR(100)", base.DXDatabaseTypeOracle: "VARCHAR2(100)"},
	}

	DataTypeString255 = DataType{
		Description:        "Text up to 255 chars; index-safe key on all engines (255B < 900 SQL Server; 1020B < 3072 MariaDB). The platform uid width.",
		APIParameterType:   "string255",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR255, base.DXDatabaseTypeSQLServer: VARCHAR255, base.DXDatabaseTypeMariaDB: VARCHAR255, base.DXDatabaseTypeOracle: "VARCHAR2(255)"},
	}

	DataTypeString256 = DataType{
		Description:        "Text up to 256 chars (VARCHAR(256)).",
		APIParameterType:   "string256",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(256)", base.DXDatabaseTypeSQLServer: "VARCHAR(256)", base.DXDatabaseTypeMariaDB: "VARCHAR(256)", base.DXDatabaseTypeOracle: "VARCHAR2(256)"},
	}

	DataTypeString500 = DataType{
		Description:        "Text up to 500 chars (VARCHAR(500)).",
		APIParameterType:   "string500",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(500)", base.DXDatabaseTypeSQLServer: "VARCHAR(500)", base.DXDatabaseTypeMariaDB: "VARCHAR(500)", base.DXDatabaseTypeOracle: "VARCHAR2(500)"},
	}

	// DataTypeString512 is a 512-char string — index-safe as a key on all four engines
	// (MariaDB utf8mb4 512*4=2048B<3072B; SQL Server 512B<900B), unlike UID's 1024.
	DataTypeString512 = DataType{
		Description:        "Text up to 512 chars; index-safe key on all four engines, unlike the wider UID(1024).",
		APIParameterType:   "string512",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(512)", base.DXDatabaseTypeSQLServer: "VARCHAR(512)", base.DXDatabaseTypeMariaDB: "VARCHAR(512)", base.DXDatabaseTypeOracle: "VARCHAR2(512)"},
	}

	DataTypeString1024 = DataType{
		Description:        "Text up to 1024 chars (VARCHAR(1024)). NOT index-safe as a key on SQL Server (> 900B); use String255/512 for keys.",
		APIParameterType:   "string1024",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: VARCHAR1024, base.DXDatabaseTypeSQLServer: VARCHAR1024, base.DXDatabaseTypeMariaDB: VARCHAR1024, base.DXDatabaseTypeOracle: "VARCHAR2(1024)"},
	}

	DataTypeString2048 = DataType{
		Description:        "Text up to 2048 chars (VARCHAR(2048)).",
		APIParameterType:   "string2048",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(2048)", base.DXDatabaseTypeSQLServer: "VARCHAR(2048)", base.DXDatabaseTypeMariaDB: "VARCHAR(2048)", base.DXDatabaseTypeOracle: "VARCHAR2(2048)"},
	}

	DataTypeString8096 = DataType{
		Description:        "Long text up to 8096 chars; VARCHAR(MAX) on SQL Server (its VARCHAR cap is 8000), TEXT (MariaDB) / CLOB (Oracle).",
		APIParameterType:   "string8096",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(8096)", base.DXDatabaseTypeSQLServer: "VARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "TEXT", base.DXDatabaseTypeOracle: "CLOB"},
	}

	DataTypeString32768 = DataType{
		Description:        "Very long text; VARCHAR(MAX) (SQL Server) / TEXT (MariaDB) / CLOB (Oracle).",
		APIParameterType:   "string32768",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "VARCHAR(32768)", base.DXDatabaseTypeSQLServer: "VARCHAR(MAX)", base.DXDatabaseTypeMariaDB: "TEXT", base.DXDatabaseTypeOracle: "CLOB"},
	}

	// Deprecated: use DataTypeMoney (NUMERIC(23,4)) for monetary values; this legacy
	// NUMERIC(30,4) type is string-backed with no decimal semantics and is kept only
	// for backward compatibility.
	DataTypeDecimal = DataType{
		Description:        "Deprecated: use Money (NUMERIC(23,4)) for monetary values. Legacy fixed-point NUMERIC(30,4) backed by a plain Go string with no decimal semantics; kept only for compatibility.",
		APIParameterType:   "decimal",
		JSONType:           JSONTypeString,
		GoType:             GoTypeString,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "NUMERIC(30,4)", base.DXDatabaseTypeSQLServer: "DECIMAL(30,4)", base.DXDatabaseTypeMariaDB: "DECIMAL(30,4)", base.DXDatabaseTypeOracle: "NUMBER(30,4)"},
	}

	// DataTypeMoney — fixed-point monetary amount, NUMERIC(23,4) on every engine (19
	// integer digits cover 10,000-trillion needs + 4 decimals; fits SQL Server max 38,
	// MariaDB 65, Oracle 38, PostgreSQL unbounded). JSON string ("1250000.375") for JS
	// precision; Go shopspring decimal.Decimal. Currency (fixed or companion-field) is
	// metadata on the data-model field, not the type.
	DataTypeMoney = DataType{
		Description:        "Fixed-point monetary amount - essentially a number, but stored as NUMERIC(23,4) and carried as a JSON string (JS loses precision on large/decimal numbers) and as shopspring decimal.Decimal in Go for exact arithmetic. Currency is field metadata, not part of the type.",
		APIParameterType:   APIParameterTypeMoney,
		JSONType:           JSONTypeString,
		GoType:             GoTypeMoney,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "NUMERIC(23,4)", base.DXDatabaseTypeSQLServer: "DECIMAL(23,4)", base.DXDatabaseTypeMariaDB: "DECIMAL(23,4)", base.DXDatabaseTypeOracle: "NUMBER(23,4)"},
	}

	DataTypeGeometryPoint = DataType{
		Description:        "Geographic point (lon/lat, SRID 4326); native spatial type per engine (geometry/GEOGRAPHY/POINT/SDO_GEOMETRY), Go map.",
		APIParameterType:   "geometry_point",
		JSONType:           JSONTypeObject,
		GoType:             GoTypeMapStringInterface,
		TypeByDatabaseType: map[base.DXDatabaseType]string{base.DXDatabaseTypePostgreSQL: "geometry(Point, 4326)", base.DXDatabaseTypeSQLServer: "GEOGRAPHY", base.DXDatabaseTypeMariaDB: "POINT SRID 4326", base.DXDatabaseTypeOracle: "SDO_GEOMETRY"},
	}
)

var (
	DataTypes = []DataType{

		DataTypeString,
		DataTypeProtectedString,
		DataTypeProtectedSQLString,
		DataTypeProtectedNonEmptyString,
		DataTypeNullableString,
		DataTypeNonEmptyString,
		DataTypeEmail,
		DataTypePhoneNumber,
		DataTypeNPWP,

		DataTypeInt32,
		DataTypeInt32P,
		DataTypeInt32ZP,
		DataTypeNullableInt32,

		DataTypeInt64,
		DataTypeInt64P,
		DataTypeInt64ZP,
		DataTypeNullableInt64,

		DataTypeFloat32,
		DataTypeFloat32P,
		DataTypeFloat32ZP,

		DataTypeFloat64,
		DataTypeFloat64P,
		DataTypeFloat64ZP,

		DataTypeMoney,

		DataTypeBool,

		DataTypeISO8601,
		DataTypeDate,
		DataTypeTime,

		DataTypeJSON,
		DataTypeJSONPassthrough,

		DataTypeArray,
		DataTypeArrayString,
		DataTypeArrayInt64,
		DataTypeArrayJSONTemplate,
	}

	Types = map[APIParameterType]DataType{

		APIParameterTypeString:                  DataTypeString,
		APIParameterTypeProtectedString:         DataTypeProtectedString,
		APIParameterTypeProtectedSQLString:      DataTypeProtectedSQLString,
		APIParameterTypeProtectedNonEmptyString: DataTypeProtectedNonEmptyString,
		APIParameterTypeNullableString:          DataTypeNullableString,
		APIParameterTypeNonEmptyString:          DataTypeNonEmptyString,
		APIParameterTypeEmail:                   DataTypeEmail,
		APIParameterTypePhoneNumber:             DataTypePhoneNumber,
		APIParameterTypeNPWP:                    DataTypeNPWP,

		APIParameterTypeInt32:         DataTypeInt32,
		APIParameterTypeInt32P:        DataTypeInt32P,
		APIParameterTypeInt32ZP:       DataTypeInt32ZP,
		APIParameterTypeNullableInt32: DataTypeNullableInt32,
		APIParameterTypeInt64:         DataTypeInt64,
		APIParameterTypeInt64P:        DataTypeInt64P,
		APIParameterTypeInt64ZP:       DataTypeInt64ZP,
		APIParameterTypeNullableInt64: DataTypeNullableInt64,
		APIParameterTypeID:            DataTypeID,

		APIParameterTypeFloat32:   DataTypeFloat32,
		APIParameterTypeFloat32P:  DataTypeFloat32P,
		APIParameterTypeFloat32ZP: DataTypeFloat32ZP,

		APIParameterTypeFloat64:   DataTypeFloat64,
		APIParameterTypeFloat64P:  DataTypeFloat64P,
		APIParameterTypeFloat64ZP: DataTypeFloat64ZP,

		APIParameterTypeMoney: DataTypeMoney,

		APIParameterTypeBoolean: DataTypeBool,

		APIParameterTypeISO8601: DataTypeISO8601,
		APIParameterTypeDate:    DataTypeDate,
		APIParameterTypeTime:    DataTypeTime,

		APIParameterTypeJSON:            DataTypeJSON,
		APIParameterTypeJSONPassthrough: DataTypeJSONPassthrough,

		APIParameterTypeArray:             DataTypeArray,
		APIParameterTypeArrayString:       DataTypeArrayString,
		APIParameterTypeArrayInt64:        DataTypeArrayInt64,
		APIParameterTypeArrayJSONTemplate: DataTypeArrayJSONTemplate,

		APIParameterTypeMapStringString: DataTypeMapStringString,
	}
)