Struct PluginV1 

pub struct PluginV1<P>
where
    P: GtsSchema,
{
    pub id: GtsInstanceId,
    pub vendor: String,
    pub priority: i16,
    pub properties: P,
}

Base Type Schema for all toolkit plugin instances.

Plugins of any kind (resolvers, gateways, policy engines, etc.) register a well-known GTS Instance of this type in types-registry. The properties generic holds the plugin-kind-specific spec type (derived from this base via GTS type chaining).

GTS Type Identifier: gts.cf.toolkit.plugins.plugin.v1~

Fields

id: GtsInstanceId

Full GTS Instance Identifier for this plugin instance.

vendor: String

Vendor name, used for plugin selection when multiple of the same kind are registered.

priority: i16

Selection priority — lower = higher priority.

properties: P

Plugin-kind-specific spec (derived type’s properties).

Implementations

impl<P> PluginV1<P>

where P: GtsSchema + JsonSchema,

pub fn gts_type_id() -> &'static GtsTypeId

Get the GTS type identifier as a static reference.

pub fn gts_schema_id() -> &'static GtsTypeId

👎Deprecated since 0.10.0:

renamed to gts_type_id

Deprecated alias for Self::gts_type_id.

pub fn gts_base_type_id() -> Option<&'static GtsTypeId>

Get the parent (base) type identifier as a static reference. Returns None for base structs (those with base = true).

pub fn gts_base_schema_id() -> Option<&'static GtsTypeId>

👎Deprecated since 0.10.0:

renamed to gts_base_type_id

Deprecated alias for Self::gts_base_type_id.

pub fn gts_make_instance_id(segment: &str) -> GtsInstanceId

Generate a GTS instance ID by appending a segment to the type ID.

impl<P> PluginV1<P>

where P: GtsSchema + JsonSchema,

pub fn gts_schema_with_refs_as_string() -> String

Get the JSON Schema with allOf + $ref for inheritance as a JSON string.

pub fn gts_schema_with_refs_as_string_pretty() -> String

Get the JSON Schema with allOf + $ref for inheritance as a pretty-printed JSON string.

impl<P> PluginV1<P>

where P: GtsSchema + GtsSerialize,

pub fn gts_instance_json(&self) -> Value

Serialize this instance to a serde_json::Value.

pub fn gts_instance_json_as_string(&self) -> String

Serialize this instance to a JSON string.

pub fn gts_instance_json_as_string_pretty(&self) -> String

Serialize this instance to a pretty-printed JSON string.

impl<P> PluginV1<P>

where P: GtsSchema + GtsSerialize + Default,

pub fn build_registration( instance_segment: &str, vendor: impl Into<String>, priority: i16, ) -> Result<(GtsInstanceId, Value), Error>

Assembles a PluginV1<P> from runtime config and returns the pair (instance_id, json_payload) ready for scoped-client registration and TypesRegistryClient::register(...).

P is constructed internally via P::default(). Derived unit-struct plugin specs declared through #[toolkit_gts::gts_type_schema(base = PluginV1, ...)] must #[derive(Default)] so the caller only specifies the type once — in the turbofish.

Typical usage in a plugin gear’s init():

let (instance_id, payload) = PluginV1::<MyPluginSpecV1>::build_registration(
    "<vendor>.<package>.<plugin_name>.v1",   // instance segment
    cfg.vendor,                               // from YAML
    cfg.priority,                             // from YAML
)?;

// Publish to types-registry:
let results = registry.register(vec![payload]).await?;
RegisterResult::ensure_all_ok(&results)?;

// Register scoped client under the same instance id:
ctx.client_hub().register_scoped::<dyn MyPluginClient>(
    ClientScope::gts_id(&instance_id),
    api,
);

The final instance id is P::SCHEMA_ID + instance_segment (e.g. gts.cf.toolkit.plugins.plugin.v1~cf.core.authn_resolver.plugin.v1~cf.builtin.static_authn_resolver.plugin.v1). Registration via types-registry-sdk stays in the caller — this helper only builds the payload.

For plugin specs that carry real data in P (rare — most specs are unit-struct markers), bypass this helper and construct PluginV1 { id, vendor, priority, properties } manually.

Errors

Returns a serde_json::Error if serialisation fails (should not happen for well-formed derived specs produced by #[struct_to_gts_schema(base = PluginV1, ...)]).

Trait Implementations

impl<P> Debug for PluginV1<P>

where P: Debug + GtsSchema,

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

Formats the value using the given formatter.

impl<'de, P> Deserialize<'de> for PluginV1<P>

where P: GtsSchema + GtsDeserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<PluginV1<P>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P> GtsSchema for PluginV1<P>

where P: GtsSchema + JsonSchema,

const TYPE_ID: &'static str = "gts.cf.toolkit.plugins.plugin.v1~"

The GTS type ID for this type (formerly SCHEMA_ID).

const GENERIC_FIELD: Option<&'static str>

The name of the field that contains the generic type parameter, if any. For example, BaseEventV1<P> has payload as the generic field.

const GTS_FINAL: bool = false

true if this type declares x-gts-final (not inheritable). Set by #[struct_to_gts_schema] from gts_final = true; read by the derive-from-final compile-time guard.

const GTS_ABSTRACT: bool = false

true if this type declares x-gts-abstract (not directly instantiable). Set by #[struct_to_gts_schema] from gts_abstract = true; read by the gts_instance! compile-time guard.

const TRAIT_SCHEMA: TraitSchemaState

Chain-aggregated x-gts-traits-schema state (this type’s own layer allOf-composed with its ancestors’). Set by #[struct_to_gts_schema]; read by the compile-time guard that rejects traits values when the chain has no usable trait shape (TraitSchemaState::Absent) or prohibits traits (TraitSchemaState::Prohibited).

fn gts_schema_with_refs() -> Value

Returns the JSON schema for this type with $ref references intact.

fn gts_traits_schema() -> Option<Value>

This type’s own declared x-gts-traits-schema, or None if it declares none. The single layer this type contributes — not the chain-aggregated effective trait-schema (the registry composes those along the $id chain via allOf). Overridden by #[struct_to_gts_schema] when traits_schema = … is set.

fn gts_traits() -> Option<Value>

This type’s own declared x-gts-traits values, or None if it resolves none. The single layer this type contributes — not the chain-merged effective traits object. Overridden by #[struct_to_gts_schema] when traits = … is set.

fn gts_schema() -> Value

Returns the composed JSON schema for this type. For types with generic parameters that implement GtsSchema, this returns the schema with the generic field’s type replaced by the nested type’s schema.

fn innermost_type_id() -> &'static str

Get the innermost type ID in a nested generic chain. For BaseEventV1<AuditPayloadV1<PlaceOrderDataV1>>, returns PlaceOrderDataV1’s ID.

fn innermost_schema() -> Value

Get the innermost (leaf) type’s raw schema. For BaseEventV1<AuditPayloadV1<PlaceOrderDataV1>>, returns PlaceOrderDataV1’s schema.

fn collect_nesting_path() -> Vec<&'static str>

Collect the nesting path (generic field names) from outer to inner types. For BaseEventV1<AuditPayloadV1<PlaceOrderDataV1>>, returns ["payload", "data"].

fn gts_schema_with_refs_allof() -> Value

Generate a GTS-style schema with allOf and $ref to base type.

const SCHEMA_ID: &'static str = Self::TYPE_ID

👎Deprecated since 0.10.0:

use TYPE_ID instead

Deprecated alias for Self::TYPE_ID.

fn innermost_schema_id() -> &'static str

👎Deprecated since 0.10.0:

renamed to innermost_type_id

Deprecated alias for Self::innermost_type_id.

fn outer_generic_path() -> Vec<&'static str>

Path of generic-slot field names from the document root (the outermost base type in the chain) down to where this type’s own properties live in a composed instance.

fn wrap_in_nesting_path( path: &[&str], properties: Value, required: Value, generic_field: Option<&str>, ) -> Value

Wrap properties in a nested structure following the nesting path. For path ["payload", "data"] and properties {order_id, product_id, last}, returns { "payload": { "type": "object", "properties": { "data": { "type": "object", "additionalProperties": false, "properties": {...}, "required": [...] } } } }

impl<P> JsonSchema for PluginV1<P>

where P: GtsSchema + JsonSchema,

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl<P> Serialize for PluginV1<P>

where P: GtsSchema + GtsSerialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.