infrahub-server 1.2.11__py3-none-any.whl → 1.3.0__py3-none-any.whl

infrahub/core/relationship/constraints/peer_parent.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping
+
+from infrahub.exceptions import ValidationError
+
+from .interface import RelationshipManagerConstraintInterface
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import MainSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import RelationshipManager
+
+
+class RelationshipPeerParentConstraint(RelationshipManagerConstraintInterface):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    async def _check_relationship_peers_parent(
+        self, relm: RelationshipManager, parent_rel_name: str, node: Node, peers: Mapping[str, Node]
+    ) -> None:
+        """Validate that all peers of a given `relm` have the same parent for the given `relationship_name`."""
+        node_parent = await node.get_parent_relationship_peer(db=self.db, name=parent_rel_name)
+        if not node_parent:
+            # If the schema is properly validated we are not expecting this to happen
+            raise ValidationError(f"Node {node.id} ({node.get_kind()}) does not have a parent peer")
+
+        parents: set[str] = {node_parent.id}
+        for peer in peers.values():
+            parent = await peer.get_parent_relationship_peer(db=self.db, name=parent_rel_name)
+            if not parent:
+                # If the schema is properly validated we are not expecting this to happen
+                raise ValidationError(f"Peer {peer.id} ({peer.get_kind()}) does not have a parent peer")
+            parents.add(parent.id)
+
+        if len(parents) != 1:
+            raise ValidationError(
+                f"All the elements of the '{relm.name}' relationship on node {node.id} ({node.get_kind()}) must have the same parent "
+                "as the node"
+            )
+
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
+        if not relm.schema.common_parent:
+            return
+
+        peers = await relm.get_peers(db=self.db)
+        if not peers:
+            return
+
+        await self._check_relationship_peers_parent(
+            relm=relm, parent_rel_name=relm.schema.common_parent, node=node, peers=peers
+        )

infrahub/core/relationship/constraints/peer_relatives.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Mapping
+
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.exceptions import ValidationError
+
+from .interface import RelationshipManagerConstraintInterface
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import MainSchemaTypes, NonGenericSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import RelationshipManager
+
+
+@dataclass
+class NodeToValidate:
+    uuid: str
+    relative_uuids: set[str]
+    schema: NonGenericSchemaTypes
+
+
+class RelationshipPeerRelativesConstraint(RelationshipManagerConstraintInterface):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    async def _check_relationship_peers_relatives(
+        self,
+        relm: RelationshipManager,
+        node_schema: MainSchemaTypes,
+        peers: Mapping[str, Node],
+        relationship_name: str,
+    ) -> None:
+        """Validate that all peers of a given `relm` have the same set of relatives (aka peers) for the given `relationship_name`."""
+        nodes_to_validate: list[NodeToValidate] = []
+
+        for peer in peers.values():
+            peer_schema = peer.get_schema()
+            peer_relm: RelationshipManager = getattr(peer, relationship_name)
+            peer_relm_peers = await peer_relm.get_peers(db=self.db)
+
+            nodes_to_validate.append(
+                NodeToValidate(
+                    uuid=peer.id, relative_uuids={n.id for n in peer_relm_peers.values()}, schema=peer_schema
+                )
+            )
+
+        relative_uuids = nodes_to_validate[0].relative_uuids
+        for node in nodes_to_validate[1:]:
+            if node.relative_uuids != relative_uuids:
+                raise ValidationError(
+                    f"All the elements of the '{relm.name}' relationship on node {node.uuid} ({node_schema.kind}) must have the same set of peers "
+                    f"for their '{node.schema.kind}.{relationship_name}' relationship"
+                )
+
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
+        if relm.schema.cardinality != RelationshipCardinality.MANY or not relm.schema.common_relatives:
+            return
+
+        peers = await relm.get_peers(db=self.db)
+        if not peers:
+            return
+
+        for rel_name in relm.schema.common_relatives:
+            await self._check_relationship_peers_relatives(
+                relm=relm, node_schema=node_schema, peers=peers, relationship_name=rel_name
+            )

infrahub/core/relationship/constraints/profiles_kind.py

@@ -23,7 +23,7 @@ class RelationshipProfilesKindConstraint(RelationshipManagerConstraintInterface)
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         if relm.name != "profiles" or not isinstance(node_schema, NodeSchema):
             return
 

infrahub/core/relationship/model.py

@@ -494,7 +494,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             peer_fields = {
                 key: value
                 for key, value in fields.items()
-                if not key.startswith(PREFIX_PROPERTY) or not key == "__typename"
+                if not key.startswith(PREFIX_PROPERTY) or key != "__typename"
             }
             rel_fields = {
                 key.replace(PREFIX_PROPERTY, ""): value
@@ -789,6 +789,9 @@ class RelationshipManager:
 
         return len(self._relationships)
 
+    def validate(self) -> None:
+        self._relationships.validate()
+
     @overload
     async def get_peer(
         self,

infrahub/core/schema/__init__.py

@@ -21,7 +21,8 @@ from .profile_schema import ProfileSchema
 from .relationship_schema import RelationshipSchema
 from .template_schema import TemplateSchema
 
-MainSchemaTypes: TypeAlias = NodeSchema | GenericSchema | ProfileSchema | TemplateSchema
+NonGenericSchemaTypes: TypeAlias = NodeSchema | ProfileSchema | TemplateSchema
+MainSchemaTypes: TypeAlias = NonGenericSchemaTypes | GenericSchema
 
 
 # -----------------------------------------------------

infrahub/core/schema/attribute_parameters.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import sys
+from typing import Self
+
+from pydantic import ConfigDict, Field, model_validator
+
+from infrahub import config
+from infrahub.core.constants.schema import UpdateSupport
+from infrahub.core.models import HashableModel
+
+
+def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParameters]:
+    param_classes: dict[str, type[AttributeParameters]] = {
+        "NumberPool": NumberPoolParameters,
+        "Text": TextAttributeParameters,
+        "TextArea": TextAttributeParameters,
+        "Number": NumberAttributeParameters,
+    }
+    return param_classes.get(kind, AttributeParameters)
+
+
+class AttributeParameters(HashableModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class TextAttributeParameters(AttributeParameters):
+    regex: str | None = Field(
+        default=None,
+        description="Regular expression that attribute value must match if defined",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    min_length: int | None = Field(
+        default=None,
+        description="Set a minimum number of characters allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    max_length: int | None = Field(
+        default=None,
+        description="Set a maximum number of characters allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+    @model_validator(mode="after")
+    def validate_min_max(self) -> Self:
+        if (
+            config.SETTINGS.initialized
+            and config.SETTINGS.main.schema_strict_mode
+            and self.min_length is not None
+            and self.max_length is not None
+        ):
+            if self.min_length > self.max_length:
+                raise ValueError(
+                    "`max_length` can't be less than `min_length` when the schema is configured with strict mode"
+                )
+
+        return self
+
+
+class NumberAttributeParameters(AttributeParameters):
+    min_value: int | None = Field(
+        default=None,
+        description="Set a minimum value allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    max_value: int | None = Field(
+        default=None,
+        description="Set a maximum value allowed.",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    excluded_values: str | None = Field(
+        default=None,
+        description="List of values or range of values not allowed for the attribute, format is: '100,150-200,280,300-400'",
+        pattern=r"^(\d+(?:-\d+)?)(?:,\d+(?:-\d+)?)*$",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+    @model_validator(mode="after")
+    def validate_ranges(self) -> Self:
+        ranges = self.get_excluded_ranges()
+        for i, (start_range_1, end_range_1) in enumerate(ranges):
+            if start_range_1 > end_range_1:
+                raise ValueError("`start_range` can't be less than `end_range`")
+
+            # Check for overlapping ranges
+            for start_range_2, end_range_2 in ranges[i + 1 :]:
+                if not (end_range_1 < start_range_2 or start_range_1 > end_range_2):
+                    raise ValueError("Excluded ranges cannot overlap")
+
+        return self
+
+    @model_validator(mode="after")
+    def validate_min_max(self) -> Self:
+        if (
+            config.SETTINGS.initialized
+            and config.SETTINGS.main.schema_strict_mode
+            and self.min_value is not None
+            and self.max_value is not None
+        ):
+            if self.min_value > self.max_value:
+                raise ValueError(
+                    "`max_value` can't be less than `min_value` when the schema is configured with strict mode"
+                )
+
+        return self
+
+    def get_excluded_single_values(self) -> list[int]:
+        if not self.excluded_values:
+            return []
+
+        results = [int(value) for value in self.excluded_values.split(",") if "-" not in value]
+        return results
+
+    def get_excluded_ranges(self) -> list[tuple[int, int]]:
+        if not self.excluded_values:
+            return []
+
+        ranges = []
+        for value in self.excluded_values.split(","):
+            if "-" in value:
+                start, end = map(int, value.split("-"))
+                ranges.append((start, end))
+
+        return ranges
+
+    def is_valid_value(self, value: int) -> bool:
+        if self.min_value is not None and value < self.min_value:
+            return False
+        if self.max_value is not None and value > self.max_value:
+            return False
+        if value in self.get_excluded_single_values():
+            return False
+        for start, end in self.get_excluded_ranges():
+            if start <= value <= end:
+                return False
+        return True
+
+
+class NumberPoolParameters(AttributeParameters):
+    end_range: int = Field(
+        default=sys.maxsize,
+        description="End range for numbers for the associated NumberPool",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    start_range: int = Field(
+        default=1,
+        description="Start range for numbers for the associated NumberPool",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+    number_pool_id: str | None = Field(
+        default=None,
+        description="The ID of the numberpool associated with this attribute",
+        json_schema_extra={"update": UpdateSupport.NOT_SUPPORTED.value},
+    )
+
+    @model_validator(mode="after")
+    def validate_ranges(self) -> Self:
+        if self.start_range > self.end_range:
+            raise ValueError("`start_range` can't be less than `end_range`")
+        return self

infrahub/core/schema/attribute_schema.py

@@ -2,15 +2,23 @@ from __future__ import annotations
 
 import enum
 from enum import Enum
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Self
 
-from pydantic import field_validator, model_validator
+from pydantic import Field, ValidationInfo, field_validator, model_validator
 
 from infrahub import config
+from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.enums import generate_python_enum
 from infrahub.core.query.attribute import default_attribute_query_filter
 from infrahub.types import ATTRIBUTE_KIND_LABELS, ATTRIBUTE_TYPES
 
+from .attribute_parameters import (
+    AttributeParameters,
+    NumberAttributeParameters,
+    NumberPoolParameters,
+    TextAttributeParameters,
+    get_attribute_parameters_class_for_kind,
+)
 from .generated.attribute_schema import GeneratedAttributeSchema
 
 if TYPE_CHECKING:
@@ -21,10 +29,32 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
+def get_attribute_schema_class_for_kind(kind: str) -> type[AttributeSchema]:
+    return attribute_schema_class_by_kind.get(kind, AttributeSchema)
+
+
 class AttributeSchema(GeneratedAttributeSchema):
     _sort_by: list[str] = ["name"]
     _enum_class: type[enum.Enum] | None = None
 
+    @classmethod
+    def model_json_schema(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        schema = super().model_json_schema(*args, **kwargs)
+
+        # Build conditional schema based on attribute_schema_class_by_kind mapping
+        # This override allows people using the Yaml language server to get the correct mappings
+        # for the parameters when selecting the appropriate kind
+        schema["allOf"] = []
+        for kind, schema_class in attribute_schema_class_by_kind.items():
+            schema["allOf"].append(
+                {
+                    "if": {"properties": {"kind": {"const": kind}}},
+                    "then": {"properties": {"parameters": {"$ref": f"#/definitions/{schema_class.__name__}"}}},
+                }
+            )
+
+        return schema
+
     @property
     def is_attribute(self) -> bool:
         return True
@@ -53,16 +83,46 @@ class AttributeSchema(GeneratedAttributeSchema):
 
     @model_validator(mode="before")
     @classmethod
-    def validate_dropdown_choices(cls, values: dict[str, Any]) -> dict[str, Any]:
+    def validate_dropdown_choices(cls, values: Any) -> Any:
         """Validate that choices are defined for a dropdown but not for other kinds."""
-        if values.get("kind") != "Dropdown" and values.get("choices"):
-            raise ValueError(f"Can only specify 'choices' for kind=Dropdown: {values['kind']}")
+        if isinstance(values, dict):
+            kind = values.get("kind")
+            choices = values.get("choices")
+        elif isinstance(values, AttributeSchema):
+            kind = values.kind
+            choices = values.choices
+        else:
+            return values
+        if kind != "Dropdown" and choices:
+            raise ValueError(f"Can only specify 'choices' for kind=Dropdown: {kind}")
 
-        if values.get("kind") == "Dropdown" and not values.get("choices"):
+        if kind == "Dropdown" and not choices:
             raise ValueError("The property 'choices' is required for kind=Dropdown")
 
         return values
 
+    @field_validator("parameters", mode="before")
+    @classmethod
+    def set_parameters_type(cls, value: Any, info: ValidationInfo) -> Any:
+        """Override parameters class if using base AttributeParameters class and should be using a subclass"""
+        kind = info.data["kind"]
+        expected_parameters_class = get_attribute_parameters_class_for_kind(kind=kind)
+        if value is None:
+            return expected_parameters_class()
+        if not isinstance(value, expected_parameters_class) and isinstance(value, AttributeParameters):
+            return expected_parameters_class(**value.model_dump())
+        return value
+
+    @model_validator(mode="after")
+    def validate_parameters(self) -> Self:
+        if isinstance(self.parameters, NumberPoolParameters) and not self.kind == "NumberPool":
+            raise ValueError(f"NumberPoolParameters can't be used as parameters for {self.kind}")
+
+        if isinstance(self.parameters, TextAttributeParameters) and self.kind not in ["Text", "TextArea"]:
+            raise ValueError(f"TextAttributeParameters can't be used as parameters for {self.kind}")
+
+        return self
+
     def get_class(self) -> type[BaseAttribute]:
         return ATTRIBUTE_TYPES[self.kind].get_infrahub_class()
 
@@ -106,7 +166,7 @@ class AttributeSchema(GeneratedAttributeSchema):
 
     def to_node(self) -> dict[str, Any]:
         fields_to_exclude = {"id", "state", "filters"}
-        fields_to_json = {"computed_attribute"}
+        fields_to_json = {"computed_attribute", "parameters"}
         data = self.model_dump(exclude=fields_to_exclude | fields_to_json)
 
         for field_name in fields_to_json:
@@ -117,6 +177,15 @@ class AttributeSchema(GeneratedAttributeSchema):
 
         return data
 
+    def get_regex(self) -> str | None:
+        return self.regex
+
+    def get_min_length(self) -> int | None:
+        return self.min_length
+
+    def get_max_length(self) -> int | None:
+        return self.max_length
+
     async def get_query_filter(
         self,
         name: str,
@@ -144,3 +213,57 @@ class AttributeSchema(GeneratedAttributeSchema):
             partial_match=partial_match,
             support_profiles=support_profiles,
         )
+
+
+class NumberPoolSchema(AttributeSchema):
+    parameters: NumberPoolParameters = Field(
+        default_factory=NumberPoolParameters,
+        description="Extra parameters specific to NumberPool attributes",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+
+class TextAttributeSchema(AttributeSchema):
+    parameters: TextAttributeParameters = Field(
+        default_factory=TextAttributeParameters,
+        description="Extra parameters specific to text attributes",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+    @model_validator(mode="after")
+    def reconcile_parameters(self) -> Self:
+        if self.regex != self.parameters.regex:
+            final_regex = self.parameters.regex if self.parameters.regex is not None else self.regex
+            self.regex = self.parameters.regex = final_regex
+        if self.min_length != self.parameters.min_length:
+            final_min_length = self.parameters.min_length if self.parameters.min_length is not None else self.min_length
+            self.min_length = self.parameters.min_length = final_min_length
+        if self.max_length != self.parameters.max_length:
+            final_max_length = self.parameters.max_length if self.parameters.max_length is not None else self.max_length
+            self.max_length = self.parameters.max_length = final_max_length
+        return self
+
+    def get_regex(self) -> str | None:
+        return self.parameters.regex
+
+    def get_min_length(self) -> int | None:
+        return self.parameters.min_length
+
+    def get_max_length(self) -> int | None:
+        return self.parameters.max_length
+
+
+class NumberAttributeSchema(AttributeSchema):
+    parameters: NumberAttributeParameters = Field(
+        default_factory=NumberAttributeParameters,
+        description="Extra parameters specific to number attributes",
+        json_schema_extra={"update": UpdateSupport.VALIDATE_CONSTRAINT.value},
+    )
+
+
+attribute_schema_class_by_kind: dict[str, type[AttributeSchema]] = {
+    "NumberPool": NumberPoolSchema,
+    "Text": TextAttributeSchema,
+    "TextArea": TextAttributeSchema,
+    "Number": NumberAttributeSchema,
+}

infrahub/core/schema/basenode_schema.py

@@ -13,7 +13,7 @@ from pydantic import field_validator
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
 from infrahub.core.models import HashableModel, HashableModelDiff
 
-from .attribute_schema import AttributeSchema
+from .attribute_schema import AttributeSchema, get_attribute_schema_class_for_kind
 from .generated.base_node_schema import GeneratedBaseNodeSchema
 from .relationship_schema import RelationshipSchema
 
@@ -74,6 +74,30 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         Be careful hash generated from hash() have a salt by default and they will not be the same across run"""
         return hash(self.get_hash())
 
+    @field_validator("attributes", mode="before")
+    @classmethod
+    def set_attribute_type(cls, raw_attributes: Any) -> Any:
+        if not isinstance(raw_attributes, list):
+            return raw_attributes
+        attribute_schemas_with_types: list[Any] = []
+        for raw_attr in raw_attributes:
+            if not isinstance(raw_attr, (dict, AttributeSchema)):
+                attribute_schemas_with_types.append(raw_attr)
+                continue
+            if isinstance(raw_attr, dict):
+                kind = raw_attr.get("kind")
+                attribute_type_class = get_attribute_schema_class_for_kind(kind=kind)
+                attribute_schemas_with_types.append(attribute_type_class(**raw_attr))
+                continue
+
+            expected_attr_schema_class = get_attribute_schema_class_for_kind(kind=raw_attr.kind)
+            if not isinstance(raw_attr, expected_attr_schema_class):
+                final_attr = expected_attr_schema_class(**raw_attr.model_dump())
+            else:
+                final_attr = raw_attr
+            attribute_schemas_with_types.append(final_attr)
+        return attribute_schemas_with_types
+
     def to_dict(self) -> dict:
         data = self.model_dump(
             exclude_unset=True, exclude_none=True, exclude_defaults=True, exclude={"attributes", "relationships"}
@@ -362,7 +386,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.display_labels:
             return None
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         for item in self.display_labels:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
@@ -377,7 +401,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.human_friendly_id:
             return None
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         for item in self.human_friendly_id:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields

infrahub/core/schema/definitions/core/__init__.py

@@ -1,5 +1,17 @@
 from typing import Any
 
+from infrahub.actions.schema import (
+    core_action,
+    core_generator_action,
+    core_group_action,
+    core_group_trigger_rule,
+    core_node_trigger_attribute_match,
+    core_node_trigger_match,
+    core_node_trigger_relationship_match,
+    core_node_trigger_rule,
+    core_trigger_rule,
+)
+
 from ...generic_schema import GenericSchema
 from ...node_schema import NodeSchema
 from .account import (
@@ -16,7 +28,13 @@ from .check import core_check_definition
 from .core import core_node, core_task_target
 from .generator import core_generator_definition, core_generator_instance
 from .graphql_query import core_graphql_query
-from .group import core_generator_group, core_graphql_query_group, core_group, core_standard_group
+from .group import (
+    core_generator_group,
+    core_graphql_query_group,
+    core_group,
+    core_repository_group,
+    core_standard_group,
+)
 from .ipam import builtin_ip_address, builtin_ip_prefix, builtin_ipam, core_ipam_namespace
 from .lineage import lineage_owner, lineage_source
 from .menu import generic_menu_item, menu_item
@@ -69,6 +87,9 @@ from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
 
 core_models_mixed: dict[str, list] = {
     "generics": [
+        core_action,
+        core_trigger_rule,
+        core_node_trigger_match,
         core_node,
         lineage_owner,
         core_profile_schema_definition,
@@ -97,12 +118,19 @@ core_models_mixed: dict[str, list] = {
     ],
     "nodes": [
         menu_item,
+        core_group_action,
         core_standard_group,
         core_generator_group,
         core_graphql_query_group,
+        core_repository_group,
         builtin_tag,
         core_account,
         core_account_token,
+        core_generator_action,
+        core_group_trigger_rule,
+        core_node_trigger_rule,
+        core_node_trigger_attribute_match,
+        core_node_trigger_relationship_match,
         core_password_credential,
         core_refresh_token,
         core_proposed_change,