@meshery/schemas 0.8.119 → 0.8.121

package/dist/constructs/v1alpha3/relationship/RelationshipSchema.d.mts

@@ -0,0 +1,1934 @@
+/**
+ * This file was automatically generated from OpenAPI schema.
+ * Do not manually modify this file.
+ */
+declare const RelationshipSchema: {
+    readonly openapi: "3.0.0";
+    readonly info: {
+        readonly title: "relationship";
+        readonly version: "1.0.0";
+    };
+    readonly paths: {};
+    readonly components: {
+        readonly schemas: {
+            readonly RelationshipDefinition: {
+                readonly $id: "https://schemas.meshery.io/relationship.yaml";
+                readonly $schema: "http://json-schema.org/draft-07/schema#";
+                readonly description: "Relationships define the nature of interaction between interconnected components in Meshery. The combination of relationship properties kind, type, and subtype characterize various genealogical relations among and between components. Relationships have selectors, selector sets, metadata, and optional parameters. Learn more at https://docs.meshery.io/concepts/logical/relationships.";
+                readonly required: readonly ["schemaVersion", "version", "model", "kind", "type", "subType"];
+                readonly additionalProperties: false;
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly description: "Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design).";
+                        readonly type: "string";
+                        readonly format: "uuid";
+                        readonly "x-go-type": "uuid.UUID";
+                        readonly "x-go-type-import": {
+                            readonly path: "github.com/gofrs/uuid";
+                        };
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "id";
+                            readonly json: "id";
+                        };
+                    };
+                    readonly schemaVersion: {
+                        readonly description: "Specifies the version of the schema used for the relationship definition.";
+                        readonly type: "string";
+                        readonly minLength: 2;
+                        readonly maxLength: 100;
+                        readonly pattern: "([a-z.])*(?!^/)v(alpha|beta|[0-9]+)([.-]*[a-z0-9]+)*$";
+                        readonly example: readonly ["v1", "v1alpha1", "v2beta3", "v1.custom-suffix"];
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "schemaVersion";
+                            readonly json: "schemaVersion";
+                        };
+                        readonly default: "relationships.meshery.io/v1alpha3";
+                    };
+                    readonly version: {
+                        readonly description: "Specifies the version of the relationship definition.";
+                        readonly type: "string";
+                        readonly minLength: 5;
+                        readonly maxLength: 100;
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "version";
+                            readonly json: "version";
+                        };
+                        readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                    };
+                    readonly model: {
+                        readonly "x-go-type": "model.ModelReference";
+                        readonly "x-go-type-import": {
+                            readonly path: "github.com/meshery/schemas/models/v1beta1/model";
+                        };
+                        readonly "x-order": 8;
+                        readonly description: "Reference to the specific registered model to which the component belongs and from which model version, category, and other properties may be referenced. Learn more at https://docs.meshery.io/concepts/models";
+                        readonly type: "object";
+                        readonly required: readonly ["id", "name", "version", "displayName", "model", "registrant"];
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                                readonly format: "uuid";
+                                readonly description: "A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.";
+                                readonly "x-go-type": "uuid.UUID";
+                                readonly "x-go-type-import": {
+                                    readonly path: "github.com/gofrs/uuid";
+                                };
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                                readonly description: "The unique name for the model within the scope of a registrant.";
+                                readonly helperText: "Model name should be in lowercase with hyphens, not whitespaces.";
+                                readonly pattern: "^[a-z0-9-]+$";
+                                readonly examples: readonly ["cert-manager"];
+                                readonly "x-order": 4;
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "name";
+                                    readonly json: "name";
+                                };
+                                readonly default: "untitled-model";
+                            };
+                            readonly version: {
+                                readonly description: "Version of the model definition.";
+                                readonly type: "string";
+                                readonly "x-order": 3;
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "version";
+                                    readonly json: "version";
+                                };
+                                readonly minLength: 5;
+                                readonly maxLength: 100;
+                                readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                            };
+                            readonly displayName: {
+                                readonly description: "Human-readable name for the model.";
+                                readonly helperText: "Model display name may include letters, numbers, and spaces. Special characters are not allowed.";
+                                readonly minLength: 1;
+                                readonly maxLength: 100;
+                                readonly type: "string";
+                                readonly pattern: "^[a-zA-Z0-9 ]+$";
+                                readonly examples: readonly ["Cert Manager"];
+                                readonly "x-order": 5;
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "displayName";
+                                    readonly json: "displayName";
+                                };
+                                readonly default: "Untitled Model";
+                            };
+                            readonly model: {
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly gorm: "type:bytes;serializer:json";
+                                };
+                                readonly "x-order": 12;
+                                readonly type: "object";
+                                readonly description: "Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31).";
+                                readonly required: readonly ["version"];
+                                readonly properties: {
+                                    readonly version: {
+                                        readonly description: "Version of the model as defined by the registrant.";
+                                        readonly allOf: readonly [{
+                                            readonly type: "string";
+                                            readonly minLength: 5;
+                                            readonly maxLength: 100;
+                                            readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                            readonly description: "A valid semantic version string between 5 and 256 characters. The pattern allows for a major.minor.patch version followed by an optional pre-release tag like '-alpha' or '-beta.2' and an optional build metadata tag like '+build.1.";
+                                        }];
+                                        readonly "x-oapi-codegen-extra-tags": {
+                                            readonly yaml: "version";
+                                            readonly json: "version";
+                                        };
+                                        readonly "x-order": 1;
+                                    };
+                                };
+                            };
+                            readonly registrant: {
+                                readonly "x-go-type": "RegistrantReference";
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "registrant";
+                                    readonly json: "registrant";
+                                };
+                                readonly type: "object";
+                                readonly required: readonly ["kind"];
+                                readonly properties: {
+                                    readonly kind: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly kind: {
+                        readonly description: "Kind of the Relationship. Learn more about relationships - https://docs.meshery.io/concepts/logical/relationships.";
+                        readonly enum: readonly ["hierarchical", "edge", "sibling"];
+                        readonly type: "string";
+                        readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "kind";
+                            readonly json: "kind";
+                        };
+                    };
+                    readonly type: {
+                        readonly description: "Classification of relationships. Used to group relationships similar in nature.";
+                        readonly "x-go-name": "RelationshipType";
+                        readonly gorm: "column:type";
+                        readonly type: "string";
+                        readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "type";
+                            readonly json: "type";
+                        };
+                    };
+                    readonly subType: {
+                        readonly description: "Most granular unit of relationship classification. The combination of Kind, Type and SubType together uniquely identify a Relationship.";
+                        readonly type: "string";
+                        readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "subType";
+                            readonly json: "subType";
+                        };
+                    };
+                    readonly status: {
+                        readonly type: "string";
+                        readonly description: "Status of the relationship.";
+                        readonly default: "enabled";
+                        readonly enum: readonly ["pending", "approved", "ignored", "enabled", "deleted"];
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "status";
+                            readonly json: "status";
+                        };
+                    };
+                    readonly evaluationQuery: {
+                        readonly description: "Optional. Assigns the policy to be used for the evaluation of the relationship. Deprecation Notice: In the future, this property is either to be removed or to it is to be an array of optional policy $refs.";
+                        readonly type: "string";
+                        readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly yaml: "evaluationQuery";
+                            readonly json: "evaluationQuery";
+                        };
+                    };
+                    readonly capabilities: {
+                        readonly type: "array";
+                        readonly description: "Capabilities associated with the relationship.";
+                        readonly items: {
+                            readonly $id: "https://schemas.meshery.io/capability.yaml";
+                            readonly $schema: "http://json-schema.org/draft-07/schema#";
+                            readonly description: "Meshery manages entities in accordance with their specific capabilities. This field explicitly identifies those capabilities largely by what actions a given component supports; e.g. metric-scrape, sub-interface, and so on. This field is extensible. Entities may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management.";
+                            readonly additionalProperties: false;
+                            readonly type: "object";
+                            readonly required: readonly ["schemaVersion", "version", "displayName", "kind", "type", "entityState", "status"];
+                            readonly "x-oapi-codegen-extra-tags": {
+                                readonly gorm: "type:bytes;serializer:json";
+                            };
+                            readonly properties: {
+                                readonly schemaVersion: {
+                                    readonly description: "Specifies the version of the schema to which the capability definition conforms.";
+                                    readonly type: "string";
+                                    readonly minLength: 2;
+                                    readonly maxLength: 100;
+                                    readonly pattern: "([a-z.])*(?!^/)v(alpha|beta|[0-9]+)([.-]*[a-z0-9]+)*$";
+                                    readonly example: readonly ["v1", "v1alpha1", "v2beta3", "v1.custom-suffix"];
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "schemaVersion";
+                                        readonly json: "schemaVersion";
+                                    };
+                                };
+                                readonly version: {
+                                    readonly description: "Version of the capability definition.";
+                                    readonly type: "string";
+                                    readonly minLength: 5;
+                                    readonly maxLength: 100;
+                                    readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "version";
+                                        readonly json: "version";
+                                    };
+                                };
+                                readonly displayName: {
+                                    readonly description: "Name of the capability in human-readible format.";
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "displayName";
+                                        readonly json: "displayName";
+                                    };
+                                };
+                                readonly description: {
+                                    readonly type: "string";
+                                    readonly description: "A written representation of the purpose and characteristics of the capability.";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "description";
+                                        readonly json: "description";
+                                    };
+                                };
+                                readonly kind: {
+                                    readonly description: "Top-level categorization of the capability";
+                                    readonly additionalProperties: false;
+                                    readonly anyOf: readonly [{
+                                        readonly const: "action";
+                                        readonly description: "For capabilities related to executing actions on entities. Example: initiate log streaming on a Pod. Example: initiate deployment of a component.";
+                                    }, {
+                                        readonly const: "mutate";
+                                        readonly description: "For capabilities related to mutating an entity. Example: the ability to change the configuration of a component.";
+                                    }, {
+                                        readonly const: "view";
+                                        readonly description: "For capabilities related to viewing an entity. Example: the ability to view a components configuration.";
+                                    }, {
+                                        readonly const: "interaction";
+                                        readonly description: "Catch all for capabilities related to interaction with entities. Example: the ability for a component to be dragged and dropped. Example: supports event bubbling to parent components. ";
+                                    }];
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "kind";
+                                        readonly json: "kind";
+                                    };
+                                };
+                                readonly type: {
+                                    readonly description: "Classification of capabilities. Used to group capabilities similar in nature.";
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "type";
+                                        readonly json: "type";
+                                    };
+                                };
+                                readonly subType: {
+                                    readonly description: "Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability.";
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "subType";
+                                        readonly json: "subType";
+                                    };
+                                };
+                                readonly key: {
+                                    readonly description: "Key that backs the capability.";
+                                    readonly type: "string";
+                                    readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "key";
+                                        readonly json: "key";
+                                    };
+                                };
+                                readonly entityState: {
+                                    readonly description: "State of the entity in which the capability is applicable.";
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["declaration", "instance"];
+                                        readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                        readonly description: "A string starting with an alphanumeric character. Spaces and hyphens allowed.";
+                                        readonly "x-oapi-codegen-extra-tags": {
+                                            readonly yaml: "entityState";
+                                            readonly json: "entityState";
+                                        };
+                                    };
+                                };
+                                readonly status: {
+                                    readonly type: "string";
+                                    readonly description: "Status of the capability";
+                                    readonly default: "enabled";
+                                    readonly enum: readonly ["enabled", "disabled"];
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "status";
+                                        readonly json: "status";
+                                    };
+                                };
+                                readonly metadata: {
+                                    readonly type: "object";
+                                    readonly description: "Metadata contains additional information associated with the capability. Extension point.";
+                                    readonly additionalProperties: true;
+                                    readonly "x-oapi-codegen-extra-tags": {
+                                        readonly yaml: "metadata";
+                                        readonly json: "metadata";
+                                    };
+                                };
+                            };
+                        };
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly gorm: "type:bytes;serializer:json";
+                        };
+                    };
+                    readonly metadata: {
+                        readonly type: "object";
+                        readonly description: "Metadata contains additional information associated with the Relationship.";
+                        readonly additionalProperties: true;
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly gorm: "foreignKey:ModelId;references:Id";
+                        };
+                        readonly properties: {
+                            readonly description: {
+                                readonly description: "Characterization of the meaning of the relationship and its relevance to both Meshery and entities under management.";
+                                readonly type: "string";
+                                readonly pattern: "^[a-zA-Z_][a-zA-Z0-9_-]*[a-zA-Z0-9_]$";
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "description";
+                                    readonly json: "description";
+                                };
+                            };
+                            readonly isAnnotation: {
+                                readonly type: "boolean";
+                                readonly description: "Indicates whether the relationship should be treated as a logical representation only";
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "isAnnotation";
+                                    readonly json: "isAnnotation";
+                                };
+                                readonly default: false;
+                            };
+                            readonly styles: {
+                                readonly anyOf: readonly [{
+                                    readonly type: "object";
+                                    readonly description: "Visualization styles for a relationship";
+                                    readonly allOf: readonly [{
+                                        readonly type: "object";
+                                        readonly description: "Common styles for all entities";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["primaryColor", "svgColor", "svgWhite"];
+                                        readonly properties: {
+                                            readonly primaryColor: {
+                                                readonly type: "string";
+                                                readonly description: "Primary color of the component used for UI representation.";
+                                            };
+                                            readonly secondaryColor: {
+                                                readonly type: "string";
+                                                readonly description: "Secondary color of the entity used for UI representation.";
+                                            };
+                                            readonly svgWhite: {
+                                                readonly type: "string";
+                                                readonly description: "White SVG of the entity used for UI representation on dark background.";
+                                            };
+                                            readonly svgColor: {
+                                                readonly type: "string";
+                                                readonly description: "Colored SVG of the entity used for UI representation on light background.";
+                                            };
+                                            readonly svgComplete: {
+                                                readonly type: "string";
+                                                readonly description: "Complete SVG of the entity used for UI representation, often inclusive of background.";
+                                            };
+                                            readonly color: {
+                                                readonly type: "string";
+                                                readonly description: "The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. #ff0000 or #f00), RGB (e.g. rgb(255, 0, 0)), or HSL (e.g. hsl(0, 100%, 50%)).";
+                                            };
+                                            readonly "text-opacity": {
+                                                readonly type: "number";
+                                                readonly description: "The opacity of the label text, including its outline.";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1;
+                                            };
+                                            readonly "font-family": {
+                                                readonly type: "string";
+                                                readonly description: "A comma-separated list of font names to use on the label text.";
+                                            };
+                                            readonly "font-size": {
+                                                readonly type: "string";
+                                                readonly description: "The size of the label text.";
+                                            };
+                                            readonly "font-style": {
+                                                readonly type: "string";
+                                                readonly description: "A CSS font style to be applied to the label text.";
+                                            };
+                                            readonly "font-weight": {
+                                                readonly type: "string";
+                                                readonly description: "A CSS font weight to be applied to the label text.";
+                                            };
+                                            readonly "text-transform": {
+                                                readonly type: "string";
+                                                readonly description: "A transformation to apply to the label text";
+                                                readonly enum: readonly ["none", "uppercase", "lowercase"];
+                                            };
+                                            readonly opacity: {
+                                                readonly type: "number";
+                                                readonly description: "The opacity of the element, ranging from 0 to 1. Note that the opacity of a compound node parent affects the effective opacity of its children.See https://js.cytoscape.org/#style/visibility";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1;
+                                            };
+                                            readonly "z-index": {
+                                                readonly type: "integer";
+                                                readonly description: "An integer value that affects the relative draw order of elements. In general, an element with a higher z-index will be drawn on top of an element with a lower z-index. Note that edges are under nodes despite z-index.";
+                                            };
+                                            readonly label: {
+                                                readonly type: "string";
+                                                readonly description: "The text to display for an element’s label. Can give a path, e.g. data(id) will label with the elements id";
+                                            };
+                                        };
+                                    }, {
+                                        readonly properties: {
+                                            readonly "edge-animation": {
+                                                readonly type: "string";
+                                                readonly description: "The animation to use for the edge. Can be like 'marching-ants' , 'blink' , 'moving-gradient',etc .";
+                                            };
+                                            readonly "curve-style": {
+                                                readonly type: "string";
+                                                readonly description: "The curving method used to separate two or more edges between two nodes; may be haystack (very fast, bundled straight edges for which loops and compounds are unsupported), straight (straight edges with all arrows supported), bezier (bundled curved edges), unbundled-bezier (curved edges for use with manual control points), segments (a series of straight lines), taxi (right-angled lines, hierarchically bundled). Note that haystack edges work best with ellipse, rectangle, or similar nodes. Smaller node shapes, like triangle, will not be as aesthetically pleasing. Also note that edge endpoint arrows are unsupported for haystack edges.";
+                                                readonly default: "straight";
+                                                readonly enum: readonly ["straight", "haystack", "bezier", "unbundled-bezier", "segments", "taxi"];
+                                            };
+                                            readonly "line-color": {
+                                                readonly type: "string";
+                                                readonly description: "The colour of the edge’s line. Colours may be specified by name (e.g. red), hex (e.g. #ff0000 or #f00), RGB (e.g. rgb(255, 0, 0)), or HSL (e.g. hsl(0, 100%, 50%)).";
+                                            };
+                                            readonly "line-style": {
+                                                readonly type: "string";
+                                                readonly description: "The style of the edge’s line.";
+                                                readonly enum: readonly ["solid", "dotted", "dashed"];
+                                            };
+                                            readonly "line-cap": {
+                                                readonly type: "string";
+                                                readonly description: "The cap style of the edge’s line; may be butt (default), round, or square. The cap may or may not be visible, depending on the shape of the node and the relative size of the node and edge. Caps other than butt extend beyond the specified endpoint of the edge.";
+                                                readonly enum: readonly ["butt", "round", "square"];
+                                                readonly default: "butt";
+                                            };
+                                            readonly "line-opacity": {
+                                                readonly type: "number";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1;
+                                                readonly default: 1;
+                                                readonly description: "The opacity of the edge’s line and arrow. Useful if you wish to have a separate opacity for the edge label versus the edge line. Note that the opacity value of the edge element affects the effective opacity of its line and label subcomponents.";
+                                            };
+                                            readonly "target-arrow-color": {
+                                                readonly type: "string";
+                                                readonly description: "The colour of the edge’s source arrow. Colours may be specified by name (e.g. red), hex (e.g. #ff0000 or #f00), RGB (e.g. rgb(255, 0, 0)), or HSL (e.g. hsl(0, 100%, 50%)).";
+                                            };
+                                            readonly "target-arrow-shape": {
+                                                readonly type: "string";
+                                                readonly description: "The shape of the edge’s source arrow";
+                                                readonly enum: readonly ["triangle", "triangle-tee", "circle-triangle", "triangle-cross", "triangle-backcurve", "vee", "tee", "square", "circle", "diamond", "chevron", "none"];
+                                            };
+                                            readonly "target-arrow-fill": {
+                                                readonly type: "string";
+                                                readonly description: "The fill state of the edge’s source arrow";
+                                                readonly enum: readonly ["filled", "hollow"];
+                                            };
+                                            readonly "mid-target-arrow-color": {
+                                                readonly type: "string";
+                                                readonly description: "The colour of the edge’s source arrow. Colours may be specified by name (e.g. red), hex (e.g. #ff0000 or #f00), RGB (e.g. rgb(255, 0, 0)), or HSL (e.g. hsl(0, 100%, 50%)).";
+                                            };
+                                            readonly "mid-target-arrow-shape": {
+                                                readonly type: "string";
+                                                readonly description: "The shape of the edge’s source arrow";
+                                                readonly enum: readonly ["triangle", "triangle-tee", "circle-triangle", "triangle-cross", "triangle-backcurve", "vee", "tee", "square", "circle", "diamond", "chevron", "none"];
+                                            };
+                                            readonly "mid-target-arrow-fill": {
+                                                readonly type: "string";
+                                                readonly description: "The fill state of the edge’s source arrow";
+                                                readonly enum: readonly ["filled", "hollow"];
+                                            };
+                                            readonly "arrow-scale": {
+                                                readonly type: "number";
+                                                readonly description: "Scaling for the arrow size.";
+                                                readonly minimum: 0;
+                                            };
+                                            readonly "source-label": {
+                                                readonly type: "string";
+                                                readonly description: "The text to display for an edge’s source label. Can give a path, e.g. data(id) will label with the elements id";
+                                            };
+                                            readonly "target-label": {
+                                                readonly type: "string";
+                                                readonly description: "The text to display for an edge’s target label. Can give a path, e.g. data(id) will label with the elements id";
+                                            };
+                                        };
+                                    }];
+                                }, {
+                                    readonly type: "object";
+                                    readonly description: "Common styles for all entities";
+                                    readonly additionalProperties: false;
+                                    readonly required: readonly ["primaryColor", "svgColor", "svgWhite"];
+                                    readonly properties: {
+                                        readonly primaryColor: {
+                                            readonly type: "string";
+                                            readonly description: "Primary color of the component used for UI representation.";
+                                        };
+                                        readonly secondaryColor: {
+                                            readonly type: "string";
+                                            readonly description: "Secondary color of the entity used for UI representation.";
+                                        };
+                                        readonly svgWhite: {
+                                            readonly type: "string";
+                                            readonly description: "White SVG of the entity used for UI representation on dark background.";
+                                        };
+                                        readonly svgColor: {
+                                            readonly type: "string";
+                                            readonly description: "Colored SVG of the entity used for UI representation on light background.";
+                                        };
+                                        readonly svgComplete: {
+                                            readonly type: "string";
+                                            readonly description: "Complete SVG of the entity used for UI representation, often inclusive of background.";
+                                        };
+                                        readonly color: {
+                                            readonly type: "string";
+                                            readonly description: "The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. #ff0000 or #f00), RGB (e.g. rgb(255, 0, 0)), or HSL (e.g. hsl(0, 100%, 50%)).";
+                                        };
+                                        readonly "text-opacity": {
+                                            readonly type: "number";
+                                            readonly description: "The opacity of the label text, including its outline.";
+                                            readonly minimum: 0;
+                                            readonly maximum: 1;
+                                        };
+                                        readonly "font-family": {
+                                            readonly type: "string";
+                                            readonly description: "A comma-separated list of font names to use on the label text.";
+                                        };
+                                        readonly "font-size": {
+                                            readonly type: "string";
+                                            readonly description: "The size of the label text.";
+                                        };
+                                        readonly "font-style": {
+                                            readonly type: "string";
+                                            readonly description: "A CSS font style to be applied to the label text.";
+                                        };
+                                        readonly "font-weight": {
+                                            readonly type: "string";
+                                            readonly description: "A CSS font weight to be applied to the label text.";
+                                        };
+                                        readonly "text-transform": {
+                                            readonly type: "string";
+                                            readonly description: "A transformation to apply to the label text";
+                                            readonly enum: readonly ["none", "uppercase", "lowercase"];
+                                        };
+                                        readonly opacity: {
+                                            readonly type: "number";
+                                            readonly description: "The opacity of the element, ranging from 0 to 1. Note that the opacity of a compound node parent affects the effective opacity of its children.See https://js.cytoscape.org/#style/visibility";
+                                            readonly minimum: 0;
+                                            readonly maximum: 1;
+                                        };
+                                        readonly "z-index": {
+                                            readonly type: "integer";
+                                            readonly description: "An integer value that affects the relative draw order of elements. In general, an element with a higher z-index will be drawn on top of an element with a lower z-index. Note that edges are under nodes despite z-index.";
+                                        };
+                                        readonly label: {
+                                            readonly type: "string";
+                                            readonly description: "The text to display for an element’s label. Can give a path, e.g. data(id) will label with the elements id";
+                                        };
+                                    };
+                                    readonly $comment: "Extension point for additional styles";
+                                }];
+                                readonly "x-oapi-codegen-extra-tags": {
+                                    readonly yaml: "styles";
+                                    readonly json: "styles";
+                                };
+                            };
+                        };
+                    };
+                    readonly selectors: {
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly gorm: "type:bytes;serializer:json";
+                        };
+                        readonly type: "array";
+                        readonly description: "Selectors are organized as an array, with each item containing a distinct set of selectors that share a common functionality. This structure allows for flexibility in defining relationships, even when different components are involved.";
+                        readonly $comment: "Sets of selectors are interpreted as a logical UNION. Properties within a selector `allow` and `deny` are interpreted as logical AND, while 'from' and 'to' represents a UNION of set of combinatorial pairs.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly description: "Optional selectors used to match Components. Absence of a selector means that it is applied to all Components.";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["allow"];
+                            readonly properties: {
+                                readonly deny: {
+                                    readonly description: "Optional selectors used to define relationships which should not be created / is restricted.";
+                                    readonly type: "object";
+                                    readonly required: readonly ["to", "from"];
+                                    readonly properties: {
+                                        readonly from: {
+                                            readonly description: "Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match.";
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly type: "string";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "kind";
+                                                            readonly json: "kind";
+                                                        };
+                                                    };
+                                                    readonly model: {
+                                                        readonly "x-go-type": "model.ModelReference";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/meshery/schemas/models/v1beta1/model";
+                                                        };
+                                                        readonly "x-order": 8;
+                                                        readonly description: "Reference to the specific registered model to which the component belongs and from which model version, category, and other properties may be referenced. Learn more at https://docs.meshery.io/concepts/models";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly gorm: "-";
+                                                        };
+                                                        readonly type: "object";
+                                                        readonly required: readonly ["id", "name", "version", "displayName", "model", "registrant"];
+                                                        readonly properties: {
+                                                            readonly id: {
+                                                                readonly type: "string";
+                                                                readonly format: "uuid";
+                                                                readonly description: "A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.";
+                                                                readonly "x-go-type": "uuid.UUID";
+                                                                readonly "x-go-type-import": {
+                                                                    readonly path: "github.com/gofrs/uuid";
+                                                                };
+                                                            };
+                                                            readonly name: {
+                                                                readonly type: "string";
+                                                                readonly description: "The unique name for the model within the scope of a registrant.";
+                                                                readonly helperText: "Model name should be in lowercase with hyphens, not whitespaces.";
+                                                                readonly pattern: "^[a-z0-9-]+$";
+                                                                readonly examples: readonly ["cert-manager"];
+                                                                readonly "x-order": 4;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "name";
+                                                                    readonly json: "name";
+                                                                };
+                                                                readonly default: "untitled-model";
+                                                            };
+                                                            readonly version: {
+                                                                readonly description: "Version of the model definition.";
+                                                                readonly type: "string";
+                                                                readonly "x-order": 3;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "version";
+                                                                    readonly json: "version";
+                                                                };
+                                                                readonly minLength: 5;
+                                                                readonly maxLength: 100;
+                                                                readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                            };
+                                                            readonly displayName: {
+                                                                readonly description: "Human-readable name for the model.";
+                                                                readonly helperText: "Model display name may include letters, numbers, and spaces. Special characters are not allowed.";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 100;
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[a-zA-Z0-9 ]+$";
+                                                                readonly examples: readonly ["Cert Manager"];
+                                                                readonly "x-order": 5;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "displayName";
+                                                                    readonly json: "displayName";
+                                                                };
+                                                                readonly default: "Untitled Model";
+                                                            };
+                                                            readonly model: {
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly gorm: "type:bytes;serializer:json";
+                                                                };
+                                                                readonly "x-order": 12;
+                                                                readonly type: "object";
+                                                                readonly description: "Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31).";
+                                                                readonly required: readonly ["version"];
+                                                                readonly properties: {
+                                                                    readonly version: {
+                                                                        readonly description: "Version of the model as defined by the registrant.";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly type: "string";
+                                                                            readonly minLength: 5;
+                                                                            readonly maxLength: 100;
+                                                                            readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                                            readonly description: "A valid semantic version string between 5 and 256 characters. The pattern allows for a major.minor.patch version followed by an optional pre-release tag like '-alpha' or '-beta.2' and an optional build metadata tag like '+build.1.";
+                                                                        }];
+                                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                                            readonly yaml: "version";
+                                                                            readonly json: "version";
+                                                                        };
+                                                                        readonly "x-order": 1;
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly registrant: {
+                                                                readonly "x-go-type": "RegistrantReference";
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "registrant";
+                                                                    readonly json: "registrant";
+                                                                };
+                                                                readonly type: "object";
+                                                                readonly required: readonly ["kind"];
+                                                                readonly properties: {
+                                                                    readonly kind: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly id: {
+                                                        readonly type: "string";
+                                                        readonly format: "uuid";
+                                                        readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                        readonly "x-go-type": "uuid.UUID";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/gofrs/uuid";
+                                                        };
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "id";
+                                                            readonly json: "id";
+                                                        };
+                                                    };
+                                                    readonly match: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly properties: {
+                                                                readonly from: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                                readonly to: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "match";
+                                                            readonly json: "match";
+                                                        };
+                                                    };
+                                                    readonly patch: {
+                                                        readonly allOf: readonly [{
+                                                            readonly properties: {
+                                                                readonly patchStrategy: {
+                                                                    readonly description: "patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902). \n\nadd: Inserts a value into an array or adds a member to an object.\nreplace: Replaces a value.\nmerge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.\nstrategic:specific to Kubernetes and understands the structure of Kubernetes objects. It can handle complex changes like updating lists and maps, as well as preserving default values. However, it's not supported for custom resources. For custom resources, only JSON Patch and Merge Patch are typically supported.\nremove: Removes a value.\ncopy: Copies a value from one location to another.\nmove: Moves a value from one location to another.\ntest: Tests that a value at the target location is equal to a specified value.";
+                                                                    readonly $comment: "Array Indexing: When working with arrays, be aware that Kubernetes uses zero-based indexing in JSON patch paths.\nMerge Patch vs. JSON Patch: Merge patches are less flexible than JSON patches and do not support all the same operations.\nStrategic Merge Patch: For some Kubernetes resources, you can also use the strategic type for a strategic merge patch, which understands the structure of Kubernetes objects and can handle complex operations.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["merge", "strategic", "add", "remove", "copy", "move", "test"];
+                                                                    readonly default: "copy";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly oneOf: readonly [{
+                                                                readonly properties: {
+                                                                    readonly mutatorRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                        };
+                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly properties: {
+                                                                    readonly mutatedRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }];
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "patch";
+                                                            readonly json: "patch";
+                                                        };
+                                                    };
+                                                };
+                                                readonly description: "Optional fields that are a part of the `from` selector. Absence of a field has an implied * meaning.";
+                                            };
+                                        };
+                                        readonly to: {
+                                            readonly description: "Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match.";
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly type: "string";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "kind";
+                                                            readonly json: "kind";
+                                                        };
+                                                    };
+                                                    readonly model: {
+                                                        readonly "x-go-type": "model.ModelReference";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/meshery/schemas/models/v1beta1/model";
+                                                        };
+                                                        readonly "x-order": 8;
+                                                        readonly description: "Reference to the specific registered model to which the component belongs and from which model version, category, and other properties may be referenced. Learn more at https://docs.meshery.io/concepts/models";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly gorm: "-";
+                                                        };
+                                                        readonly type: "object";
+                                                        readonly required: readonly ["id", "name", "version", "displayName", "model", "registrant"];
+                                                        readonly properties: {
+                                                            readonly id: {
+                                                                readonly type: "string";
+                                                                readonly format: "uuid";
+                                                                readonly description: "A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.";
+                                                                readonly "x-go-type": "uuid.UUID";
+                                                                readonly "x-go-type-import": {
+                                                                    readonly path: "github.com/gofrs/uuid";
+                                                                };
+                                                            };
+                                                            readonly name: {
+                                                                readonly type: "string";
+                                                                readonly description: "The unique name for the model within the scope of a registrant.";
+                                                                readonly helperText: "Model name should be in lowercase with hyphens, not whitespaces.";
+                                                                readonly pattern: "^[a-z0-9-]+$";
+                                                                readonly examples: readonly ["cert-manager"];
+                                                                readonly "x-order": 4;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "name";
+                                                                    readonly json: "name";
+                                                                };
+                                                                readonly default: "untitled-model";
+                                                            };
+                                                            readonly version: {
+                                                                readonly description: "Version of the model definition.";
+                                                                readonly type: "string";
+                                                                readonly "x-order": 3;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "version";
+                                                                    readonly json: "version";
+                                                                };
+                                                                readonly minLength: 5;
+                                                                readonly maxLength: 100;
+                                                                readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                            };
+                                                            readonly displayName: {
+                                                                readonly description: "Human-readable name for the model.";
+                                                                readonly helperText: "Model display name may include letters, numbers, and spaces. Special characters are not allowed.";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 100;
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[a-zA-Z0-9 ]+$";
+                                                                readonly examples: readonly ["Cert Manager"];
+                                                                readonly "x-order": 5;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "displayName";
+                                                                    readonly json: "displayName";
+                                                                };
+                                                                readonly default: "Untitled Model";
+                                                            };
+                                                            readonly model: {
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly gorm: "type:bytes;serializer:json";
+                                                                };
+                                                                readonly "x-order": 12;
+                                                                readonly type: "object";
+                                                                readonly description: "Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31).";
+                                                                readonly required: readonly ["version"];
+                                                                readonly properties: {
+                                                                    readonly version: {
+                                                                        readonly description: "Version of the model as defined by the registrant.";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly type: "string";
+                                                                            readonly minLength: 5;
+                                                                            readonly maxLength: 100;
+                                                                            readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                                            readonly description: "A valid semantic version string between 5 and 256 characters. The pattern allows for a major.minor.patch version followed by an optional pre-release tag like '-alpha' or '-beta.2' and an optional build metadata tag like '+build.1.";
+                                                                        }];
+                                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                                            readonly yaml: "version";
+                                                                            readonly json: "version";
+                                                                        };
+                                                                        readonly "x-order": 1;
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly registrant: {
+                                                                readonly "x-go-type": "RegistrantReference";
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "registrant";
+                                                                    readonly json: "registrant";
+                                                                };
+                                                                readonly type: "object";
+                                                                readonly required: readonly ["kind"];
+                                                                readonly properties: {
+                                                                    readonly kind: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly id: {
+                                                        readonly type: "string";
+                                                        readonly format: "uuid";
+                                                        readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                        readonly "x-go-type": "uuid.UUID";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/gofrs/uuid";
+                                                        };
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "id";
+                                                            readonly json: "id";
+                                                        };
+                                                    };
+                                                    readonly match: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly properties: {
+                                                                readonly from: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                                readonly to: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "match";
+                                                            readonly json: "match";
+                                                        };
+                                                    };
+                                                    readonly patch: {
+                                                        readonly allOf: readonly [{
+                                                            readonly properties: {
+                                                                readonly patchStrategy: {
+                                                                    readonly description: "patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902). \n\nadd: Inserts a value into an array or adds a member to an object.\nreplace: Replaces a value.\nmerge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.\nstrategic:specific to Kubernetes and understands the structure of Kubernetes objects. It can handle complex changes like updating lists and maps, as well as preserving default values. However, it's not supported for custom resources. For custom resources, only JSON Patch and Merge Patch are typically supported.\nremove: Removes a value.\ncopy: Copies a value from one location to another.\nmove: Moves a value from one location to another.\ntest: Tests that a value at the target location is equal to a specified value.";
+                                                                    readonly $comment: "Array Indexing: When working with arrays, be aware that Kubernetes uses zero-based indexing in JSON patch paths.\nMerge Patch vs. JSON Patch: Merge patches are less flexible than JSON patches and do not support all the same operations.\nStrategic Merge Patch: For some Kubernetes resources, you can also use the strategic type for a strategic merge patch, which understands the structure of Kubernetes objects and can handle complex operations.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["merge", "strategic", "add", "remove", "copy", "move", "test"];
+                                                                    readonly default: "copy";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly oneOf: readonly [{
+                                                                readonly properties: {
+                                                                    readonly mutatorRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                        };
+                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly properties: {
+                                                                    readonly mutatedRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }];
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "patch";
+                                                            readonly json: "patch";
+                                                        };
+                                                    };
+                                                };
+                                                readonly description: "Optional fields that are a part of the `from` selector. Absence of a field has an implied * meaning.";
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly allow: {
+                                    readonly description: "Selectors used to define relationships which are allowed.";
+                                    readonly type: "object";
+                                    readonly required: readonly ["to", "from"];
+                                    readonly properties: {
+                                        readonly from: {
+                                            readonly description: "Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match.";
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly type: "string";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "kind";
+                                                            readonly json: "kind";
+                                                        };
+                                                    };
+                                                    readonly match_strategy_matrix: {
+                                                        readonly description: "Strategy criterion for determing how to match the values at mutator/mutated paths";
+                                                        readonly type: "array";
+                                                        readonly items: {
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "string";
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly model: {
+                                                        readonly "x-go-type": "model.ModelReference";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/meshery/schemas/models/v1beta1/model";
+                                                        };
+                                                        readonly "x-order": 8;
+                                                        readonly description: "Reference to the specific registered model to which the component belongs and from which model version, category, and other properties may be referenced. Learn more at https://docs.meshery.io/concepts/models";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly gorm: "-";
+                                                        };
+                                                        readonly type: "object";
+                                                        readonly required: readonly ["id", "name", "version", "displayName", "model", "registrant"];
+                                                        readonly properties: {
+                                                            readonly id: {
+                                                                readonly type: "string";
+                                                                readonly format: "uuid";
+                                                                readonly description: "A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.";
+                                                                readonly "x-go-type": "uuid.UUID";
+                                                                readonly "x-go-type-import": {
+                                                                    readonly path: "github.com/gofrs/uuid";
+                                                                };
+                                                            };
+                                                            readonly name: {
+                                                                readonly type: "string";
+                                                                readonly description: "The unique name for the model within the scope of a registrant.";
+                                                                readonly helperText: "Model name should be in lowercase with hyphens, not whitespaces.";
+                                                                readonly pattern: "^[a-z0-9-]+$";
+                                                                readonly examples: readonly ["cert-manager"];
+                                                                readonly "x-order": 4;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "name";
+                                                                    readonly json: "name";
+                                                                };
+                                                                readonly default: "untitled-model";
+                                                            };
+                                                            readonly version: {
+                                                                readonly description: "Version of the model definition.";
+                                                                readonly type: "string";
+                                                                readonly "x-order": 3;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "version";
+                                                                    readonly json: "version";
+                                                                };
+                                                                readonly minLength: 5;
+                                                                readonly maxLength: 100;
+                                                                readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                            };
+                                                            readonly displayName: {
+                                                                readonly description: "Human-readable name for the model.";
+                                                                readonly helperText: "Model display name may include letters, numbers, and spaces. Special characters are not allowed.";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 100;
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[a-zA-Z0-9 ]+$";
+                                                                readonly examples: readonly ["Cert Manager"];
+                                                                readonly "x-order": 5;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "displayName";
+                                                                    readonly json: "displayName";
+                                                                };
+                                                                readonly default: "Untitled Model";
+                                                            };
+                                                            readonly model: {
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly gorm: "type:bytes;serializer:json";
+                                                                };
+                                                                readonly "x-order": 12;
+                                                                readonly type: "object";
+                                                                readonly description: "Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31).";
+                                                                readonly required: readonly ["version"];
+                                                                readonly properties: {
+                                                                    readonly version: {
+                                                                        readonly description: "Version of the model as defined by the registrant.";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly type: "string";
+                                                                            readonly minLength: 5;
+                                                                            readonly maxLength: 100;
+                                                                            readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                                            readonly description: "A valid semantic version string between 5 and 256 characters. The pattern allows for a major.minor.patch version followed by an optional pre-release tag like '-alpha' or '-beta.2' and an optional build metadata tag like '+build.1.";
+                                                                        }];
+                                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                                            readonly yaml: "version";
+                                                                            readonly json: "version";
+                                                                        };
+                                                                        readonly "x-order": 1;
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly registrant: {
+                                                                readonly "x-go-type": "RegistrantReference";
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "registrant";
+                                                                    readonly json: "registrant";
+                                                                };
+                                                                readonly type: "object";
+                                                                readonly required: readonly ["kind"];
+                                                                readonly properties: {
+                                                                    readonly kind: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly id: {
+                                                        readonly type: "string";
+                                                        readonly format: "uuid";
+                                                        readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                        readonly "x-go-type": "uuid.UUID";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/gofrs/uuid";
+                                                        };
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "id";
+                                                            readonly json: "id";
+                                                        };
+                                                    };
+                                                    readonly match: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly properties: {
+                                                                readonly from: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                                readonly to: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "match";
+                                                            readonly json: "match";
+                                                        };
+                                                    };
+                                                    readonly patch: {
+                                                        readonly allOf: readonly [{
+                                                            readonly properties: {
+                                                                readonly patchStrategy: {
+                                                                    readonly description: "patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902). \n\nadd: Inserts a value into an array or adds a member to an object.\nreplace: Replaces a value.\nmerge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.\nstrategic:specific to Kubernetes and understands the structure of Kubernetes objects. It can handle complex changes like updating lists and maps, as well as preserving default values. However, it's not supported for custom resources. For custom resources, only JSON Patch and Merge Patch are typically supported.\nremove: Removes a value.\ncopy: Copies a value from one location to another.\nmove: Moves a value from one location to another.\ntest: Tests that a value at the target location is equal to a specified value.";
+                                                                    readonly $comment: "Array Indexing: When working with arrays, be aware that Kubernetes uses zero-based indexing in JSON patch paths.\nMerge Patch vs. JSON Patch: Merge patches are less flexible than JSON patches and do not support all the same operations.\nStrategic Merge Patch: For some Kubernetes resources, you can also use the strategic type for a strategic merge patch, which understands the structure of Kubernetes objects and can handle complex operations.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["merge", "strategic", "add", "remove", "copy", "move", "test"];
+                                                                    readonly default: "copy";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly oneOf: readonly [{
+                                                                readonly properties: {
+                                                                    readonly mutatorRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                        };
+                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly properties: {
+                                                                    readonly mutatedRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }];
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "patch";
+                                                            readonly json: "patch";
+                                                        };
+                                                    };
+                                                };
+                                                readonly description: "Optional fields that are a part of the `from` selector. Absence of a field has an implied * meaning.";
+                                            };
+                                        };
+                                        readonly to: {
+                                            readonly description: "Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match.";
+                                            readonly type: "array";
+                                            readonly items: {
+                                                readonly type: "object";
+                                                readonly additionalProperties: false;
+                                                readonly properties: {
+                                                    readonly kind: {
+                                                        readonly type: "string";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "kind";
+                                                            readonly json: "kind";
+                                                        };
+                                                    };
+                                                    readonly model: {
+                                                        readonly "x-go-type": "model.ModelReference";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/meshery/schemas/models/v1beta1/model";
+                                                        };
+                                                        readonly "x-order": 8;
+                                                        readonly description: "Reference to the specific registered model to which the component belongs and from which model version, category, and other properties may be referenced. Learn more at https://docs.meshery.io/concepts/models";
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly gorm: "-";
+                                                        };
+                                                        readonly type: "object";
+                                                        readonly required: readonly ["id", "name", "version", "displayName", "model", "registrant"];
+                                                        readonly properties: {
+                                                            readonly id: {
+                                                                readonly type: "string";
+                                                                readonly format: "uuid";
+                                                                readonly description: "A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.";
+                                                                readonly "x-go-type": "uuid.UUID";
+                                                                readonly "x-go-type-import": {
+                                                                    readonly path: "github.com/gofrs/uuid";
+                                                                };
+                                                            };
+                                                            readonly name: {
+                                                                readonly type: "string";
+                                                                readonly description: "The unique name for the model within the scope of a registrant.";
+                                                                readonly helperText: "Model name should be in lowercase with hyphens, not whitespaces.";
+                                                                readonly pattern: "^[a-z0-9-]+$";
+                                                                readonly examples: readonly ["cert-manager"];
+                                                                readonly "x-order": 4;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "name";
+                                                                    readonly json: "name";
+                                                                };
+                                                                readonly default: "untitled-model";
+                                                            };
+                                                            readonly version: {
+                                                                readonly description: "Version of the model definition.";
+                                                                readonly type: "string";
+                                                                readonly "x-order": 3;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "version";
+                                                                    readonly json: "version";
+                                                                };
+                                                                readonly minLength: 5;
+                                                                readonly maxLength: 100;
+                                                                readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                            };
+                                                            readonly displayName: {
+                                                                readonly description: "Human-readable name for the model.";
+                                                                readonly helperText: "Model display name may include letters, numbers, and spaces. Special characters are not allowed.";
+                                                                readonly minLength: 1;
+                                                                readonly maxLength: 100;
+                                                                readonly type: "string";
+                                                                readonly pattern: "^[a-zA-Z0-9 ]+$";
+                                                                readonly examples: readonly ["Cert Manager"];
+                                                                readonly "x-order": 5;
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "displayName";
+                                                                    readonly json: "displayName";
+                                                                };
+                                                                readonly default: "Untitled Model";
+                                                            };
+                                                            readonly model: {
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly gorm: "type:bytes;serializer:json";
+                                                                };
+                                                                readonly "x-order": 12;
+                                                                readonly type: "object";
+                                                                readonly description: "Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31).";
+                                                                readonly required: readonly ["version"];
+                                                                readonly properties: {
+                                                                    readonly version: {
+                                                                        readonly description: "Version of the model as defined by the registrant.";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly type: "string";
+                                                                            readonly minLength: 5;
+                                                                            readonly maxLength: 100;
+                                                                            readonly pattern: "^[a-z0-9]+.[0-9]+.[0-9]+(-[0-9A-Za-z-]+(.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$";
+                                                                            readonly description: "A valid semantic version string between 5 and 256 characters. The pattern allows for a major.minor.patch version followed by an optional pre-release tag like '-alpha' or '-beta.2' and an optional build metadata tag like '+build.1.";
+                                                                        }];
+                                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                                            readonly yaml: "version";
+                                                                            readonly json: "version";
+                                                                        };
+                                                                        readonly "x-order": 1;
+                                                                    };
+                                                                };
+                                                            };
+                                                            readonly registrant: {
+                                                                readonly "x-go-type": "RegistrantReference";
+                                                                readonly "x-oapi-codegen-extra-tags": {
+                                                                    readonly yaml: "registrant";
+                                                                    readonly json: "registrant";
+                                                                };
+                                                                readonly type: "object";
+                                                                readonly required: readonly ["kind"];
+                                                                readonly properties: {
+                                                                    readonly kind: {
+                                                                        readonly type: "string";
+                                                                    };
+                                                                };
+                                                            };
+                                                        };
+                                                    };
+                                                    readonly id: {
+                                                        readonly type: "string";
+                                                        readonly format: "uuid";
+                                                        readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                        readonly "x-go-type": "uuid.UUID";
+                                                        readonly "x-go-type-import": {
+                                                            readonly path: "github.com/gofrs/uuid";
+                                                        };
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "id";
+                                                            readonly json: "id";
+                                                        };
+                                                    };
+                                                    readonly match: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: false;
+                                                        readonly oneOf: readonly [{
+                                                            readonly type: "array";
+                                                            readonly items: {
+                                                                readonly type: "array";
+                                                                readonly items: {
+                                                                    readonly type: "string";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly properties: {
+                                                                readonly from: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                                readonly to: {
+                                                                    readonly $comment: "Type is array so that mutliple bindings can be supported between 2 nodes";
+                                                                    readonly type: "array";
+                                                                    readonly items: {
+                                                                        readonly type: "object";
+                                                                        readonly allOf: readonly [{
+                                                                            readonly properties: {
+                                                                                readonly kind: {
+                                                                                    readonly type: "string";
+                                                                                };
+                                                                                readonly id: {
+                                                                                    readonly type: "string";
+                                                                                    readonly format: "uuid";
+                                                                                    readonly description: "A Universally Unique Identifier used to uniquely identify entites in Meshery. The UUID core defintion is used across different schemas.";
+                                                                                    readonly "x-go-type": "uuid.UUID";
+                                                                                    readonly "x-go-type-import": {
+                                                                                        readonly path: "github.com/gofrs/uuid";
+                                                                                    };
+                                                                                    readonly "x-oapi-codegen-extra-tags": {
+                                                                                        readonly yaml: "id";
+                                                                                        readonly json: "id";
+                                                                                    };
+                                                                                };
+                                                                            };
+                                                                        }, {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly properties: {
+                                                                                    readonly mutatorRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                                        };
+                                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                                    };
+                                                                                };
+                                                                            }, {
+                                                                                readonly properties: {
+                                                                                    readonly mutatedRef: {
+                                                                                        readonly type: "array";
+                                                                                        readonly items: {
+                                                                                            readonly type: "array";
+                                                                                            readonly items: {
+                                                                                                readonly type: "string";
+                                                                                            };
+                                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                                        };
+                                                                                    };
+                                                                                };
+                                                                            }];
+                                                                        }];
+                                                                    };
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "match";
+                                                            readonly json: "match";
+                                                        };
+                                                    };
+                                                    readonly patch: {
+                                                        readonly allOf: readonly [{
+                                                            readonly properties: {
+                                                                readonly patchStrategy: {
+                                                                    readonly description: "patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902). \n\nadd: Inserts a value into an array or adds a member to an object.\nreplace: Replaces a value.\nmerge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.\nstrategic:specific to Kubernetes and understands the structure of Kubernetes objects. It can handle complex changes like updating lists and maps, as well as preserving default values. However, it's not supported for custom resources. For custom resources, only JSON Patch and Merge Patch are typically supported.\nremove: Removes a value.\ncopy: Copies a value from one location to another.\nmove: Moves a value from one location to another.\ntest: Tests that a value at the target location is equal to a specified value.";
+                                                                    readonly $comment: "Array Indexing: When working with arrays, be aware that Kubernetes uses zero-based indexing in JSON patch paths.\nMerge Patch vs. JSON Patch: Merge patches are less flexible than JSON patches and do not support all the same operations.\nStrategic Merge Patch: For some Kubernetes resources, you can also use the strategic type for a strategic merge patch, which understands the structure of Kubernetes objects and can handle complex operations.";
+                                                                    readonly type: "string";
+                                                                    readonly enum: readonly ["merge", "strategic", "add", "remove", "copy", "move", "test"];
+                                                                    readonly default: "copy";
+                                                                };
+                                                            };
+                                                        }, {
+                                                            readonly oneOf: readonly [{
+                                                                readonly properties: {
+                                                                    readonly mutatorRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "The sequence of mutatorRef and mutatedRef must match. eg: mutatorRef: [[config, url], [config, name]], mutatedRef: [[configPatch, value], [name]]. The value [config, url] will be patched at [configPatch, value]. Similarly [config,name] will be patched at [name].";
+                                                                        };
+                                                                        readonly description: "JSON ref to value from where patch should be applied.";
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly properties: {
+                                                                    readonly mutatedRef: {
+                                                                        readonly type: "array";
+                                                                        readonly items: {
+                                                                            readonly type: "array";
+                                                                            readonly items: {
+                                                                                readonly type: "string";
+                                                                            };
+                                                                            readonly description: "JSONPath (https://en.wikipedia.org/wiki/JSONPath) to property to be patched.";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }];
+                                                        }];
+                                                        readonly "x-oapi-codegen-extra-tags": {
+                                                            readonly yaml: "patch";
+                                                            readonly json: "patch";
+                                                        };
+                                                    };
+                                                };
+                                                readonly description: "Optional fields that are a part of the `from` selector. Absence of a field has an implied * meaning.";
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly created_at: {
+                        readonly description: "Timestamp when the resource was created.";
+                        readonly "x-go-type": "time.Time";
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly "x-go-name": "CreatedAt";
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly db: "created_at";
+                            readonly yaml: "created_at";
+                        };
+                        readonly "x-go-type-skip-optional-pointer": true;
+                    };
+                    readonly updated_at: {
+                        readonly description: "Timestamp when the resource was updated.";
+                        readonly "x-go-type": "time.Time";
+                        readonly type: "string";
+                        readonly format: "date-time";
+                        readonly "x-go-name": "UpdatedAt";
+                        readonly "x-oapi-codegen-extra-tags": {
+                            readonly db: "updated_at";
+                            readonly yaml: "updated_at";
+                        };
+                        readonly "x-go-type-skip-optional-pointer": true;
+                    };
+                };
+            };
+        };
+    };
+};
+
+export { RelationshipSchema as default };