Struct IntermediateField 

pub struct IntermediateField {

    pub name: String,
    pub field_type: String,
    pub nullable: bool,
    pub description: Option<String>,
    pub directives: Option<Vec<IntermediateAppliedDirective>>,
    pub function: Option<String>,
    pub deprecated: Option<IntermediateDeprecation>,
    pub requires_scope: Option<String>,
    pub on_deny: Option<String>,
    pub vector_config: Option<VectorConfig>,
    pub vector_distance: Option<String>,
    pub authorize: Option<bool>,
    pub hierarchy: Option<String>,
    pub unique: Option<bool>,
    pub localized: bool,
}

Field definition in intermediate format

NOTE: Uses type field (not field_type) This is the language-agnostic format. Rust conversion happens in converter.

Fields

name: String

Field name (e.g., “id”)

field_type: String

Field type name (e.g., “Int”, “String”, “User”)

Language-agnostic: All languages use “type”, not “field_type”

nullable: bool

Is field nullable?

description: Option<String>

Field description (from docstring)

directives: Option<Vec<IntermediateAppliedDirective>>

Applied directives (e.g., @deprecated)

function: Option<String>

Declarable only to be refused, with a reason (#1329).

A root query field can be backed by a function; a nested field cannot, and this key exists so that saying so is a sentence rather than unknown field \function``. It is the natural next thing to try after declaring one on a query, and the difference between the two messages is the difference between an author who learns the rule and one who concludes the feature is broken.

The refusal is not a limitation to be lifted later. A nested resolver runs once per row, so a function there is an N+1 measured in V8 isolates — at ~5–8 ms each, a hundred-row page costs most of a second before the function does any work. Root-only makes “one invocation per query” a property of the shape; see QueryDefinition::function for the rest of the reasoning.

deprecated: Option<IntermediateDeprecation>

Deprecation information for this field.

The first-class spelling, matching IntermediateQuery, IntermediateInputField, IntermediateSubscription and enum values. Field deprecation used to be reachable only through a @deprecated entry in directives, so a field was the one construct that could not say it plainly — and both the Python and TypeScript SDKs emitted this key, which deny_unknown_fields turned into a refusal of the whole document (#1025).

The directive spelling still works; this takes precedence when both are present.

requires_scope: Option<String>

Scope required to access this field (field-level access control)

When set, users must have this scope in their JWT to query this field. Supports patterns like “read:Type.field” or custom scopes like “hr:view_pii”.

Example

{
  "name": "salary",
  "type": "Int",
  "nullable": false,
  "requires_scope": "read:Employee.salary"
}

on_deny: Option<String>

Policy when the user lacks requires_scope: "reject" (default) or "mask".

vector_config: Option<VectorConfig>

pgvector configuration for Vector fields (#386).

Required when type is "Vector" (the compiler needs the dimension for DDL and request-time validation); an error on any other type. Reuses the compiled-schema type so the authored and compiled shapes cannot drift.

Example

{
  "name": "embedding",
  "type": "Vector",
  "nullable": false,
  "vector_config": { "dimensions": 1536, "index_type": "hnsw", "distance_metric": "cosine" }
}

vector_distance: Option<String>

Names the vector field whose search distance this field carries (#959).

Example

{
  "name": "similarity",
  "type": "Float",
  "nullable": false,
  "vector_distance": "embedding"
}

authorize: Option<bool>

Whether this field is gated by the dynamic field authorizer at runtime.

When true, the compiled field is marked policy-gated (FieldDefinition.authorize) and a configured FieldAuthorizer is consulted per row. Defaults to false when absent.

Example

{
  "name": "email",
  "type": "String",
  "nullable": true,
  "authorize": true
}

hierarchy: Option<String>

Named hierarchy reference for ID-based ltree operators. References a key in the hierarchies config map.

unique: Option<bool>

Whether this field’s column is unique over the type’s relation.

Declares the fact a to-one relationship joining on this field needs, and without which the schema is refused at load; see FieldDefinition::is_unique_key for why the entity identity is exempt and pk_<type> is not.

Option<bool> rather than bool for the reason authorize is: absent and false reach the converter as the same compiled value, but the key is then omitted from a re-emitted document rather than written back as false on every field in the schema.

Example

{
  "name": "identifier",
  "type": "String",
  "nullable": false,
  "unique": true
}

localized: bool

A localized String (#1513): stored as a locale map ({"fr-FR": "Pomme", ...}) and returned as the request locale’s label. Emitted by the SDKs’ Localized type.

Trait Implementations

impl Clone for IntermediateField

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IntermediateField

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IntermediateField

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for IntermediateField

impl PartialEq for IntermediateField

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for IntermediateField

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IntermediateField